8 files changed, 24329 insertions, 0 deletions
diff --git a/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/geometry.pas b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/geometry.pas
new file mode 100644
index 00000000..15783515
--- /dev/null
+++ b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/geometry.pas
@@ -0,0 +1,1994 @@
+unit geometry;
+{
+  $Id: geometry.pas,v 1.1 2004/03/30 21:53:54 savage Exp $
+  
+}
+
+// This unit contains many needed types, functions and procedures for
+// quaternion, vector and matrix arithmetics. It is specifically designed
+// for geometric calculations within R3 (affine vector space)
+// and R4 (homogeneous vector space).
+//
+// Note: The terms 'affine' or 'affine coordinates' are not really correct here
+//       because an 'affine transformation' describes generally a transformation which leads
+//       to a uniquely solvable system of equations and has nothing to do with the dimensionality
+//       of a vector. One could use 'projective coordinates' but this is also not really correct
+//       and since I haven't found a better name (or even any correct one), 'affine' is as good
+//       as any other one.
+//
+// Identifiers containing no dimensionality (like affine or homogeneous)
+// and no datatype (integer..extended) are supposed as R4 representation
+// with 'single' floating point type (examples are TVector, TMatrix,
+// and TQuaternion). The default data type is 'single' ('GLFloat' for OpenGL)
+// and used in all routines (except conversions and trigonometric functions).
+//
+// Routines with an open array as argument can either take Func([1,2,3,4,..]) or Func(Vect).
+// The latter is prefered, since no extra stack operations is required.
+// Note: Be careful while passing open array elements! If you pass more elements
+//       than there's room in the result the behaviour will be unpredictable.
+//
+// If not otherwise stated, all angles are given in radians
+// (instead of degrees). Use RadToDeg or DegToRad to convert between them.
+//
+// Geometry.pas was assembled from different sources (like GraphicGems)
+// and relevant books or based on self written code, respectivly.
+//
+// Note: Some aspects need to be considered when using Delphi and pure
+//       assembler code. Delphi ensures that the direction flag is always
+//       cleared while entering a function and expects it cleared on return.
+//       This is in particular important in routines with (CPU) string commands (MOVSD etc.)
+//       The registers EDI, ESI and EBX (as well as the stack management
+//       registers EBP and ESP) must not be changed! EAX, ECX and EDX are
+//       freely available and mostly used for parameter.
+//
+// Version 2.5
+// last change : 04. January 2000
+//
+// (c) Copyright 1999, Dipl. Ing. Mike Lischke (public@lischke-online.de)
+{
+  $Log: geometry.pas,v $
+  Revision 1.1  2004/03/30 21:53:54  savage
+  Moved to it's own folder.
+
+  Revision 1.1  2004/02/05 00:08:19  savage
+  Module 1.0 release
+
+  
+}
+
+interface
+
+{$I jedi-sdl.inc}
+
+type
+  // data types needed for 3D graphics calculation,
+  // included are 'C like' aliases for each type (to be
+  // conformal with OpenGL types)
+
+  PByte = ^Byte;
+  PWord = ^Word;
+  PInteger = ^Integer;
+  PFloat = ^Single;
+  PDouble = ^Double;
+  PExtended = ^Extended;
+  PPointer = ^Pointer;
+
+  // types to specify continous streams of a specific type
+  // switch off range checking to access values beyond the limits
+  PByteVector = ^TByteVector;
+  PByteArray = PByteVector;
+  TByteVector = array[0..0] of Byte;
+
+  PWordVector = ^TWordVector;
+  PWordArray = PWordVector;  // note: there's a same named type in SysUtils
+  TWordVector = array[0..0] of Word;
+
+  PIntegerVector = ^TIntegerVector;
+  PIntegerArray = PIntegerVector;
+  TIntegerVector = array[0..0] of Integer;
+
+  PFloatVector = ^TFloatVector;
+  PFloatArray = PFloatVector;
+  TFloatVector = array[0..0] of Single;
+
+  PDoubleVector = ^TDoubleVector;
+  PDoubleArray = PDoubleVector;
+  TDoubleVector = array[0..0] of Double;
+
+  PExtendedVector = ^TExtendedVector;
+  PExtendedArray = PExtendedVector;
+  TExtendedVector = array[0..0] of Extended;
+
+  PPointerVector = ^TPointerVector;
+  PPointerArray = PPointerVector;
+  TPointerVector = array[0..0] of Pointer;
+
+  PCardinalVector = ^TCardinalVector;
+  PCardinalArray = PCardinalVector;
+  TCardinalVector = array[0..0] of Cardinal;
+
+  // common vector and matrix types with predefined limits
+  // indices correspond like: x -> 0
+  //                          y -> 1
+  //                          z -> 2
+  //                          w -> 3
+
+  PHomogeneousByteVector = ^THomogeneousByteVector;
+  THomogeneousByteVector = array[0..3] of Byte;
+  TVector4b = THomogeneousByteVector;
+
+  PHomogeneousWordVector = ^THomogeneousWordVector;
+  THomogeneousWordVector = array[0..3] of Word;
+  TVector4w = THomogeneousWordVector;
+
+  PHomogeneousIntVector = ^THomogeneousIntVector;
+  THomogeneousIntVector = array[0..3] of Integer;
+  TVector4i = THomogeneousIntVector;
+
+  PHomogeneousFltVector = ^THomogeneousFltVector;
+  THomogeneousFltVector = array[0..3] of Single;
+  TVector4f = THomogeneousFltVector;
+
+  PHomogeneousDblVector = ^THomogeneousDblVector;
+  THomogeneousDblVector = array[0..3] of Double;
+  TVector4d = THomogeneousDblVector;
+
+  PHomogeneousExtVector = ^THomogeneousExtVector;
+  THomogeneousExtVector = array[0..3] of Extended;
+  TVector4e = THomogeneousExtVector;
+
+  PHomogeneousPtrVector = ^THomogeneousPtrVector;
+  THomogeneousPtrVector = array[0..3] of Pointer;
+  TVector4p = THomogeneousPtrVector;
+
+  PAffineByteVector = ^TAffineByteVector;
+  TAffineByteVector = array[0..2] of Byte;
+  TVector3b = TAffineByteVector;
+
+  PAffineWordVector = ^TAffineWordVector;
+  TAffineWordVector = array[0..2] of Word;
+  TVector3w = TAffineWordVector;
+
+  PAffineIntVector = ^TAffineIntVector;
+  TAffineIntVector = array[0..2] of Integer;
+  TVector3i = TAffineIntVector;
+
+  PAffineFltVector = ^TAffineFltVector;
+  TAffineFltVector = array[0..2] of Single;
+  TVector3f = TAffineFltVector;
+
+  PAffineDblVector = ^TAffineDblVector;
+  TAffineDblVector = array[0..2] of Double;
+  TVector3d = TAffineDblVector;
+
+  PAffineExtVector = ^TAffineExtVector;
+  TAffineExtVector = array[0..2] of Extended;
+  TVector3e = TAffineExtVector;
+
+  PAffinePtrVector = ^TAffinePtrVector;
+  TAffinePtrVector = array[0..2] of Pointer;
+  TVector3p = TAffinePtrVector;
+
+  // some simplified names
+  PVector = ^TVector;
+  TVector = THomogeneousFltVector;
+
+  PHomogeneousVector = ^THomogeneousVector;
+  THomogeneousVector = THomogeneousFltVector;
+
+  PAffineVector = ^TAffineVector;
+  TAffineVector = TAffineFltVector;
+
+  // arrays of vectors
+  PVectorArray = ^TVectorArray;
+  TVectorArray = array[0..0] of TAffineVector;
+
+  // matrices
+  THomogeneousByteMatrix = array[0..3] of THomogeneousByteVector;
+  TMatrix4b = THomogeneousByteMatrix;
+
+  THomogeneousWordMatrix = array[0..3] of THomogeneousWordVector;
+  TMatrix4w = THomogeneousWordMatrix;
+
+  THomogeneousIntMatrix = array[0..3] of THomogeneousIntVector;
+  TMatrix4i = THomogeneousIntMatrix;
+
+  THomogeneousFltMatrix  = array[0..3] of THomogeneousFltVector;
+  TMatrix4f = THomogeneousFltMatrix;
+
+  THomogeneousDblMatrix = array[0..3] of THomogeneousDblVector;
+  TMatrix4d = THomogeneousDblMatrix;
+
+  THomogeneousExtMatrix = array[0..3] of THomogeneousExtVector;
+  TMatrix4e = THomogeneousExtMatrix;
+
+  TAffineByteMatrix = array[0..2] of TAffineByteVector;
+  TMatrix3b = TAffineByteMatrix;
+
+  TAffineWordMatrix = array[0..2] of TAffineWordVector;
+  TMatrix3w = TAffineWordMatrix;
+
+  TAffineIntMatrix = array[0..2] of TAffineIntVector;
+  TMatrix3i = TAffineIntMatrix;
+
+  TAffineFltMatrix = array[0..2] of TAffineFltVector;
+  TMatrix3f = TAffineFltMatrix;
+
+  TAffineDblMatrix = array[0..2] of TAffineDblVector;
+  TMatrix3d = TAffineDblMatrix;
+
+  TAffineExtMatrix = array[0..2] of TAffineExtVector;
+  TMatrix3e = TAffineExtMatrix;
+
+  // some simplified names
+  PMatrix = ^TMatrix;
+  TMatrix = THomogeneousFltMatrix;
+
+  PHomogeneousMatrix = ^THomogeneousMatrix;
+  THomogeneousMatrix = THomogeneousFltMatrix;
+
+  PAffineMatrix = ^TAffineMatrix;
+  TAffineMatrix = TAffineFltMatrix;
+
+  // q = ([x, y, z], w)
+  TQuaternion = record
+    case Integer of
+      0:
+        (ImagPart: TAffineVector;
+         RealPart: Single);
+      1:
+        (Vector: TVector4f);
+  end;
+
+  TRectangle = record
+    Left,
+    Top,
+    Width,
+    Height: Integer;
+  end;
+
+  TTransType = (ttScaleX, ttScaleY, ttScaleZ,
+                ttShearXY, ttShearXZ, ttShearYZ,
+                ttRotateX, ttRotateY, ttRotateZ,
+                ttTranslateX, ttTranslateY, ttTranslateZ,
+                ttPerspectiveX, ttPerspectiveY, ttPerspectiveZ, ttPerspectiveW);
+
+  // used to describe a sequence of transformations in following order:
+  // [Sx][Sy][Sz][ShearXY][ShearXZ][ShearZY][Rx][Ry][Rz][Tx][Ty][Tz][P(x,y,z,w)]
+  // constants are declared for easier access (see MatrixDecompose below)
+  TTransformations  = array[TTransType] of Single;
+
+
+const
+  // useful constants
+
+  // standard vectors
+  XVector: TAffineVector = (1, 0, 0);
+  YVector: TAffineVector = (0, 1, 0);
+  ZVector: TAffineVector = (0, 0, 1);
+  NullVector: TAffineVector = (0, 0, 0);
+
+  IdentityMatrix: TMatrix = ((1, 0, 0, 0),
+                             (0, 1, 0, 0),
+                             (0, 0, 1, 0),
+                             (0, 0, 0, 1));
+  EmptyMatrix: TMatrix = ((0, 0, 0, 0),
+                          (0, 0, 0, 0),
+                          (0, 0, 0, 0),
+                          (0, 0, 0, 0));
+  // some very small numbers
+  EPSILON  = 1e-100;
+  EPSILON2 = 1e-50;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+// vector functions
+function  VectorAdd(V1, V2: TVector): TVector;
+function  VectorAffineAdd(V1, V2: TAffineVector): TAffineVector;
+function  VectorAffineCombine(V1, V2: TAffineVector; F1, F2: Single): TAffineVector;
+function  VectorAffineDotProduct(V1, V2: TAffineVector): Single;
+function  VectorAffineLerp(V1, V2: TAffineVector; t: Single): TAffineVector;
+function  VectorAffineSubtract(V1, V2: TAffineVector): TAffineVector;
+function  VectorAngle(V1, V2: TAffineVector): Single;
+function  VectorCombine(V1, V2: TVector; F1, F2: Single): TVector;
+function  VectorCrossProduct(V1, V2: TAffineVector): TAffineVector;
+function  VectorDotProduct(V1, V2: TVector): Single;
+function  VectorLength(V: array of Single): Single;
+function  VectorLerp(V1, V2: TVector; t: Single): TVector;
+procedure VectorNegate(V: array of Single);
+function  VectorNorm(V: array of Single): Single;
+function  VectorNormalize(V: array of Single): Single;
+function  VectorPerpendicular(V, N: TAffineVector): TAffineVector;
+function  VectorReflect(V, N: TAffineVector): TAffineVector;
+procedure VectorRotate(var Vector: TVector4f; Axis: TVector3f; Angle: Single);
+procedure VectorScale(V: array of Single; Factor: Single);
+function  VectorSubtract(V1, V2: TVector): TVector;
+
+// matrix functions
+function  CreateRotationMatrixX(Sine, Cosine: Single): TMatrix;
+function  CreateRotationMatrixY(Sine, Cosine: Single): TMatrix;
+function  CreateRotationMatrixZ(Sine, Cosine: Single): TMatrix;
+function  CreateScaleMatrix(V: TAffineVector): TMatrix;
+function  CreateTranslationMatrix(V: TVector): TMatrix;
+procedure MatrixAdjoint(var M: TMatrix);
+function  MatrixAffineDeterminant(M: TAffineMatrix): Single;
+procedure MatrixAffineTranspose(var M: TAffineMatrix);
+function  MatrixDeterminant(M: TMatrix): Single;
+procedure MatrixInvert(var M: TMatrix);
+function  MatrixMultiply(M1, M2: TMatrix): TMatrix;
+procedure MatrixScale(var M: TMatrix; Factor: Single);
+procedure MatrixTranspose(var M: TMatrix);
+
+// quaternion functions
+function  QuaternionConjugate(Q: TQuaternion): TQuaternion;
+function  QuaternionFromPoints(V1, V2: TAffineVector): TQuaternion;
+function  QuaternionMultiply(qL, qR: TQuaternion): TQuaternion;
+function  QuaternionSlerp(QStart, QEnd: TQuaternion; Spin: Integer; t: Single): TQuaternion;
+function  QuaternionToMatrix(Q: TQuaternion): TMatrix;
+procedure QuaternionToPoints(Q: TQuaternion; var ArcFrom, ArcTo: TAffineVector);
+
+// mixed functions
+function  ConvertRotation(Angles: TAffineVector): TVector;
+function  CreateRotationMatrix(Axis: TVector3f; Angle: Single): TMatrix;
+function  MatrixDecompose(M: TMatrix; var Tran: TTransformations): Boolean;
+function  VectorAffineTransform(V: TAffineVector; M: TAffineMatrix): TAffineVector;
+function  VectorTransform(V: TVector4f; M: TMatrix): TVector4f; overload;
+function  VectorTransform(V: TVector3f; M: TMatrix): TVector3f; overload;
+
+// miscellaneous functions
+function  MakeAffineDblVector(V: array of Double): TAffineDblVector;
+function  MakeDblVector(V: array of Double): THomogeneousDblVector;
+function  MakeAffineVector(V: array of Single): TAffineVector;
+function  MakeQuaternion(Imag: array of Single; Real: Single): TQuaternion;
+function  MakeVector(V: array of Single): TVector;
+function  PointInPolygon(xp, yp : array of Single; x, y: Single): Boolean;
+function  VectorAffineDblToFlt(V: TAffineDblVector): TAffineVector;
+function  VectorDblToFlt(V: THomogeneousDblVector): THomogeneousVector;
+function  VectorAffineFltToDbl(V: TAffineVector): TAffineDblVector;
+function  VectorFltToDbl(V: TVector): THomogeneousDblVector;
+
+// trigonometric functions
+function  ArcCos(X: Extended): Extended;
+function  ArcSin(X: Extended): Extended;
+function  ArcTan2(Y, X: Extended): Extended;
+function  CoTan(X: Extended): Extended;
+function  DegToRad(Degrees: Extended): Extended;
+function  RadToDeg(Radians: Extended): Extended;
+procedure SinCos(Theta: Extended; var Sin, Cos: Extended);
+function  Tan(X: Extended): Extended;
+
+// coordinate system manipulation functions
+function Turn(Matrix: TMatrix; Angle: Single): TMatrix; overload;
+function Turn(Matrix: TMatrix; MasterUp: TAffineVector; Angle: Single): TMatrix; overload;
+function Pitch(Matrix: TMatrix; Angle: Single): TMatrix; overload;
+function Pitch(Matrix: TMatrix; MasterRight: TAffineVector; Angle: Single): TMatrix; overload;
+function Roll(Matrix: TMatrix; Angle: Single): TMatrix; overload;
+function Roll(Matrix: TMatrix; MasterDirection: TAffineVector; Angle: Single): TMatrix; overload;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+implementation
+
+const
+  // FPU status flags (high order byte)
+  C0 = 1;
+  C1 = 2;
+  C2 = 4;
+  C3 = $40;
+
+  // to be used as descriptive indices
+  X = 0;
+  Y = 1;
+  Z = 2;
+  W = 3;
+
+//----------------- trigonometric helper functions ---------------------------------------------------------------------
+
+function DegToRad(Degrees: Extended): Extended;
+
+begin
+  Result := Degrees * (PI / 180);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function RadToDeg(Radians: Extended): Extended;
+
+begin
+  Result := Radians * (180 / PI);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure SinCos(Theta: Extended; var Sin, Cos: Extended); assembler; register;
+
+// calculates sine and cosine from the given angle Theta
+// EAX contains address of Sin
+// EDX contains address of Cos
+// Theta is passed over the stack
+
+asm
+              FLD  Theta
+              FSINCOS
+              FSTP TBYTE PTR [EDX]    // cosine
+              FSTP TBYTE PTR [EAX]    // sine
+              FWAIT
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function ArcCos(X: Extended): Extended;
+
+begin
+  Result := ArcTan2(Sqrt(1 - X * X), X);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function ArcSin(X: Extended): Extended;
+
+begin
+  Result := ArcTan2(X, Sqrt(1 - X * X))
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function ArcTan2(Y, X: Extended): Extended;
+
+asm
+              FLD  Y
+              FLD  X
+              FPATAN
+              FWAIT
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function Tan(X: Extended): Extended;
+
+asm
+              FLD  X
+              FPTAN
+              FSTP ST(0)      // FPTAN pushes 1.0 after result
+              FWAIT
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function CoTan(X: Extended): Extended;
+
+asm
+              FLD  X
+              FPTAN
+              FDIVRP
+              FWAIT
+end;
+
+//----------------- miscellaneous vector functions ---------------------------------------------------------------------
+
+function MakeAffineDblVector(V: array of Double): TAffineDblVector; assembler;
+
+// creates a vector from given values
+// EAX contains address of V
+// ECX contains address to result vector
+// EDX contains highest index of V
+
+asm
+              PUSH EDI
+              PUSH ESI
+              MOV EDI, ECX
+              MOV ESI, EAX
+              MOV ECX, EDX
+              ADD ECX, 2
+              REP MOVSD
+              POP ESI
+              POP EDI
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function MakeDblVector(V: array of Double): THomogeneousDblVector; assembler;
+
+// creates a vector from given values
+// EAX contains address of V
+// ECX contains address to result vector
+// EDX contains highest index of V
+
+asm
+              PUSH EDI
+              PUSH ESI
+              MOV EDI, ECX
+              MOV ESI, EAX
+              MOV ECX, EDX
+              ADD ECX, 2
+              REP MOVSD
+              POP ESI
+              POP EDI
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function MakeAffineVector(V: array of Single): TAffineVector; assembler;
+
+// creates a vector from given values
+// EAX contains address of V
+// ECX contains address to result vector
+// EDX contains highest index of V
+
+asm
+              PUSH EDI
+              PUSH ESI
+              MOV EDI, ECX
+              MOV ESI, EAX
+              MOV ECX, EDX
+              INC ECX
+              CMP ECX, 3
+              JB  @@1
+              MOV ECX, 3
+@@1:          REP MOVSD                     // copy given values
+              MOV ECX, 2
+              SUB ECX, EDX                   // determine missing entries
+              JS  @@Finish
+              XOR EAX, EAX
+              REP STOSD                     // set remaining fields to 0
+@@Finish:     POP ESI
+              POP EDI
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function MakeQuaternion(Imag: array of Single; Real: Single): TQuaternion; assembler;
+
+// creates a quaternion from the given values
+// EAX contains address of Imag
+// ECX contains address to result vector
+// EDX contains highest index of Imag
+// Real part is passed on the stack
+
+asm
+              PUSH EDI
+              PUSH ESI
+              MOV EDI, ECX
+              MOV ESI, EAX
+              MOV ECX, EDX
+              INC ECX
+              REP MOVSD
+              MOV EAX, [Real]
+              MOV [EDI], EAX
+              POP ESI
+              POP EDI
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function MakeVector(V: array of Single): TVector; assembler;
+
+// creates a vector from given values
+// EAX contains address of V
+// ECX contains address to result vector
+// EDX contains highest index of V
+
+asm
+              PUSH EDI
+              PUSH ESI
+              MOV EDI, ECX
+              MOV ESI, EAX
+              MOV ECX, EDX
+              INC ECX
+              CMP ECX, 4
+              JB  @@1
+              MOV ECX, 4
+@@1:          REP MOVSD                     // copy given values
+              MOV ECX, 3
+              SUB ECX, EDX                   // determine missing entries
+              JS  @@Finish
+              XOR EAX, EAX
+              REP STOSD                     // set remaining fields to 0
+@@Finish:     POP ESI
+              POP EDI
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorLength(V: array of Single): Single; assembler;
+
+// calculates the length of a vector following the equation: sqrt(x * x + y * y + ...)
+// Note: The parameter of this function is declared as open array. Thus
+// there's no restriction about the number of the components of the vector.
+//
+// EAX contains address of V
+// EDX contains the highest index of V
+// the result is returned in ST(0)
+
+asm
+              FLDZ                           // initialize sum
+@@Loop:       FLD  DWORD PTR [EAX  +  4 * EDX] // load a component
+              FMUL ST, ST
+              FADDP
+              SUB  EDX, 1
+              JNL  @@Loop
+              FSQRT
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorAngle(V1, V2: TAffineVector): Single; assembler;
+
+// calculates the cosine of the angle between Vector1 and Vector2
+// Result = DotProduct(V1, V2) / (Length(V1) * Length(V2))
+//
+// EAX contains address of Vector1
+// EDX contains address of Vector2
+
+asm
+              FLD DWORD PTR [EAX]           // V1[0]
+              FLD ST                        // double V1[0]
+              FMUL ST, ST                   // V1[0]^2 (prep. for divisor)
+              FLD DWORD PTR [EDX]           // V2[0]
+              FMUL ST(2), ST                // ST(2) := V1[0] * V2[0]
+              FMUL ST, ST                   // V2[0]^2 (prep. for divisor)
+              FLD DWORD PTR [EAX + 4]       // V1[1]
+              FLD ST                        // double V1[1]
+              FMUL ST, ST                   // ST(0) := V1[1]^2
+              FADDP ST(3), ST               // ST(2) := V1[0]^2 + V1[1] *  * 2
+              FLD DWORD PTR [EDX + 4]       // V2[1]
+              FMUL ST(1), ST                // ST(1) := V1[1] * V2[1]
+              FMUL ST, ST                   // ST(0) := V2[1]^2
+              FADDP ST(2), ST               // ST(1) := V2[0]^2 + V2[1]^2
+              FADDP ST(3), ST               // ST(2) := V1[0] * V2[0] + V1[1] * V2[1]
+              FLD DWORD PTR [EAX + 8]       // load V2[1]
+              FLD ST                        // same calcs go here
+              FMUL ST, ST                   // (compare above)
+              FADDP ST(3), ST
+              FLD DWORD PTR [EDX + 8]
+              FMUL ST(1), ST
+              FMUL ST, ST
+              FADDP ST(2), ST
+              FADDP ST(3), ST
+              FMULP                         // ST(0) := (V1[0]^2 + V1[1]^2 + V1[2]) *
+                                            //          (V2[0]^2 + V2[1]^2 + V2[2])
+              FSQRT                         // sqrt(ST(0))
+              FDIVP                         // ST(0) := Result := ST(1) / ST(0)
+  // the result is expected in ST(0), if it's invalid, an error is raised
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorNorm(V: array of Single): Single; assembler; register;
+
+// calculates norm of a vector which is defined as norm = x * x + y * y + ...
+// EAX contains address of V
+// EDX contains highest index in V
+// result is passed in ST(0)
+
+asm
+              FLDZ                           // initialize sum
+@@Loop:       FLD  DWORD PTR [EAX + 4 * EDX] // load a component
+              FMUL ST, ST                    // make square
+              FADDP                          // add previous calculated sum
+              SUB  EDX, 1
+              JNL  @@Loop
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorNormalize(V: array of Single): Single; assembler; register;
+
+// transforms a vector to unit length and return length
+// EAX contains address of V
+// EDX contains the highest index in V
+// return former length of V in ST
+
+asm
+              PUSH EBX
+              MOV ECX, EDX                  // save size of V
+              CALL VectorLength             // calculate length of vector
+              FTST                          // test if length = 0
+              MOV EBX, EAX                  // save parameter address
+              FSTSW AX                      // get test result
+              TEST AH, C3                   // check the test result
+              JNZ @@Finish
+              SUB EBX, 4                    // simplyfied address calculation
+              INC ECX
+              FLD1                          // calculate reciprocal of length
+              FDIV ST, ST(1)
+@@1:          FLD ST                        // double reciprocal
+              FMUL DWORD PTR [EBX + 4 * ECX] // scale component
+              WAIT
+              FSTP DWORD PTR [EBX + 4 * ECX] // store result
+              LOOP @@1
+              FSTP ST                       // remove reciprocal from FPU stack
+@@Finish:     POP EBX
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorAffineSubtract(V1, V2: TAffineVector): TAffineVector; assembler; register;
+
+// returns v1 minus v2
+// EAX contains address of V1
+// EDX contains address of V2
+// ECX contains address of the result
+
+asm
+  {Result[X] := V1[X]-V2[X];
+  Result[Y] := V1[Y]-V2[Y];
+  Result[Z] := V1[Z]-V2[Z];}
+
+                   FLD DWORD PTR [EAX]
+                   FSUB DWORD PTR [EDX]
+                   FSTP DWORD PTR [ECX]
+                   FLD DWORD PTR [EAX + 4]
+                   FSUB DWORD PTR [EDX + 4]
+                   FSTP DWORD PTR [ECX + 4]
+                   FLD DWORD PTR [EAX + 8]
+                   FSUB DWORD PTR [EDX + 8]
+                   FSTP DWORD PTR [ECX + 8]
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorReflect(V, N: TAffineVector): TAffineVector; assembler; register;
+
+// reflects vector V against N (assumes N is normalized)
+// EAX contains address of V
+// EDX contains address of N
+// ECX contains address of the result
+
+//var Dot : Single;
+
+asm
+   {Dot := VectorAffineDotProduct(V, N);
+   Result[X] := V[X]-2 * Dot * N[X];
+   Result[Y] := V[Y]-2 * Dot * N[Y];
+   Result[Z] := V[Z]-2 * Dot * N[Z];}
+
+                   CALL VectorAffineDotProduct   // dot is now in ST(0)
+                   FCHS                          // -dot
+                   FADD ST, ST                   // -dot * 2
+                   FLD DWORD PTR [EDX]           // ST := N[X]
+                   FMUL ST, ST(1)                // ST := -2 * dot * N[X]
+                   FADD DWORD PTR[EAX]           // ST := V[X] - 2 * dot * N[X]
+                   FSTP DWORD PTR [ECX]          // store result
+                   FLD DWORD PTR [EDX + 4]       // etc.
+                   FMUL ST, ST(1)
+                   FADD DWORD PTR[EAX + 4]
+                   FSTP DWORD PTR [ECX + 4]
+                   FLD DWORD PTR [EDX + 8]
+                   FMUL ST, ST(1)
+                   FADD DWORD PTR[EAX + 8]
+                   FSTP DWORD PTR [ECX + 8]
+                   FSTP ST                       // clean FPU stack
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure VectorRotate(var Vector: TVector4f; Axis: TVector3f; Angle: Single);
+
+// rotates Vector about Axis with Angle radiants
+
+var RotMatrix : TMatrix4f;
+
+begin
+  RotMatrix := CreateRotationMatrix(Axis, Angle);
+  Vector := VectorTransform(Vector, RotMatrix);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure VectorScale(V: array of Single; Factor: Single); assembler; register;
+
+// returns a vector scaled by a factor
+// EAX contains address of V
+// EDX contains highest index in V
+// Factor is located on the stack
+
+asm
+  {for I := Low(V) to High(V) do V[I] := V[I] * Factor;}
+
+              FLD DWORD PTR [Factor]        // load factor
+@@Loop:       FLD DWORD PTR [EAX + 4 * EDX] // load a component
+              FMUL ST, ST(1)                // multiply it with the factor
+              WAIT
+              FSTP DWORD PTR [EAX + 4 * EDX] // store the result
+              DEC EDX                       // do the entire array
+              JNS @@Loop
+              FSTP ST(0)                    // clean the FPU stack
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure VectorNegate(V: array of Single); assembler; register;
+
+// returns a negated vector
+// EAX contains address of V
+// EDX contains highest index in V
+
+asm
+  {V[X] := -V[X];
+  V[Y] := -V[Y];
+  V[Z] := -V[Z];}
+
+@@Loop:       FLD DWORD PTR [EAX + 4 * EDX]
+              FCHS
+              WAIT
+              FSTP DWORD PTR [EAX + 4 * EDX]
+              DEC EDX
+              JNS @@Loop
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorAdd(V1, V2: TVector): TVector; register;
+
+// returns the sum of two vectors
+
+begin
+  Result[X] := V1[X] + V2[X];
+  Result[Y] := V1[Y] + V2[Y];
+  Result[Z] := V1[Z] + V2[Z];
+  Result[W] := V1[W] + V2[W];
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorAffineAdd(V1, V2: TAffineVector): TAffineVector; register;
+
+// returns the sum of two vectors
+
+begin
+  Result[X] := V1[X] + V2[X];
+  Result[Y] := V1[Y] + V2[Y];
+  Result[Z] := V1[Z] + V2[Z];
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorSubtract(V1, V2: TVector): TVector; register;
+
+// returns the difference of two vectors
+
+begin
+  Result[X] := V1[X] - V2[X];
+  Result[Y] := V1[Y] - V2[Y];
+  Result[Z] := V1[Z] - V2[Z];
+  Result[W] := V1[W] - V2[W];
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorDotProduct(V1, V2: TVector): Single; register;
+
+begin
+  Result := V1[X] * V2[X] + V1[Y] * V2[Y] + V1[Z] * V2[Z] + V1[W] * V2[W];
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorAffineDotProduct(V1, V2: TAffineVector): Single; assembler; register;
+
+// calculates the dot product between V1 and V2
+// EAX contains address of V1
+// EDX contains address of V2
+// result is stored in ST(0)
+
+asm
+  //Result := V1[X] * V2[X] + V1[Y] * V2[Y] + V1[Z] * V2[Z];
+
+                   FLD DWORD PTR [EAX]
+                   FMUL DWORD PTR [EDX]
+                   FLD DWORD PTR [EAX + 4]
+                   FMUL DWORD PTR [EDX + 4]
+                   FADDP
+                   FLD DWORD PTR [EAX + 8]
+                   FMUL DWORD PTR [EDX + 8]
+                   FADDP
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorCrossProduct(V1, V2: TAffineVector): TAffineVector;
+
+// calculates the cross product between vector 1 and 2, Temp is necessary because
+// either V1 or V2 could also be the result vector
+//
+// EAX contains address of V1
+// EDX contains address of V2
+// ECX contains address of result
+
+var Temp: TAffineVector;
+
+asm
+  {Temp[X] := V1[Y] * V2[Z]-V1[Z] * V2[Y];
+  Temp[Y] := V1[Z] * V2[X]-V1[X] * V2[Z];
+  Temp[Z] := V1[X] * V2[Y]-V1[Y] * V2[X];
+  Result := Temp;}
+
+              PUSH EBX                      // save EBX, must be restored to original value
+              LEA EBX, [Temp]
+              FLD DWORD PTR [EDX + 8]       // first load both vectors onto FPU register stack
+              FLD DWORD PTR [EDX + 4]
+              FLD DWORD PTR [EDX + 0]
+              FLD DWORD PTR [EAX + 8]
+              FLD DWORD PTR [EAX + 4]
+              FLD DWORD PTR [EAX + 0]
+
+              FLD ST(1)                     // ST(0) := V1[Y]
+              FMUL ST, ST(6)                // ST(0) := V1[Y] * V2[Z]
+              FLD ST(3)                     // ST(0) := V1[Z]
+              FMUL ST, ST(6)                // ST(0) := V1[Z] * V2[Y]
+              FSUBP ST(1), ST               // ST(0) := ST(1)-ST(0)
+              FSTP DWORD [EBX]              // Temp[X] := ST(0)
+              FLD ST(2)                     // ST(0) := V1[Z]
+              FMUL ST, ST(4)                // ST(0) := V1[Z] * V2[X]
+              FLD ST(1)                     // ST(0) := V1[X]
+              FMUL ST, ST(7)                // ST(0) := V1[X] * V2[Z]
+              FSUBP ST(1), ST               // ST(0) := ST(1)-ST(0)
+              FSTP DWORD [EBX + 4]          // Temp[Y] := ST(0)
+              FLD ST                        // ST(0) := V1[X]
+              FMUL ST, ST(5)                // ST(0) := V1[X] * V2[Y]
+              FLD ST(2)                     // ST(0) := V1[Y]
+              FMUL ST, ST(5)                // ST(0) := V1[Y] * V2[X]
+              FSUBP ST(1), ST               // ST(0) := ST(1)-ST(0)
+              FSTP DWORD [EBX + 8]          // Temp[Z] := ST(0)
+              FSTP ST(0)                    // clear FPU register stack
+              FSTP ST(0)
+              FSTP ST(0)
+              FSTP ST(0)
+              FSTP ST(0)
+              FSTP ST(0)
+              MOV EAX, [EBX]                // copy Temp to Result
+              MOV [ECX], EAX
+              MOV EAX, [EBX + 4]
+              MOV [ECX + 4], EAX
+              MOV EAX, [EBX + 8]
+              MOV [ECX + 8], EAX
+              POP EBX
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorPerpendicular(V, N: TAffineVector): TAffineVector;
+
+// calculates a vector perpendicular to N (N is assumed to be of unit length)
+// subtract out any component parallel to N
+
+var Dot: Single;
+
+begin
+   Dot := VectorAffineDotProduct(V, N);
+   Result[X] := V[X]-Dot * N[X];
+   Result[Y] := V[Y]-Dot * N[Y];
+   Result[Z] := V[Z]-Dot * N[Z];
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorTransform(V: TVector4f; M: TMatrix): TVector4f; register;
+
+// transforms a homogeneous vector by multiplying it with a matrix
+
+var TV: TVector4f;
+
+begin
+  TV[X] := V[X] * M[X, X] + V[Y] * M[Y, X] + V[Z] * M[Z, X] + V[W] * M[W, X];
+  TV[Y] := V[X] * M[X, Y] + V[Y] * M[Y, Y] + V[Z] * M[Z, Y] + V[W] * M[W, Y];
+  TV[Z] := V[X] * M[X, Z] + V[Y] * M[Y, Z] + V[Z] * M[Z, Z] + V[W] * M[W, Z];
+  TV[W] := V[X] * M[X, W] + V[Y] * M[Y, W] + V[Z] * M[Z, W] + V[W] * M[W, W];
+  Result := TV
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function  VectorTransform(V: TVector3f; M: TMatrix): TVector3f;
+
+// transforms an affine vector by multiplying it with a (homogeneous) matrix
+
+var TV: TVector3f;
+
+begin
+  TV[X] := V[X] * M[X, X] + V[Y] * M[Y, X] + V[Z] * M[Z, X] + M[W, X];
+  TV[Y] := V[X] * M[X, Y] + V[Y] * M[Y, Y] + V[Z] * M[Z, Y] + M[W, Y];
+  TV[Z] := V[X] * M[X, Z] + V[Y] * M[Y, Z] + V[Z] * M[Z, Z] + M[W, Z];
+  Result := TV;
+end;
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorAffineTransform(V: TAffineVector; M: TAffineMatrix): TAffineVector; register;
+
+// transforms an affine vector by multiplying it with a matrix
+
+var TV: TAffineVector;
+
+begin
+  TV[X] := V[X] * M[X, X] + V[Y] * M[Y, X] + V[Z] * M[Z, X];
+  TV[Y] := V[X] * M[X, Y] + V[Y] * M[Y, Y] + V[Z] * M[Z, Y];
+  TV[Z] := V[X] * M[X, Z] + V[Y] * M[Y, Z] + V[Z] * M[Z, Z];
+  Result := TV;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function PointInPolygon(xp, yp : array of Single; x, y: Single): Boolean;
+
+// The code below is from Wm. Randolph Franklin <wrf@ecse.rpi.edu>
+// with some minor modifications for speed.  It returns 1 for strictly
+// interior points, 0 for strictly exterior, and 0 or 1 for points on
+// the boundary.
+// This code is not yet tested!
+
+var I, J: Integer;
+
+begin
+  Result := False;
+  if High(XP) <> High(YP) then Exit;
+  J := High(XP);
+  for I := 0 to High(XP) do
+  begin
+    if ((((yp[I] <= y) and (y < yp[J])) or ((yp[J] <= y) and (y < yp[I]))) and
+        (x < (xp[J] - xp[I]) * (y - yp[I]) / (yp[J] - yp[I]) + xp[I]))
+    then Result := not Result;
+    J := I + 1;
+  end;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function QuaternionConjugate(Q: TQuaternion): TQuaternion; assembler;
+
+// returns the conjugate of a quaternion
+// EAX contains address of Q
+// EDX contains address of result
+
+asm
+              FLD DWORD PTR [EAX]
+              FCHS
+              WAIT
+              FSTP DWORD PTR [EDX]
+              FLD DWORD PTR [EAX + 4]
+              FCHS
+              WAIT
+              FSTP DWORD PTR [EDX + 4]
+              FLD DWORD PTR [EAX + 8]
+              FCHS
+              WAIT
+              FSTP DWORD PTR [EDX + 8]
+              MOV EAX, [EAX + 12]
+              MOV [EDX + 12], EAX
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function QuaternionFromPoints(V1, V2: TAffineVector): TQuaternion; assembler;
+
+// constructs a unit quaternion from two points on unit sphere
+// EAX contains address of V1
+// ECX contains address to result
+// EDX contains address of V2
+
+asm
+  {Result.ImagPart := VectorCrossProduct(V1, V2);
+   Result.RealPart :=  Sqrt((VectorAffineDotProduct(V1, V2) + 1)/2);}
+
+              PUSH EAX
+              CALL VectorCrossProduct       // determine axis to rotate about
+              POP EAX
+              FLD1                          // prepare next calculation
+              Call VectorAffineDotProduct   // calculate cos(angle between V1 and V2)
+              FADD ST, ST(1)                // transform angle to angle/2 by: cos(a/2)=sqrt((1 + cos(a))/2)
+              FXCH ST(1)
+              FADD ST, ST
+              FDIVP ST(1), ST
+              FSQRT
+              FSTP DWORD PTR [ECX + 12]     // Result.RealPart := ST(0)
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function QuaternionMultiply(qL, qR: TQuaternion): TQuaternion;
+
+// Returns quaternion product qL * qR.  Note: order is important!
+// To combine rotations, use the product QuaternionMuliply(qSecond, qFirst),
+// which gives the effect of rotating by qFirst then qSecond.
+
+var Temp : TQuaternion;
+
+begin
+  Temp.RealPart := qL.RealPart * qR.RealPart - qL.ImagPart[X] * qR.ImagPart[X] -
+                   qL.ImagPart[Y] * qR.ImagPart[Y] - qL.ImagPart[Z] * qR.ImagPart[Z];
+  Temp.ImagPart[X] := qL.RealPart * qR.ImagPart[X] + qL.ImagPart[X] * qR.RealPart +
+                      qL.ImagPart[Y] * qR.ImagPart[Z] - qL.ImagPart[Z] * qR.ImagPart[Y];
+  Temp.ImagPart[Y] := qL.RealPart * qR.ImagPart[Y] + qL.ImagPart[Y] * qR.RealPart +
+                      qL.ImagPart[Z] * qR.ImagPart[X] - qL.ImagPart[X] * qR.ImagPart[Z];
+  Temp.ImagPart[Z] := qL.RealPart * qR.ImagPart[Z] + qL.ImagPart[Z] * qR.RealPart +
+                      qL.ImagPart[X] * qR.ImagPart[Y] - qL.ImagPart[Y] * qR.ImagPart[X];
+  Result := Temp;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function QuaternionToMatrix(Q: TQuaternion): TMatrix;
+
+// Constructs rotation matrix from (possibly non-unit) quaternion.
+// Assumes matrix is used to multiply column vector on the left:
+// vnew = mat vold.  Works correctly for right-handed coordinate system
+// and right-handed rotations.
+
+// Essentially, this function is the same as CreateRotationMatrix and you can consider it as
+// being for reference here.
+
+{var Norm, S,
+    XS, YS, ZS,
+    WX, WY, WZ,
+    XX, XY, XZ,
+    YY, YZ, ZZ   : Single;
+
+begin
+  Norm := Q.Vector[X] * Q.Vector[X] + Q.Vector[Y] * Q.Vector[Y] + Q.Vector[Z] * Q.Vector[Z] + Q.RealPart * Q.RealPart;
+  if Norm > 0 then S := 2 / Norm
+              else S := 0;
+
+  XS := Q.Vector[X] * S;   YS := Q.Vector[Y] * S;   ZS := Q.Vector[Z] * S;
+  WX := Q.RealPart * XS;   WY := Q.RealPart * YS;   WZ := Q.RealPart * ZS;
+  XX := Q.Vector[X] * XS;  XY := Q.Vector[X] * YS;  XZ := Q.Vector[X] * ZS;
+  YY := Q.Vector[Y] * YS;  YZ := Q.Vector[Y] * ZS;  ZZ := Q.Vector[Z] * ZS;
+
+  Result[X, X] := 1 - (YY + ZZ); Result[Y, X] := XY + WZ;       Result[Z, X] := XZ - WY;       Result[W, X] := 0;
+  Result[X, Y] := XY - WZ;       Result[Y, Y] := 1 - (XX + ZZ); Result[Z, Y] := YZ + WX;       Result[W, Y] := 0;
+  Result[X, Z] := XZ + WY;       Result[Y, Z] := YZ - WX;       Result[Z, Z] := 1 - (XX + YY); Result[W, Z] := 0;
+  Result[X, W] := 0;             Result[Y, W] := 0;             Result[Z, W] := 0;             Result[W, W] := 1;}
+
+var
+  V: TAffineVector;
+  SinA, CosA,
+  A, B, C: Extended;
+
+begin
+  V := Q.ImagPart;
+  VectorNormalize(V);
+  SinCos(Q.RealPart / 2, SinA, CosA);
+  A := V[X] * SinA;
+  B := V[Y] * SinA;
+  C := V[Z] * SinA;
+
+  Result := IdentityMatrix;
+  Result[X, X] := 1 - 2 * B * B - 2 * C * C;
+  Result[X, Y] := 2 * A * B - 2 * CosA * C;
+  Result[X, Z] := 2 * A * C + 2 * CosA * B;
+
+  Result[Y, X] := 2 * A * B + 2 * CosA * C;
+  Result[Y, Y] := 1 - 2 * A * A - 2 * C * C;
+  Result[Y, Z] := 2 * B * C - 2 * CosA * A;
+
+  Result[Z, X] := 2 * A * C - 2 * CosA * B;
+  Result[Z, Y] := 2 * B * C + 2 * CosA * A;
+  Result[Z, Z] := 1 - 2 * A * A - 2 * B * B;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure QuaternionToPoints(Q: TQuaternion; var ArcFrom, ArcTo: TAffineVector); register;
+
+// converts a unit quaternion into two points on a unit sphere
+
+var S: Single;
+
+begin
+  S := Sqrt(Q.ImagPart[X] * Q.ImagPart[X] + Q.ImagPart[Y] * Q.ImagPart[Y]);
+  if S = 0 then ArcFrom := MakeAffineVector([0, 1, 0])
+           else ArcFrom := MakeAffineVector([-Q.ImagPart[Y] / S, Q.ImagPart[X] / S, 0]);
+  ArcTo[X] := Q.RealPart * ArcFrom[X] - Q.ImagPart[Z] * ArcFrom[Y];
+  ArcTo[Y] := Q.RealPart * ArcFrom[Y] + Q.ImagPart[Z] * ArcFrom[X];
+  ArcTo[Z] := Q.ImagPart[X] * ArcFrom[Y] - Q.ImagPart[Y] * ArcFrom[X];
+  if Q.RealPart < 0 then ArcFrom := MakeAffineVector([-ArcFrom[X], -ArcFrom[Y], 0]);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function MatrixAffineDeterminant(M: TAffineMatrix): Single; register;
+
+// determinant of a 3x3 matrix
+
+begin
+  Result := M[X, X] * (M[Y, Y] * M[Z, Z] - M[Z, Y] * M[Y, Z]) -
+            M[X, Y] * (M[Y, X] * M[Z, Z] - M[Z, X] * M[Y, Z]) +
+            M[X, Z] * (M[Y, X] * M[Z, Y] - M[Z, X] * M[Y, Y]);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function MatrixDetInternal(a1, a2, a3, b1, b2, b3, c1, c2, c3: Single): Single;
+
+// internal version for the determinant of a 3x3 matrix
+
+begin
+  Result := a1 * (b2 * c3 - b3 * c2) -
+            b1 * (a2 * c3 - a3 * c2) +
+            c1 * (a2 * b3 - a3 * b2);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure MatrixAdjoint(var M: TMatrix); register;
+
+// Adjoint of a 4x4 matrix - used in the computation of the inverse
+// of a 4x4 matrix
+
+var a1, a2, a3, a4,
+    b1, b2, b3, b4,
+    c1, c2, c3, c4,
+    d1, d2, d3, d4: Single;
+
+
+begin
+    a1 :=  M[X, X]; b1 :=  M[X, Y];
+    c1 :=  M[X, Z]; d1 :=  M[X, W];
+    a2 :=  M[Y, X]; b2 :=  M[Y, Y];
+    c2 :=  M[Y, Z]; d2 :=  M[Y, W];
+    a3 :=  M[Z, X]; b3 :=  M[Z, Y];
+    c3 :=  M[Z, Z]; d3 :=  M[Z, W];
+    a4 :=  M[W, X]; b4 :=  M[W, Y];
+    c4 :=  M[W, Z]; d4 :=  M[W, W];
+
+    // row column labeling reversed since we transpose rows & columns
+    M[X, X] :=  MatrixDetInternal(b2, b3, b4, c2, c3, c4, d2, d3, d4);
+    M[Y, X] := -MatrixDetInternal(a2, a3, a4, c2, c3, c4, d2, d3, d4);
+    M[Z, X] :=  MatrixDetInternal(a2, a3, a4, b2, b3, b4, d2, d3, d4);
+    M[W, X] := -MatrixDetInternal(a2, a3, a4, b2, b3, b4, c2, c3, c4);
+
+    M[X, Y] := -MatrixDetInternal(b1, b3, b4, c1, c3, c4, d1, d3, d4);
+    M[Y, Y] :=  MatrixDetInternal(a1, a3, a4, c1, c3, c4, d1, d3, d4);
+    M[Z, Y] := -MatrixDetInternal(a1, a3, a4, b1, b3, b4, d1, d3, d4);
+    M[W, Y] :=  MatrixDetInternal(a1, a3, a4, b1, b3, b4, c1, c3, c4);
+
+    M[X, Z] :=  MatrixDetInternal(b1, b2, b4, c1, c2, c4, d1, d2, d4);
+    M[Y, Z] := -MatrixDetInternal(a1, a2, a4, c1, c2, c4, d1, d2, d4);
+    M[Z, Z] :=  MatrixDetInternal(a1, a2, a4, b1, b2, b4, d1, d2, d4);
+    M[W, Z] := -MatrixDetInternal(a1, a2, a4, b1, b2, b4, c1, c2, c4);
+
+    M[X, W] := -MatrixDetInternal(b1, b2, b3, c1, c2, c3, d1, d2, d3);
+    M[Y, W] :=  MatrixDetInternal(a1, a2, a3, c1, c2, c3, d1, d2, d3);
+    M[Z, W] := -MatrixDetInternal(a1, a2, a3, b1, b2, b3, d1, d2, d3);
+    M[W, W] :=  MatrixDetInternal(a1, a2, a3, b1, b2, b3, c1, c2, c3);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function MatrixDeterminant(M: TMatrix): Single; register;
+
+// Determinant of a 4x4 matrix
+
+var a1, a2, a3, a4,
+    b1, b2, b3, b4,
+    c1, c2, c3, c4,
+    d1, d2, d3, d4  : Single;
+
+begin
+  a1 := M[X, X];  b1 := M[X, Y];  c1 := M[X, Z];  d1 := M[X, W];
+  a2 := M[Y, X];  b2 := M[Y, Y];  c2 := M[Y, Z];  d2 := M[Y, W];
+  a3 := M[Z, X];  b3 := M[Z, Y];  c3 := M[Z, Z];  d3 := M[Z, W];
+  a4 := M[W, X];  b4 := M[W, Y];  c4 := M[W, Z];  d4 := M[W, W];
+
+  Result := a1 * MatrixDetInternal(b2, b3, b4, c2, c3, c4, d2, d3, d4) -
+            b1 * MatrixDetInternal(a2, a3, a4, c2, c3, c4, d2, d3, d4) +
+            c1 * MatrixDetInternal(a2, a3, a4, b2, b3, b4, d2, d3, d4) -
+            d1 * MatrixDetInternal(a2, a3, a4, b2, b3, b4, c2, c3, c4);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure MatrixScale(var M: TMatrix; Factor: Single); register;
+
+// multiplies all elements of a 4x4 matrix with a factor
+
+var I, J: Integer;
+
+begin
+  for I := 0 to 3 do
+    for J := 0 to 3 do M[I, J] := M[I, J] * Factor;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure MatrixInvert(var M: TMatrix); register;
+
+// finds the inverse of a 4x4 matrix
+
+var Det: Single;
+
+begin
+  Det := MatrixDeterminant(M);
+  if Abs(Det) < EPSILON then M := IdentityMatrix
+                        else
+  begin
+    MatrixAdjoint(M);
+    MatrixScale(M, 1 / Det);
+  end;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure MatrixTranspose(var M: TMatrix); register;
+
+// computes transpose of 4x4 matrix
+
+var I, J: Integer;
+    TM: TMatrix;
+
+begin
+  for I := 0 to 3 do
+    for J := 0 to 3 do TM[J, I] := M[I, J];
+  M := TM;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure MatrixAffineTranspose(var M: TAffineMatrix); register;
+
+// computes transpose of 3x3 matrix
+
+var I, J: Integer;
+    TM: TAffineMatrix;
+
+begin
+  for I := 0 to 2 do
+    for J := 0 to 2 do TM[J, I] := M[I, J];
+  M := TM;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function MatrixMultiply(M1, M2: TMatrix): TMatrix; register;
+
+// multiplies two 4x4 matrices
+
+var I, J: Integer;
+    TM: TMatrix;
+
+begin
+  for I := 0 to 3 do
+    for J := 0 to 3 do
+      TM[I, J] := M1[I, X] * M2[X, J] +
+                  M1[I, Y] * M2[Y, J] +
+                  M1[I, Z] * M2[Z, J] +
+                  M1[I, W] * M2[W, J];
+  Result := TM;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function CreateRotationMatrix(Axis: TVector3f; Angle: Single): TMatrix; register;
+
+// Creates a rotation matrix along the given Axis by the given Angle in radians.
+
+var cosine,
+    sine,
+    Len,
+    one_minus_cosine: Extended;
+
+begin
+  SinCos(Angle, Sine, Cosine);
+  one_minus_cosine := 1 - cosine;
+  Len := VectorNormalize(Axis);
+
+  if Len = 0 then Result := IdentityMatrix
+             else
+  begin
+    Result[X, X] := (one_minus_cosine * Sqr(Axis[0])) + Cosine;
+    Result[X, Y] := (one_minus_cosine * Axis[0] * Axis[1]) - (Axis[2] * Sine);
+    Result[X, Z] := (one_minus_cosine * Axis[2] * Axis[0]) + (Axis[1] * Sine);
+    Result[X, W] := 0;
+
+    Result[Y, X] := (one_minus_cosine * Axis[0] * Axis[1]) + (Axis[2] * Sine);
+    Result[Y, Y] := (one_minus_cosine * Sqr(Axis[1])) + Cosine;
+    Result[Y, Z] := (one_minus_cosine * Axis[1] * Axis[2]) - (Axis[0] * Sine);
+    Result[Y, W] := 0;
+
+    Result[Z, X] := (one_minus_cosine * Axis[2] * Axis[0]) - (Axis[1] * Sine);
+    Result[Z, Y] := (one_minus_cosine * Axis[1] * Axis[2]) + (Axis[0] * Sine);
+    Result[Z, Z] := (one_minus_cosine * Sqr(Axis[2])) + Cosine;
+    Result[Z, W] := 0;
+
+    Result[W, X] := 0;
+    Result[W, Y] := 0;
+    Result[W, Z] := 0;
+    Result[W, W] := 1;
+  end;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function ConvertRotation(Angles: TAffineVector): TVector; register;
+
+{ Turn a triplet of rotations about x, y, and z (in that order) into an
+   equivalent rotation around a single axis (all in radians).
+
+   Rotation of the Angle t about the axis (X, Y, Z) is given by:
+
+     | X^2 + (1-X^2) Cos(t),    XY(1-Cos(t))  +  Z Sin(t), XZ(1-Cos(t))-Y Sin(t) |
+ M = | XY(1-Cos(t))-Z Sin(t), Y^2 + (1-Y^2) Cos(t),      YZ(1-Cos(t)) + X Sin(t) |
+     | XZ(1-Cos(t)) + Y Sin(t), YZ(1-Cos(t))-X Sin(t),   Z^2 + (1-Z^2) Cos(t)    |
+
+   Rotation about the three axes (Angles a1, a2, a3) can be represented as
+   the product of the individual rotation matrices:
+
+      | 1  0       0       | | Cos(a2) 0 -Sin(a2) | |  Cos(a3) Sin(a3) 0 |
+      | 0  Cos(a1) Sin(a1) | * | 0       1  0       | * | -Sin(a3) Cos(a3) 0 |
+      | 0 -Sin(a1) Cos(a1) | | Sin(a2) 0  Cos(a2) | |  0       0       1 |
+	     Mx                       My                     Mz
+
+   We now want to solve for X, Y, Z, and t given 9 equations in 4 unknowns.
+   Using the diagonal elements of the two matrices, we get:
+
+      X^2 + (1-X^2) Cos(t) = M[0][0]
+      Y^2 + (1-Y^2) Cos(t) = M[1][1]
+      Z^2 + (1-Z^2) Cos(t) = M[2][2]
+
+   Adding the three equations, we get:
+
+      X^2  +  Y^2  +  Z^2 - (M[0][0]  +  M[1][1]  +  M[2][2]) =
+	 - (3 - X^2 - Y^2 - Z^2) Cos(t)
+
+   Since (X^2  +  Y^2  +  Z^2) = 1, we can rewrite as:
+
+      Cos(t) = (1 - (M[0][0]  +  M[1][1]  +  M[2][2])) / 2
+
+   Solving for t, we get:
+
+      t = Acos(((M[0][0]  +  M[1][1]  +  M[2][2]) - 1) / 2)
+
+    We can substitute t into the equations for X^2, Y^2, and Z^2 above
+    to get the values for X, Y, and Z.  To find the proper signs we note
+    that:
+
+	2 X Sin(t) = M[1][2] - M[2][1]
+	2 Y Sin(t) = M[2][0] - M[0][2]
+	2 Z Sin(t) = M[0][1] - M[1][0]
+}
+
+var Axis1, Axis2: TVector3f;
+    M, M1, M2: TMatrix;
+    cost, cost1,
+    sint,
+    s1, s2, s3: Single;
+    I: Integer;
+
+
+begin
+  // see if we are only rotating about a single Axis
+  if Abs(Angles[X]) < EPSILON then
+  begin
+    if Abs(Angles[Y]) < EPSILON then
+    begin
+      Result := MakeVector([0, 0, 1, Angles[Z]]);
+      Exit;
+    end
+    else
+      if Abs(Angles[Z]) < EPSILON then
+      begin
+        Result := MakeVector([0, 1, 0, Angles[Y]]);
+        Exit;
+      end
+   end
+   else
+     if (Abs(Angles[Y]) < EPSILON) and
+        (Abs(Angles[Z]) < EPSILON) then
+     begin
+       Result := MakeVector([1, 0, 0, Angles[X]]);
+       Exit;
+     end;
+
+  // make the rotation matrix
+  Axis1 := MakeAffineVector([1, 0, 0]);
+  M := CreateRotationMatrix(Axis1, Angles[X]);
+
+  Axis2 := MakeAffineVector([0, 1, 0]);
+  M2 := CreateRotationMatrix(Axis2, Angles[Y]);
+  M1 := MatrixMultiply(M, M2);
+
+  Axis2 := MakeAffineVector([0, 0, 1]);
+  M2 := CreateRotationMatrix(Axis2, Angles[Z]);
+  M := MatrixMultiply(M1, M2);
+
+  cost := ((M[X, X] + M[Y, Y] + M[Z, Z])-1) / 2;
+  if cost < -1 then cost := -1
+               else
+    if cost > 1 - EPSILON then
+    begin
+      // Bad Angle - this would cause a crash
+      Result := MakeVector([1, 0, 0, 0]);
+      Exit;
+    end;
+
+  cost1 := 1 - cost;
+  Result := Makevector([Sqrt((M[X, X]-cost) / cost1),
+                      Sqrt((M[Y, Y]-cost) / cost1),
+                      sqrt((M[Z, Z]-cost) / cost1),
+                      arccos(cost)]);
+
+  sint := 2 * Sqrt(1 - cost * cost); // This is actually 2 Sin(t)
+
+  // Determine the proper signs
+  for I := 0 to 7 do
+  begin
+    if (I and 1) > 1 then s1 := -1 else s1 := 1;
+    if (I and 2) > 1 then s2 := -1 else s2 := 1;
+    if (I and 4) > 1 then s3 := -1 else s3 := 1;
+    if (Abs(s1 * Result[X] * sint-M[Y, Z] + M[Z, Y]) < EPSILON2) and
+       (Abs(s2 * Result[Y] * sint-M[Z, X] + M[X, Z]) < EPSILON2) and
+       (Abs(s3 * Result[Z] * sint-M[X, Y] + M[Y, X]) < EPSILON2) then
+        begin
+          // We found the right combination of signs
+          Result[X] := Result[X] * s1;
+          Result[Y] := Result[Y] * s2;
+          Result[Z] := Result[Z] * s3;
+          Exit;
+        end;
+  end;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function CreateRotationMatrixX(Sine, Cosine: Single): TMatrix; register;
+
+// creates matrix for rotation about x-axis
+
+begin
+  Result := EmptyMatrix;
+  Result[X, X] := 1;
+  Result[Y, Y] := Cosine;
+  Result[Y, Z] := Sine;
+  Result[Z, Y] := -Sine;
+  Result[Z, Z] := Cosine;
+  Result[W, W] := 1;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function CreateRotationMatrixY(Sine, Cosine: Single): TMatrix; register;
+
+// creates matrix for rotation about y-axis
+
+begin
+  Result := EmptyMatrix;
+  Result[X, X] := Cosine;
+  Result[X, Z] := -Sine;
+  Result[Y, Y] := 1;
+  Result[Z, X] := Sine;
+  Result[Z, Z] := Cosine;
+  Result[W, W] := 1;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function CreateRotationMatrixZ(Sine, Cosine: Single): TMatrix; register;
+
+// creates matrix for rotation about z-axis
+
+begin
+  Result := EmptyMatrix;
+  Result[X, X] := Cosine;
+  Result[X, Y] := Sine;
+  Result[Y, X] := -Sine;
+  Result[Y, Y] := Cosine;
+  Result[Z, Z] := 1;
+  Result[W, W] := 1;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function CreateScaleMatrix(V: TAffineVector): TMatrix; register;
+
+// creates scaling matrix
+
+begin
+  Result := IdentityMatrix;
+  Result[X, X] := V[X];
+  Result[Y, Y] := V[Y];
+  Result[Z, Z] := V[Z];
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function CreateTranslationMatrix(V: TVector): TMatrix; register;
+
+// creates translation matrix
+
+begin
+  Result := IdentityMatrix;
+  Result[W, X] := V[X];
+  Result[W, Y] := V[Y];
+  Result[W, Z] := V[Z];
+  Result[W, W] := V[W];
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function Lerp(Start, Stop, t: Single): Single;
+
+// calculates linear interpolation between start and stop at point t
+
+begin
+  Result := Start + (Stop - Start) * t;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorAffineLerp(V1, V2: TAffineVector; t: Single): TAffineVector;
+
+// calculates linear interpolation between vector1 and vector2 at point t
+
+begin
+  Result[X] := Lerp(V1[X], V2[X], t);
+  Result[Y] := Lerp(V1[Y], V2[Y], t);
+  Result[Z] := Lerp(V1[Z], V2[Z], t);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorLerp(V1, V2: TVector; t: Single): TVector;
+
+// calculates linear interpolation between vector1 and vector2 at point t
+
+begin
+  Result[X] := Lerp(V1[X], V2[X], t);
+  Result[Y] := Lerp(V1[Y], V2[Y], t);
+  Result[Z] := Lerp(V1[Z], V2[Z], t);
+  Result[W] := Lerp(V1[W], V2[W], t);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function QuaternionSlerp(QStart, QEnd: TQuaternion; Spin: Integer; t: Single): TQuaternion;
+
+// spherical linear interpolation of unit quaternions with spins
+// QStart, QEnd - start and end unit quaternions
+// t            - interpolation parameter (0 to 1)
+// Spin         - number of extra spin rotations to involve
+
+var beta,                   // complementary interp parameter
+    theta,                  // Angle between A and B
+    sint, cost,             // sine, cosine of theta
+    phi: Single;            // theta plus spins
+    bflip: Boolean;         // use negativ t?
+
+
+begin
+  // cosine theta
+  cost := VectorAngle(QStart.ImagPart, QEnd.ImagPart);
+
+  // if QEnd is on opposite hemisphere from QStart, use -QEnd instead
+  if cost < 0 then
+  begin
+    cost := -cost;
+    bflip := True;
+  end
+  else bflip := False;
+
+  // if QEnd is (within precision limits) the same as QStart,
+  // just linear interpolate between QStart and QEnd.
+  // Can't do spins, since we don't know what direction to spin.
+
+  if (1 - cost) < EPSILON then beta := 1 - t
+                          else
+  begin
+    // normal case
+    theta := arccos(cost);
+    phi := theta + Spin * Pi;
+    sint := sin(theta);
+    beta := sin(theta - t * phi) / sint;
+    t := sin(t * phi) / sint;
+  end;
+
+  if bflip then t := -t;
+
+  // interpolate
+  Result.ImagPart[X] := beta * QStart.ImagPart[X] + t * QEnd.ImagPart[X];
+  Result.ImagPart[Y] := beta * QStart.ImagPart[Y] + t * QEnd.ImagPart[Y];
+  Result.ImagPart[Z] := beta * QStart.ImagPart[Z] + t * QEnd.ImagPart[Z];
+  Result.RealPart := beta * QStart.RealPart + t * QEnd.RealPart;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorAffineCombine(V1, V2: TAffineVector; F1, F2: Single): TAffineVector;
+
+// makes a linear combination of two vectors and return the result
+
+begin
+  Result[X] := (F1 * V1[X]) + (F2 * V2[X]);
+  Result[Y] := (F1 * V1[Y]) + (F2 * V2[Y]);
+  Result[Z] := (F1 * V1[Z]) + (F2 * V2[Z]);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorCombine(V1, V2: TVector; F1, F2: Single): TVector;
+
+// makes a linear combination of two vectors and return the result
+
+begin
+  Result[X] := (F1 * V1[X]) + (F2 * V2[X]);
+  Result[Y] := (F1 * V1[Y]) + (F2 * V2[Y]);
+  Result[Z] := (F1 * V1[Z]) + (F2 * V2[Z]);
+  Result[W] := (F1 * V1[W]) + (F2 * V2[W]);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function MatrixDecompose(M: TMatrix; var Tran: TTransformations): Boolean; register;
+
+// Author: Spencer W. Thomas, University of Michigan
+//
+// MatrixDecompose - Decompose a non-degenerated 4x4 transformation matrix into
+// the sequence of transformations that produced it.
+//
+// The coefficient of each transformation is returned in the corresponding
+// element of the vector Tran.
+//
+// Returns true upon success, false if the matrix is singular.
+
+var I, J: Integer;
+    LocMat,
+    pmat,
+    invpmat,
+    tinvpmat: TMatrix;
+    prhs,
+    psol: TVector;
+    Row: array[0..2] of TAffineVector;
+
+begin
+  Result := False;
+  locmat := M;
+  // normalize the matrix
+  if locmat[W, W] = 0 then Exit;
+  for I := 0 to 3 do
+    for J := 0 to 3 do
+      locmat[I, J] := locmat[I, J] / locmat[W, W];
+
+  // pmat is used to solve for perspective, but it also provides
+  // an easy way to test for singularity of the upper 3x3 component.
+
+  pmat := locmat;
+  for I := 0 to 2 do pmat[I, W] := 0;
+  pmat[W, W] := 1;
+
+  if MatrixDeterminant(pmat) = 0 then Exit;
+
+  // First, isolate perspective.  This is the messiest.
+  if (locmat[X, W] <> 0) or
+     (locmat[Y, W] <> 0) or
+     (locmat[Z, W] <> 0) then
+  begin
+    // prhs is the right hand side of the equation.
+    prhs[X] := locmat[X, W];
+    prhs[Y] := locmat[Y, W];
+    prhs[Z] := locmat[Z, W];
+    prhs[W] := locmat[W, W];
+
+    // Solve the equation by inverting pmat and multiplying
+    // prhs by the inverse.  (This is the easiest way, not
+    // necessarily the best.)
+
+    invpmat := pmat;
+    MatrixInvert(invpmat);
+    MatrixTranspose(invpmat);
+    psol := VectorTransform(prhs, tinvpmat);
+
+    // stuff the answer away
+    Tran[ttPerspectiveX] := psol[X];
+    Tran[ttPerspectiveY] := psol[Y];
+    Tran[ttPerspectiveZ] := psol[Z];
+    Tran[ttPerspectiveW] := psol[W];
+
+    // clear the perspective partition
+    locmat[X, W] := 0;
+    locmat[Y, W] := 0;
+    locmat[Z, W] := 0;
+    locmat[W, W] := 1;
+  end
+  else
+  begin
+    // no perspective
+    Tran[ttPerspectiveX] := 0;
+    Tran[ttPerspectiveY] := 0;
+    Tran[ttPerspectiveZ] := 0;
+    Tran[ttPerspectiveW] := 0;
+  end;
+
+  // next take care of translation (easy)
+  for I := 0 to 2 do
+  begin
+    Tran[TTransType(Ord(ttTranslateX) + I)] := locmat[W, I];
+    locmat[W, I] := 0;
+  end;
+
+  // now get scale and shear
+  for I := 0 to 2 do
+  begin
+    row[I, X] := locmat[I, X];
+    row[I, Y] := locmat[I, Y];
+    row[I, Z] := locmat[I, Z];
+  end;
+
+  // compute X scale factor and normalize first row
+  Tran[ttScaleX] := Sqr(VectorNormalize(row[0])); // ml: calculation optimized
+
+  // compute XY shear factor and make 2nd row orthogonal to 1st
+  Tran[ttShearXY] := VectorAffineDotProduct(row[0], row[1]);
+  row[1] := VectorAffineCombine(row[1], row[0], 1, -Tran[ttShearXY]);
+
+  // now, compute Y scale and normalize 2nd row
+  Tran[ttScaleY] := Sqr(VectorNormalize(row[1])); // ml: calculation optimized
+  Tran[ttShearXY] := Tran[ttShearXY]/Tran[ttScaleY];
+
+  // compute XZ and YZ shears, orthogonalize 3rd row
+  Tran[ttShearXZ] := VectorAffineDotProduct(row[0], row[2]);
+  row[2] := VectorAffineCombine(row[2], row[0], 1, -Tran[ttShearXZ]);
+  Tran[ttShearYZ] := VectorAffineDotProduct(row[1], row[2]);
+  row[2] := VectorAffineCombine(row[2], row[1], 1, -Tran[ttShearYZ]);
+
+  // next, get Z scale and normalize 3rd row
+  Tran[ttScaleZ] := Sqr(VectorNormalize(row[1])); // (ML) calc. optimized
+  Tran[ttShearXZ] := Tran[ttShearXZ] / tran[ttScaleZ];
+  Tran[ttShearYZ] := Tran[ttShearYZ] / Tran[ttScaleZ];
+
+  // At this point, the matrix (in rows[]) is orthonormal.
+  // Check for a coordinate system flip.  If the determinant
+  // is -1, then negate the matrix and the scaling factors.
+  if VectorAffineDotProduct(row[0], VectorCrossProduct(row[1], row[2])) < 0 then
+    for I := 0 to 2 do
+    begin
+      Tran[TTransType(Ord(ttScaleX) + I)] := -Tran[TTransType(Ord(ttScaleX) + I)];
+      row[I, X] := -row[I, X];
+      row[I, Y] := -row[I, Y];
+      row[I, Z] := -row[I, Z];
+    end;
+
+  // now, get the rotations out, as described in the gem
+  Tran[ttRotateY] := arcsin(-row[0, Z]);
+  if cos(Tran[ttRotateY]) <> 0 then
+  begin
+    Tran[ttRotateX] := arctan2(row[1, Z], row[2, Z]);
+    Tran[ttRotateZ] := arctan2(row[0, Y], row[0, X]);
+  end
+  else
+  begin
+    tran[ttRotateX] := arctan2(row[1, X], row[1, Y]);
+    tran[ttRotateZ] := 0;
+  end;
+  // All done!
+  Result := True;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorDblToFlt(V: THomogeneousDblVector): THomogeneousVector; assembler;
+
+// converts a vector containing double sized values into a vector with single sized values
+
+asm
+              FLD  QWORD PTR [EAX]
+              FSTP DWORD PTR [EDX]
+              FLD  QWORD PTR [EAX + 8]
+              FSTP DWORD PTR [EDX + 4]
+              FLD  QWORD PTR [EAX + 16]
+              FSTP DWORD PTR [EDX + 8]
+              FLD  QWORD PTR [EAX + 24]
+              FSTP DWORD PTR [EDX + 12]
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorAffineDblToFlt(V: TAffineDblVector): TAffineVector; assembler;
+
+// converts a vector containing double sized values into a vector with single sized values
+
+asm
+              FLD  QWORD PTR [EAX]
+              FSTP DWORD PTR [EDX]
+              FLD  QWORD PTR [EAX + 8]
+              FSTP DWORD PTR [EDX + 4]
+              FLD  QWORD PTR [EAX + 16]
+              FSTP DWORD PTR [EDX + 8]
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorAffineFltToDbl(V: TAffineVector): TAffineDblVector; assembler;
+
+// converts a vector containing single sized values into a vector with double sized values
+
+asm
+              FLD  DWORD PTR [EAX]
+              FSTP QWORD PTR [EDX]
+              FLD  DWORD PTR [EAX + 8]
+              FSTP QWORD PTR [EDX + 4]
+              FLD  DWORD PTR [EAX + 16]
+              FSTP QWORD PTR [EDX + 8]
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function VectorFltToDbl(V: TVector): THomogeneousDblVector; assembler;
+
+// converts a vector containing single sized values into a vector with double sized values
+
+asm
+              FLD  DWORD PTR [EAX]
+              FSTP QWORD PTR [EDX]
+              FLD  DWORD PTR [EAX + 8]
+              FSTP QWORD PTR [EDX + 4]
+              FLD  DWORD PTR [EAX + 16]
+              FSTP QWORD PTR [EDX + 8]
+              FLD  DWORD PTR [EAX + 24]
+              FSTP QWORD PTR [EDX + 12]
+end;
+
+//----------------- coordinate system manipulation functions -----------------------------------------------------------
+
+function Turn(Matrix: TMatrix; Angle: Single): TMatrix;
+
+// rotates the given coordinate system (represented by the matrix) around its Y-axis
+
+begin
+  Result := MatrixMultiply(Matrix, CreateRotationMatrix(MakeAffineVector(Matrix[1]), Angle));
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function Turn(Matrix: TMatrix; MasterUp: TAffineVector; Angle: Single): TMatrix;
+
+// rotates the given coordinate system (represented by the matrix) around MasterUp
+
+begin
+  Result := MatrixMultiply(Matrix, CreateRotationMatrix(MasterUp, Angle));
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function Pitch(Matrix: TMatrix; Angle: Single): TMatrix;
+
+// rotates the given coordinate system (represented by the matrix) around its X-axis
+
+begin
+  Result := MatrixMultiply(Matrix, CreateRotationMatrix(MakeAffineVector(Matrix[0]), Angle));
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function Pitch(Matrix: TMatrix; MasterRight: TAffineVector; Angle: Single): TMatrix; overload;
+
+// rotates the given coordinate system (represented by the matrix) around MasterRight
+
+begin
+  Result := MatrixMultiply(Matrix, CreateRotationMatrix(MasterRight, Angle));
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function Roll(Matrix: TMatrix; Angle: Single): TMatrix;
+
+// rotates the given coordinate system (represented by the matrix) around its Z-axis
+
+begin
+  Result := MatrixMultiply(Matrix, CreateRotationMatrix(MakeAffineVector(Matrix[2]), Angle));
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function Roll(Matrix: TMatrix; MasterDirection: TAffineVector; Angle: Single): TMatrix; overload;
+
+// rotates the given coordinate system (represented by the matrix) around MasterDirection
+
+begin
+  Result := MatrixMultiply(Matrix, CreateRotationMatrix(MasterDirection, Angle));
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+end.
+
+
diff --git a/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/gl.pas b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/gl.pas
new file mode 100644
index 00000000..aa0dd169
--- /dev/null
+++ b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/gl.pas
@@ -0,0 +1,2294 @@
+unit gl;
+{
+  $Id: gl.pas,v 1.2 2004/08/14 22:54:30 savage Exp $
+
+  Adaption of the delphi3d.net OpenGL units to FreePascal
+  Sebastian Guenther (sg@freepascal.org) in 2002
+  These units are free to use
+}
+
+(*++ BUILD Version: 0004    // Increment this if a change has global effects
+
+Copyright (c) 1985-96, Microsoft Corporation
+
+Module Name:
+
+    gl.h
+
+Abstract:
+
+    Procedure declarations, constant definitions and macros for the OpenGL
+    component.
+
+--*)
+
+(*
+** Copyright 1996 Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
+** the contents of this file may not be disclosed to third parties, copied or
+** duplicated in any form, in whole or in part, without the prior written
+** permission of Silicon Graphics, Inc.
+**
+** RESTRICTED RIGHTS LEGEND:
+** Use, duplication or disclosure by the Government is subject to restrictions
+** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
+** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
+** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
+** rights reserved under the Copyright Laws of the United States.
+*)
+
+{******************************************************************************}
+{                                                                              }
+{ Converted to Delphi by Tom Nuydens (tom@delphi3d.net)                        }
+{ For the latest updates, visit Delphi3D: http://www.delphi3d.net              }
+{                                                                              }
+{ Modified for Delphi/Kylix and FreePascal                                     }
+{    by Dominique Louis ( Dominique@Savagesoftware.com.au)                     }
+{ For the latest updates, visit JEDI-SDL : http://www.sf.net/projects/jedi-sdl }
+{                                                                              }
+{******************************************************************************}
+
+{
+  $Log: gl.pas,v $
+  Revision 1.2  2004/08/14 22:54:30  savage
+  Updated so that Library name defines are correctly defined for MacOS X.
+
+  Revision 1.1  2004/03/30 21:53:54  savage
+  Moved to it's own folder.
+
+  Revision 1.4  2004/02/20 17:09:55  savage
+  Code tidied up in gl, glu and glut, while extensions in glext.pas are now loaded using SDL_GL_GetProcAddress, thus making it more cross-platform compatible, but now more tied to SDL.
+
+  Revision 1.3  2004/02/14 00:23:39  savage
+  As UNIX is defined in jedi-sdl.inc this will be used to check linux compatability as well. Units have been changed to reflect this change.
+
+  Revision 1.2  2004/02/14 00:09:18  savage
+  Changed uses to now make use of moduleloader.pas rather than dllfuncs.pas
+
+  Revision 1.1  2004/02/05 00:08:19  savage
+  Module 1.0 release
+
+  Revision 1.6  2003/06/02 12:32:12  savage
+  Modified Sources to avoid warnings with Delphi by moving CVS Logging to the top of the header files. Hopefully CVS Logging still works.
+
+}
+
+interface
+
+{$I jedi-sdl.inc}
+
+uses
+{$IFDEF __GPC__}
+  system,
+  gpc,
+{$ENDIF}
+
+{$IFDEF WIN32}
+  Windows,
+{$ENDIF}
+  moduleloader;
+
+
+var
+  LibGL: TModuleHandle;
+
+type
+  GLenum     = Cardinal;      PGLenum     = ^GLenum;
+  GLboolean  = Byte;          PGLboolean  = ^GLboolean;
+  GLbitfield = Cardinal;      PGLbitfield = ^GLbitfield;
+  GLbyte     = ShortInt;      PGLbyte     = ^GLbyte;
+  GLshort    = SmallInt;      PGLshort    = ^GLshort;
+  GLint      = Integer;       PGLint      = ^GLint;
+  GLsizei    = Integer;       PGLsizei    = ^GLsizei;
+  GLubyte    = Byte;          PGLubyte    = ^GLubyte;
+  GLushort   = Word;          PGLushort   = ^GLushort;
+  GLuint     = Cardinal;      PGLuint     = ^GLuint;
+  GLfloat    = Single;        PGLfloat    = ^GLfloat;
+  GLclampf   = Single;        PGLclampf   = ^GLclampf;
+  GLdouble   = Double;        PGLdouble   = ^GLdouble;
+  GLclampd   = Double;        PGLclampd   = ^GLclampd;
+{ GLvoid     = void; }        PGLvoid     = Pointer;
+
+{******************************************************************************}
+
+const
+{$IFDEF WIN32}
+  GLLibName = 'OpenGL32.dll';
+{$ENDIF}
+
+{$IFDEF UNIX}
+{$IFDEF DARWIN}
+  GLLibName = 'libGL.dylib';
+{$ELSE}
+  GLLibName = 'libGL.so';
+{$ENDIF}
+{$ENDIF}
+
+  // Version
+  GL_VERSION_1_1                    = 1;
+
+  // AccumOp
+  GL_ACCUM                          = $0100;
+  GL_LOAD                           = $0101;
+  GL_RETURN                         = $0102;
+  GL_MULT                           = $0103;
+  GL_ADD                            = $0104;
+
+  // AlphaFunction
+  GL_NEVER                          = $0200;
+  GL_LESS                           = $0201;
+  GL_EQUAL                          = $0202;
+  GL_LEQUAL                         = $0203;
+  GL_GREATER                        = $0204;
+  GL_NOTEQUAL                       = $0205;
+  GL_GEQUAL                         = $0206;
+  GL_ALWAYS                         = $0207;
+
+  // AttribMask
+  GL_CURRENT_BIT                    = $00000001;
+  GL_POINT_BIT                      = $00000002;
+  GL_LINE_BIT                       = $00000004;
+  GL_POLYGON_BIT                    = $00000008;
+  GL_POLYGON_STIPPLE_BIT            = $00000010;
+  GL_PIXEL_MODE_BIT                 = $00000020;
+  GL_LIGHTING_BIT                   = $00000040;
+  GL_FOG_BIT                        = $00000080;
+  GL_DEPTH_BUFFER_BIT               = $00000100;
+  GL_ACCUM_BUFFER_BIT               = $00000200;
+  GL_STENCIL_BUFFER_BIT             = $00000400;
+  GL_VIEWPORT_BIT                   = $00000800;
+  GL_TRANSFORM_BIT                  = $00001000;
+  GL_ENABLE_BIT                     = $00002000;
+  GL_COLOR_BUFFER_BIT               = $00004000;
+  GL_HINT_BIT                       = $00008000;
+  GL_EVAL_BIT                       = $00010000;
+  GL_LIST_BIT                       = $00020000;
+  GL_TEXTURE_BIT                    = $00040000;
+  GL_SCISSOR_BIT                    = $00080000;
+  GL_ALL_ATTRIB_BITS                = $000FFFFF;
+
+  // BeginMode
+  GL_POINTS                         = $0000;
+  GL_LINES                          = $0001;
+  GL_LINE_LOOP                      = $0002;
+  GL_LINE_STRIP                     = $0003;
+  GL_TRIANGLES                      = $0004;
+  GL_TRIANGLE_STRIP                 = $0005;
+  GL_TRIANGLE_FAN                   = $0006;
+  GL_QUADS                          = $0007;
+  GL_QUAD_STRIP                     = $0008;
+  GL_POLYGON                        = $0009;
+
+  // BlendingFactorDest
+  GL_ZERO                           = 0;
+  GL_ONE                            = 1;
+  GL_SRC_COLOR                      = $0300;
+  GL_ONE_MINUS_SRC_COLOR            = $0301;
+  GL_SRC_ALPHA                      = $0302;
+  GL_ONE_MINUS_SRC_ALPHA            = $0303;
+  GL_DST_ALPHA                      = $0304;
+  GL_ONE_MINUS_DST_ALPHA            = $0305;
+
+  // BlendingFactorSrc
+  //      GL_ZERO
+  //      GL_ONE
+  GL_DST_COLOR                      = $0306;
+  GL_ONE_MINUS_DST_COLOR            = $0307;
+  GL_SRC_ALPHA_SATURATE             = $0308;
+  //      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                    = $3000;
+  GL_CLIP_PLANE1                    = $3001;
+  GL_CLIP_PLANE2                    = $3002;
+  GL_CLIP_PLANE3                    = $3003;
+  GL_CLIP_PLANE4                    = $3004;
+  GL_CLIP_PLANE5                    = $3005;
+
+  // 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                           = $1400;
+  GL_UNSIGNED_BYTE                  = $1401;
+  GL_SHORT                          = $1402;
+  GL_UNSIGNED_SHORT                 = $1403;
+  GL_INT                            = $1404;
+  GL_UNSIGNED_INT                   = $1405;
+  GL_FLOAT                          = $1406;
+  GL_2_BYTES                        = $1407;
+  GL_3_BYTES                        = $1408;
+  GL_4_BYTES                        = $1409;
+  GL_DOUBLE                         = $140A;
+
+  // DepthFunction
+  //      GL_NEVER
+  //      GL_LESS
+  //      GL_EQUAL
+  //      GL_LEQUAL
+  //      GL_GREATER
+  //      GL_NOTEQUAL
+  //      GL_GEQUAL
+  //      GL_ALWAYS
+
+  // DrawBufferMode
+  GL_NONE                           = 0;
+  GL_FRONT_LEFT                     = $0400;
+  GL_FRONT_RIGHT                    = $0401;
+  GL_BACK_LEFT                      = $0402;
+  GL_BACK_RIGHT                     = $0403;
+  GL_FRONT                          = $0404;
+  GL_BACK                           = $0405;
+  GL_LEFT                           = $0406;
+  GL_RIGHT                          = $0407;
+  GL_FRONT_AND_BACK                 = $0408;
+  GL_AUX0                           = $0409;
+  GL_AUX1                           = $040A;
+  GL_AUX2                           = $040B;
+  GL_AUX3                           = $040C;
+
+  // 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                   = $0500;
+  GL_INVALID_VALUE                  = $0501;
+  GL_INVALID_OPERATION              = $0502;
+  GL_STACK_OVERFLOW                 = $0503;
+  GL_STACK_UNDERFLOW                = $0504;
+  GL_OUT_OF_MEMORY                  = $0505;
+
+  // FeedBackMode
+  GL_2D                             = $0600;
+  GL_3D                             = $0601;
+  GL_3D_COLOR                       = $0602;
+  GL_3D_COLOR_TEXTURE               = $0603;
+  GL_4D_COLOR_TEXTURE               = $0604;
+
+  // FeedBackToken
+  GL_PASS_THROUGH_TOKEN             = $0700;
+  GL_POINT_TOKEN                    = $0701;
+  GL_LINE_TOKEN                     = $0702;
+  GL_POLYGON_TOKEN                  = $0703;
+  GL_BITMAP_TOKEN                   = $0704;
+  GL_DRAW_PIXEL_TOKEN               = $0705;
+  GL_COPY_PIXEL_TOKEN               = $0706;
+  GL_LINE_RESET_TOKEN               = $0707;
+
+  // FogMode
+  //      GL_LINEAR
+  GL_EXP                            = $0800;
+  GL_EXP2                           = $0801;
+
+  // FogParameter
+  //      GL_FOG_COLOR
+  //      GL_FOG_DENSITY
+  //      GL_FOG_END
+  //      GL_FOG_INDEX
+  //      GL_FOG_MODE
+  //      GL_FOG_START
+
+  // FrontFaceDirection
+  GL_CW                             = $0900;
+  GL_CCW                            = $0901;
+
+  // GetMapTarget
+  GL_COEFF                          = $0A00;
+  GL_ORDER                          = $0A01;
+  GL_DOMAIN                         = $0A02;
+
+  // 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                  = $0B00;
+  GL_CURRENT_INDEX                  = $0B01;
+  GL_CURRENT_NORMAL                 = $0B02;
+  GL_CURRENT_TEXTURE_COORDS         = $0B03;
+  GL_CURRENT_RASTER_COLOR           = $0B04;
+  GL_CURRENT_RASTER_INDEX           = $0B05;
+  GL_CURRENT_RASTER_TEXTURE_COORDS  = $0B06;
+  GL_CURRENT_RASTER_POSITION        = $0B07;
+  GL_CURRENT_RASTER_POSITION_VALID  = $0B08;
+  GL_CURRENT_RASTER_DISTANCE        = $0B09;
+  GL_POINT_SMOOTH                   = $0B10;
+  GL_POINT_SIZE                     = $0B11;
+  GL_POINT_SIZE_RANGE               = $0B12;
+  GL_POINT_SIZE_GRANULARITY         = $0B13;
+  GL_LINE_SMOOTH                    = $0B20;
+  GL_LINE_WIDTH                     = $0B21;
+  GL_LINE_WIDTH_RANGE               = $0B22;
+  GL_LINE_WIDTH_GRANULARITY         = $0B23;
+  GL_LINE_STIPPLE                   = $0B24;
+  GL_LINE_STIPPLE_PATTERN           = $0B25;
+  GL_LINE_STIPPLE_REPEAT            = $0B26;
+  GL_LIST_MODE                      = $0B30;
+  GL_MAX_LIST_NESTING               = $0B31;
+  GL_LIST_BASE                      = $0B32;
+  GL_LIST_INDEX                     = $0B33;
+  GL_POLYGON_MODE                   = $0B40;
+  GL_POLYGON_SMOOTH                 = $0B41;
+  GL_POLYGON_STIPPLE                = $0B42;
+  GL_EDGE_FLAG                      = $0B43;
+  GL_CULL_FACE                      = $0B44;
+  GL_CULL_FACE_MODE                 = $0B45;
+  GL_FRONT_FACE                     = $0B46;
+  GL_LIGHTING                       = $0B50;
+  GL_LIGHT_MODEL_LOCAL_VIEWER       = $0B51;
+  GL_LIGHT_MODEL_TWO_SIDE           = $0B52;
+  GL_LIGHT_MODEL_AMBIENT            = $0B53;
+  GL_SHADE_MODEL                    = $0B54;
+  GL_COLOR_MATERIAL_FACE            = $0B55;
+  GL_COLOR_MATERIAL_PARAMETER       = $0B56;
+  GL_COLOR_MATERIAL                 = $0B57;
+  GL_FOG                            = $0B60;
+  GL_FOG_INDEX                      = $0B61;
+  GL_FOG_DENSITY                    = $0B62;
+  GL_FOG_START                      = $0B63;
+  GL_FOG_END                        = $0B64;
+  GL_FOG_MODE                       = $0B65;
+  GL_FOG_COLOR                      = $0B66;
+  GL_DEPTH_RANGE                    = $0B70;
+  GL_DEPTH_TEST                     = $0B71;
+  GL_DEPTH_WRITEMASK                = $0B72;
+  GL_DEPTH_CLEAR_VALUE              = $0B73;
+  GL_DEPTH_FUNC                     = $0B74;
+  GL_ACCUM_CLEAR_VALUE              = $0B80;
+  GL_STENCIL_TEST                   = $0B90;
+  GL_STENCIL_CLEAR_VALUE            = $0B91;
+  GL_STENCIL_FUNC                   = $0B92;
+  GL_STENCIL_VALUE_MASK             = $0B93;
+  GL_STENCIL_FAIL                   = $0B94;
+  GL_STENCIL_PASS_DEPTH_FAIL        = $0B95;
+  GL_STENCIL_PASS_DEPTH_PASS        = $0B96;
+  GL_STENCIL_REF                    = $0B97;
+  GL_STENCIL_WRITEMASK              = $0B98;
+  GL_MATRIX_MODE                    = $0BA0;
+  GL_NORMALIZE                      = $0BA1;
+  GL_VIEWPORT                       = $0BA2;
+  GL_MODELVIEW_STACK_DEPTH          = $0BA3;
+  GL_PROJECTION_STACK_DEPTH         = $0BA4;
+  GL_TEXTURE_STACK_DEPTH            = $0BA5;
+  GL_MODELVIEW_MATRIX               = $0BA6;
+  GL_PROJECTION_MATRIX              = $0BA7;
+  GL_TEXTURE_MATRIX                 = $0BA8;
+  GL_ATTRIB_STACK_DEPTH             = $0BB0;
+  GL_CLIENT_ATTRIB_STACK_DEPTH      = $0BB1;
+  GL_ALPHA_TEST                     = $0BC0;
+  GL_ALPHA_TEST_FUNC                = $0BC1;
+  GL_ALPHA_TEST_REF                 = $0BC2;
+  GL_DITHER                         = $0BD0;
+  GL_BLEND_DST                      = $0BE0;
+  GL_BLEND_SRC                      = $0BE1;
+  GL_BLEND                          = $0BE2;
+  GL_LOGIC_OP_MODE                  = $0BF0;
+  GL_INDEX_LOGIC_OP                 = $0BF1;
+  GL_COLOR_LOGIC_OP                 = $0BF2;
+  GL_AUX_BUFFERS                    = $0C00;
+  GL_DRAW_BUFFER                    = $0C01;
+  GL_READ_BUFFER                    = $0C02;
+  GL_SCISSOR_BOX                    = $0C10;
+  GL_SCISSOR_TEST                   = $0C11;
+  GL_INDEX_CLEAR_VALUE              = $0C20;
+  GL_INDEX_WRITEMASK                = $0C21;
+  GL_COLOR_CLEAR_VALUE              = $0C22;
+  GL_COLOR_WRITEMASK                = $0C23;
+  GL_INDEX_MODE                     = $0C30;
+  GL_RGBA_MODE                      = $0C31;
+  GL_DOUBLEBUFFER                   = $0C32;
+  GL_STEREO                         = $0C33;
+  GL_RENDER_MODE                    = $0C40;
+  GL_PERSPECTIVE_CORRECTION_HINT    = $0C50;
+  GL_POINT_SMOOTH_HINT              = $0C51;
+  GL_LINE_SMOOTH_HINT               = $0C52;
+  GL_POLYGON_SMOOTH_HINT            = $0C53;
+  GL_FOG_HINT                       = $0C54;
+  GL_TEXTURE_GEN_S                  = $0C60;
+  GL_TEXTURE_GEN_T                  = $0C61;
+  GL_TEXTURE_GEN_R                  = $0C62;
+  GL_TEXTURE_GEN_Q                  = $0C63;
+  GL_PIXEL_MAP_I_TO_I               = $0C70;
+  GL_PIXEL_MAP_S_TO_S               = $0C71;
+  GL_PIXEL_MAP_I_TO_R               = $0C72;
+  GL_PIXEL_MAP_I_TO_G               = $0C73;
+  GL_PIXEL_MAP_I_TO_B               = $0C74;
+  GL_PIXEL_MAP_I_TO_A               = $0C75;
+  GL_PIXEL_MAP_R_TO_R               = $0C76;
+  GL_PIXEL_MAP_G_TO_G               = $0C77;
+  GL_PIXEL_MAP_B_TO_B               = $0C78;
+  GL_PIXEL_MAP_A_TO_A               = $0C79;
+  GL_PIXEL_MAP_I_TO_I_SIZE          = $0CB0;
+  GL_PIXEL_MAP_S_TO_S_SIZE          = $0CB1;
+  GL_PIXEL_MAP_I_TO_R_SIZE          = $0CB2;
+  GL_PIXEL_MAP_I_TO_G_SIZE          = $0CB3;
+  GL_PIXEL_MAP_I_TO_B_SIZE          = $0CB4;
+  GL_PIXEL_MAP_I_TO_A_SIZE          = $0CB5;
+  GL_PIXEL_MAP_R_TO_R_SIZE          = $0CB6;
+  GL_PIXEL_MAP_G_TO_G_SIZE          = $0CB7;
+  GL_PIXEL_MAP_B_TO_B_SIZE          = $0CB8;
+  GL_PIXEL_MAP_A_TO_A_SIZE          = $0CB9;
+  GL_UNPACK_SWAP_BYTES              = $0CF0;
+  GL_UNPACK_LSB_FIRST               = $0CF1;
+  GL_UNPACK_ROW_LENGTH              = $0CF2;
+  GL_UNPACK_SKIP_ROWS               = $0CF3;
+  GL_UNPACK_SKIP_PIXELS             = $0CF4;
+  GL_UNPACK_ALIGNMENT               = $0CF5;
+  GL_PACK_SWAP_BYTES                = $0D00;
+  GL_PACK_LSB_FIRST                 = $0D01;
+  GL_PACK_ROW_LENGTH                = $0D02;
+  GL_PACK_SKIP_ROWS                 = $0D03;
+  GL_PACK_SKIP_PIXELS               = $0D04;
+  GL_PACK_ALIGNMENT                 = $0D05;
+  GL_MAP_COLOR                      = $0D10;
+  GL_MAP_STENCIL                    = $0D11;
+  GL_INDEX_SHIFT                    = $0D12;
+  GL_INDEX_OFFSET                   = $0D13;
+  GL_RED_SCALE                      = $0D14;
+  GL_RED_BIAS                       = $0D15;
+  GL_ZOOM_X                         = $0D16;
+  GL_ZOOM_Y                         = $0D17;
+  GL_GREEN_SCALE                    = $0D18;
+  GL_GREEN_BIAS                     = $0D19;
+  GL_BLUE_SCALE                     = $0D1A;
+  GL_BLUE_BIAS                      = $0D1B;
+  GL_ALPHA_SCALE                    = $0D1C;
+  GL_ALPHA_BIAS                     = $0D1D;
+  GL_DEPTH_SCALE                    = $0D1E;
+  GL_DEPTH_BIAS                     = $0D1F;
+  GL_MAX_EVAL_ORDER                 = $0D30;
+  GL_MAX_LIGHTS                     = $0D31;
+  GL_MAX_CLIP_PLANES                = $0D32;
+  GL_MAX_TEXTURE_SIZE               = $0D33;
+  GL_MAX_PIXEL_MAP_TABLE            = $0D34;
+  GL_MAX_ATTRIB_STACK_DEPTH         = $0D35;
+  GL_MAX_MODELVIEW_STACK_DEPTH      = $0D36;
+  GL_MAX_NAME_STACK_DEPTH           = $0D37;
+  GL_MAX_PROJECTION_STACK_DEPTH     = $0D38;
+  GL_MAX_TEXTURE_STACK_DEPTH        = $0D39;
+  GL_MAX_VIEWPORT_DIMS              = $0D3A;
+  GL_MAX_CLIENT_ATTRIB_STACK_DEPTH  = $0D3B;
+  GL_SUBPIXEL_BITS                  = $0D50;
+  GL_INDEX_BITS                     = $0D51;
+  GL_RED_BITS                       = $0D52;
+  GL_GREEN_BITS                     = $0D53;
+  GL_BLUE_BITS                      = $0D54;
+  GL_ALPHA_BITS                     = $0D55;
+  GL_DEPTH_BITS                     = $0D56;
+  GL_STENCIL_BITS                   = $0D57;
+  GL_ACCUM_RED_BITS                 = $0D58;
+  GL_ACCUM_GREEN_BITS               = $0D59;
+  GL_ACCUM_BLUE_BITS                = $0D5A;
+  GL_ACCUM_ALPHA_BITS               = $0D5B;
+  GL_NAME_STACK_DEPTH               = $0D70;
+  GL_AUTO_NORMAL                    = $0D80;
+  GL_MAP1_COLOR_4                   = $0D90;
+  GL_MAP1_INDEX                     = $0D91;
+  GL_MAP1_NORMAL                    = $0D92;
+  GL_MAP1_TEXTURE_COORD_1           = $0D93;
+  GL_MAP1_TEXTURE_COORD_2           = $0D94;
+  GL_MAP1_TEXTURE_COORD_3           = $0D95;
+  GL_MAP1_TEXTURE_COORD_4           = $0D96;
+  GL_MAP1_VERTEX_3                  = $0D97;
+  GL_MAP1_VERTEX_4                  = $0D98;
+  GL_MAP2_COLOR_4                   = $0DB0;
+  GL_MAP2_INDEX                     = $0DB1;
+  GL_MAP2_NORMAL                    = $0DB2;
+  GL_MAP2_TEXTURE_COORD_1           = $0DB3;
+  GL_MAP2_TEXTURE_COORD_2           = $0DB4;
+  GL_MAP2_TEXTURE_COORD_3           = $0DB5;
+  GL_MAP2_TEXTURE_COORD_4           = $0DB6;
+  GL_MAP2_VERTEX_3                  = $0DB7;
+  GL_MAP2_VERTEX_4                  = $0DB8;
+  GL_MAP1_GRID_DOMAIN               = $0DD0;
+  GL_MAP1_GRID_SEGMENTS             = $0DD1;
+  GL_MAP2_GRID_DOMAIN               = $0DD2;
+  GL_MAP2_GRID_SEGMENTS             = $0DD3;
+  GL_TEXTURE_1D                     = $0DE0;
+  GL_TEXTURE_2D                     = $0DE1;
+  GL_FEEDBACK_BUFFER_POINTER        = $0DF0;
+  GL_FEEDBACK_BUFFER_SIZE           = $0DF1;
+  GL_FEEDBACK_BUFFER_TYPE           = $0DF2;
+  GL_SELECTION_BUFFER_POINTER       = $0DF3;
+  GL_SELECTION_BUFFER_SIZE          = $0DF4;
+  //      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                  = $1000;
+  GL_TEXTURE_HEIGHT                 = $1001;
+  GL_TEXTURE_INTERNAL_FORMAT        = $1003;
+  GL_TEXTURE_BORDER_COLOR           = $1004;
+  GL_TEXTURE_BORDER                 = $1005;
+  //      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                      = $1100;
+  GL_FASTEST                        = $1101;
+  GL_NICEST                         = $1102;
+
+  // 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                         = $4000;
+  GL_LIGHT1                         = $4001;
+  GL_LIGHT2                         = $4002;
+  GL_LIGHT3                         = $4003;
+  GL_LIGHT4                         = $4004;
+  GL_LIGHT5                         = $4005;
+  GL_LIGHT6                         = $4006;
+  GL_LIGHT7                         = $4007;
+
+  // LightParameter
+  GL_AMBIENT                        = $1200;
+  GL_DIFFUSE                        = $1201;
+  GL_SPECULAR                       = $1202;
+  GL_POSITION                       = $1203;
+  GL_SPOT_DIRECTION                 = $1204;
+  GL_SPOT_EXPONENT                  = $1205;
+  GL_SPOT_CUTOFF                    = $1206;
+  GL_CONSTANT_ATTENUATION           = $1207;
+  GL_LINEAR_ATTENUATION             = $1208;
+  GL_QUADRATIC_ATTENUATION          = $1209;
+
+  // 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                        = $1300;
+  GL_COMPILE_AND_EXECUTE            = $1301;
+
+  // 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
+  GL_CLEAR                          = $1500;
+  GL_AND                            = $1501;
+  GL_AND_REVERSE                    = $1502;
+  GL_COPY                           = $1503;
+  GL_AND_INVERTED                   = $1504;
+  GL_NOOP                           = $1505;
+  GL_XOR                            = $1506;
+  GL_OR                             = $1507;
+  GL_NOR                            = $1508;
+  GL_EQUIV                          = $1509;
+  GL_INVERT                         = $150A;
+  GL_OR_REVERSE                     = $150B;
+  GL_COPY_INVERTED                  = $150C;
+  GL_OR_INVERTED                    = $150D;
+  GL_NAND                           = $150E;
+  GL_SET                            = $150F;
+
+  // 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                       = $1600;
+  GL_SHININESS                      = $1601;
+  GL_AMBIENT_AND_DIFFUSE            = $1602;
+  GL_COLOR_INDEXES                  = $1603;
+  //      GL_AMBIENT
+  //      GL_DIFFUSE
+  //      GL_SPECULAR
+
+  // MatrixMode
+  GL_MODELVIEW                      = $1700;
+  GL_PROJECTION                     = $1701;
+  GL_TEXTURE                        = $1702;
+
+  // 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                          = $1800;
+  GL_DEPTH                          = $1801;
+  GL_STENCIL                        = $1802;
+
+  // PixelFormat
+  GL_COLOR_INDEX                    = $1900;
+  GL_STENCIL_INDEX                  = $1901;
+  GL_DEPTH_COMPONENT                = $1902;
+  GL_RED                            = $1903;
+  GL_GREEN                          = $1904;
+  GL_BLUE                           = $1905;
+  GL_ALPHA                          = $1906;
+  GL_RGB                            = $1907;
+  GL_RGBA                           = $1908;
+  GL_LUMINANCE                      = $1909;
+  GL_LUMINANCE_ALPHA                = $190A;
+
+  // 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
+  GL_BITMAP                         = $1A00;
+  //      GL_BYTE
+  //      GL_UNSIGNED_BYTE
+  //      GL_SHORT
+  //      GL_UNSIGNED_SHORT
+  //      GL_INT
+  //      GL_UNSIGNED_INT
+  //      GL_FLOAT
+
+  // PolygonMode
+  GL_POINT                          = $1B00;
+  GL_LINE                           = $1B01;
+  GL_FILL                           = $1B02;
+
+  // 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                         = $1C00;
+  GL_FEEDBACK                       = $1C01;
+  GL_SELECT                         = $1C02;
+
+  // ShadingModel
+  GL_FLAT                           = $1D00;
+  GL_SMOOTH                         = $1D01;
+
+  // StencilFunction
+  //      GL_NEVER
+  //      GL_LESS
+  //      GL_EQUAL
+  //      GL_LEQUAL
+  //      GL_GREATER
+  //      GL_NOTEQUAL
+  //      GL_GEQUAL
+  //      GL_ALWAYS
+
+  // StencilOp
+  //      GL_ZERO
+  GL_KEEP                           = $1E00;
+  GL_REPLACE                        = $1E01;
+  GL_INCR                           = $1E02;
+  GL_DECR                           = $1E03;
+  //      GL_INVERT
+
+  // StringName
+  GL_VENDOR                         = $1F00;
+  GL_RENDERER                       = $1F01;
+  GL_VERSION                        = $1F02;
+  GL_EXTENSIONS                     = $1F03;
+
+  // TextureCoordName
+  GL_S                              = $2000;
+  GL_T                              = $2001;
+  GL_R                              = $2002;
+  GL_Q                              = $2003;
+
+  // TexCoordPointerType
+  //      GL_SHORT
+  //      GL_INT
+  //      GL_FLOAT
+  //      GL_DOUBLE
+
+  // TextureEnvMode
+  GL_MODULATE                       = $2100;
+  GL_DECAL                          = $2101;
+  //      GL_BLEND
+  //      GL_REPLACE
+
+  // TextureEnvParameter
+  GL_TEXTURE_ENV_MODE               = $2200;
+  GL_TEXTURE_ENV_COLOR              = $2201;
+
+  // TextureEnvTarget
+  GL_TEXTURE_ENV                    = $2300;
+
+  // TextureGenMode
+  GL_EYE_LINEAR                     = $2400;
+  GL_OBJECT_LINEAR                  = $2401;
+  GL_SPHERE_MAP                     = $2402;
+
+  // TextureGenParameter
+  GL_TEXTURE_GEN_MODE               = $2500;
+  GL_OBJECT_PLANE                   = $2501;
+  GL_EYE_PLANE                      = $2502;
+
+  // TextureMagFilter
+  GL_NEAREST                        = $2600;
+  GL_LINEAR                         = $2601;
+
+  // TextureMinFilter
+  //      GL_NEAREST
+  //      GL_LINEAR
+  GL_NEAREST_MIPMAP_NEAREST         = $2700;
+  GL_LINEAR_MIPMAP_NEAREST          = $2701;
+  GL_NEAREST_MIPMAP_LINEAR          = $2702;
+  GL_LINEAR_MIPMAP_LINEAR           = $2703;
+
+  // TextureParameterName
+  GL_TEXTURE_MAG_FILTER             = $2800;
+  GL_TEXTURE_MIN_FILTER             = $2801;
+  GL_TEXTURE_WRAP_S                 = $2802;
+  GL_TEXTURE_WRAP_T                 = $2803;
+  //      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                          = $2900;
+  GL_REPEAT                         = $2901;
+
+  // VertexPointerType
+  //      GL_SHORT
+  //      GL_INT
+  //      GL_FLOAT
+  //      GL_DOUBLE
+
+  // ClientAttribMask
+  GL_CLIENT_PIXEL_STORE_BIT         = $00000001;
+  GL_CLIENT_VERTEX_ARRAY_BIT        = $00000002;
+  GL_CLIENT_ALL_ATTRIB_BITS         = $FFFFFFFF;
+
+  // polygon_offset
+  GL_POLYGON_OFFSET_FACTOR          = $8038;
+  GL_POLYGON_OFFSET_UNITS           = $2A00;
+  GL_POLYGON_OFFSET_POINT           = $2A01;
+  GL_POLYGON_OFFSET_LINE            = $2A02;
+  GL_POLYGON_OFFSET_FILL            = $8037;
+
+  // texture
+  GL_ALPHA4                         = $803B;
+  GL_ALPHA8                         = $803C;
+  GL_ALPHA12                        = $803D;
+  GL_ALPHA16                        = $803E;
+  GL_LUMINANCE4                     = $803F;
+  GL_LUMINANCE8                     = $8040;
+  GL_LUMINANCE12                    = $8041;
+  GL_LUMINANCE16                    = $8042;
+  GL_LUMINANCE4_ALPHA4              = $8043;
+  GL_LUMINANCE6_ALPHA2              = $8044;
+  GL_LUMINANCE8_ALPHA8              = $8045;
+  GL_LUMINANCE12_ALPHA4             = $8046;
+  GL_LUMINANCE12_ALPHA12            = $8047;
+  GL_LUMINANCE16_ALPHA16            = $8048;
+  GL_INTENSITY                      = $8049;
+  GL_INTENSITY4                     = $804A;
+  GL_INTENSITY8                     = $804B;
+  GL_INTENSITY12                    = $804C;
+  GL_INTENSITY16                    = $804D;
+  GL_R3_G3_B2                       = $2A10;
+  GL_RGB4                           = $804F;
+  GL_RGB5                           = $8050;
+  GL_RGB8                           = $8051;
+  GL_RGB10                          = $8052;
+  GL_RGB12                          = $8053;
+  GL_RGB16                          = $8054;
+  GL_RGBA2                          = $8055;
+  GL_RGBA4                          = $8056;
+  GL_RGB5_A1                        = $8057;
+  GL_RGBA8                          = $8058;
+  GL_RGB10_A2                       = $8059;
+  GL_RGBA12                         = $805A;
+  GL_RGBA16                         = $805B;
+  GL_TEXTURE_RED_SIZE               = $805C;
+  GL_TEXTURE_GREEN_SIZE             = $805D;
+  GL_TEXTURE_BLUE_SIZE              = $805E;
+  GL_TEXTURE_ALPHA_SIZE             = $805F;
+  GL_TEXTURE_LUMINANCE_SIZE         = $8060;
+  GL_TEXTURE_INTENSITY_SIZE         = $8061;
+  GL_PROXY_TEXTURE_1D               = $8063;
+  GL_PROXY_TEXTURE_2D               = $8064;
+
+  // texture_object
+  GL_TEXTURE_PRIORITY               = $8066;
+  GL_TEXTURE_RESIDENT               = $8067;
+  GL_TEXTURE_BINDING_1D             = $8068;
+  GL_TEXTURE_BINDING_2D             = $8069;
+
+  // vertex_array
+  GL_VERTEX_ARRAY                   = $8074;
+  GL_NORMAL_ARRAY                   = $8075;
+  GL_COLOR_ARRAY                    = $8076;
+  GL_INDEX_ARRAY                    = $8077;
+  GL_TEXTURE_COORD_ARRAY            = $8078;
+  GL_EDGE_FLAG_ARRAY                = $8079;
+  GL_VERTEX_ARRAY_SIZE              = $807A;
+  GL_VERTEX_ARRAY_TYPE              = $807B;
+  GL_VERTEX_ARRAY_STRIDE            = $807C;
+  GL_NORMAL_ARRAY_TYPE              = $807E;
+  GL_NORMAL_ARRAY_STRIDE            = $807F;
+  GL_COLOR_ARRAY_SIZE               = $8081;
+  GL_COLOR_ARRAY_TYPE               = $8082;
+  GL_COLOR_ARRAY_STRIDE             = $8083;
+  GL_INDEX_ARRAY_TYPE               = $8085;
+  GL_INDEX_ARRAY_STRIDE             = $8086;
+  GL_TEXTURE_COORD_ARRAY_SIZE       = $8088;
+  GL_TEXTURE_COORD_ARRAY_TYPE       = $8089;
+  GL_TEXTURE_COORD_ARRAY_STRIDE     = $808A;
+  GL_EDGE_FLAG_ARRAY_STRIDE         = $808C;
+  GL_VERTEX_ARRAY_POINTER           = $808E;
+  GL_NORMAL_ARRAY_POINTER           = $808F;
+  GL_COLOR_ARRAY_POINTER            = $8090;
+  GL_INDEX_ARRAY_POINTER            = $8091;
+  GL_TEXTURE_COORD_ARRAY_POINTER    = $8092;
+  GL_EDGE_FLAG_ARRAY_POINTER        = $8093;
+  GL_V2F                            = $2A20;
+  GL_V3F                            = $2A21;
+  GL_C4UB_V2F                       = $2A22;
+  GL_C4UB_V3F                       = $2A23;
+  GL_C3F_V3F                        = $2A24;
+  GL_N3F_V3F                        = $2A25;
+  GL_C4F_N3F_V3F                    = $2A26;
+  GL_T2F_V3F                        = $2A27;
+  GL_T4F_V4F                        = $2A28;
+  GL_T2F_C4UB_V3F                   = $2A29;
+  GL_T2F_C3F_V3F                    = $2A2A;
+  GL_T2F_N3F_V3F                    = $2A2B;
+  GL_T2F_C4F_N3F_V3F                = $2A2C;
+  GL_T4F_C4F_N3F_V4F                = $2A2D;
+
+  // 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               = $8074;
+  GL_NORMAL_ARRAY_EXT               = $8075;
+  GL_COLOR_ARRAY_EXT                = $8076;
+  GL_INDEX_ARRAY_EXT                = $8077;
+  GL_TEXTURE_COORD_ARRAY_EXT        = $8078;
+  GL_EDGE_FLAG_ARRAY_EXT            = $8079;
+  GL_VERTEX_ARRAY_SIZE_EXT          = $807A;
+  GL_VERTEX_ARRAY_TYPE_EXT          = $807B;
+  GL_VERTEX_ARRAY_STRIDE_EXT        = $807C;
+  GL_VERTEX_ARRAY_COUNT_EXT         = $807D;
+  GL_NORMAL_ARRAY_TYPE_EXT          = $807E;
+  GL_NORMAL_ARRAY_STRIDE_EXT        = $807F;
+  GL_NORMAL_ARRAY_COUNT_EXT         = $8080;
+  GL_COLOR_ARRAY_SIZE_EXT           = $8081;
+  GL_COLOR_ARRAY_TYPE_EXT           = $8082;
+  GL_COLOR_ARRAY_STRIDE_EXT         = $8083;
+  GL_COLOR_ARRAY_COUNT_EXT          = $8084;
+  GL_INDEX_ARRAY_TYPE_EXT           = $8085;
+  GL_INDEX_ARRAY_STRIDE_EXT         = $8086;
+  GL_INDEX_ARRAY_COUNT_EXT          = $8087;
+  GL_TEXTURE_COORD_ARRAY_SIZE_EXT   = $8088;
+  GL_TEXTURE_COORD_ARRAY_TYPE_EXT   = $8089;
+  GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = $808A;
+  GL_TEXTURE_COORD_ARRAY_COUNT_EXT  = $808B;
+  GL_EDGE_FLAG_ARRAY_STRIDE_EXT     = $808C;
+  GL_EDGE_FLAG_ARRAY_COUNT_EXT      = $808D;
+  GL_VERTEX_ARRAY_POINTER_EXT       = $808E;
+  GL_NORMAL_ARRAY_POINTER_EXT       = $808F;
+  GL_COLOR_ARRAY_POINTER_EXT        = $8090;
+  GL_INDEX_ARRAY_POINTER_EXT        = $8091;
+  GL_TEXTURE_COORD_ARRAY_POINTER_EXT = $8092;
+  GL_EDGE_FLAG_ARRAY_POINTER_EXT    = $8093;
+  GL_DOUBLE_EXT                     = GL_DOUBLE;
+
+  // EXT_bgra 
+  GL_BGR_EXT                        = $80E0;
+  GL_BGRA_EXT                       = $80E1;
+
+  // EXT_paletted_texture
+
+  // These must match the GL_COLOR_TABLE_*_SGI enumerants
+  GL_COLOR_TABLE_FORMAT_EXT         = $80D8;
+  GL_COLOR_TABLE_WIDTH_EXT          = $80D9;
+  GL_COLOR_TABLE_RED_SIZE_EXT       = $80DA;
+  GL_COLOR_TABLE_GREEN_SIZE_EXT     = $80DB;
+  GL_COLOR_TABLE_BLUE_SIZE_EXT      = $80DC;
+  GL_COLOR_TABLE_ALPHA_SIZE_EXT     = $80DD;
+  GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = $80DE;
+  GL_COLOR_TABLE_INTENSITY_SIZE_EXT = $80DF;
+
+  GL_COLOR_INDEX1_EXT               = $80E2;
+  GL_COLOR_INDEX2_EXT               = $80E3;
+  GL_COLOR_INDEX4_EXT               = $80E4;
+  GL_COLOR_INDEX8_EXT               = $80E5;
+  GL_COLOR_INDEX12_EXT              = $80E6;
+  GL_COLOR_INDEX16_EXT              = $80E7;
+
+  // For compatibility with OpenGL v1.0
+  GL_LOGIC_OP                       = GL_INDEX_LOGIC_OP;
+  GL_TEXTURE_COMPONENTS             = GL_TEXTURE_INTERNAL_FORMAT;
+
+{******************************************************************************}
+
+var
+  glAccum: procedure(op: GLenum; value: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glAlphaFunc: procedure(func: GLenum; ref: GLclampf); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glAreTexturesResident: function (n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glArrayElement: procedure(i: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBegin: procedure(mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBindTexture: procedure(target: GLenum; texture: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBitmap: procedure (width, height: GLsizei; xorig, yorig: GLfloat; xmove, ymove: GLfloat; const bitmap: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBlendFunc: procedure(sfactor, dfactor: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCallList: procedure(list: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCallLists: procedure(n: GLsizei; atype: GLenum; const lists: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glClear: procedure(mask: GLbitfield); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glClearAccum: procedure(red, green, blue, alpha: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glClearColor: procedure(red, green, blue, alpha: GLclampf); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glClearDepth: procedure(depth: GLclampd); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glClearIndex: procedure(c: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glClearStencil: procedure(s: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glClipPlane: procedure(plane: GLenum; const equation: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3b: procedure(red, green, blue: GLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3bv: procedure(const v: PGLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3d: procedure(red, green, blue: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3f: procedure(red, green, blue: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3i: procedure(red, green, blue: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3s: procedure(red, green, blue: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3ub: procedure(red, green, blue: GLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3ubv: procedure(const v: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3ui: procedure(red, green, blue: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3uiv: procedure(const v: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3us: procedure(red, green, blue: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3usv: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4b: procedure(red, green, blue, alpha: GLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4bv: procedure(const v: PGLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4d: procedure(red, green, blue, alpha: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4f: procedure(red, green, blue, alpha: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4i: procedure(red, green, blue, alpha: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4s: procedure(red, green, blue, alpha: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4ub: procedure(red, green, blue, alpha: GLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4ubv: procedure(const v: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4ui: procedure(red, green, blue, alpha: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4uiv: procedure(const v: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4us: procedure(red, green, blue, alpha: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4usv: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorMask: procedure(red, green, blue, alpha: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorMaterial: procedure(face, mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorPointer: procedure(size: GLint; atype: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyPixels: procedure(x, y: GLint; width, height: GLsizei; atype: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyTexImage1D: procedure (target: GLenum; level: GLint; internalFormat: GLenum; x, y: GLint; width: GLsizei; border: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyTexImage2D: procedure(target: GLenum; level: GLint; internalFormat: GLenum; x, y: GLint; width, height: GLsizei; border: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyTexSubImage1D: procedure(target: GLenum; level, xoffset, x, y: GLint; width: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset, x, y: GLint; width, height: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCullFace: procedure(mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteLists: procedure(list: GLuint; range: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteTextures: procedure(n: GLsizei; const textures: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDepthFunc: procedure(func: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDepthMask: procedure(flag: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDepthRange: procedure(zNear, zFar: GLclampd); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDisable: procedure(cap: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDisableClientState: procedure(aarray: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawArrays: procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawBuffer: procedure(mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawElements: procedure(mode: GLenum; count: GLsizei; atype: GLenum; const indices: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawPixels: procedure(width, height: GLsizei; format, atype: GLenum; const pixels: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEdgeFlag: procedure(flag: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEdgeFlagPointer: procedure(stride: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEdgeFlagv: procedure(const flag: PGLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEnable: procedure(cap: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEnableClientState: procedure(aarray: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEnd: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEndList: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalCoord1d: procedure(u: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalCoord1dv: procedure(const u: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalCoord1f: procedure(u: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalCoord1fv: procedure(const u: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalCoord2d: procedure(u, v: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalCoord2dv: procedure(const u: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalCoord2f: procedure(u, v: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalCoord2fv: procedure(const u: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalMesh1: procedure(mode: GLenum; i1, i2: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalMesh2: procedure(mode: GLenum; i1, i2, j1, j2: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalPoint1: procedure(i: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalPoint2: procedure(i, j: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFeedbackBuffer: procedure(size: GLsizei; atype: GLenum; buffer: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFinish: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFlush: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogf: procedure(pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogfv: procedure(pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogi: procedure(pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogiv: procedure(pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFrontFace: procedure(mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFrustum: procedure(left, right, bottom, top, zNear, zFar: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGenLists: function(range: GLsizei): GLuint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGenTextures: procedure(n: GLsizei; textures: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetBooleanv: procedure(pname: GLenum; params: PGLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetClipPlane: procedure(plane: GLenum; equation: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetDoublev: procedure(pname: GLenum; params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetError: function: GLenum; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetFloatv: procedure(pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetIntegerv: procedure(pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetLightfv: procedure(light, pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetLightiv: procedure(light, pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMapdv: procedure(target, query: GLenum; v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMapfv: procedure(target, query: GLenum; v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMapiv: procedure(target, query: GLenum; v: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMaterialfv: procedure(face, pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMaterialiv: procedure(face, pname: GLenum; params: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetPixelMapfv: procedure(map: GLenum; values: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetPixelMapuiv: procedure(map: GLenum; values: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetPixelMapusv: procedure(map: GLenum; values: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetPointerv: procedure(pname: GLenum; params: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetPolygonStipple: procedure(mask: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetString: function(name: GLenum): PChar; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexEnvfv: procedure(target, pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexEnviv: procedure(target, pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexGendv: procedure(coord, pname: GLenum; params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexGenfv: procedure(coord, pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexGeniv: procedure(coord, pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexImage: procedure(target: GLenum; level: GLint; format: GLenum; atype: GLenum; pixels: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexLevelParameterfv: procedure(target: GLenum; level: GLint; pname: GLenum; params: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexLevelParameteriv: procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexParameterfv: procedure(target, pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexParameteriv: procedure(target, pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glHint: procedure(target, mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexMask: procedure(mask: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexPointer: procedure(atype: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexd: procedure(c: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexdv: procedure(const c: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexf: procedure(c: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexfv: procedure(const c: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexi: procedure(c: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexiv: procedure(const c: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexs: procedure(c: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexsv: procedure(const c: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexub: procedure(c: GLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexubv: procedure(const c: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glInitNames: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glInterleavedArrays: procedure(format: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsEnabled: function(cap: GLenum): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsList: function(list: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsTexture: function(texture: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLightModelf: procedure(pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLightModelfv: procedure(pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLightModeli: procedure(pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLightModeliv: procedure(pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLightf: procedure(light, pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLightfv: procedure(light, pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLighti: procedure(light, pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLightiv: procedure(light, pname: GLenum; const params: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLineStipple: procedure(factor: GLint; pattern: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLineWidth: procedure(width: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glListBase: procedure(base: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLoadIdentity: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLoadMatrixd: procedure(const m: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLoadMatrixf: procedure(const m: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLoadName: procedure(name: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLogicOp: procedure(opcode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMap1d: procedure(target: GLenum; u1, u2: GLdouble; stride, order: GLint; const points: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMap1f: procedure(target: GLenum; u1, u2: GLfloat; stride, order: GLint; const points: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMap2d: procedure(target: GLenum; u1, u2: GLdouble; ustride, uorder: GLint; v1, v2: GLdouble; vstride, vorder: GLint; const points: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMap2f: procedure(target: GLenum; u1, u2: GLfloat; ustride, uorder: GLint; v1, v2: GLfloat; vstride, vorder: GLint; const points: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMapGrid1d: procedure(un: GLint; u1, u2: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMapGrid1f: procedure(un: GLint; u1, u2: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMapGrid2d: procedure(un: GLint; u1, u2: GLdouble; vn: GLint; v1, v2: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMapGrid2f: procedure(un: GLint; u1, u2: GLfloat; vn: GLint; v1, v2: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMaterialf: procedure(face, pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMaterialfv: procedure(face, pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMateriali: procedure(face, pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMaterialiv: procedure(face, pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMatrixMode: procedure(mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultMatrixd: procedure(const m: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultMatrixf: procedure(const m: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNewList: procedure(list: GLuint; mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3b: procedure(nx, ny, nz: GLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3bv: procedure(const v: PGLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3d: procedure(nx, ny, nz: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3f: procedure(nx, ny, nz: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3i: procedure(nx, ny, nz: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3s: procedure(nx, ny, nz: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalPointer: procedure(atype: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glOrtho: procedure(left, right, bottom, top, zNear, zFar: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPassThrough: procedure(token: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPixelMapfv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPixelMapuiv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPixelMapusv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPixelStoref: procedure(pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPixelStorei: procedure(pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPixelTransferf: procedure(pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPixelTransferi: procedure(pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPixelZoom: procedure(xfactor, yfactor: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPointSize: procedure(size: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPolygonMode: procedure(face, mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPolygonOffset: procedure(factor, units: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPolygonStipple: procedure(const mask: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPopAttrib: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPopClientAttrib: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPopMatrix: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPopName: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPrioritizeTextures: procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPushAttrib: procedure(mask: GLbitfield); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPushClientAttrib: procedure(mask: GLbitfield); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPushMatrix: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPushName: procedure(name: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos2d: procedure(x, y: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos2dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos2f: procedure(x, y: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos2fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos2i: procedure(x, y: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos2iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos2s: procedure(x, y: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos2sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos3d: procedure(x, y, z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos3dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos3f: procedure(x, y, z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos3fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos3i: procedure(x, y, z: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos3iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos3s: procedure(x, y, z: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos3sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos4d: procedure(x, y, z, w: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos4dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos4f: procedure(x, y, z, w: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos4fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos4i: procedure(x, y, z, w: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos4iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos4s: procedure(x, y, z, w: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRasterPos4sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReadBuffer: procedure(mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReadPixels: procedure(x, y: GLint; width, height: GLsizei; format, atype: GLenum; pixels: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRectd: procedure(x1, y1, x2, y2: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRectdv: procedure(const v1: PGLdouble; const v2: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRectf: procedure(x1, y1, x2, y2: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRectfv: procedure(const v1: PGLfloat; const v2: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRecti: procedure(x1, y1, x2, y2: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRectiv: procedure(const v1: PGLint; const v2: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRects: procedure(x1, y1, x2, y2: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRectsv: procedure(const v1: PGLshort; const v2: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRenderMode: function(mode: GLint): GLint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRotated: procedure(angle, x, y, z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRotatef: procedure(angle, x, y, z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glScaled: procedure(x, y, z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glScalef: procedure(x, y, z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glScissor: procedure(x, y: GLint; width, height: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSelectBuffer: procedure(size: GLsizei; buffer: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glShadeModel: procedure(mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glStencilFunc: procedure(func: GLenum; ref: GLint; mask: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glStencilMask: procedure(mask: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glStencilOp: procedure(fail, zfail, zpass: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord1d: procedure(s: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord1dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord1f: procedure(s: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord1fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord1i: procedure(s: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord1iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord1s: procedure(s: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord1sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2d: procedure(s, t: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2f: procedure(s, t: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2i: procedure(s, t: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2s: procedure(s, t: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord3d: procedure(s, t, r: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord3dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord3f: procedure(s, t, r: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord3fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord3i: procedure(s, t, r: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord3iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord3s: procedure(s, t, r: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord3sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4d: procedure(s, t, r, q: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4f: procedure(s, t, r, q: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4i: procedure(s, t, r, q: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4s: procedure(s, t, r, q: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoordPointer: procedure(size: GLint; atype: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexEnvf: procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexEnvfv: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexEnvi: procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexEnviv: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexGend: procedure(coord: GLenum; pname: GLenum; param: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexGendv: procedure(coord: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexGenf: procedure(coord: GLenum; pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexGenfv: procedure(coord: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexGeni: procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexGeniv: procedure(coord: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexImage1D: procedure(target: GLenum; level, internalformat: GLint; width: GLsizei; border: GLint; format, atype: GLenum; const pixels: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexImage2D: procedure(target: GLenum; level, internalformat: GLint; width, height: GLsizei; border: GLint; format, atype: GLenum; const pixels: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexParameterf: procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexParameterfv: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexParameteri: procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexParameteriv: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexSubImage1D: procedure(target: GLenum; level, xoffset: GLint; width: GLsizei; format, atype: GLenum; const pixels: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset: GLint; width, height: GLsizei; format, atype: GLenum; const pixels: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTranslated: procedure(x, y, z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTranslatef: procedure(x, y, z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex2d: procedure(x, y: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex2dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex2f: procedure(x, y: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex2fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex2i: procedure(x, y: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex2iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex2s: procedure(x, y: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex2sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex3d: procedure(x, y, z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex3dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex3f: procedure(x, y, z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex3fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex3i: procedure(x, y, z: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex3iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex3s: procedure(x, y, z: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex3sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex4d: procedure(x, y, z, w: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex4dv: procedure(const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex4f: procedure(x, y, z, w: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex4fv: procedure(const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex4i: procedure(x, y, z, w: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex4iv: procedure(const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex4s: procedure(x, y, z, w: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex4sv: procedure(const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexPointer: procedure(size: GLint; atype: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glViewport: procedure(x, y: GLint; width, height: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  {$IFDEF Win32}
+  ChoosePixelFormat: function(DC: HDC; p2: PPixelFormatDescriptor): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  {$ENDIF}
+
+type
+  // EXT_vertex_array
+  PFNGLARRAYELEMENTEXTPROC = procedure(i: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLDRAWARRAYSEXTPROC = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLVERTEXPOINTEREXTPROC = procedure(size: GLint; atype: GLenum;
+                                        stride, count: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLNORMALPOINTEREXTPROC = procedure(atype: GLenum; stride, count: GLsizei;
+                                        const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLCOLORPOINTEREXTPROC = procedure(size: GLint; atype: GLenum; stride, count: GLsizei;
+                                       const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLINDEXPOINTEREXTPROC = procedure(atype: GLenum; stride, count: GLsizei;
+                                       const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLTEXCOORDPOINTEREXTPROC = procedure(size: GLint; atype: GLenum;
+                                          stride, count: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLEDGEFLAGPOINTEREXTPROC = procedure(stride, count: GLsizei;
+                                          const pointer: PGLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLGETPOINTERVEXTPROC = procedure(pname: GLenum; params: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLARRAYELEMENTARRAYEXTPROC = procedure(mode: GLenum; count: GLsizei;
+                                            const pi: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+  // WIN_swap_hint
+  PFNGLADDSWAPHINTRECTWINPROC = procedure(x, y: GLint; width, height: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+  // EXT_paletted_texture
+  PFNGLCOLORTABLEEXTPROC = procedure(target, internalFormat: GLenum; width: GLsizei;
+                                     format, atype: GLenum; const data: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLCOLORSUBTABLEEXTPROC = procedure(target: GLenum; start, count: GLsizei;
+                                        format, atype: GLenum; const data: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLGETCOLORTABLEEXTPROC = procedure(target, format, atype: GLenum; data: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLGETCOLORTABLEPARAMETERIVEXTPROC = procedure(target, pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  PFNGLGETCOLORTABLEPARAMETERFVEXTPROC = procedure(target, pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+procedure LoadOpenGL( const dll: PChar );
+procedure FreeOpenGL;
+
+implementation
+
+procedure FreeOpenGL;
+begin
+
+  @glAccum := nil;
+  @glAlphaFunc := nil;
+  @glAreTexturesResident := nil;
+  @glArrayElement := nil;
+  @glBegin := nil;
+  @glBindTexture := nil;
+  @glBitmap := nil;
+  @glBlendFunc := nil;
+  @glCallList := nil;
+  @glCallLists := nil;
+  @glClear := nil;
+  @glClearAccum := nil;
+  @glClearColor := nil;
+  @glClearDepth := nil;
+  @glClearIndex := nil;
+  @glClearStencil := nil;
+  @glClipPlane := nil;
+  @glColor3b := nil;
+  @glColor3bv := nil;
+  @glColor3d := nil;
+  @glColor3dv := nil;
+  @glColor3f := nil;
+  @glColor3fv := nil;
+  @glColor3i := nil;
+  @glColor3iv := nil;
+  @glColor3s := nil;
+  @glColor3sv := nil;
+  @glColor3ub := nil;
+  @glColor3ubv := nil;
+  @glColor3ui := nil;
+  @glColor3uiv := nil;
+  @glColor3us := nil;
+  @glColor3usv := nil;
+  @glColor4b := nil;
+  @glColor4bv := nil;
+  @glColor4d := nil;
+  @glColor4dv := nil;
+  @glColor4f := nil;
+  @glColor4fv := nil;
+  @glColor4i := nil;
+  @glColor4iv := nil;
+  @glColor4s := nil;
+  @glColor4sv := nil;
+  @glColor4ub := nil;
+  @glColor4ubv := nil;
+  @glColor4ui := nil;
+  @glColor4uiv := nil;
+  @glColor4us := nil;
+  @glColor4usv := nil;
+  @glColorMask := nil;
+  @glColorMaterial := nil;
+  @glColorPointer := nil;
+  @glCopyPixels := nil;
+  @glCopyTexImage1D := nil;
+  @glCopyTexImage2D := nil;
+  @glCopyTexSubImage1D := nil;
+  @glCopyTexSubImage2D := nil;
+  @glCullFace := nil;
+  @glDeleteLists := nil;
+  @glDeleteTextures := nil;
+  @glDepthFunc := nil;
+  @glDepthMask := nil;
+  @glDepthRange := nil;
+  @glDisable := nil;
+  @glDisableClientState := nil;
+  @glDrawArrays := nil;
+  @glDrawBuffer := nil;
+  @glDrawElements := nil;
+  @glDrawPixels := nil;
+  @glEdgeFlag := nil;
+  @glEdgeFlagPointer := nil;
+  @glEdgeFlagv := nil;
+  @glEnable := nil;
+  @glEnableClientState := nil;
+  @glEnd := nil;
+  @glEndList := nil;
+  @glEvalCoord1d := nil;
+  @glEvalCoord1dv := nil;
+  @glEvalCoord1f := nil;
+  @glEvalCoord1fv := nil;
+  @glEvalCoord2d := nil;
+  @glEvalCoord2dv := nil;
+  @glEvalCoord2f := nil;
+  @glEvalCoord2fv := nil;
+  @glEvalMesh1 := nil;
+  @glEvalMesh2 := nil;
+  @glEvalPoint1 := nil;
+  @glEvalPoint2 := nil;
+  @glFeedbackBuffer := nil;
+  @glFinish := nil;
+  @glFlush := nil;
+  @glFogf := nil;
+  @glFogfv := nil;
+  @glFogi := nil;
+  @glFogiv := nil;
+  @glFrontFace := nil;
+  @glFrustum := nil;
+  @glGenLists := nil;
+  @glGenTextures := nil;
+  @glGetBooleanv := nil;
+  @glGetClipPlane := nil;
+  @glGetDoublev := nil;
+  @glGetError := nil;
+  @glGetFloatv := nil;
+  @glGetIntegerv := nil;
+  @glGetLightfv := nil;
+  @glGetLightiv := nil;
+  @glGetMapdv := nil;
+  @glGetMapfv := nil;
+  @glGetMapiv := nil;
+  @glGetMaterialfv := nil;
+  @glGetMaterialiv := nil;
+  @glGetPixelMapfv := nil;
+  @glGetPixelMapuiv := nil;
+  @glGetPixelMapusv := nil;
+  @glGetPointerv := nil;
+  @glGetPolygonStipple := nil;
+  @glGetString := nil;
+  @glGetTexEnvfv := nil;
+  @glGetTexEnviv := nil;
+  @glGetTexGendv := nil;
+  @glGetTexGenfv := nil;
+  @glGetTexGeniv := nil;
+  @glGetTexImage := nil;
+  @glGetTexLevelParameterfv := nil;
+  @glGetTexLevelParameteriv := nil;
+  @glGetTexParameterfv := nil;
+  @glGetTexParameteriv := nil;
+  @glHint := nil;
+  @glIndexMask := nil;
+  @glIndexPointer := nil;
+  @glIndexd := nil;
+  @glIndexdv := nil;
+  @glIndexf := nil;
+  @glIndexfv := nil;
+  @glIndexi := nil;
+  @glIndexiv := nil;
+  @glIndexs := nil;
+  @glIndexsv := nil;
+  @glIndexub := nil;
+  @glIndexubv := nil;
+  @glInitNames := nil;
+  @glInterleavedArrays := nil;
+  @glIsEnabled := nil;
+  @glIsList := nil;
+  @glIsTexture := nil;
+  @glLightModelf := nil;
+  @glLightModelfv := nil;
+  @glLightModeli := nil;
+  @glLightModeliv := nil;
+  @glLightf := nil;
+  @glLightfv := nil;
+  @glLighti := nil;
+  @glLightiv := nil;
+  @glLineStipple := nil;
+  @glLineWidth := nil;
+  @glListBase := nil;
+  @glLoadIdentity := nil;
+  @glLoadMatrixd := nil;
+  @glLoadMatrixf := nil;
+  @glLoadName := nil;
+  @glLogicOp := nil;
+  @glMap1d := nil;
+  @glMap1f := nil;
+  @glMap2d := nil;
+  @glMap2f := nil;
+  @glMapGrid1d := nil;
+  @glMapGrid1f := nil;
+  @glMapGrid2d := nil;
+  @glMapGrid2f := nil;
+  @glMaterialf := nil;
+  @glMaterialfv := nil;
+  @glMateriali := nil;
+  @glMaterialiv := nil;
+  @glMatrixMode := nil;
+  @glMultMatrixd := nil;
+  @glMultMatrixf := nil;
+  @glNewList := nil;
+  @glNormal3b := nil;
+  @glNormal3bv := nil;
+  @glNormal3d := nil;
+  @glNormal3dv := nil;
+  @glNormal3f := nil;
+  @glNormal3fv := nil;
+  @glNormal3i := nil;
+  @glNormal3iv := nil;
+  @glNormal3s := nil;
+  @glNormal3sv := nil;
+  @glNormalPointer := nil;
+  @glOrtho := nil;
+  @glPassThrough := nil;
+  @glPixelMapfv := nil;
+  @glPixelMapuiv := nil;
+  @glPixelMapusv := nil;
+  @glPixelStoref := nil;
+  @glPixelStorei := nil;
+  @glPixelTransferf := nil;
+  @glPixelTransferi := nil;
+  @glPixelZoom := nil;
+  @glPointSize := nil;
+  @glPolygonMode := nil;
+  @glPolygonOffset := nil;
+  @glPolygonStipple := nil;
+  @glPopAttrib := nil;
+  @glPopClientAttrib := nil;
+  @glPopMatrix := nil;
+  @glPopName := nil;
+  @glPrioritizeTextures := nil;
+  @glPushAttrib := nil;
+  @glPushClientAttrib := nil;
+  @glPushMatrix := nil;
+  @glPushName := nil;
+  @glRasterPos2d := nil;
+  @glRasterPos2dv := nil;
+  @glRasterPos2f := nil;
+  @glRasterPos2fv := nil;
+  @glRasterPos2i := nil;
+  @glRasterPos2iv := nil;
+  @glRasterPos2s := nil;
+  @glRasterPos2sv := nil;
+  @glRasterPos3d := nil;
+  @glRasterPos3dv := nil;
+  @glRasterPos3f := nil;
+  @glRasterPos3fv := nil;
+  @glRasterPos3i := nil;
+  @glRasterPos3iv := nil;
+  @glRasterPos3s := nil;
+  @glRasterPos3sv := nil;
+  @glRasterPos4d := nil;
+  @glRasterPos4dv := nil;
+  @glRasterPos4f := nil;
+  @glRasterPos4fv := nil;
+  @glRasterPos4i := nil;
+  @glRasterPos4iv := nil;
+  @glRasterPos4s := nil;
+  @glRasterPos4sv := nil;
+  @glReadBuffer := nil;
+  @glReadPixels := nil;
+  @glRectd := nil;
+  @glRectdv := nil;
+  @glRectf := nil;
+  @glRectfv := nil;
+  @glRecti := nil;
+  @glRectiv := nil;
+  @glRects := nil;
+  @glRectsv := nil;
+  @glRenderMode := nil;
+  @glRotated := nil;
+  @glRotatef := nil;
+  @glScaled := nil;
+  @glScalef := nil;
+  @glScissor := nil;
+  @glSelectBuffer := nil;
+  @glShadeModel := nil;
+  @glStencilFunc := nil;
+  @glStencilMask := nil;
+  @glStencilOp := nil;
+  @glTexCoord1d := nil;
+  @glTexCoord1dv := nil;
+  @glTexCoord1f := nil;
+  @glTexCoord1fv := nil;
+  @glTexCoord1i := nil;
+  @glTexCoord1iv := nil;
+  @glTexCoord1s := nil;
+  @glTexCoord1sv := nil;
+  @glTexCoord2d := nil;
+  @glTexCoord2dv := nil;
+  @glTexCoord2f := nil;
+  @glTexCoord2fv := nil;
+  @glTexCoord2i := nil;
+  @glTexCoord2iv := nil;
+  @glTexCoord2s := nil;
+  @glTexCoord2sv := nil;
+  @glTexCoord3d := nil;
+  @glTexCoord3dv := nil;
+  @glTexCoord3f := nil;
+  @glTexCoord3fv := nil;
+  @glTexCoord3i := nil;
+  @glTexCoord3iv := nil;
+  @glTexCoord3s := nil;
+  @glTexCoord3sv := nil;
+  @glTexCoord4d := nil;
+  @glTexCoord4dv := nil;
+  @glTexCoord4f := nil;
+  @glTexCoord4fv := nil;
+  @glTexCoord4i := nil;
+  @glTexCoord4iv := nil;
+  @glTexCoord4s := nil;
+  @glTexCoord4sv := nil;
+  @glTexCoordPointer := nil;
+  @glTexEnvf := nil;
+  @glTexEnvfv := nil;
+  @glTexEnvi := nil;
+  @glTexEnviv := nil;
+  @glTexGend := nil;
+  @glTexGendv := nil;
+  @glTexGenf := nil;
+  @glTexGenfv := nil;
+  @glTexGeni := nil;
+  @glTexGeniv := nil;
+  @glTexImage1D := nil;
+  @glTexImage2D := nil;
+  @glTexParameterf := nil;
+  @glTexParameterfv := nil;
+  @glTexParameteri := nil;
+  @glTexParameteriv := nil;
+  @glTexSubImage1D := nil;
+  @glTexSubImage2D := nil;
+  @glTranslated := nil;
+  @glTranslatef := nil;
+  @glVertex2d := nil;
+  @glVertex2dv := nil;
+  @glVertex2f := nil;
+  @glVertex2fv := nil;
+  @glVertex2i := nil;
+  @glVertex2iv := nil;
+  @glVertex2s := nil;
+  @glVertex2sv := nil;
+  @glVertex3d := nil;
+  @glVertex3dv := nil;
+  @glVertex3f := nil;
+  @glVertex3fv := nil;
+  @glVertex3i := nil;
+  @glVertex3iv := nil;
+  @glVertex3s := nil;
+  @glVertex3sv := nil;
+  @glVertex4d := nil;
+  @glVertex4dv := nil;
+  @glVertex4f := nil;
+  @glVertex4fv := nil;
+  @glVertex4i := nil;
+  @glVertex4iv := nil;
+  @glVertex4s := nil;
+  @glVertex4sv := nil;
+  @glVertexPointer := nil;
+  @glViewport := nil;
+  {$IFDEF Win32}
+  @ChoosePixelFormat := nil;
+  {$ENDIF}
+
+  UnLoadModule(LibGL);
+
+end;
+
+procedure LoadOpenGL(const dll: PChar);
+begin
+
+  FreeOpenGL;
+
+  if LoadModule( LibGL, dll ) then
+  begin
+    @glAccum := GetModuleSymbol(LibGL, 'glAccum');
+    @glAlphaFunc := GetModuleSymbol(LibGL, 'glAlphaFunc');
+    @glAreTexturesResident := GetModuleSymbol(LibGL, 'glAreTexturesResident');
+    @glArrayElement := GetModuleSymbol(LibGL, 'glArrayElement');
+    @glBegin := GetModuleSymbol(LibGL, 'glBegin');
+    @glBindTexture := GetModuleSymbol(LibGL, 'glBindTexture');
+    @glBitmap := GetModuleSymbol(LibGL, 'glBitmap');
+    @glBlendFunc := GetModuleSymbol(LibGL, 'glBlendFunc');
+    @glCallList := GetModuleSymbol(LibGL, 'glCallList');
+    @glCallLists := GetModuleSymbol(LibGL, 'glCallLists');
+    @glClear := GetModuleSymbol(LibGL, 'glClear');
+    @glClearAccum := GetModuleSymbol(LibGL, 'glClearAccum');
+    @glClearColor := GetModuleSymbol(LibGL, 'glClearColor');
+    @glClearDepth := GetModuleSymbol(LibGL, 'glClearDepth');
+    @glClearIndex := GetModuleSymbol(LibGL, 'glClearIndex');
+    @glClearStencil := GetModuleSymbol(LibGL, 'glClearStencil');
+    @glClipPlane := GetModuleSymbol(LibGL, 'glClipPlane');
+    @glColor3b := GetModuleSymbol(LibGL, 'glColor3b');
+    @glColor3bv := GetModuleSymbol(LibGL, 'glColor3bv');
+    @glColor3d := GetModuleSymbol(LibGL, 'glColor3d');
+    @glColor3dv := GetModuleSymbol(LibGL, 'glColor3dv');
+    @glColor3f := GetModuleSymbol(LibGL, 'glColor3f');
+    @glColor3fv := GetModuleSymbol(LibGL, 'glColor3fv');
+    @glColor3i := GetModuleSymbol(LibGL, 'glColor3i');
+    @glColor3iv := GetModuleSymbol(LibGL, 'glColor3iv');
+    @glColor3s := GetModuleSymbol(LibGL, 'glColor3s');
+    @glColor3sv := GetModuleSymbol(LibGL, 'glColor3sv');
+    @glColor3ub := GetModuleSymbol(LibGL, 'glColor3ub');
+    @glColor3ubv := GetModuleSymbol(LibGL, 'glColor3ubv');
+    @glColor3ui := GetModuleSymbol(LibGL, 'glColor3ui');
+    @glColor3uiv := GetModuleSymbol(LibGL, 'glColor3uiv');
+    @glColor3us := GetModuleSymbol(LibGL, 'glColor3us');
+    @glColor3usv := GetModuleSymbol(LibGL, 'glColor3usv');
+    @glColor4b := GetModuleSymbol(LibGL, 'glColor4b');
+    @glColor4bv := GetModuleSymbol(LibGL, 'glColor4bv');
+    @glColor4d := GetModuleSymbol(LibGL, 'glColor4d');
+    @glColor4dv := GetModuleSymbol(LibGL, 'glColor4dv');
+    @glColor4f := GetModuleSymbol(LibGL, 'glColor4f');
+    @glColor4fv := GetModuleSymbol(LibGL, 'glColor4fv');
+    @glColor4i := GetModuleSymbol(LibGL, 'glColor4i');
+    @glColor4iv := GetModuleSymbol(LibGL, 'glColor4iv');
+    @glColor4s := GetModuleSymbol(LibGL, 'glColor4s');
+    @glColor4sv := GetModuleSymbol(LibGL, 'glColor4sv');
+    @glColor4ub := GetModuleSymbol(LibGL, 'glColor4ub');
+    @glColor4ubv := GetModuleSymbol(LibGL, 'glColor4ubv');
+    @glColor4ui := GetModuleSymbol(LibGL, 'glColor4ui');
+    @glColor4uiv := GetModuleSymbol(LibGL, 'glColor4uiv');
+    @glColor4us := GetModuleSymbol(LibGL, 'glColor4us');
+    @glColor4usv := GetModuleSymbol(LibGL, 'glColor4usv');
+    @glColorMask := GetModuleSymbol(LibGL, 'glColorMask');
+    @glColorMaterial := GetModuleSymbol(LibGL, 'glColorMaterial');
+    @glColorPointer := GetModuleSymbol(LibGL, 'glColorPointer');
+    @glCopyPixels := GetModuleSymbol(LibGL, 'glCopyPixels');
+    @glCopyTexImage1D := GetModuleSymbol(LibGL, 'glCopyTexImage1D');
+    @glCopyTexImage2D := GetModuleSymbol(LibGL, 'glCopyTexImage2D');
+    @glCopyTexSubImage1D := GetModuleSymbol(LibGL, 'glCopyTexSubImage1D');
+    @glCopyTexSubImage2D := GetModuleSymbol(LibGL, 'glCopyTexSubImage2D');
+    @glCullFace := GetModuleSymbol(LibGL, 'glCullFace');
+    @glDeleteLists := GetModuleSymbol(LibGL, 'glDeleteLists');
+    @glDeleteTextures := GetModuleSymbol(LibGL, 'glDeleteTextures');
+    @glDepthFunc := GetModuleSymbol(LibGL, 'glDepthFunc');
+    @glDepthMask := GetModuleSymbol(LibGL, 'glDepthMask');
+    @glDepthRange := GetModuleSymbol(LibGL, 'glDepthRange');
+    @glDisable := GetModuleSymbol(LibGL, 'glDisable');
+    @glDisableClientState := GetModuleSymbol(LibGL, 'glDisableClientState');
+    @glDrawArrays := GetModuleSymbol(LibGL, 'glDrawArrays');
+    @glDrawBuffer := GetModuleSymbol(LibGL, 'glDrawBuffer');
+    @glDrawElements := GetModuleSymbol(LibGL, 'glDrawElements');
+    @glDrawPixels := GetModuleSymbol(LibGL, 'glDrawPixels');
+    @glEdgeFlag := GetModuleSymbol(LibGL, 'glEdgeFlag');
+    @glEdgeFlagPointer := GetModuleSymbol(LibGL, 'glEdgeFlagPointer');
+    @glEdgeFlagv := GetModuleSymbol(LibGL, 'glEdgeFlagv');
+    @glEnable := GetModuleSymbol(LibGL, 'glEnable');
+    @glEnableClientState := GetModuleSymbol(LibGL, 'glEnableClientState');
+    @glEnd := GetModuleSymbol(LibGL, 'glEnd');
+    @glEndList := GetModuleSymbol(LibGL, 'glEndList');
+    @glEvalCoord1d := GetModuleSymbol(LibGL, 'glEvalCoord1d');
+    @glEvalCoord1dv := GetModuleSymbol(LibGL, 'glEvalCoord1dv');
+    @glEvalCoord1f := GetModuleSymbol(LibGL, 'glEvalCoord1f');
+    @glEvalCoord1fv := GetModuleSymbol(LibGL, 'glEvalCoord1fv');
+    @glEvalCoord2d := GetModuleSymbol(LibGL, 'glEvalCoord2d');
+    @glEvalCoord2dv := GetModuleSymbol(LibGL, 'glEvalCoord2dv');
+    @glEvalCoord2f := GetModuleSymbol(LibGL, 'glEvalCoord2f');
+    @glEvalCoord2fv := GetModuleSymbol(LibGL, 'glEvalCoord2fv');
+    @glEvalMesh1 := GetModuleSymbol(LibGL, 'glEvalMesh1');
+    @glEvalMesh2 := GetModuleSymbol(LibGL, 'glEvalMesh2');
+    @glEvalPoint1 := GetModuleSymbol(LibGL, 'glEvalPoint1');
+    @glEvalPoint2 := GetModuleSymbol(LibGL, 'glEvalPoint2');
+    @glFeedbackBuffer := GetModuleSymbol(LibGL, 'glFeedbackBuffer');
+    @glFinish := GetModuleSymbol(LibGL, 'glFinish');
+    @glFlush := GetModuleSymbol(LibGL, 'glFlush');
+    @glFogf := GetModuleSymbol(LibGL, 'glFogf');
+    @glFogfv := GetModuleSymbol(LibGL, 'glFogfv');
+    @glFogi := GetModuleSymbol(LibGL, 'glFogi');
+    @glFogiv := GetModuleSymbol(LibGL, 'glFogiv');
+    @glFrontFace := GetModuleSymbol(LibGL, 'glFrontFace');
+    @glFrustum := GetModuleSymbol(LibGL, 'glFrustum');
+    @glGenLists := GetModuleSymbol(LibGL, 'glGenLists');
+    @glGenTextures := GetModuleSymbol(LibGL, 'glGenTextures');
+    @glGetBooleanv := GetModuleSymbol(LibGL, 'glGetBooleanv');
+    @glGetClipPlane := GetModuleSymbol(LibGL, 'glGetClipPlane');
+    @glGetDoublev := GetModuleSymbol(LibGL, 'glGetDoublev');
+    @glGetError := GetModuleSymbol(LibGL, 'glGetError');
+    @glGetFloatv := GetModuleSymbol(LibGL, 'glGetFloatv');
+    @glGetIntegerv := GetModuleSymbol(LibGL, 'glGetIntegerv');
+    @glGetLightfv := GetModuleSymbol(LibGL, 'glGetLightfv');
+    @glGetLightiv := GetModuleSymbol(LibGL, 'glGetLightiv');
+    @glGetMapdv := GetModuleSymbol(LibGL, 'glGetMapdv');
+    @glGetMapfv := GetModuleSymbol(LibGL, 'glGetMapfv');
+    @glGetMapiv := GetModuleSymbol(LibGL, 'glGetMapiv');
+    @glGetMaterialfv := GetModuleSymbol(LibGL, 'glGetMaterialfv');
+    @glGetMaterialiv := GetModuleSymbol(LibGL, 'glGetMaterialiv');
+    @glGetPixelMapfv := GetModuleSymbol(LibGL, 'glGetPixelMapfv');
+    @glGetPixelMapuiv := GetModuleSymbol(LibGL, 'glGetPixelMapuiv');
+    @glGetPixelMapusv := GetModuleSymbol(LibGL, 'glGetPixelMapusv');
+    @glGetPointerv := GetModuleSymbol(LibGL, 'glGetPointerv');
+    @glGetPolygonStipple := GetModuleSymbol(LibGL, 'glGetPolygonStipple');
+    @glGetString := GetModuleSymbol(LibGL, 'glGetString');
+    @glGetTexEnvfv := GetModuleSymbol(LibGL, 'glGetTexEnvfv');
+    @glGetTexEnviv := GetModuleSymbol(LibGL, 'glGetTexEnviv');
+    @glGetTexGendv := GetModuleSymbol(LibGL, 'glGetTexGendv');
+    @glGetTexGenfv := GetModuleSymbol(LibGL, 'glGetTexGenfv');
+    @glGetTexGeniv := GetModuleSymbol(LibGL, 'glGetTexGeniv');
+    @glGetTexImage := GetModuleSymbol(LibGL, 'glGetTexImage');
+    @glGetTexLevelParameterfv := GetModuleSymbol(LibGL, 'glGetTexLevelParameterfv');
+    @glGetTexLevelParameteriv := GetModuleSymbol(LibGL, 'glGetTexLevelParameteriv');
+    @glGetTexParameterfv := GetModuleSymbol(LibGL, 'glGetTexParameterfv');
+    @glGetTexParameteriv := GetModuleSymbol(LibGL, 'glGetTexParameteriv');
+    @glHint := GetModuleSymbol(LibGL, 'glHint');
+    @glIndexMask := GetModuleSymbol(LibGL, 'glIndexMask');
+    @glIndexPointer := GetModuleSymbol(LibGL, 'glIndexPointer');
+    @glIndexd := GetModuleSymbol(LibGL, 'glIndexd');
+    @glIndexdv := GetModuleSymbol(LibGL, 'glIndexdv');
+    @glIndexf := GetModuleSymbol(LibGL, 'glIndexf');
+    @glIndexfv := GetModuleSymbol(LibGL, 'glIndexfv');
+    @glIndexi := GetModuleSymbol(LibGL, 'glIndexi');
+    @glIndexiv := GetModuleSymbol(LibGL, 'glIndexiv');
+    @glIndexs := GetModuleSymbol(LibGL, 'glIndexs');
+    @glIndexsv := GetModuleSymbol(LibGL, 'glIndexsv');
+    @glIndexub := GetModuleSymbol(LibGL, 'glIndexub');
+    @glIndexubv := GetModuleSymbol(LibGL, 'glIndexubv');
+    @glInitNames := GetModuleSymbol(LibGL, 'glInitNames');
+    @glInterleavedArrays := GetModuleSymbol(LibGL, 'glInterleavedArrays');
+    @glIsEnabled := GetModuleSymbol(LibGL, 'glIsEnabled');
+    @glIsList := GetModuleSymbol(LibGL, 'glIsList');
+    @glIsTexture := GetModuleSymbol(LibGL, 'glIsTexture');
+    @glLightModelf := GetModuleSymbol(LibGL, 'glLightModelf');
+    @glLightModelfv := GetModuleSymbol(LibGL, 'glLightModelfv');
+    @glLightModeli := GetModuleSymbol(LibGL, 'glLightModeli');
+    @glLightModeliv := GetModuleSymbol(LibGL, 'glLightModeliv');
+    @glLightf := GetModuleSymbol(LibGL, 'glLightf');
+    @glLightfv := GetModuleSymbol(LibGL, 'glLightfv');
+    @glLighti := GetModuleSymbol(LibGL, 'glLighti');
+    @glLightiv := GetModuleSymbol(LibGL, 'glLightiv');
+    @glLineStipple := GetModuleSymbol(LibGL, 'glLineStipple');
+    @glLineWidth := GetModuleSymbol(LibGL, 'glLineWidth');
+    @glListBase := GetModuleSymbol(LibGL, 'glListBase');
+    @glLoadIdentity := GetModuleSymbol(LibGL, 'glLoadIdentity');
+    @glLoadMatrixd := GetModuleSymbol(LibGL, 'glLoadMatrixd');
+    @glLoadMatrixf := GetModuleSymbol(LibGL, 'glLoadMatrixf');
+    @glLoadName := GetModuleSymbol(LibGL, 'glLoadName');
+    @glLogicOp := GetModuleSymbol(LibGL, 'glLogicOp');
+    @glMap1d := GetModuleSymbol(LibGL, 'glMap1d');
+    @glMap1f := GetModuleSymbol(LibGL, 'glMap1f');
+    @glMap2d := GetModuleSymbol(LibGL, 'glMap2d');
+    @glMap2f := GetModuleSymbol(LibGL, 'glMap2f');
+    @glMapGrid1d := GetModuleSymbol(LibGL, 'glMapGrid1d');
+    @glMapGrid1f := GetModuleSymbol(LibGL, 'glMapGrid1f');
+    @glMapGrid2d := GetModuleSymbol(LibGL, 'glMapGrid2d');
+    @glMapGrid2f := GetModuleSymbol(LibGL, 'glMapGrid2f');
+    @glMaterialf := GetModuleSymbol(LibGL, 'glMaterialf');
+    @glMaterialfv := GetModuleSymbol(LibGL, 'glMaterialfv');
+    @glMateriali := GetModuleSymbol(LibGL, 'glMateriali');
+    @glMaterialiv := GetModuleSymbol(LibGL, 'glMaterialiv');
+    @glMatrixMode := GetModuleSymbol(LibGL, 'glMatrixMode');
+    @glMultMatrixd := GetModuleSymbol(LibGL, 'glMultMatrixd');
+    @glMultMatrixf := GetModuleSymbol(LibGL, 'glMultMatrixf');
+    @glNewList := GetModuleSymbol(LibGL, 'glNewList');
+    @glNormal3b := GetModuleSymbol(LibGL, 'glNormal3b');
+    @glNormal3bv := GetModuleSymbol(LibGL, 'glNormal3bv');
+    @glNormal3d := GetModuleSymbol(LibGL, 'glNormal3d');
+    @glNormal3dv := GetModuleSymbol(LibGL, 'glNormal3dv');
+    @glNormal3f := GetModuleSymbol(LibGL, 'glNormal3f');
+    @glNormal3fv := GetModuleSymbol(LibGL, 'glNormal3fv');
+    @glNormal3i := GetModuleSymbol(LibGL, 'glNormal3i');
+    @glNormal3iv := GetModuleSymbol(LibGL, 'glNormal3iv');
+    @glNormal3s := GetModuleSymbol(LibGL, 'glNormal3s');
+    @glNormal3sv := GetModuleSymbol(LibGL, 'glNormal3sv');
+    @glNormalPointer := GetModuleSymbol(LibGL, 'glNormalPointer');
+    @glOrtho := GetModuleSymbol(LibGL, 'glOrtho');
+    @glPassThrough := GetModuleSymbol(LibGL, 'glPassThrough');
+    @glPixelMapfv := GetModuleSymbol(LibGL, 'glPixelMapfv');
+    @glPixelMapuiv := GetModuleSymbol(LibGL, 'glPixelMapuiv');
+    @glPixelMapusv := GetModuleSymbol(LibGL, 'glPixelMapusv');
+    @glPixelStoref := GetModuleSymbol(LibGL, 'glPixelStoref');
+    @glPixelStorei := GetModuleSymbol(LibGL, 'glPixelStorei');
+    @glPixelTransferf := GetModuleSymbol(LibGL, 'glPixelTransferf');
+    @glPixelTransferi := GetModuleSymbol(LibGL, 'glPixelTransferi');
+    @glPixelZoom := GetModuleSymbol(LibGL, 'glPixelZoom');
+    @glPointSize := GetModuleSymbol(LibGL, 'glPointSize');
+    @glPolygonMode := GetModuleSymbol(LibGL, 'glPolygonMode');
+    @glPolygonOffset := GetModuleSymbol(LibGL, 'glPolygonOffset');
+    @glPolygonStipple := GetModuleSymbol(LibGL, 'glPolygonStipple');
+    @glPopAttrib := GetModuleSymbol(LibGL, 'glPopAttrib');
+    @glPopClientAttrib := GetModuleSymbol(LibGL, 'glPopClientAttrib');
+    @glPopMatrix := GetModuleSymbol(LibGL, 'glPopMatrix');
+    @glPopName := GetModuleSymbol(LibGL, 'glPopName');
+    @glPrioritizeTextures := GetModuleSymbol(LibGL, 'glPrioritizeTextures');
+    @glPushAttrib := GetModuleSymbol(LibGL, 'glPushAttrib');
+    @glPushClientAttrib := GetModuleSymbol(LibGL, 'glPushClientAttrib');
+    @glPushMatrix := GetModuleSymbol(LibGL, 'glPushMatrix');
+    @glPushName := GetModuleSymbol(LibGL, 'glPushName');
+    @glRasterPos2d := GetModuleSymbol(LibGL, 'glRasterPos2d');
+    @glRasterPos2dv := GetModuleSymbol(LibGL, 'glRasterPos2dv');
+    @glRasterPos2f := GetModuleSymbol(LibGL, 'glRasterPos2f');
+    @glRasterPos2fv := GetModuleSymbol(LibGL, 'glRasterPos2fv');
+    @glRasterPos2i := GetModuleSymbol(LibGL, 'glRasterPos2i');
+    @glRasterPos2iv := GetModuleSymbol(LibGL, 'glRasterPos2iv');
+    @glRasterPos2s := GetModuleSymbol(LibGL, 'glRasterPos2s');
+    @glRasterPos2sv := GetModuleSymbol(LibGL, 'glRasterPos2sv');
+    @glRasterPos3d := GetModuleSymbol(LibGL, 'glRasterPos3d');
+    @glRasterPos3dv := GetModuleSymbol(LibGL, 'glRasterPos3dv');
+    @glRasterPos3f := GetModuleSymbol(LibGL, 'glRasterPos3f');
+    @glRasterPos3fv := GetModuleSymbol(LibGL, 'glRasterPos3fv');
+    @glRasterPos3i := GetModuleSymbol(LibGL, 'glRasterPos3i');
+    @glRasterPos3iv := GetModuleSymbol(LibGL, 'glRasterPos3iv');
+    @glRasterPos3s := GetModuleSymbol(LibGL, 'glRasterPos3s');
+    @glRasterPos3sv := GetModuleSymbol(LibGL, 'glRasterPos3sv');
+    @glRasterPos4d := GetModuleSymbol(LibGL, 'glRasterPos4d');
+    @glRasterPos4dv := GetModuleSymbol(LibGL, 'glRasterPos4dv');
+    @glRasterPos4f := GetModuleSymbol(LibGL, 'glRasterPos4f');
+    @glRasterPos4fv := GetModuleSymbol(LibGL, 'glRasterPos4fv');
+    @glRasterPos4i := GetModuleSymbol(LibGL, 'glRasterPos4i');
+    @glRasterPos4iv := GetModuleSymbol(LibGL, 'glRasterPos4iv');
+    @glRasterPos4s := GetModuleSymbol(LibGL, 'glRasterPos4s');
+    @glRasterPos4sv := GetModuleSymbol(LibGL, 'glRasterPos4sv');
+    @glReadBuffer := GetModuleSymbol(LibGL, 'glReadBuffer');
+    @glReadPixels := GetModuleSymbol(LibGL, 'glReadPixels');
+    @glRectd := GetModuleSymbol(LibGL, 'glRectd');
+    @glRectdv := GetModuleSymbol(LibGL, 'glRectdv');
+    @glRectf := GetModuleSymbol(LibGL, 'glRectf');
+    @glRectfv := GetModuleSymbol(LibGL, 'glRectfv');
+    @glRecti := GetModuleSymbol(LibGL, 'glRecti');
+    @glRectiv := GetModuleSymbol(LibGL, 'glRectiv');
+    @glRects := GetModuleSymbol(LibGL, 'glRects');
+    @glRectsv := GetModuleSymbol(LibGL, 'glRectsv');
+    @glRenderMode := GetModuleSymbol(LibGL, 'glRenderMode');
+    @glRotated := GetModuleSymbol(LibGL, 'glRotated');
+    @glRotatef := GetModuleSymbol(LibGL, 'glRotatef');
+    @glScaled := GetModuleSymbol(LibGL, 'glScaled');
+    @glScalef := GetModuleSymbol(LibGL, 'glScalef');
+    @glScissor := GetModuleSymbol(LibGL, 'glScissor');
+    @glSelectBuffer := GetModuleSymbol(LibGL, 'glSelectBuffer');
+    @glShadeModel := GetModuleSymbol(LibGL, 'glShadeModel');
+    @glStencilFunc := GetModuleSymbol(LibGL, 'glStencilFunc');
+    @glStencilMask := GetModuleSymbol(LibGL, 'glStencilMask');
+    @glStencilOp := GetModuleSymbol(LibGL, 'glStencilOp');
+    @glTexCoord1d := GetModuleSymbol(LibGL, 'glTexCoord1d');
+    @glTexCoord1dv := GetModuleSymbol(LibGL, 'glTexCoord1dv');
+    @glTexCoord1f := GetModuleSymbol(LibGL, 'glTexCoord1f');
+    @glTexCoord1fv := GetModuleSymbol(LibGL, 'glTexCoord1fv');
+    @glTexCoord1i := GetModuleSymbol(LibGL, 'glTexCoord1i');
+    @glTexCoord1iv := GetModuleSymbol(LibGL, 'glTexCoord1iv');
+    @glTexCoord1s := GetModuleSymbol(LibGL, 'glTexCoord1s');
+    @glTexCoord1sv := GetModuleSymbol(LibGL, 'glTexCoord1sv');
+    @glTexCoord2d := GetModuleSymbol(LibGL, 'glTexCoord2d');
+    @glTexCoord2dv := GetModuleSymbol(LibGL, 'glTexCoord2dv');
+    @glTexCoord2f := GetModuleSymbol(LibGL, 'glTexCoord2f');
+    @glTexCoord2fv := GetModuleSymbol(LibGL, 'glTexCoord2fv');
+    @glTexCoord2i := GetModuleSymbol(LibGL, 'glTexCoord2i');
+    @glTexCoord2iv := GetModuleSymbol(LibGL, 'glTexCoord2iv');
+    @glTexCoord2s := GetModuleSymbol(LibGL, 'glTexCoord2s');
+    @glTexCoord2sv := GetModuleSymbol(LibGL, 'glTexCoord2sv');
+    @glTexCoord3d := GetModuleSymbol(LibGL, 'glTexCoord3d');
+    @glTexCoord3dv := GetModuleSymbol(LibGL, 'glTexCoord3dv');
+    @glTexCoord3f := GetModuleSymbol(LibGL, 'glTexCoord3f');
+    @glTexCoord3fv := GetModuleSymbol(LibGL, 'glTexCoord3fv');
+    @glTexCoord3i := GetModuleSymbol(LibGL, 'glTexCoord3i');
+    @glTexCoord3iv := GetModuleSymbol(LibGL, 'glTexCoord3iv');
+    @glTexCoord3s := GetModuleSymbol(LibGL, 'glTexCoord3s');
+    @glTexCoord3sv := GetModuleSymbol(LibGL, 'glTexCoord3sv');
+    @glTexCoord4d := GetModuleSymbol(LibGL, 'glTexCoord4d');
+    @glTexCoord4dv := GetModuleSymbol(LibGL, 'glTexCoord4dv');
+    @glTexCoord4f := GetModuleSymbol(LibGL, 'glTexCoord4f');
+    @glTexCoord4fv := GetModuleSymbol(LibGL, 'glTexCoord4fv');
+    @glTexCoord4i := GetModuleSymbol(LibGL, 'glTexCoord4i');
+    @glTexCoord4iv := GetModuleSymbol(LibGL, 'glTexCoord4iv');
+    @glTexCoord4s := GetModuleSymbol(LibGL, 'glTexCoord4s');
+    @glTexCoord4sv := GetModuleSymbol(LibGL, 'glTexCoord4sv');
+    @glTexCoordPointer := GetModuleSymbol(LibGL, 'glTexCoordPointer');
+    @glTexEnvf := GetModuleSymbol(LibGL, 'glTexEnvf');
+    @glTexEnvfv := GetModuleSymbol(LibGL, 'glTexEnvfv');
+    @glTexEnvi := GetModuleSymbol(LibGL, 'glTexEnvi');
+    @glTexEnviv := GetModuleSymbol(LibGL, 'glTexEnviv');
+    @glTexGend := GetModuleSymbol(LibGL, 'glTexGend');
+    @glTexGendv := GetModuleSymbol(LibGL, 'glTexGendv');
+    @glTexGenf := GetModuleSymbol(LibGL, 'glTexGenf');
+    @glTexGenfv := GetModuleSymbol(LibGL, 'glTexGenfv');
+    @glTexGeni := GetModuleSymbol(LibGL, 'glTexGeni');
+    @glTexGeniv := GetModuleSymbol(LibGL, 'glTexGeniv');
+    @glTexImage1D := GetModuleSymbol(LibGL, 'glTexImage1D');
+    @glTexImage2D := GetModuleSymbol(LibGL, 'glTexImage2D');
+    @glTexParameterf := GetModuleSymbol(LibGL, 'glTexParameterf');
+    @glTexParameterfv := GetModuleSymbol(LibGL, 'glTexParameterfv');
+    @glTexParameteri := GetModuleSymbol(LibGL, 'glTexParameteri');
+    @glTexParameteriv := GetModuleSymbol(LibGL, 'glTexParameteriv');
+    @glTexSubImage1D := GetModuleSymbol(LibGL, 'glTexSubImage1D');
+    @glTexSubImage2D := GetModuleSymbol(LibGL, 'glTexSubImage2D');
+    @glTranslated := GetModuleSymbol(LibGL, 'glTranslated');
+    @glTranslatef := GetModuleSymbol(LibGL, 'glTranslatef');
+    @glVertex2d := GetModuleSymbol(LibGL, 'glVertex2d');
+    @glVertex2dv := GetModuleSymbol(LibGL, 'glVertex2dv');
+    @glVertex2f := GetModuleSymbol(LibGL, 'glVertex2f');
+    @glVertex2fv := GetModuleSymbol(LibGL, 'glVertex2fv');
+    @glVertex2i := GetModuleSymbol(LibGL, 'glVertex2i');
+    @glVertex2iv := GetModuleSymbol(LibGL, 'glVertex2iv');
+    @glVertex2s := GetModuleSymbol(LibGL, 'glVertex2s');
+    @glVertex2sv := GetModuleSymbol(LibGL, 'glVertex2sv');
+    @glVertex3d := GetModuleSymbol(LibGL, 'glVertex3d');
+    @glVertex3dv := GetModuleSymbol(LibGL, 'glVertex3dv');
+    @glVertex3f := GetModuleSymbol(LibGL, 'glVertex3f');
+    @glVertex3fv := GetModuleSymbol(LibGL, 'glVertex3fv');
+    @glVertex3i := GetModuleSymbol(LibGL, 'glVertex3i');
+    @glVertex3iv := GetModuleSymbol(LibGL, 'glVertex3iv');
+    @glVertex3s := GetModuleSymbol(LibGL, 'glVertex3s');
+    @glVertex3sv := GetModuleSymbol(LibGL, 'glVertex3sv');
+    @glVertex4d := GetModuleSymbol(LibGL, 'glVertex4d');
+    @glVertex4dv := GetModuleSymbol(LibGL, 'glVertex4dv');
+    @glVertex4f := GetModuleSymbol(LibGL, 'glVertex4f');
+    @glVertex4fv := GetModuleSymbol(LibGL, 'glVertex4fv');
+    @glVertex4i := GetModuleSymbol(LibGL, 'glVertex4i');
+    @glVertex4iv := GetModuleSymbol(LibGL, 'glVertex4iv');
+    @glVertex4s := GetModuleSymbol(LibGL, 'glVertex4s');
+    @glVertex4sv := GetModuleSymbol(LibGL, 'glVertex4sv');
+    @glVertexPointer := GetModuleSymbol(LibGL, 'glVertexPointer');
+    @glViewport := GetModuleSymbol(LibGL, 'glViewport');
+
+    {$IFDEF WIN32}
+    @ChoosePixelFormat := GetModuleSymbol(LibGL, 'ChoosePixelFormat');
+    if not Assigned(ChoosePixelFormat) then
+      {$IFNDEF FPC}@{$ENDIF}ChoosePixelFormat := @Windows.ChoosePixelFormat;
+    {$ENDIF}
+  end;
+end;
+
+initialization
+  {$IFNDEF FPC}
+  {$IFNDEF __GPC__}
+  Set8087CW($133F);
+  {$ENDIF}
+  {$ENDIF}
+
+  LoadOpenGL( GLLibName );
+
+finalization
+
+  FreeOpenGL;
+
+end.
+
diff --git a/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glext.pas b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glext.pas
new file mode 100644
index 00000000..19ed2023
--- /dev/null
+++ b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glext.pas
@@ -0,0 +1,8527 @@
+unit glext;
+{
+  $Id: glext.pas,v 1.3 2004/08/24 19:33:06 savage Exp $
+  
+}
+(**************************************************
+ *        OpenGL extension loading library        *
+ * Generated by MetaGLext, written by Tom Nuydens *
+ *  (tom@delphi3d.net -- http://www.delphi3d.net  *
+ **************************************************)
+
+{
+  $Log: glext.pas,v $
+  Revision 1.3  2004/08/24 19:33:06  savage
+  Removed declarations of SDL_GL_GetProcAddress as the correct ones are in sdl.pas.
+
+  Revision 1.2  2004/08/09 00:38:01  savage
+  Updated to Tom's latest version. May contains bugs, but I hope not.
+
+  Revision 1.1  2004/03/30 21:53:54  savage
+  Moved to it's own folder.
+
+  Revision 1.6  2004/03/28 00:28:43  savage
+  Fixed some glSecondaryColor definitions...
+
+  Revision 1.5  2004/02/20 17:18:16  savage
+  Forgot to prefix function pointer with @ for FPC and other Pascal compilers.
+
+  Revision 1.4  2004/02/20 17:09:55  savage
+  Code tidied up in gl, glu and glut, while extensions in glext.pas are now loaded using SDL_GL_GetProcAddress, thus making it more cross-platform compatible, but now more tied to SDL.
+
+  Revision 1.3  2004/02/14 22:36:29  savage
+  Fixed inconsistencies of using LoadLibrary and LoadModule.
+  Now all units make use of LoadModule rather than LoadLibrary and other dynamic proc procedures.
+
+  Revision 1.2  2004/02/14 00:09:19  savage
+  Changed uses to now make use of moduleloader.pas rather than dllfuncs.pas
+
+  Revision 1.1  2004/02/05 00:08:19  savage
+  Module 1.0 release
+
+  Revision 1.7  2003/06/02 12:32:13  savage
+  Modified Sources to avoid warnings with Delphi by moving CVS Logging to the top of the header files. Hopefully CVS Logging still works.
+
+}
+
+interface
+
+{$I jedi-sdl.inc}
+
+uses
+  SysUtils,
+{$IFDEF __GPC__}
+  gpc,
+{$ENDIF}
+
+{$IFDEF WIN32}
+  Windows,
+{$ENDIF}
+  moduleloader,
+  gl;
+
+// Test if the given extension name is present in the given extension string.
+function glext_ExtensionSupported(const extension: PChar; const searchIn: PChar): Boolean;
+
+// Load the extension with the given name.
+function glext_LoadExtension(ext: PChar): Boolean;
+
+// Some types that were introduced by extensions:
+type
+  GLintptrARB = Integer;
+  PGLintptrARB = ^GLintptrARB;
+
+  GLsizeiptrARB = Integer;
+  PGLsizeiptrARB = ^GLsizeiptrARB;
+
+  GLcharARB = Char;
+  PGLcharARB = ^GLcharARB;
+
+  GLhandleARB = Cardinal;
+  PGLhandleARB = ^GLhandleARB;
+
+//***** GL_version_1_2 *****//
+const
+  GL_UNSIGNED_BYTE_3_3_2 = $8032;
+  GL_UNSIGNED_SHORT_4_4_4_4 = $8033;
+  GL_UNSIGNED_SHORT_5_5_5_1 = $8034;
+  GL_UNSIGNED_INT_8_8_8_8 = $8035;
+  GL_UNSIGNED_INT_10_10_10_2 = $8036;
+  GL_RESCALE_NORMAL = $803A;
+  GL_UNSIGNED_BYTE_2_3_3_REV = $8362;
+  GL_UNSIGNED_SHORT_5_6_5 = $8363;
+  GL_UNSIGNED_SHORT_5_6_5_REV = $8364;
+  GL_UNSIGNED_SHORT_4_4_4_4_REV = $8365;
+  GL_UNSIGNED_SHORT_1_5_5_5_REV = $8366;
+  GL_UNSIGNED_INT_8_8_8_8_REV = $8367;
+  GL_UNSIGNED_INT_2_10_10_10_REV = $8368;
+  GL_BGR = $80E0;
+  GL_BGRA = $80E1;
+  GL_MAX_ELEMENTS_VERTICES = $80E8;
+  GL_MAX_ELEMENTS_INDICES = $80E9;
+  GL_CLAMP_TO_EDGE = $812F;
+  GL_TEXTURE_MIN_LOD = $813A;
+  GL_TEXTURE_MAX_LOD = $813B;
+  GL_TEXTURE_BASE_LEVEL = $813C;
+  GL_TEXTURE_MAX_LEVEL = $813D;
+  GL_LIGHT_MODEL_COLOR_CONTROL = $81F8;
+  GL_SINGLE_COLOR = $81F9;
+  GL_SEPARATE_SPECULAR_COLOR = $81FA;
+  GL_SMOOTH_POINT_SIZE_RANGE = $0B12;
+  GL_SMOOTH_POINT_SIZE_GRANULARITY = $0B13;
+  GL_SMOOTH_LINE_WIDTH_RANGE = $0B22;
+  GL_SMOOTH_LINE_WIDTH_GRANULARITY = $0B23;
+  GL_ALIASED_POINT_SIZE_RANGE = $846D;
+  GL_ALIASED_LINE_WIDTH_RANGE = $846E;
+  GL_PACK_SKIP_IMAGES = $806B;
+  GL_PACK_IMAGE_HEIGHT = $806C;
+  GL_UNPACK_SKIP_IMAGES = $806D;
+  GL_UNPACK_IMAGE_HEIGHT = $806E;
+  GL_TEXTURE_3D = $806F;
+  GL_PROXY_TEXTURE_3D = $8070;
+  GL_TEXTURE_DEPTH = $8071;
+  GL_TEXTURE_WRAP_R = $8072;
+  GL_MAX_3D_TEXTURE_SIZE = $8073;
+var
+  glDrawRangeElements: procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexImage3D: procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexSubImage3D: procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyTexSubImage3D: procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_version_1_2: Boolean;
+
+//***** GL_ARB_imaging *****//
+const
+  GL_CONSTANT_COLOR = $8001;
+  GL_ONE_MINUS_CONSTANT_COLOR = $8002;
+  GL_CONSTANT_ALPHA = $8003;
+  GL_ONE_MINUS_CONSTANT_ALPHA = $8004;
+  GL_BLEND_COLOR = $8005;
+  GL_FUNC_ADD = $8006;
+  GL_MIN = $8007;
+  GL_MAX = $8008;
+  GL_BLEND_EQUATION = $8009;
+  GL_FUNC_SUBTRACT = $800A;
+  GL_FUNC_REVERSE_SUBTRACT = $800B;
+  GL_CONVOLUTION_1D = $8010;
+  GL_CONVOLUTION_2D = $8011;
+  GL_SEPARABLE_2D = $8012;
+  GL_CONVOLUTION_BORDER_MODE = $8013;
+  GL_CONVOLUTION_FILTER_SCALE = $8014;
+  GL_CONVOLUTION_FILTER_BIAS = $8015;
+  GL_REDUCE = $8016;
+  GL_CONVOLUTION_FORMAT = $8017;
+  GL_CONVOLUTION_WIDTH = $8018;
+  GL_CONVOLUTION_HEIGHT = $8019;
+  GL_MAX_CONVOLUTION_WIDTH = $801A;
+  GL_MAX_CONVOLUTION_HEIGHT = $801B;
+  GL_POST_CONVOLUTION_RED_SCALE = $801C;
+  GL_POST_CONVOLUTION_GREEN_SCALE = $801D;
+  GL_POST_CONVOLUTION_BLUE_SCALE = $801E;
+  GL_POST_CONVOLUTION_ALPHA_SCALE = $801F;
+  GL_POST_CONVOLUTION_RED_BIAS = $8020;
+  GL_POST_CONVOLUTION_GREEN_BIAS = $8021;
+  GL_POST_CONVOLUTION_BLUE_BIAS = $8022;
+  GL_POST_CONVOLUTION_ALPHA_BIAS = $8023;
+  GL_HISTOGRAM = $8024;
+  GL_PROXY_HISTOGRAM = $8025;
+  GL_HISTOGRAM_WIDTH = $8026;
+  GL_HISTOGRAM_FORMAT = $8027;
+  GL_HISTOGRAM_RED_SIZE = $8028;
+  GL_HISTOGRAM_GREEN_SIZE = $8029;
+  GL_HISTOGRAM_BLUE_SIZE = $802A;
+  GL_HISTOGRAM_ALPHA_SIZE = $802B;
+  GL_HISTOGRAM_LUMINANCE_SIZE = $802C;
+  GL_HISTOGRAM_SINK = $802D;
+  GL_MINMAX = $802E;
+  GL_MINMAX_FORMAT = $802F;
+  GL_MINMAX_SINK = $8030;
+  GL_TABLE_TOO_LARGE = $8031;
+  GL_COLOR_MATRIX = $80B1;
+  GL_COLOR_MATRIX_STACK_DEPTH = $80B2;
+  GL_MAX_COLOR_MATRIX_STACK_DEPTH = $80B3;
+  GL_POST_COLOR_MATRIX_RED_SCALE = $80B4;
+  GL_POST_COLOR_MATRIX_GREEN_SCALE = $80B5;
+  GL_POST_COLOR_MATRIX_BLUE_SCALE = $80B6;
+  GL_POST_COLOR_MATRIX_ALPHA_SCALE = $80B7;
+  GL_POST_COLOR_MATRIX_RED_BIAS = $80B8;
+  GL_POST_COLOR_MATRIX_GREEN_BIAS = $80B9;
+  GL_POST_COLOR_MATRIX_BLUE_BIAS = $80BA;
+  GL_POST_COLOR_MATIX_ALPHA_BIAS = $80BB;
+  GL_COLOR_TABLE = $80D0;
+  GL_POST_CONVOLUTION_COLOR_TABLE = $80D1;
+  GL_POST_COLOR_MATRIX_COLOR_TABLE = $80D2;
+  GL_PROXY_COLOR_TABLE = $80D3;
+  GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = $80D4;
+  GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = $80D5;
+  GL_COLOR_TABLE_SCALE = $80D6;
+  GL_COLOR_TABLE_BIAS = $80D7;
+  GL_COLOR_TABLE_FORMAT = $80D8;
+  GL_COLOR_TABLE_WIDTH = $80D9;
+  GL_COLOR_TABLE_RED_SIZE = $80DA;
+  GL_COLOR_TABLE_GREEN_SIZE = $80DB;
+  GL_COLOR_TABLE_BLUE_SIZE = $80DC;
+  GL_COLOR_TABLE_ALPHA_SIZE = $80DD;
+  GL_COLOR_TABLE_LUMINANCE_SIZE = $80DE;
+  GL_COLOR_TABLE_INTENSITY_SIZE = $80DF;
+  GL_IGNORE_BORDER = $8150;
+  GL_CONSTANT_BORDER = $8151;
+  GL_WRAP_BORDER = $8152;
+  GL_REPLICATE_BORDER = $8153;
+  GL_CONVOLUTION_BORDER_COLOR = $8154;
+var
+  glColorTable: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorTableParameterfv: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorTableParameteriv: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyColorTable: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetColorTable: procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetColorTableParameterfv: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetColorTableParameteriv: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorSubTable: procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyColorSubTable: procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionFilter1D: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionFilter2D: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionParameterf: procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionParameterfv: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionParameteri: procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionParameteriv: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyConvolutionFilter1D: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyConvolutionFilter2D: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetConvolutionFilter: procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetConvolutionParameterfv: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetConvolutionParameteriv: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetSeparableFilter: procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSeparableFilter2D: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetHistogram: procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetHistogramParameterfv: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetHistogramParameteriv: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMinmax: procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMinmaxParameterfv: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMinmaxParameteriv: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glHistogram: procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMinmax: procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glResetHistogram: procedure(target: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glResetMinmax: procedure(target: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBlendEquation: procedure(mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBlendColor: procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_imaging: Boolean;
+
+//***** GL_version_1_3 *****//
+const
+  GL_TEXTURE0 = $84C0;
+  GL_TEXTURE1 = $84C1;
+  GL_TEXTURE2 = $84C2;
+  GL_TEXTURE3 = $84C3;
+  GL_TEXTURE4 = $84C4;
+  GL_TEXTURE5 = $84C5;
+  GL_TEXTURE6 = $84C6;
+  GL_TEXTURE7 = $84C7;
+  GL_TEXTURE8 = $84C8;
+  GL_TEXTURE9 = $84C9;
+  GL_TEXTURE10 = $84CA;
+  GL_TEXTURE11 = $84CB;
+  GL_TEXTURE12 = $84CC;
+  GL_TEXTURE13 = $84CD;
+  GL_TEXTURE14 = $84CE;
+  GL_TEXTURE15 = $84CF;
+  GL_TEXTURE16 = $84D0;
+  GL_TEXTURE17 = $84D1;
+  GL_TEXTURE18 = $84D2;
+  GL_TEXTURE19 = $84D3;
+  GL_TEXTURE20 = $84D4;
+  GL_TEXTURE21 = $84D5;
+  GL_TEXTURE22 = $84D6;
+  GL_TEXTURE23 = $84D7;
+  GL_TEXTURE24 = $84D8;
+  GL_TEXTURE25 = $84D9;
+  GL_TEXTURE26 = $84DA;
+  GL_TEXTURE27 = $84DB;
+  GL_TEXTURE28 = $84DC;
+  GL_TEXTURE29 = $84DD;
+  GL_TEXTURE30 = $84DE;
+  GL_TEXTURE31 = $84DF;
+  GL_ACTIVE_TEXTURE = $84E0;
+  GL_CLIENT_ACTIVE_TEXTURE = $84E1;
+  GL_MAX_TEXTURE_UNITS = $84E2;
+  GL_TRANSPOSE_MODELVIEW_MATRIX = $84E3;
+  GL_TRANSPOSE_PROJECTION_MATRIX = $84E4;
+  GL_TRANSPOSE_TEXTURE_MATRIX = $84E5;
+  GL_TRANSPOSE_COLOR_MATRIX = $84E6;
+  GL_MULTISAMPLE = $809D;
+  GL_SAMPLE_ALPHA_TO_COVERAGE = $809E;
+  GL_SAMPLE_ALPHA_TO_ONE = $809F;
+  GL_SAMPLE_COVERAGE = $80A0;
+  GL_SAMPLE_BUFFERS = $80A8;
+  GL_SAMPLES = $80A9;
+  GL_SAMPLE_COVERAGE_VALUE = $80AA;
+  GL_SAMPLE_COVERAGE_INVERT = $80AB;
+  GL_MULTISAMPLE_BIT = $20000000;
+  GL_NORMAL_MAP = $8511;
+  GL_REFLECTION_MAP = $8512;
+  GL_TEXTURE_CUBE_MAP = $8513;
+  GL_TEXTURE_BINDING_CUBE_MAP = $8514;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X = $8515;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $8516;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $8517;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $8518;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $8519;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $851A;
+  GL_PROXY_TEXTURE_CUBE_MAP = $851B;
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C;
+  GL_COMPRESSED_ALPHA = $84E9;
+  GL_COMPRESSED_LUMINANCE = $84EA;
+  GL_COMPRESSED_LUMINANCE_ALPHA = $84EB;
+  GL_COMPRESSED_INTENSITY = $84EC;
+  GL_COMPRESSED_RGB = $84ED;
+  GL_COMPRESSED_RGBA = $84EE;
+  GL_TEXTURE_COMPRESSION_HINT = $84EF;
+  GL_TEXTURE_COMPRESSED_IMAGE_SIZE = $86A0;
+  GL_TEXTURE_COMPRESSED = $86A1;
+  GL_NUM_COMPRESSED_TEXTURE_FORMATS = $86A2;
+  GL_COMPRESSED_TEXTURE_FORMATS = $86A3;
+  GL_CLAMP_TO_BORDER = $812D;
+  GL_CLAMP_TO_BORDER_SGIS = $812D;
+  GL_COMBINE = $8570;
+  GL_COMBINE_RGB = $8571;
+  GL_COMBINE_ALPHA = $8572;
+  GL_SOURCE0_RGB = $8580;
+  GL_SOURCE1_RGB = $8581;
+  GL_SOURCE2_RGB = $8582;
+  GL_SOURCE0_ALPHA = $8588;
+  GL_SOURCE1_ALPHA = $8589;
+  GL_SOURCE2_ALPHA = $858A;
+  GL_OPERAND0_RGB = $8590;
+  GL_OPERAND1_RGB = $8591;
+  GL_OPERAND2_RGB = $8592;
+  GL_OPERAND0_ALPHA = $8598;
+  GL_OPERAND1_ALPHA = $8599;
+  GL_OPERAND2_ALPHA = $859A;
+  GL_RGB_SCALE = $8573;
+  GL_ADD_SIGNED = $8574;
+  GL_INTERPOLATE = $8575;
+  GL_SUBTRACT = $84E7;
+  GL_CONSTANT = $8576;
+  GL_PRIMARY_COLOR = $8577;
+  GL_PREVIOUS = $8578;
+  GL_DOT3_RGB = $86AE;
+  GL_DOT3_RGBA = $86AF;
+var
+  glActiveTexture: procedure(texture: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glClientActiveTexture: procedure(texture: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1d: procedure(target: GLenum; s: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1dv: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1f: procedure(target: GLenum; s: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1fv: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1i: procedure(target: GLenum; s: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1iv: procedure(target: GLenum; const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1s: procedure(target: GLenum; s: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1sv: procedure(target: GLenum; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2d: procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2dv: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2f: procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2fv: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2i: procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2iv: procedure(target: GLenum; const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2s: procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2sv: procedure(target: GLenum; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3d: procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3dv: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3f: procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3fv: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3i: procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3iv: procedure(target: GLenum; const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3s: procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3sv: procedure(target: GLenum; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4d: procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4dv: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4f: procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4fv: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4i: procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4iv: procedure(target: GLenum; const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4s: procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4sv: procedure(target: GLenum; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLoadTransposeMatrixf: procedure(const m: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLoadTransposeMatrixd: procedure(const m: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultTransposeMatrixf: procedure(const m: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultTransposeMatrixd: procedure(const m: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSampleCoverage: procedure(value: GLclampf; invert: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexImage3D: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexImage2D: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexImage1D: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexSubImage3D: procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexSubImage2D: procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexSubImage1D: procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetCompressedTexImage: procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_version_1_3: Boolean;
+
+//***** GL_ARB_multitexture *****//
+const
+  GL_TEXTURE0_ARB = $84C0;
+  GL_TEXTURE1_ARB = $84C1;
+  GL_TEXTURE2_ARB = $84C2;
+  GL_TEXTURE3_ARB = $84C3;
+  GL_TEXTURE4_ARB = $84C4;
+  GL_TEXTURE5_ARB = $84C5;
+  GL_TEXTURE6_ARB = $84C6;
+  GL_TEXTURE7_ARB = $84C7;
+  GL_TEXTURE8_ARB = $84C8;
+  GL_TEXTURE9_ARB = $84C9;
+  GL_TEXTURE10_ARB = $84CA;
+  GL_TEXTURE11_ARB = $84CB;
+  GL_TEXTURE12_ARB = $84CC;
+  GL_TEXTURE13_ARB = $84CD;
+  GL_TEXTURE14_ARB = $84CE;
+  GL_TEXTURE15_ARB = $84CF;
+  GL_TEXTURE16_ARB = $84D0;
+  GL_TEXTURE17_ARB = $84D1;
+  GL_TEXTURE18_ARB = $84D2;
+  GL_TEXTURE19_ARB = $84D3;
+  GL_TEXTURE20_ARB = $84D4;
+  GL_TEXTURE21_ARB = $84D5;
+  GL_TEXTURE22_ARB = $84D6;
+  GL_TEXTURE23_ARB = $84D7;
+  GL_TEXTURE24_ARB = $84D8;
+  GL_TEXTURE25_ARB = $84D9;
+  GL_TEXTURE26_ARB = $84DA;
+  GL_TEXTURE27_ARB = $84DB;
+  GL_TEXTURE28_ARB = $84DC;
+  GL_TEXTURE29_ARB = $84DD;
+  GL_TEXTURE30_ARB = $84DE;
+  GL_TEXTURE31_ARB = $84DF;
+  GL_ACTIVE_TEXTURE_ARB = $84E0;
+  GL_CLIENT_ACTIVE_TEXTURE_ARB = $84E1;
+  GL_MAX_TEXTURE_UNITS_ARB = $84E2;
+var
+  glActiveTextureARB: procedure(texture: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glClientActiveTextureARB: procedure(texture: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1dARB: procedure(target: GLenum; s: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1dvARB: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1fARB: procedure(target: GLenum; s: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1fvARB: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1iARB: procedure(target: GLenum; s: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1ivARB: procedure(target: GLenum; const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1sARB: procedure(target: GLenum; s: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1svARB: procedure(target: GLenum; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2dARB: procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2dvARB: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2fARB: procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2fvARB: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2iARB: procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2ivARB: procedure(target: GLenum; const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2sARB: procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2svARB: procedure(target: GLenum; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3dARB: procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3dvARB: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3fARB: procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3fvARB: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3iARB: procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3ivARB: procedure(target: GLenum; const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3sARB: procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3svARB: procedure(target: GLenum; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4dARB: procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4dvARB: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4fARB: procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4fvARB: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4iARB: procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4ivARB: procedure(target: GLenum; const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4sARB: procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4svARB: procedure(target: GLenum; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_multitexture: Boolean;
+
+//***** GL_ARB_transpose_matrix *****//
+const
+  GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = $84E3;
+  GL_TRANSPOSE_PROJECTION_MATRIX_ARB = $84E4;
+  GL_TRANSPOSE_TEXTURE_MATRIX_ARB = $84E5;
+  GL_TRANSPOSE_COLOR_MATRIX_ARB = $84E6;
+var
+  glLoadTransposeMatrixfARB: procedure(m: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLoadTransposeMatrixdARB: procedure(m: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultTransposeMatrixfARB: procedure(m: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultTransposeMatrixdARB: procedure(m: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_transpose_matrix: Boolean;
+
+//***** GL_ARB_multisample *****//
+const
+  WGL_SAMPLE_BUFFERS_ARB = $2041;
+  WGL_SAMPLES_ARB = $2042;
+  GL_MULTISAMPLE_ARB = $809D;
+  GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = $809E;
+  GL_SAMPLE_ALPHA_TO_ONE_ARB = $809F;
+  GL_SAMPLE_COVERAGE_ARB = $80A0;
+  GL_MULTISAMPLE_BIT_ARB = $20000000;
+  GL_SAMPLE_BUFFERS_ARB = $80A8;
+  GL_SAMPLES_ARB = $80A9;
+  GL_SAMPLE_COVERAGE_VALUE_ARB = $80AA;
+  GL_SAMPLE_COVERAGE_INVERT_ARB = $80AB;
+var
+  glSampleCoverageARB: procedure(value: GLclampf; invert: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_multisample: Boolean;
+
+//***** GL_ARB_texture_env_add *****//
+
+function Load_GL_ARB_texture_env_add: Boolean;
+
+{$IFDEF Win32}
+//***** WGL_ARB_extensions_string *****//
+var
+  wglGetExtensionsStringARB: function(hdc: HDC): Pchar; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_ARB_extensions_string: Boolean;
+
+//***** WGL_ARB_buffer_region *****//
+const
+  WGL_FRONT_COLOR_BUFFER_BIT_ARB = $0001;
+  WGL_BACK_COLOR_BUFFER_BIT_ARB = $0002;
+  WGL_DEPTH_BUFFER_BIT_ARB = $0004;
+  WGL_STENCIL_BUFFER_BIT_ARB = $0008;
+var
+  wglCreateBufferRegionARB: function(hDC: HDC; iLayerPlane: GLint; uType: GLuint): THandle; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglDeleteBufferRegionARB: procedure(hRegion: THandle); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglSaveBufferRegionARB: function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglRestoreBufferRegionARB: function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint; xSrc: GLint; ySrc: GLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_ARB_buffer_region: Boolean;
+{$ENDIF}
+
+//***** GL_ARB_texture_cube_map *****//
+const
+  GL_NORMAL_MAP_ARB = $8511;
+  GL_REFLECTION_MAP_ARB = $8512;
+  GL_TEXTURE_CUBE_MAP_ARB = $8513;
+  GL_TEXTURE_BINDING_CUBE_MAP_ARB = $8514;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $8515;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $8516;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $8517;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $8518;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $8519;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $851A;
+  GL_PROXY_TEXTURE_CUBE_MAP_ARB = $851B;
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = $851C;
+
+function Load_GL_ARB_texture_cube_map: Boolean;
+
+//***** GL_ARB_depth_texture *****//
+const
+  GL_DEPTH_COMPONENT16_ARB = $81A5;
+  GL_DEPTH_COMPONENT24_ARB = $81A6;
+  GL_DEPTH_COMPONENT32_ARB = $81A7;
+  GL_TEXTURE_DEPTH_SIZE_ARB = $884A;
+  GL_DEPTH_TEXTURE_MODE_ARB = $884B;
+
+function Load_GL_ARB_depth_texture: Boolean;
+
+//***** GL_ARB_point_parameters *****//
+const
+  GL_POINT_SIZE_MIN_ARB = $8126;
+  GL_POINT_SIZE_MAX_ARB = $8127;
+  GL_POINT_FADE_THRESHOLD_SIZE_ARB = $8128;
+  GL_POINT_DISTANCE_ATTENUATION_ARB = $8129;
+var
+  glPointParameterfARB: procedure(pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPointParameterfvARB: procedure(pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_point_parameters: Boolean;
+
+//***** GL_ARB_shadow *****//
+const
+  GL_TEXTURE_COMPARE_MODE_ARB = $884C;
+  GL_TEXTURE_COMPARE_FUNC_ARB = $884D;
+  GL_COMPARE_R_TO_TEXTURE_ARB = $884E;
+
+function Load_GL_ARB_shadow: Boolean;
+
+//***** GL_ARB_shadow_ambient *****//
+const
+  GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = $80BF;
+
+function Load_GL_ARB_shadow_ambient: Boolean;
+
+//***** GL_ARB_texture_border_clamp *****//
+const
+  GL_CLAMP_TO_BORDER_ARB = $812D;
+
+function Load_GL_ARB_texture_border_clamp: Boolean;
+
+//***** GL_ARB_texture_compression *****//
+const
+  GL_COMPRESSED_ALPHA_ARB = $84E9;
+  GL_COMPRESSED_LUMINANCE_ARB = $84EA;
+  GL_COMPRESSED_LUMINANCE_ALPHA_ARB = $84EB;
+  GL_COMPRESSED_INTENSITY_ARB = $84EC;
+  GL_COMPRESSED_RGB_ARB = $84ED;
+  GL_COMPRESSED_RGBA_ARB = $84EE;
+  GL_TEXTURE_COMPRESSION_HINT_ARB = $84EF;
+  GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = $86A0;
+  GL_TEXTURE_COMPRESSED_ARB = $86A1;
+  GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = $86A2;
+  GL_COMPRESSED_TEXTURE_FORMATS_ARB = $86A3;
+var
+  glCompressedTexImage3DARB: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexImage2DARB: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexImage1DARB: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexSubImage3DARB: procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexSubImage2DARB: procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompressedTexSubImage1DARB: procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetCompressedTexImageARB: procedure(target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_texture_compression: Boolean;
+
+//***** GL_ARB_texture_env_combine *****//
+const
+  GL_COMBINE_ARB = $8570;
+  GL_COMBINE_RGB_ARB = $8571;
+  GL_COMBINE_ALPHA_ARB = $8572;
+  GL_SOURCE0_RGB_ARB = $8580;
+  GL_SOURCE1_RGB_ARB = $8581;
+  GL_SOURCE2_RGB_ARB = $8582;
+  GL_SOURCE0_ALPHA_ARB = $8588;
+  GL_SOURCE1_ALPHA_ARB = $8589;
+  GL_SOURCE2_ALPHA_ARB = $858A;
+  GL_OPERAND0_RGB_ARB = $8590;
+  GL_OPERAND1_RGB_ARB = $8591;
+  GL_OPERAND2_RGB_ARB = $8592;
+  GL_OPERAND0_ALPHA_ARB = $8598;
+  GL_OPERAND1_ALPHA_ARB = $8599;
+  GL_OPERAND2_ALPHA_ARB = $859A;
+  GL_RGB_SCALE_ARB = $8573;
+  GL_ADD_SIGNED_ARB = $8574;
+  GL_INTERPOLATE_ARB = $8575;
+  GL_SUBTRACT_ARB = $84E7;
+  GL_CONSTANT_ARB = $8576;
+  GL_PRIMARY_COLOR_ARB = $8577;
+  GL_PREVIOUS_ARB = $8578;
+
+function Load_GL_ARB_texture_env_combine: Boolean;
+
+//***** GL_ARB_texture_env_crossbar *****//
+
+function Load_GL_ARB_texture_env_crossbar: Boolean;
+
+//***** GL_ARB_texture_env_dot3 *****//
+const
+  GL_DOT3_RGB_ARB = $86AE;
+  GL_DOT3_RGBA_ARB = $86AF;
+
+function Load_GL_ARB_texture_env_dot3: Boolean;
+
+//***** GL_ARB_texture_mirrored_repeat *****//
+const
+  GL_MIRRORED_REPEAT_ARB = $8370;
+
+function Load_GL_ARB_texture_mirrored_repeat: Boolean;
+
+//***** GL_ARB_vertex_blend *****//
+const
+  GL_MAX_VERTEX_UNITS_ARB = $86A4;
+  GL_ACTIVE_VERTEX_UNITS_ARB = $86A5;
+  GL_WEIGHT_SUM_UNITY_ARB = $86A6;
+  GL_VERTEX_BLEND_ARB = $86A7;
+  GL_MODELVIEW0_ARB = $1700;
+  GL_MODELVIEW1_ARB = $850A;
+  GL_MODELVIEW2_ARB = $8722;
+  GL_MODELVIEW3_ARB = $8723;
+  GL_MODELVIEW4_ARB = $8724;
+  GL_MODELVIEW5_ARB = $8725;
+  GL_MODELVIEW6_ARB = $8726;
+  GL_MODELVIEW7_ARB = $8727;
+  GL_MODELVIEW8_ARB = $8728;
+  GL_MODELVIEW9_ARB = $8729;
+  GL_MODELVIEW10_ARB = $872A;
+  GL_MODELVIEW11_ARB = $872B;
+  GL_MODELVIEW12_ARB = $872C;
+  GL_MODELVIEW13_ARB = $872D;
+  GL_MODELVIEW14_ARB = $872E;
+  GL_MODELVIEW15_ARB = $872F;
+  GL_MODELVIEW16_ARB = $8730;
+  GL_MODELVIEW17_ARB = $8731;
+  GL_MODELVIEW18_ARB = $8732;
+  GL_MODELVIEW19_ARB = $8733;
+  GL_MODELVIEW20_ARB = $8734;
+  GL_MODELVIEW21_ARB = $8735;
+  GL_MODELVIEW22_ARB = $8736;
+  GL_MODELVIEW23_ARB = $8737;
+  GL_MODELVIEW24_ARB = $8738;
+  GL_MODELVIEW25_ARB = $8739;
+  GL_MODELVIEW26_ARB = $873A;
+  GL_MODELVIEW27_ARB = $873B;
+  GL_MODELVIEW28_ARB = $873C;
+  GL_MODELVIEW29_ARB = $873D;
+  GL_MODELVIEW30_ARB = $873E;
+  GL_MODELVIEW31_ARB = $873F;
+  GL_CURRENT_WEIGHT_ARB = $86A8;
+  GL_WEIGHT_ARRAY_TYPE_ARB = $86A9;
+  GL_WEIGHT_ARRAY_STRIDE_ARB = $86AA;
+  GL_WEIGHT_ARRAY_SIZE_ARB = $86AB;
+  GL_WEIGHT_ARRAY_POINTER_ARB = $86AC;
+  GL_WEIGHT_ARRAY_ARB = $86AD;
+var
+  glWeightbvARB: procedure(size: GLint; weights: PGLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWeightsvARB: procedure(size: GLint; weights: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWeightivARB: procedure(size: GLint; weights: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWeightfvARB: procedure(size: GLint; weights: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWeightdvARB: procedure(size: GLint; weights: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWeightvARB: procedure(size: GLint; weights: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWeightubvARB: procedure(size: GLint; weights: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWeightusvARB: procedure(size: GLint; weights: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWeightuivARB: procedure(size: GLint; weights: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWeightPointerARB: procedure(size: GLint; _type: GLenum; stride: GLsizei; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexBlendARB: procedure(count: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_vertex_blend: Boolean;
+
+//***** GL_ARB_vertex_program *****//
+const
+  GL_VERTEX_PROGRAM_ARB = $8620;
+  GL_VERTEX_PROGRAM_POINT_SIZE_ARB = $8642;
+  GL_VERTEX_PROGRAM_TWO_SIDE_ARB = $8643;
+  GL_COLOR_SUM_ARB = $8458;
+  GL_PROGRAM_FORMAT_ASCII_ARB = $8875;
+  GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = $8622;
+  GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = $8623;
+  GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = $8624;
+  GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = $8625;
+  GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = $886A;
+  GL_CURRENT_VERTEX_ATTRIB_ARB = $8626;
+  GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = $8645;
+  GL_PROGRAM_LENGTH_ARB = $8627;
+  GL_PROGRAM_FORMAT_ARB = $8876;
+  GL_PROGRAM_BINDING_ARB = $8677;
+  GL_PROGRAM_INSTRUCTIONS_ARB = $88A0;
+  GL_MAX_PROGRAM_INSTRUCTIONS_ARB = $88A1;
+  GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A2;
+  GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A3;
+  GL_PROGRAM_TEMPORARIES_ARB = $88A4;
+  GL_MAX_PROGRAM_TEMPORARIES_ARB = $88A5;
+  GL_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A6;
+  GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A7;
+  GL_PROGRAM_PARAMETERS_ARB = $88A8;
+  GL_MAX_PROGRAM_PARAMETERS_ARB = $88A9;
+  GL_PROGRAM_NATIVE_PARAMETERS_ARB = $88AA;
+  GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = $88AB;
+  GL_PROGRAM_ATTRIBS_ARB = $88AC;
+  GL_MAX_PROGRAM_ATTRIBS_ARB = $88AD;
+  GL_PROGRAM_NATIVE_ATTRIBS_ARB = $88AE;
+  GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = $88AF;
+  GL_PROGRAM_ADDRESS_REGISTERS_ARB = $88B0;
+  GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = $88B1;
+  GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B2;
+  GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B3;
+  GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = $88B4;
+  GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = $88B5;
+  GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = $88B6;
+  GL_PROGRAM_STRING_ARB = $8628;
+  GL_PROGRAM_ERROR_POSITION_ARB = $864B;
+  GL_CURRENT_MATRIX_ARB = $8641;
+  GL_TRANSPOSE_CURRENT_MATRIX_ARB = $88B7;
+  GL_CURRENT_MATRIX_STACK_DEPTH_ARB = $8640;
+  GL_MAX_VERTEX_ATTRIBS_ARB = $8869;
+  GL_MAX_PROGRAM_MATRICES_ARB = $862F;
+  GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = $862E;
+  GL_PROGRAM_ERROR_STRING_ARB = $8874;
+  GL_MATRIX0_ARB = $88C0;
+  GL_MATRIX1_ARB = $88C1;
+  GL_MATRIX2_ARB = $88C2;
+  GL_MATRIX3_ARB = $88C3;
+  GL_MATRIX4_ARB = $88C4;
+  GL_MATRIX5_ARB = $88C5;
+  GL_MATRIX6_ARB = $88C6;
+  GL_MATRIX7_ARB = $88C7;
+  GL_MATRIX8_ARB = $88C8;
+  GL_MATRIX9_ARB = $88C9;
+  GL_MATRIX10_ARB = $88CA;
+  GL_MATRIX11_ARB = $88CB;
+  GL_MATRIX12_ARB = $88CC;
+  GL_MATRIX13_ARB = $88CD;
+  GL_MATRIX14_ARB = $88CE;
+  GL_MATRIX15_ARB = $88CF;
+  GL_MATRIX16_ARB = $88D0;
+  GL_MATRIX17_ARB = $88D1;
+  GL_MATRIX18_ARB = $88D2;
+  GL_MATRIX19_ARB = $88D3;
+  GL_MATRIX20_ARB = $88D4;
+  GL_MATRIX21_ARB = $88D5;
+  GL_MATRIX22_ARB = $88D6;
+  GL_MATRIX23_ARB = $88D7;
+  GL_MATRIX24_ARB = $88D8;
+  GL_MATRIX25_ARB = $88D9;
+  GL_MATRIX26_ARB = $88DA;
+  GL_MATRIX27_ARB = $88DB;
+  GL_MATRIX28_ARB = $88DC;
+  GL_MATRIX29_ARB = $88DD;
+  GL_MATRIX30_ARB = $88DE;
+  GL_MATRIX31_ARB = $88DF;
+var
+  glVertexAttrib1sARB: procedure(index: GLuint; x: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1fARB: procedure(index: GLuint; x: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1dARB: procedure(index: GLuint; x: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2sARB: procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2fARB: procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2dARB: procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3sARB: procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3fARB: procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3dARB: procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4sARB: procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4fARB: procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4dARB: procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4NubARB: procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1svARB: procedure(index: GLuint; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1fvARB: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1dvARB: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2svARB: procedure(index: GLuint; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2fvARB: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2dvARB: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3svARB: procedure(index: GLuint; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3fvARB: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3dvARB: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4bvARB: procedure(index: GLuint; const v: PGLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4svARB: procedure(index: GLuint; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4ivARB: procedure(index: GLuint; const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4ubvARB: procedure(index: GLuint; const v: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4usvARB: procedure(index: GLuint; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4uivARB: procedure(index: GLuint; const v: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4fvARB: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4dvARB: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4NbvARB: procedure(index: GLuint; const v: PGLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4NsvARB: procedure(index: GLuint; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4NivARB: procedure(index: GLuint; const v: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4NubvARB: procedure(index: GLuint; const v: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4NusvARB: procedure(index: GLuint; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4NuivARB: procedure(index: GLuint; const v: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribPointerARB: procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEnableVertexAttribArrayARB: procedure(index: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDisableVertexAttribArrayARB: procedure(index: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramStringARB: procedure(target: GLenum; format: GLenum; len: GLsizei; const _string: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBindProgramARB: procedure(target: GLenum; _program: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteProgramsARB: procedure(n: GLsizei; const programs: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGenProgramsARB: procedure(n: GLsizei; programs: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramEnvParameter4dARB: procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramEnvParameter4dvARB: procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramEnvParameter4fARB: procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramEnvParameter4fvARB: procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramLocalParameter4dARB: procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramLocalParameter4dvARB: procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramLocalParameter4fARB: procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramLocalParameter4fvARB: procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramEnvParameterdvARB: procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramEnvParameterfvARB: procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramLocalParameterdvARB: procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramLocalParameterfvARB: procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramivARB: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramStringARB: procedure(target: GLenum; pname: GLenum; _string: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVertexAttribdvARB: procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVertexAttribfvARB: procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVertexAttribivARB: procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVertexAttribPointervARB: procedure(index: GLuint; pname: GLenum; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsProgramARB: function(_program: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_vertex_program: Boolean;
+
+//***** GL_ARB_window_pos *****//
+var
+  glWindowPos2dARB: procedure(x: GLdouble; y: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2fARB: procedure(x: GLfloat; y: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2iARB: procedure(x: GLint; y: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2sARB: procedure(x: GLshort; y: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2dvARB: procedure(const p: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2fvARB: procedure(const p: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2ivARB: procedure(const p: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2svARB: procedure(const p: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3dARB: procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3fARB: procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3iARB: procedure(x: GLint; y: GLint; z: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3sARB: procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3dvARB: procedure(const p: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3fvARB: procedure(const p: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3ivARB: procedure(const p: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3svARB: procedure(const p: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_window_pos: Boolean;
+
+//***** GL_EXT_422_pixels *****//
+const
+  GL_422_EXT = $80CC;
+  GL_422_REV_EXT = $80CD;
+  GL_422_AVERAGE_EXT = $80CE;
+  GL_422_REV_AVERAGE_EXT = $80CF;
+
+function Load_GL_EXT_422_pixels: Boolean;
+
+//***** GL_EXT_abgr *****//
+const
+  GL_ABGR_EXT = $8000;
+
+function Load_GL_EXT_abgr: Boolean;
+
+//***** GL_EXT_bgra *****//
+const
+  GL_BGR_EXT = $80E0;
+  GL_BGRA_EXT = $80E1;
+
+function Load_GL_EXT_bgra: Boolean;
+
+//***** GL_EXT_blend_color *****//
+const
+  GL_CONSTANT_COLOR_EXT = $8001;
+  GL_ONE_MINUS_CONSTANT_COLOR_EXT = $8002;
+  GL_CONSTANT_ALPHA_EXT = $8003;
+  GL_ONE_MINUS_CONSTANT_ALPHA_EXT = $8004;
+  GL_BLEND_COLOR_EXT = $8005;
+var
+  glBlendColorEXT: procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_blend_color: Boolean;
+
+//***** GL_EXT_blend_func_separate *****//
+const
+  GL_BLEND_DST_RGB_EXT = $80C8;
+  GL_BLEND_SRC_RGB_EXT = $80C9;
+  GL_BLEND_DST_ALPHA_EXT = $80CA;
+  GL_BLEND_SRC_ALPHA_EXT = $80CB;
+var
+  glBlendFuncSeparateEXT: procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_blend_func_separate: Boolean;
+
+//***** GL_EXT_blend_logic_op *****//
+
+function Load_GL_EXT_blend_logic_op: Boolean;
+
+//***** GL_EXT_blend_minmax *****//
+const
+  GL_FUNC_ADD_EXT = $8006;
+  GL_MIN_EXT = $8007;
+  GL_MAX_EXT = $8008;
+  GL_BLEND_EQUATION_EXT = $8009;
+var
+  glBlendEquationEXT: procedure(mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_blend_minmax: Boolean;
+
+//***** GL_EXT_blend_subtract *****//
+const
+  GL_FUNC_SUBTRACT_EXT = $800A;
+  GL_FUNC_REVERSE_SUBTRACT_EXT = $800B;
+
+function Load_GL_EXT_blend_subtract: Boolean;
+
+//***** GL_EXT_clip_volume_hint *****//
+const
+  GL_CLIP_VOLUME_CLIPPING_HINT_EXT = $80F0;
+
+function Load_GL_EXT_clip_volume_hint: Boolean;
+
+//***** GL_EXT_color_subtable *****//
+var
+  glColorSubTableEXT: procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyColorSubTableEXT: procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_color_subtable: Boolean;
+
+//***** GL_EXT_compiled_vertex_array *****//
+const
+  GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = $81A8;
+  GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = $81A9;
+var
+  glLockArraysEXT: procedure(first: GLint; count: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUnlockArraysEXT: procedure(); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_compiled_vertex_array: Boolean;
+
+//***** GL_EXT_convolution *****//
+const
+  GL_CONVOLUTION_1D_EXT = $8010;
+  GL_CONVOLUTION_2D_EXT = $8011;
+  GL_SEPARABLE_2D_EXT = $8012;
+  GL_CONVOLUTION_BORDER_MODE_EXT = $8013;
+  GL_CONVOLUTION_FILTER_SCALE_EXT = $8014;
+  GL_CONVOLUTION_FILTER_BIAS_EXT = $8015;
+  GL_REDUCE_EXT = $8016;
+  GL_CONVOLUTION_FORMAT_EXT = $8017;
+  GL_CONVOLUTION_WIDTH_EXT = $8018;
+  GL_CONVOLUTION_HEIGHT_EXT = $8019;
+  GL_MAX_CONVOLUTION_WIDTH_EXT = $801A;
+  GL_MAX_CONVOLUTION_HEIGHT_EXT = $801B;
+  GL_POST_CONVOLUTION_RED_SCALE_EXT = $801C;
+  GL_POST_CONVOLUTION_GREEN_SCALE_EXT = $801D;
+  GL_POST_CONVOLUTION_BLUE_SCALE_EXT = $801E;
+  GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = $801F;
+  GL_POST_CONVOLUTION_RED_BIAS_EXT = $8020;
+  GL_POST_CONVOLUTION_GREEN_BIAS_EXT = $8021;
+  GL_POST_CONVOLUTION_BLUE_BIAS_EXT = $8022;
+  GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = $8023;
+var
+  glConvolutionFilter1DEXT: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionFilter2DEXT: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyConvolutionFilter1DEXT: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyConvolutionFilter2DEXT: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetConvolutionFilterEXT: procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSeparableFilter2DEXT: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetSeparableFilterEXT: procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionParameteriEXT: procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionParameterivEXT: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionParameterfEXT: procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glConvolutionParameterfvEXT: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetConvolutionParameterivEXT: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetConvolutionParameterfvEXT: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_convolution: Boolean;
+
+//***** GL_EXT_histogram *****//
+const
+  GL_HISTOGRAM_EXT = $8024;
+  GL_PROXY_HISTOGRAM_EXT = $8025;
+  GL_HISTOGRAM_WIDTH_EXT = $8026;
+  GL_HISTOGRAM_FORMAT_EXT = $8027;
+  GL_HISTOGRAM_RED_SIZE_EXT = $8028;
+  GL_HISTOGRAM_GREEN_SIZE_EXT = $8029;
+  GL_HISTOGRAM_BLUE_SIZE_EXT = $802A;
+  GL_HISTOGRAM_ALPHA_SIZE_EXT = $802B;
+  GL_HISTOGRAM_LUMINANCE_SIZE_EXT = $802C;
+  GL_HISTOGRAM_SINK_EXT = $802D;
+  GL_MINMAX_EXT = $802E;
+  GL_MINMAX_FORMAT_EXT = $802F;
+  GL_MINMAX_SINK_EXT = $8030;
+var
+  glHistogramEXT: procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glResetHistogramEXT: procedure(target: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetHistogramEXT: procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetHistogramParameterivEXT: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetHistogramParameterfvEXT: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMinmaxEXT: procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glResetMinmaxEXT: procedure(target: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMinmaxEXT: procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMinmaxParameterivEXT: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMinmaxParameterfvEXT: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_histogram: Boolean;
+
+//***** GL_EXT_multi_draw_arrays *****//
+var
+  glMultiDrawArraysEXT: procedure(mode: GLenum; first: PGLint; count: PGLsizei; primcount: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiDrawElementsEXT: procedure(mode: GLenum; count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_multi_draw_arrays: Boolean;
+
+//***** GL_EXT_packed_pixels *****//
+const
+  GL_UNSIGNED_BYTE_3_3_2_EXT = $8032;
+  GL_UNSIGNED_SHORT_4_4_4_4_EXT = $8033;
+  GL_UNSIGNED_SHORT_5_5_5_1_EXT = $8034;
+  GL_UNSIGNED_INT_8_8_8_8_EXT = $8035;
+  GL_UNSIGNED_INT_10_10_10_2_EXT = $8036;
+
+function Load_GL_EXT_packed_pixels: Boolean;
+
+//***** GL_EXT_paletted_texture *****//
+const
+  GL_COLOR_INDEX1_EXT = $80E2;
+  GL_COLOR_INDEX2_EXT = $80E3;
+  GL_COLOR_INDEX4_EXT = $80E4;
+  GL_COLOR_INDEX8_EXT = $80E5;
+  GL_COLOR_INDEX12_EXT = $80E6;
+  GL_COLOR_INDEX16_EXT = $80E7;
+  GL_COLOR_TABLE_FORMAT_EXT = $80D8;
+  GL_COLOR_TABLE_WIDTH_EXT = $80D9;
+  GL_COLOR_TABLE_RED_SIZE_EXT = $80DA;
+  GL_COLOR_TABLE_GREEN_SIZE_EXT = $80DB;
+  GL_COLOR_TABLE_BLUE_SIZE_EXT = $80DC;
+  GL_COLOR_TABLE_ALPHA_SIZE_EXT = $80DD;
+  GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = $80DE;
+  GL_COLOR_TABLE_INTENSITY_SIZE_EXT = $80DF;
+  GL_TEXTURE_INDEX_SIZE_EXT = $80ED;
+  GL_TEXTURE_1D = $0DE0;
+  GL_TEXTURE_2D = $0DE1;
+  GL_TEXTURE_3D_EXT = $806F;
+  // GL_TEXTURE_CUBE_MAP_ARB  { already defined }
+  GL_PROXY_TEXTURE_1D = $8063;
+  GL_PROXY_TEXTURE_2D = $8064;
+  GL_PROXY_TEXTURE_3D_EXT = $8070;
+  // GL_PROXY_TEXTURE_CUBE_MAP_ARB  { already defined }
+  // GL_TEXTURE_1D  { already defined }
+  // GL_TEXTURE_2D  { already defined }
+  // GL_TEXTURE_3D_EXT  { already defined }
+  // GL_TEXTURE_CUBE_MAP_ARB  { already defined }
+var
+  glColorTableEXT: procedure(target: GLenum; internalFormat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  // glColorSubTableEXT  { already defined }
+  glGetColorTableEXT: procedure(target: GLenum; format: GLenum; _type: GLenum; data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetColorTableParameterivEXT: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetColorTableParameterfvEXT: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_paletted_texture: Boolean;
+
+//***** GL_EXT_point_parameters *****//
+const
+  GL_POINT_SIZE_MIN_EXT = $8126;
+  GL_POINT_SIZE_MAX_EXT = $8127;
+  GL_POINT_FADE_THRESHOLD_SIZE_EXT = $8128;
+  GL_DISTANCE_ATTENUATION_EXT = $8129;
+var
+  glPointParameterfEXT: procedure(pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPointParameterfvEXT: procedure(pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_point_parameters: Boolean;
+
+//***** GL_EXT_polygon_offset *****//
+const
+  GL_POLYGON_OFFSET_EXT = $8037;
+  GL_POLYGON_OFFSET_FACTOR_EXT = $8038;
+  GL_POLYGON_OFFSET_BIAS_EXT = $8039;
+var
+  glPolygonOffsetEXT: procedure(factor: GLfloat; bias: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_polygon_offset: Boolean;
+
+//***** GL_EXT_separate_specular_color *****//
+const
+  GL_LIGHT_MODEL_COLOR_CONTROL_EXT = $81F8;
+  GL_SINGLE_COLOR_EXT = $81F9;
+  GL_SEPARATE_SPECULAR_COLOR_EXT = $81FA;
+
+function Load_GL_EXT_separate_specular_color: Boolean;
+
+//***** GL_EXT_shadow_funcs *****//
+
+function Load_GL_EXT_shadow_funcs: Boolean;
+
+//***** GL_EXT_shared_texture_palette *****//
+const
+  GL_SHARED_TEXTURE_PALETTE_EXT = $81FB;
+
+function Load_GL_EXT_shared_texture_palette: Boolean;
+
+//***** GL_EXT_stencil_two_side *****//
+const
+  GL_STENCIL_TEST_TWO_SIDE_EXT = $8910;
+  GL_ACTIVE_STENCIL_FACE_EXT = $8911;
+var
+  glActiveStencilFaceEXT: procedure(face: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_stencil_two_side: Boolean;
+
+//***** GL_EXT_stencil_wrap *****//
+const
+  GL_INCR_WRAP_EXT = $8507;
+  GL_DECR_WRAP_EXT = $8508;
+
+function Load_GL_EXT_stencil_wrap: Boolean;
+
+//***** GL_EXT_subtexture *****//
+var
+  glTexSubImage1DEXT: procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexSubImage2DEXT: procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexSubImage3DEXT: procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_subtexture: Boolean;
+
+//***** GL_EXT_texture3D *****//
+const
+  GL_PACK_SKIP_IMAGES_EXT = $806B;
+  GL_PACK_IMAGE_HEIGHT_EXT = $806C;
+  GL_UNPACK_SKIP_IMAGES_EXT = $806D;
+  GL_UNPACK_IMAGE_HEIGHT_EXT = $806E;
+  // GL_TEXTURE_3D_EXT  { already defined }
+  // GL_PROXY_TEXTURE_3D_EXT  { already defined }
+  GL_TEXTURE_DEPTH_EXT = $8071;
+  GL_TEXTURE_WRAP_R_EXT = $8072;
+  GL_MAX_3D_TEXTURE_SIZE_EXT = $8073;
+var
+  glTexImage3DEXT: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_texture3D: Boolean;
+
+//***** GL_EXT_texture_compression_s3tc *****//
+const
+  GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0;
+  GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1;
+  GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2;
+  GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3;
+
+function Load_GL_EXT_texture_compression_s3tc: Boolean;
+
+//***** GL_EXT_texture_env_add *****//
+
+function Load_GL_EXT_texture_env_add: Boolean;
+
+//***** GL_EXT_texture_env_combine *****//
+const
+  GL_COMBINE_EXT = $8570;
+  GL_COMBINE_RGB_EXT = $8571;
+  GL_COMBINE_ALPHA_EXT = $8572;
+  GL_SOURCE0_RGB_EXT = $8580;
+  GL_SOURCE1_RGB_EXT = $8581;
+  GL_SOURCE2_RGB_EXT = $8582;
+  GL_SOURCE0_ALPHA_EXT = $8588;
+  GL_SOURCE1_ALPHA_EXT = $8589;
+  GL_SOURCE2_ALPHA_EXT = $858A;
+  GL_OPERAND0_RGB_EXT = $8590;
+  GL_OPERAND1_RGB_EXT = $8591;
+  GL_OPERAND2_RGB_EXT = $8592;
+  GL_OPERAND0_ALPHA_EXT = $8598;
+  GL_OPERAND1_ALPHA_EXT = $8599;
+  GL_OPERAND2_ALPHA_EXT = $859A;
+  GL_RGB_SCALE_EXT = $8573;
+  GL_ADD_SIGNED_EXT = $8574;
+  GL_INTERPOLATE_EXT = $8575;
+  GL_CONSTANT_EXT = $8576;
+  GL_PRIMARY_COLOR_EXT = $8577;
+  GL_PREVIOUS_EXT = $8578;
+
+function Load_GL_EXT_texture_env_combine: Boolean;
+
+//***** GL_EXT_texture_env_dot3 *****//
+const
+  GL_DOT3_RGB_EXT = $8740;
+  GL_DOT3_RGBA_EXT = $8741;
+
+function Load_GL_EXT_texture_env_dot3: Boolean;
+
+//***** GL_EXT_texture_filter_anisotropic *****//
+const
+  GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE;
+  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
+
+function Load_GL_EXT_texture_filter_anisotropic: Boolean;
+
+//***** GL_EXT_texture_lod_bias *****//
+const
+  GL_TEXTURE_FILTER_CONTROL_EXT = $8500;
+  GL_TEXTURE_LOD_BIAS_EXT = $8501;
+  GL_MAX_TEXTURE_LOD_BIAS_EXT = $84FD;
+
+function Load_GL_EXT_texture_lod_bias: Boolean;
+
+//***** GL_EXT_texture_object *****//
+const
+  GL_TEXTURE_PRIORITY_EXT = $8066;
+  GL_TEXTURE_RESIDENT_EXT = $8067;
+  GL_TEXTURE_1D_BINDING_EXT = $8068;
+  GL_TEXTURE_2D_BINDING_EXT = $8069;
+  GL_TEXTURE_3D_BINDING_EXT = $806A;
+var
+  glGenTexturesEXT: procedure(n: GLsizei; textures: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteTexturesEXT: procedure(n: GLsizei; const textures: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBindTextureEXT: procedure(target: GLenum; texture: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPrioritizeTexturesEXT: procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glAreTexturesResidentEXT: function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsTextureEXT: function(texture: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_texture_object: Boolean;
+
+//***** GL_EXT_vertex_array *****//
+const
+  GL_VERTEX_ARRAY_EXT = $8074;
+  GL_NORMAL_ARRAY_EXT = $8075;
+  GL_COLOR_ARRAY_EXT = $8076;
+  GL_INDEX_ARRAY_EXT = $8077;
+  GL_TEXTURE_COORD_ARRAY_EXT = $8078;
+  GL_EDGE_FLAG_ARRAY_EXT = $8079;
+  GL_DOUBLE_EXT = $140A;
+  GL_VERTEX_ARRAY_SIZE_EXT = $807A;
+  GL_VERTEX_ARRAY_TYPE_EXT = $807B;
+  GL_VERTEX_ARRAY_STRIDE_EXT = $807C;
+  GL_VERTEX_ARRAY_COUNT_EXT = $807D;
+  GL_NORMAL_ARRAY_TYPE_EXT = $807E;
+  GL_NORMAL_ARRAY_STRIDE_EXT = $807F;
+  GL_NORMAL_ARRAY_COUNT_EXT = $8080;
+  GL_COLOR_ARRAY_SIZE_EXT = $8081;
+  GL_COLOR_ARRAY_TYPE_EXT = $8082;
+  GL_COLOR_ARRAY_STRIDE_EXT = $8083;
+  GL_COLOR_ARRAY_COUNT_EXT = $8084;
+  GL_INDEX_ARRAY_TYPE_EXT = $8085;
+  GL_INDEX_ARRAY_STRIDE_EXT = $8086;
+  GL_INDEX_ARRAY_COUNT_EXT = $8087;
+  GL_TEXTURE_COORD_ARRAY_SIZE_EXT = $8088;
+  GL_TEXTURE_COORD_ARRAY_TYPE_EXT = $8089;
+  GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = $808A;
+  GL_TEXTURE_COORD_ARRAY_COUNT_EXT = $808B;
+  GL_EDGE_FLAG_ARRAY_STRIDE_EXT = $808C;
+  GL_EDGE_FLAG_ARRAY_COUNT_EXT = $808D;
+  GL_VERTEX_ARRAY_POINTER_EXT = $808E;
+  GL_NORMAL_ARRAY_POINTER_EXT = $808F;
+  GL_COLOR_ARRAY_POINTER_EXT = $8090;
+  GL_INDEX_ARRAY_POINTER_EXT = $8091;
+  GL_TEXTURE_COORD_ARRAY_POINTER_EXT = $8092;
+  GL_EDGE_FLAG_ARRAY_POINTER_EXT = $8093;
+var
+  glArrayElementEXT: procedure(i: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawArraysEXT: procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexPointerEXT: procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalPointerEXT: procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorPointerEXT: procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIndexPointerEXT: procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoordPointerEXT: procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEdgeFlagPointerEXT: procedure(stride: GLsizei; count: GLsizei; const pointer: PGLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetPointervEXT: procedure(pname: GLenum; params: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_vertex_array: Boolean;
+
+//***** GL_EXT_vertex_shader *****//
+const
+  GL_VERTEX_SHADER_EXT = $8780;
+  GL_VARIANT_VALUE_EXT = $87E4;
+  GL_VARIANT_DATATYPE_EXT = $87E5;
+  GL_VARIANT_ARRAY_STRIDE_EXT = $87E6;
+  GL_VARIANT_ARRAY_TYPE_EXT = $87E7;
+  GL_VARIANT_ARRAY_EXT = $87E8;
+  GL_VARIANT_ARRAY_POINTER_EXT = $87E9;
+  GL_INVARIANT_VALUE_EXT = $87EA;
+  GL_INVARIANT_DATATYPE_EXT = $87EB;
+  GL_LOCAL_CONSTANT_VALUE_EXT = $87EC;
+  GL_LOCAL_CONSTANT_DATATYPE_EXT = $87ED;
+  GL_OP_INDEX_EXT = $8782;
+  GL_OP_NEGATE_EXT = $8783;
+  GL_OP_DOT3_EXT = $8784;
+  GL_OP_DOT4_EXT = $8785;
+  GL_OP_MUL_EXT = $8786;
+  GL_OP_ADD_EXT = $8787;
+  GL_OP_MADD_EXT = $8788;
+  GL_OP_FRAC_EXT = $8789;
+  GL_OP_MAX_EXT = $878A;
+  GL_OP_MIN_EXT = $878B;
+  GL_OP_SET_GE_EXT = $878C;
+  GL_OP_SET_LT_EXT = $878D;
+  GL_OP_CLAMP_EXT = $878E;
+  GL_OP_FLOOR_EXT = $878F;
+  GL_OP_ROUND_EXT = $8790;
+  GL_OP_EXP_BASE_2_EXT = $8791;
+  GL_OP_LOG_BASE_2_EXT = $8792;
+  GL_OP_POWER_EXT = $8793;
+  GL_OP_RECIP_EXT = $8794;
+  GL_OP_RECIP_SQRT_EXT = $8795;
+  GL_OP_SUB_EXT = $8796;
+  GL_OP_CROSS_PRODUCT_EXT = $8797;
+  GL_OP_MULTIPLY_MATRIX_EXT = $8798;
+  GL_OP_MOV_EXT = $8799;
+  GL_OUTPUT_VERTEX_EXT = $879A;
+  GL_OUTPUT_COLOR0_EXT = $879B;
+  GL_OUTPUT_COLOR1_EXT = $879C;
+  GL_OUTPUT_TEXTURE_COORD0_EXT = $879D;
+  GL_OUTPUT_TEXTURE_COORD1_EXT = $879E;
+  GL_OUTPUT_TEXTURE_COORD2_EXT = $879F;
+  GL_OUTPUT_TEXTURE_COORD3_EXT = $87A0;
+  GL_OUTPUT_TEXTURE_COORD4_EXT = $87A1;
+  GL_OUTPUT_TEXTURE_COORD5_EXT = $87A2;
+  GL_OUTPUT_TEXTURE_COORD6_EXT = $87A3;
+  GL_OUTPUT_TEXTURE_COORD7_EXT = $87A4;
+  GL_OUTPUT_TEXTURE_COORD8_EXT = $87A5;
+  GL_OUTPUT_TEXTURE_COORD9_EXT = $87A6;
+  GL_OUTPUT_TEXTURE_COORD10_EXT = $87A7;
+  GL_OUTPUT_TEXTURE_COORD11_EXT = $87A8;
+  GL_OUTPUT_TEXTURE_COORD12_EXT = $87A9;
+  GL_OUTPUT_TEXTURE_COORD13_EXT = $87AA;
+  GL_OUTPUT_TEXTURE_COORD14_EXT = $87AB;
+  GL_OUTPUT_TEXTURE_COORD15_EXT = $87AC;
+  GL_OUTPUT_TEXTURE_COORD16_EXT = $87AD;
+  GL_OUTPUT_TEXTURE_COORD17_EXT = $87AE;
+  GL_OUTPUT_TEXTURE_COORD18_EXT = $87AF;
+  GL_OUTPUT_TEXTURE_COORD19_EXT = $87B0;
+  GL_OUTPUT_TEXTURE_COORD20_EXT = $87B1;
+  GL_OUTPUT_TEXTURE_COORD21_EXT = $87B2;
+  GL_OUTPUT_TEXTURE_COORD22_EXT = $87B3;
+  GL_OUTPUT_TEXTURE_COORD23_EXT = $87B4;
+  GL_OUTPUT_TEXTURE_COORD24_EXT = $87B5;
+  GL_OUTPUT_TEXTURE_COORD25_EXT = $87B6;
+  GL_OUTPUT_TEXTURE_COORD26_EXT = $87B7;
+  GL_OUTPUT_TEXTURE_COORD27_EXT = $87B8;
+  GL_OUTPUT_TEXTURE_COORD28_EXT = $87B9;
+  GL_OUTPUT_TEXTURE_COORD29_EXT = $87BA;
+  GL_OUTPUT_TEXTURE_COORD30_EXT = $87BB;
+  GL_OUTPUT_TEXTURE_COORD31_EXT = $87BC;
+  GL_OUTPUT_FOG_EXT = $87BD;
+  GL_SCALAR_EXT = $87BE;
+  GL_VECTOR_EXT = $87BF;
+  GL_MATRIX_EXT = $87C0;
+  GL_VARIANT_EXT = $87C1;
+  GL_INVARIANT_EXT = $87C2;
+  GL_LOCAL_CONSTANT_EXT = $87C3;
+  GL_LOCAL_EXT = $87C4;
+  GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = $87C5;
+  GL_MAX_VERTEX_SHADER_VARIANTS_EXT = $87C6;
+  GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = $87C7;
+  GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87C8;
+  GL_MAX_VERTEX_SHADER_LOCALS_EXT = $87C9;
+  GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CA;
+  GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = $87CB;
+  GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87CC;
+  GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = $87CD;
+  GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = $87CE;
+  GL_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CF;
+  GL_VERTEX_SHADER_VARIANTS_EXT = $87D0;
+  GL_VERTEX_SHADER_INVARIANTS_EXT = $87D1;
+  GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87D2;
+  GL_VERTEX_SHADER_LOCALS_EXT = $87D3;
+  GL_VERTEX_SHADER_BINDING_EXT = $8781;
+  GL_VERTEX_SHADER_OPTIMIZED_EXT = $87D4;
+  GL_X_EXT = $87D5;
+  GL_Y_EXT = $87D6;
+  GL_Z_EXT = $87D7;
+  GL_W_EXT = $87D8;
+  GL_NEGATIVE_X_EXT = $87D9;
+  GL_NEGATIVE_Y_EXT = $87DA;
+  GL_NEGATIVE_Z_EXT = $87DB;
+  GL_NEGATIVE_W_EXT = $87DC;
+  GL_ZERO_EXT = $87DD;
+  GL_ONE_EXT = $87DE;
+  GL_NEGATIVE_ONE_EXT = $87DF;
+  GL_NORMALIZED_RANGE_EXT = $87E0;
+  GL_FULL_RANGE_EXT = $87E1;
+  GL_CURRENT_VERTEX_EXT = $87E2;
+  GL_MVP_MATRIX_EXT = $87E3;
+var
+  glBeginVertexShaderEXT: procedure(); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEndVertexShaderEXT: procedure(); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBindVertexShaderEXT: procedure(id: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGenVertexShadersEXT: function(range: GLuint): GLuint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteVertexShaderEXT: procedure(id: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glShaderOp1EXT: procedure(op: GLenum; res: GLuint; arg1: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glShaderOp2EXT: procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glShaderOp3EXT: procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint; arg3: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSwizzleEXT: procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWriteMaskEXT: procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glInsertComponentEXT: procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glExtractComponentEXT: procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGenSymbolsEXT: function(datatype: GLenum; storagetype: GLenum; range: GLenum; components: GLuint): GLuint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSetInvariantEXT: procedure(id: GLuint; _type: GLenum; addr: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSetLocalConstantEXT: procedure(id: GLuint; _type: GLenum; addr: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVariantbvEXT: procedure(id: GLuint; addr: PGLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVariantsvEXT: procedure(id: GLuint; addr: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVariantivEXT: procedure(id: GLuint; addr: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVariantfvEXT: procedure(id: GLuint; addr: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVariantdvEXT: procedure(id: GLuint; addr: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVariantubvEXT: procedure(id: GLuint; addr: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVariantusvEXT: procedure(id: GLuint; addr: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVariantuivEXT: procedure(id: GLuint; addr: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVariantPointerEXT: procedure(id: GLuint; _type: GLenum; stride: GLuint; addr: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEnableVariantClientStateEXT: procedure(id: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDisableVariantClientStateEXT: procedure(id: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBindLightParameterEXT: function(light: GLenum; value: GLenum): GLuint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBindMaterialParameterEXT: function(face: GLenum; value: GLenum): GLuint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBindTexGenParameterEXT: function(_unit: GLenum; coord: GLenum; value: GLenum): GLuint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBindTextureUnitParameterEXT: function(_unit: GLenum; value: GLenum): GLuint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBindParameterEXT: function(value: GLenum): GLuint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsVariantEnabledEXT: function(id: GLuint; cap: GLenum): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVariantBooleanvEXT: procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVariantIntegervEXT: procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVariantFloatvEXT: procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVariantPointervEXT: procedure(id: GLuint; value: GLenum; data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetInvariantBooleanvEXT: procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetInvariantIntegervEXT: procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetInvariantFloatvEXT: procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetLocalConstantBooleanvEXT: procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetLocalConstantIntegervEXT: procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetLocalConstantFloatvEXT: procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_vertex_shader: Boolean;
+
+//***** GL_EXT_vertex_weighting *****//
+const
+  GL_VERTEX_WEIGHTING_EXT = $8509;
+  GL_MODELVIEW0_EXT = $1700;
+  GL_MODELVIEW1_EXT = $850A;
+  GL_MODELVIEW0_MATRIX_EXT = $0BA6;
+  GL_MODELVIEW1_MATRIX_EXT = $8506;
+  GL_CURRENT_VERTEX_WEIGHT_EXT = $850B;
+  GL_VERTEX_WEIGHT_ARRAY_EXT = $850C;
+  GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = $850D;
+  GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = $850E;
+  GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = $850F;
+  GL_MODELVIEW0_STACK_DEPTH_EXT = $0BA3;
+  GL_MODELVIEW1_STACK_DEPTH_EXT = $8502;
+  GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = $8510;
+var
+  glVertexWeightfEXT: procedure(weight: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexWeightfvEXT: procedure(weight: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexWeightPointerEXT: procedure(size: GLint; _type: GLenum; stride: GLsizei; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_vertex_weighting: Boolean;
+
+//***** GL_HP_occlusion_test *****//
+const
+  GL_OCCLUSION_TEST_HP = $8165;
+  GL_OCCLUSION_TEST_RESULT_HP = $8166;
+
+function Load_GL_HP_occlusion_test: Boolean;
+
+//***** GL_NV_blend_square *****//
+
+function Load_GL_NV_blend_square: Boolean;
+
+//***** GL_NV_copy_depth_to_color *****//
+const
+  GL_DEPTH_STENCIL_TO_RGBA_NV = $886E;
+  GL_DEPTH_STENCIL_TO_BGRA_NV = $886F;
+
+function Load_GL_NV_copy_depth_to_color: Boolean;
+
+//***** GL_NV_depth_clamp *****//
+const
+  GL_DEPTH_CLAMP_NV = $864F;
+
+function Load_GL_NV_depth_clamp: Boolean;
+
+//***** GL_NV_evaluators *****//
+const
+  GL_EVAL_2D_NV = $86C0;
+  GL_EVAL_TRIANGULAR_2D_NV = $86C1;
+  GL_MAP_TESSELLATION_NV = $86C2;
+  GL_MAP_ATTRIB_U_ORDER_NV = $86C3;
+  GL_MAP_ATTRIB_V_ORDER_NV = $86C4;
+  GL_EVAL_FRACTIONAL_TESSELLATION_NV = $86C5;
+  GL_EVAL_VERTEX_ATTRIB0_NV = $86C6;
+  GL_EVAL_VERTEX_ATTRIB1_NV = $86C7;
+  GL_EVAL_VERTEX_ATTRIB2_NV = $86C8;
+  GL_EVAL_VERTEX_ATTRIB3_NV = $86C9;
+  GL_EVAL_VERTEX_ATTRIB4_NV = $86CA;
+  GL_EVAL_VERTEX_ATTRIB5_NV = $86CB;
+  GL_EVAL_VERTEX_ATTRIB6_NV = $86CC;
+  GL_EVAL_VERTEX_ATTRIB7_NV = $86CD;
+  GL_EVAL_VERTEX_ATTRIB8_NV = $86CE;
+  GL_EVAL_VERTEX_ATTRIB9_NV = $86CF;
+  GL_EVAL_VERTEX_ATTRIB10_NV = $86D0;
+  GL_EVAL_VERTEX_ATTRIB11_NV = $86D1;
+  GL_EVAL_VERTEX_ATTRIB12_NV = $86D2;
+  GL_EVAL_VERTEX_ATTRIB13_NV = $86D3;
+  GL_EVAL_VERTEX_ATTRIB14_NV = $86D4;
+  GL_EVAL_VERTEX_ATTRIB15_NV = $86D5;
+  GL_MAX_MAP_TESSELLATION_NV = $86D6;
+  GL_MAX_RATIONAL_EVAL_ORDER_NV = $86D7;
+var
+  glMapControlPointsNV: procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; uorder: GLint; vorder: GLint; _packed: GLboolean; const points: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMapParameterivNV: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMapParameterfvNV: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMapControlPointsNV: procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; _packed: GLboolean; points: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMapParameterivNV: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMapParameterfvNV: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMapAttribParameterivNV: procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetMapAttribParameterfvNV: procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEvalMapsNV: procedure(target: GLenum; mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_NV_evaluators: Boolean;
+
+//***** GL_NV_fence *****//
+const
+  GL_ALL_COMPLETED_NV = $84F2;
+  GL_FENCE_STATUS_NV = $84F3;
+  GL_FENCE_CONDITION_NV = $84F4;
+var
+  glGenFencesNV: procedure(n: GLsizei; fences: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteFencesNV: procedure(n: GLsizei; const fences: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSetFenceNV: procedure(fence: GLuint; condition: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTestFenceNV: function(fence: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFinishFenceNV: procedure(fence: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsFenceNV: function(fence: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetFenceivNV: procedure(fence: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_NV_fence: Boolean;
+
+//***** GL_NV_fog_distance *****//
+const
+  GL_FOG_DISTANCE_MODE_NV = $855A;
+  GL_EYE_RADIAL_NV = $855B;
+  GL_EYE_PLANE_ABSOLUTE_NV = $855C;
+
+function Load_GL_NV_fog_distance: Boolean;
+
+//***** GL_NV_light_max_exponent *****//
+const
+  GL_MAX_SHININESS_NV = $8504;
+  GL_MAX_SPOT_EXPONENT_NV = $8505;
+
+function Load_GL_NV_light_max_exponent: Boolean;
+
+//***** GL_NV_multisample_filter_hint *****//
+const
+  GL_MULTISAMPLE_FILTER_HINT_NV = $8534;
+
+function Load_GL_NV_multisample_filter_hint: Boolean;
+
+//***** GL_NV_occlusion_query *****//
+  // GL_OCCLUSION_TEST_HP  { already defined }
+  // GL_OCCLUSION_TEST_RESULT_HP  { already defined }
+const
+  GL_PIXEL_COUNTER_BITS_NV = $8864;
+  GL_CURRENT_OCCLUSION_QUERY_ID_NV = $8865;
+  GL_PIXEL_COUNT_NV = $8866;
+  GL_PIXEL_COUNT_AVAILABLE_NV = $8867;
+var
+  glGenOcclusionQueriesNV: procedure(n: GLsizei; ids: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteOcclusionQueriesNV: procedure(n: GLsizei; const ids: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsOcclusionQueryNV: function(id: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBeginOcclusionQueryNV: procedure(id: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEndOcclusionQueryNV: procedure(); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetOcclusionQueryivNV: procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetOcclusionQueryuivNV: procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_NV_occlusion_query: Boolean;
+
+//***** GL_NV_packed_depth_stencil *****//
+const
+  GL_DEPTH_STENCIL_NV = $84F9;
+  GL_UNSIGNED_INT_24_8_NV = $84FA;
+
+function Load_GL_NV_packed_depth_stencil: Boolean;
+
+//***** GL_NV_point_sprite *****//
+const
+  GL_POINT_SPRITE_NV = $8861;
+  GL_COORD_REPLACE_NV = $8862;
+  GL_POINT_SPRITE_R_MODE_NV = $8863;
+var
+  glPointParameteriNV: procedure(pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPointParameterivNV: procedure(pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_NV_point_sprite: Boolean;
+
+//***** GL_NV_register_combiners *****//
+const
+  GL_REGISTER_COMBINERS_NV = $8522;
+  GL_COMBINER0_NV = $8550;
+  GL_COMBINER1_NV = $8551;
+  GL_COMBINER2_NV = $8552;
+  GL_COMBINER3_NV = $8553;
+  GL_COMBINER4_NV = $8554;
+  GL_COMBINER5_NV = $8555;
+  GL_COMBINER6_NV = $8556;
+  GL_COMBINER7_NV = $8557;
+  GL_VARIABLE_A_NV = $8523;
+  GL_VARIABLE_B_NV = $8524;
+  GL_VARIABLE_C_NV = $8525;
+  GL_VARIABLE_D_NV = $8526;
+  GL_VARIABLE_E_NV = $8527;
+  GL_VARIABLE_F_NV = $8528;
+  GL_VARIABLE_G_NV = $8529;
+  GL_CONSTANT_COLOR0_NV = $852A;
+  GL_CONSTANT_COLOR1_NV = $852B;
+  GL_PRIMARY_COLOR_NV = $852C;
+  GL_SECONDARY_COLOR_NV = $852D;
+  GL_SPARE0_NV = $852E;
+  GL_SPARE1_NV = $852F;
+  GL_UNSIGNED_IDENTITY_NV = $8536;
+  GL_UNSIGNED_INVERT_NV = $8537;
+  GL_EXPAND_NORMAL_NV = $8538;
+  GL_EXPAND_NEGATE_NV = $8539;
+  GL_HALF_BIAS_NORMAL_NV = $853A;
+  GL_HALF_BIAS_NEGATE_NV = $853B;
+  GL_SIGNED_IDENTITY_NV = $853C;
+  GL_SIGNED_NEGATE_NV = $853D;
+  GL_E_TIMES_F_NV = $8531;
+  GL_SPARE0_PLUS_SECONDARY_COLOR_NV = $8532;
+  GL_SCALE_BY_TWO_NV = $853E;
+  GL_SCALE_BY_FOUR_NV = $853F;
+  GL_SCALE_BY_ONE_HALF_NV = $8540;
+  GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = $8541;
+  GL_DISCARD_NV = $8530;
+  GL_COMBINER_INPUT_NV = $8542;
+  GL_COMBINER_MAPPING_NV = $8543;
+  GL_COMBINER_COMPONENT_USAGE_NV = $8544;
+  GL_COMBINER_AB_DOT_PRODUCT_NV = $8545;
+  GL_COMBINER_CD_DOT_PRODUCT_NV = $8546;
+  GL_COMBINER_MUX_SUM_NV = $8547;
+  GL_COMBINER_SCALE_NV = $8548;
+  GL_COMBINER_BIAS_NV = $8549;
+  GL_COMBINER_AB_OUTPUT_NV = $854A;
+  GL_COMBINER_CD_OUTPUT_NV = $854B;
+  GL_COMBINER_SUM_OUTPUT_NV = $854C;
+  GL_NUM_GENERAL_COMBINERS_NV = $854E;
+  GL_COLOR_SUM_CLAMP_NV = $854F;
+  GL_MAX_GENERAL_COMBINERS_NV = $854D;
+var
+  glCombinerParameterfvNV: procedure(pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCombinerParameterivNV: procedure(pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCombinerParameterfNV: procedure(pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCombinerParameteriNV: procedure(pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCombinerInputNV: procedure(stage: GLenum; portion: GLenum; variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCombinerOutputNV: procedure(stage: GLenum; portion: GLenum; abOutput: GLenum; cdOutput: GLenum; sumOutput: GLenum; scale: GLenum; bias: GLenum; abDotProduct: GLboolean; cdDotProduct: GLboolean; muxSum: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFinalCombinerInputNV: procedure(variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetCombinerInputParameterfvNV: procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetCombinerInputParameterivNV: procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetCombinerOutputParameterfvNV: procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetCombinerOutputParameterivNV: procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetFinalCombinerInputParameterfvNV: procedure(variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetFinalCombinerInputParameterivNV: procedure(variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_NV_register_combiners: Boolean;
+
+//***** GL_NV_register_combiners2 *****//
+const
+  GL_PER_STAGE_CONSTANTS_NV = $8535;
+var
+  glCombinerStageParameterfvNV: procedure(stage: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetCombinerStageParameterfvNV: procedure(stage: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_NV_register_combiners2: Boolean;
+
+//***** GL_NV_texgen_emboss *****//
+const
+  GL_EMBOSS_MAP_NV = $855F;
+  GL_EMBOSS_LIGHT_NV = $855D;
+  GL_EMBOSS_CONSTANT_NV = $855E;
+
+function Load_GL_NV_texgen_emboss: Boolean;
+
+//***** GL_NV_texgen_reflection *****//
+const
+  GL_NORMAL_MAP_NV = $8511;
+  GL_REFLECTION_MAP_NV = $8512;
+
+function Load_GL_NV_texgen_reflection: Boolean;
+
+//***** GL_NV_texture_compression_vtc *****//
+  // GL_COMPRESSED_RGB_S3TC_DXT1_EXT  { already defined }
+  // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT  { already defined }
+  // GL_COMPRESSED_RGBA_S3TC_DXT3_EXT  { already defined }
+  // GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  { already defined }
+
+function Load_GL_NV_texture_compression_vtc: Boolean;
+
+//***** GL_NV_texture_env_combine4 *****//
+const
+  GL_COMBINE4_NV = $8503;
+  GL_SOURCE3_RGB_NV = $8583;
+  GL_SOURCE3_ALPHA_NV = $858B;
+  GL_OPERAND3_RGB_NV = $8593;
+  GL_OPERAND3_ALPHA_NV = $859B;
+
+function Load_GL_NV_texture_env_combine4: Boolean;
+
+//***** GL_NV_texture_rectangle *****//
+const
+  GL_TEXTURE_RECTANGLE_NV = $84F5;
+  GL_TEXTURE_BINDING_RECTANGLE_NV = $84F6;
+  GL_PROXY_TEXTURE_RECTANGLE_NV = $84F7;
+  GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = $84F8;
+
+function Load_GL_NV_texture_rectangle: Boolean;
+
+//***** GL_NV_texture_shader *****//
+const
+  GL_TEXTURE_SHADER_NV = $86DE;
+  GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = $86D9;
+  GL_SHADER_OPERATION_NV = $86DF;
+  GL_CULL_MODES_NV = $86E0;
+  GL_OFFSET_TEXTURE_MATRIX_NV = $86E1;
+  GL_OFFSET_TEXTURE_SCALE_NV = $86E2;
+  GL_OFFSET_TEXTURE_BIAS_NV = $86E3;
+  GL_PREVIOUS_TEXTURE_INPUT_NV = $86E4;
+  GL_CONST_EYE_NV = $86E5;
+  GL_SHADER_CONSISTENT_NV = $86DD;
+  GL_PASS_THROUGH_NV = $86E6;
+  GL_CULL_FRAGMENT_NV = $86E7;
+  GL_OFFSET_TEXTURE_2D_NV = $86E8;
+  GL_OFFSET_TEXTURE_RECTANGLE_NV = $864C;
+  GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = $864D;
+  GL_DEPENDENT_AR_TEXTURE_2D_NV = $86E9;
+  GL_DEPENDENT_GB_TEXTURE_2D_NV = $86EA;
+  GL_DOT_PRODUCT_NV = $86EC;
+  GL_DOT_PRODUCT_DEPTH_REPLACE_NV = $86ED;
+  GL_DOT_PRODUCT_TEXTURE_2D_NV = $86EE;
+  GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = $864E;
+  GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = $86F0;
+  GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = $86F1;
+  GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = $86F2;
+  GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = $86F3;
+  GL_HILO_NV = $86F4;
+  GL_DSDT_NV = $86F5;
+  GL_DSDT_MAG_NV = $86F6;
+  GL_DSDT_MAG_VIB_NV = $86F7;
+  GL_UNSIGNED_INT_S8_S8_8_8_NV = $86DA;
+  GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = $86DB;
+  GL_SIGNED_RGBA_NV = $86FB;
+  GL_SIGNED_RGBA8_NV = $86FC;
+  GL_SIGNED_RGB_NV = $86FE;
+  GL_SIGNED_RGB8_NV = $86FF;
+  GL_SIGNED_LUMINANCE_NV = $8701;
+  GL_SIGNED_LUMINANCE8_NV = $8702;
+  GL_SIGNED_LUMINANCE_ALPHA_NV = $8703;
+  GL_SIGNED_LUMINANCE8_ALPHA8_NV = $8704;
+  GL_SIGNED_ALPHA_NV = $8705;
+  GL_SIGNED_ALPHA8_NV = $8706;
+  GL_SIGNED_INTENSITY_NV = $8707;
+  GL_SIGNED_INTENSITY8_NV = $8708;
+  GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = $870C;
+  GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = $870D;
+  GL_HILO16_NV = $86F8;
+  GL_SIGNED_HILO_NV = $86F9;
+  GL_SIGNED_HILO16_NV = $86FA;
+  GL_DSDT8_NV = $8709;
+  GL_DSDT8_MAG8_NV = $870A;
+  GL_DSDT_MAG_INTENSITY_NV = $86DC;
+  GL_DSDT8_MAG8_INTENSITY8_NV = $870B;
+  GL_HI_SCALE_NV = $870E;
+  GL_LO_SCALE_NV = $870F;
+  GL_DS_SCALE_NV = $8710;
+  GL_DT_SCALE_NV = $8711;
+  GL_MAGNITUDE_SCALE_NV = $8712;
+  GL_VIBRANCE_SCALE_NV = $8713;
+  GL_HI_BIAS_NV = $8714;
+  GL_LO_BIAS_NV = $8715;
+  GL_DS_BIAS_NV = $8716;
+  GL_DT_BIAS_NV = $8717;
+  GL_MAGNITUDE_BIAS_NV = $8718;
+  GL_VIBRANCE_BIAS_NV = $8719;
+  GL_TEXTURE_BORDER_VALUES_NV = $871A;
+  GL_TEXTURE_HI_SIZE_NV = $871B;
+  GL_TEXTURE_LO_SIZE_NV = $871C;
+  GL_TEXTURE_DS_SIZE_NV = $871D;
+  GL_TEXTURE_DT_SIZE_NV = $871E;
+  GL_TEXTURE_MAG_SIZE_NV = $871F;
+
+function Load_GL_NV_texture_shader: Boolean;
+
+//***** GL_NV_texture_shader2 *****//
+const
+  GL_DOT_PRODUCT_TEXTURE_3D_NV = $86EF;
+  // GL_HILO_NV  { already defined }
+  // GL_DSDT_NV  { already defined }
+  // GL_DSDT_MAG_NV  { already defined }
+  // GL_DSDT_MAG_VIB_NV  { already defined }
+  // GL_UNSIGNED_INT_S8_S8_8_8_NV  { already defined }
+  // GL_UNSIGNED_INT_8_8_S8_S8_REV_NV  { already defined }
+  // GL_SIGNED_RGBA_NV  { already defined }
+  // GL_SIGNED_RGBA8_NV  { already defined }
+  // GL_SIGNED_RGB_NV  { already defined }
+  // GL_SIGNED_RGB8_NV  { already defined }
+  // GL_SIGNED_LUMINANCE_NV  { already defined }
+  // GL_SIGNED_LUMINANCE8_NV  { already defined }
+  // GL_SIGNED_LUMINANCE_ALPHA_NV  { already defined }
+  // GL_SIGNED_LUMINANCE8_ALPHA8_NV  { already defined }
+  // GL_SIGNED_ALPHA_NV  { already defined }
+  // GL_SIGNED_ALPHA8_NV  { already defined }
+  // GL_SIGNED_INTENSITY_NV  { already defined }
+  // GL_SIGNED_INTENSITY8_NV  { already defined }
+  // GL_SIGNED_RGB_UNSIGNED_ALPHA_NV  { already defined }
+  // GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV  { already defined }
+  // GL_HILO16_NV  { already defined }
+  // GL_SIGNED_HILO_NV  { already defined }
+  // GL_SIGNED_HILO16_NV  { already defined }
+  // GL_DSDT8_NV  { already defined }
+  // GL_DSDT8_MAG8_NV  { already defined }
+  // GL_DSDT_MAG_INTENSITY_NV  { already defined }
+  // GL_DSDT8_MAG8_INTENSITY8_NV  { already defined }
+
+function Load_GL_NV_texture_shader2: Boolean;
+
+//***** GL_NV_texture_shader3 *****//
+const
+  GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = $8850;
+  GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = $8851;
+  GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8852;
+  GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = $8853;
+  GL_OFFSET_HILO_TEXTURE_2D_NV = $8854;
+  GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = $8855;
+  GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = $8856;
+  GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8857;
+  GL_DEPENDENT_HILO_TEXTURE_2D_NV = $8858;
+  GL_DEPENDENT_RGB_TEXTURE_3D_NV = $8859;
+  GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = $885A;
+  GL_DOT_PRODUCT_PASS_THROUGH_NV = $885B;
+  GL_DOT_PRODUCT_TEXTURE_1D_NV = $885C;
+  GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = $885D;
+  GL_HILO8_NV = $885E;
+  GL_SIGNED_HILO8_NV = $885F;
+  GL_FORCE_BLUE_TO_ONE_NV = $8860;
+
+function Load_GL_NV_texture_shader3: Boolean;
+
+//***** GL_NV_vertex_array_range *****//
+const
+  GL_VERTEX_ARRAY_RANGE_NV = $851D;
+  GL_VERTEX_ARRAY_RANGE_LENGTH_NV = $851E;
+  GL_VERTEX_ARRAY_RANGE_VALID_NV = $851F;
+  GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = $8520;
+  GL_VERTEX_ARRAY_RANGE_POINTER_NV = $8521;
+var
+  glVertexArrayRangeNV: procedure(length: GLsizei; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFlushVertexArrayRangeNV: procedure(); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+{$IFDEF Win32}
+  wglAllocateMemoryNV: function(size: GLsizei; readFrequency: GLfloat; writeFrequency: GLfloat; priority: GLfloat): PGLvoid; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglFreeMemoryNV: procedure(pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+{$ENDIF}
+
+function Load_GL_NV_vertex_array_range: Boolean;
+
+//***** GL_NV_vertex_array_range2 *****//
+const
+  GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = $8533;
+
+function Load_GL_NV_vertex_array_range2: Boolean;
+
+//***** GL_NV_vertex_program *****//
+const
+  GL_VERTEX_PROGRAM_NV = $8620;
+  GL_VERTEX_PROGRAM_POINT_SIZE_NV = $8642;
+  GL_VERTEX_PROGRAM_TWO_SIDE_NV = $8643;
+  GL_VERTEX_STATE_PROGRAM_NV = $8621;
+  GL_ATTRIB_ARRAY_SIZE_NV = $8623;
+  GL_ATTRIB_ARRAY_STRIDE_NV = $8624;
+  GL_ATTRIB_ARRAY_TYPE_NV = $8625;
+  GL_CURRENT_ATTRIB_NV = $8626;
+  GL_PROGRAM_PARAMETER_NV = $8644;
+  GL_ATTRIB_ARRAY_POINTER_NV = $8645;
+  GL_PROGRAM_TARGET_NV = $8646;
+  GL_PROGRAM_LENGTH_NV = $8627;
+  GL_PROGRAM_RESIDENT_NV = $8647;
+  GL_PROGRAM_STRING_NV = $8628;
+  GL_TRACK_MATRIX_NV = $8648;
+  GL_TRACK_MATRIX_TRANSFORM_NV = $8649;
+  GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = $862E;
+  GL_MAX_TRACK_MATRICES_NV = $862F;
+  GL_CURRENT_MATRIX_STACK_DEPTH_NV = $8640;
+  GL_CURRENT_MATRIX_NV = $8641;
+  GL_VERTEX_PROGRAM_BINDING_NV = $864A;
+  GL_PROGRAM_ERROR_POSITION_NV = $864B;
+  GL_MODELVIEW_PROJECTION_NV = $8629;
+  GL_MATRIX0_NV = $8630;
+  GL_MATRIX1_NV = $8631;
+  GL_MATRIX2_NV = $8632;
+  GL_MATRIX3_NV = $8633;
+  GL_MATRIX4_NV = $8634;
+  GL_MATRIX5_NV = $8635;
+  GL_MATRIX6_NV = $8636;
+  GL_MATRIX7_NV = $8637;
+  GL_IDENTITY_NV = $862A;
+  GL_INVERSE_NV = $862B;
+  GL_TRANSPOSE_NV = $862C;
+  GL_INVERSE_TRANSPOSE_NV = $862D;
+  GL_VERTEX_ATTRIB_ARRAY0_NV = $8650;
+  GL_VERTEX_ATTRIB_ARRAY1_NV = $8651;
+  GL_VERTEX_ATTRIB_ARRAY2_NV = $8652;
+  GL_VERTEX_ATTRIB_ARRAY3_NV = $8653;
+  GL_VERTEX_ATTRIB_ARRAY4_NV = $8654;
+  GL_VERTEX_ATTRIB_ARRAY5_NV = $8655;
+  GL_VERTEX_ATTRIB_ARRAY6_NV = $8656;
+  GL_VERTEX_ATTRIB_ARRAY7_NV = $8657;
+  GL_VERTEX_ATTRIB_ARRAY8_NV = $8658;
+  GL_VERTEX_ATTRIB_ARRAY9_NV = $8659;
+  GL_VERTEX_ATTRIB_ARRAY10_NV = $865A;
+  GL_VERTEX_ATTRIB_ARRAY11_NV = $865B;
+  GL_VERTEX_ATTRIB_ARRAY12_NV = $865C;
+  GL_VERTEX_ATTRIB_ARRAY13_NV = $865D;
+  GL_VERTEX_ATTRIB_ARRAY14_NV = $865E;
+  GL_VERTEX_ATTRIB_ARRAY15_NV = $865F;
+  GL_MAP1_VERTEX_ATTRIB0_4_NV = $8660;
+  GL_MAP1_VERTEX_ATTRIB1_4_NV = $8661;
+  GL_MAP1_VERTEX_ATTRIB2_4_NV = $8662;
+  GL_MAP1_VERTEX_ATTRIB3_4_NV = $8663;
+  GL_MAP1_VERTEX_ATTRIB4_4_NV = $8664;
+  GL_MAP1_VERTEX_ATTRIB5_4_NV = $8665;
+  GL_MAP1_VERTEX_ATTRIB6_4_NV = $8666;
+  GL_MAP1_VERTEX_ATTRIB7_4_NV = $8667;
+  GL_MAP1_VERTEX_ATTRIB8_4_NV = $8668;
+  GL_MAP1_VERTEX_ATTRIB9_4_NV = $8669;
+  GL_MAP1_VERTEX_ATTRIB10_4_NV = $866A;
+  GL_MAP1_VERTEX_ATTRIB11_4_NV = $866B;
+  GL_MAP1_VERTEX_ATTRIB12_4_NV = $866C;
+  GL_MAP1_VERTEX_ATTRIB13_4_NV = $866D;
+  GL_MAP1_VERTEX_ATTRIB14_4_NV = $866E;
+  GL_MAP1_VERTEX_ATTRIB15_4_NV = $866F;
+  GL_MAP2_VERTEX_ATTRIB0_4_NV = $8670;
+  GL_MAP2_VERTEX_ATTRIB1_4_NV = $8671;
+  GL_MAP2_VERTEX_ATTRIB2_4_NV = $8672;
+  GL_MAP2_VERTEX_ATTRIB3_4_NV = $8673;
+  GL_MAP2_VERTEX_ATTRIB4_4_NV = $8674;
+  GL_MAP2_VERTEX_ATTRIB5_4_NV = $8675;
+  GL_MAP2_VERTEX_ATTRIB6_4_NV = $8676;
+  GL_MAP2_VERTEX_ATTRIB7_4_NV = $8677;
+  GL_MAP2_VERTEX_ATTRIB8_4_NV = $8678;
+  GL_MAP2_VERTEX_ATTRIB9_4_NV = $8679;
+  GL_MAP2_VERTEX_ATTRIB10_4_NV = $867A;
+  GL_MAP2_VERTEX_ATTRIB11_4_NV = $867B;
+  GL_MAP2_VERTEX_ATTRIB12_4_NV = $867C;
+  GL_MAP2_VERTEX_ATTRIB13_4_NV = $867D;
+  GL_MAP2_VERTEX_ATTRIB14_4_NV = $867E;
+  GL_MAP2_VERTEX_ATTRIB15_4_NV = $867F;
+var
+  glBindProgramNV: procedure(target: GLenum; id: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteProgramsNV: procedure(n: GLsizei; const ids: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glExecuteProgramNV: procedure(target: GLenum; id: GLuint; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGenProgramsNV: procedure(n: GLsizei; ids: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glAreProgramsResidentNV: function(n: GLsizei; const ids: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glRequestResidentProgramsNV: procedure(n: GLsizei; ids: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramParameterfvNV: procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramParameterdvNV: procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramivNV: procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramStringNV: procedure(id: GLuint; pname: GLenum; _program: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTrackMatrixivNV: procedure(target: GLenum; address: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVertexAttribdvNV: procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVertexAttribfvNV: procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVertexAttribivNV: procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVertexAttribPointervNV: procedure(index: GLuint; pname: GLenum; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsProgramNV: function(id: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLoadProgramNV: procedure(target: GLenum; id: GLuint; len: GLsizei; const _program: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramParameter4fNV: procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramParameter4fvNV: procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramParameters4dvNV: procedure(target: GLenum; index: GLuint; num: GLuint; const params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramParameters4fvNV: procedure(target: GLenum; index: GLuint; num: GLuint; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTrackMatrixNV: procedure(target: GLenum; address: GLuint; matrix: GLenum; transform: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribPointerNV: procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1sNV: procedure(index: GLuint; x: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1fNV: procedure(index: GLuint; x: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1dNV: procedure(index: GLuint; x: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2sNV: procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2fNV: procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2dNV: procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3sNV: procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3fNV: procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3dNV: procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4sNV: procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4fNV: procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4dNV: procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4ubNV: procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1svNV: procedure(index: GLuint; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1fvNV: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1dvNV: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2svNV: procedure(index: GLuint; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2fvNV: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2dvNV: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3svNV: procedure(index: GLuint; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3fvNV: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3dvNV: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4svNV: procedure(index: GLuint; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4fvNV: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4dvNV: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4ubvNV: procedure(index: GLuint; const v: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs1svNV: procedure(index: GLuint; n: GLsizei; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs1fvNV: procedure(index: GLuint; n: GLsizei; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs1dvNV: procedure(index: GLuint; n: GLsizei; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs2svNV: procedure(index: GLuint; n: GLsizei; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs2fvNV: procedure(index: GLuint; n: GLsizei; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs2dvNV: procedure(index: GLuint; n: GLsizei; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs3svNV: procedure(index: GLuint; n: GLsizei; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs3fvNV: procedure(index: GLuint; n: GLsizei; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs3dvNV: procedure(index: GLuint; n: GLsizei; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs4svNV: procedure(index: GLuint; n: GLsizei; const v: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs4fvNV: procedure(index: GLuint; n: GLsizei; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs4dvNV: procedure(index: GLuint; n: GLsizei; const v: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs4ubvNV: procedure(index: GLuint; n: GLsizei; const v: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_NV_vertex_program: Boolean;
+
+//***** GL_NV_vertex_program1_1 *****//
+
+function Load_GL_NV_vertex_program1_1: Boolean;
+
+//***** GL_ATI_element_array *****//
+const
+  GL_ELEMENT_ARRAY_ATI = $8768;
+  GL_ELEMENT_ARRAY_TYPE_ATI = $8769;
+  GL_ELEMENT_ARRAY_POINTER_ATI = $876A;
+var
+  glElementPointerATI: procedure(_type: GLenum; const pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawElementArrayATI: procedure(mode: GLenum; count: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawRangeElementArrayATI: procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ATI_element_array: Boolean;
+
+//***** GL_ATI_envmap_bumpmap *****//
+const
+  GL_BUMP_ROT_MATRIX_ATI = $8775;
+  GL_BUMP_ROT_MATRIX_SIZE_ATI = $8776;
+  GL_BUMP_NUM_TEX_UNITS_ATI = $8777;
+  GL_BUMP_TEX_UNITS_ATI = $8778;
+  GL_DUDV_ATI = $8779;
+  GL_DU8DV8_ATI = $877A;
+  GL_BUMP_ENVMAP_ATI = $877B;
+  GL_BUMP_TARGET_ATI = $877C;
+var
+  glTexBumpParameterivATI: procedure(pname: GLenum; param: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexBumpParameterfvATI: procedure(pname: GLenum; param: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexBumpParameterivATI: procedure(pname: GLenum; param: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetTexBumpParameterfvATI: procedure(pname: GLenum; param: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ATI_envmap_bumpmap: Boolean;
+
+//***** GL_ATI_fragment_shader *****//
+const
+  GL_FRAGMENT_SHADER_ATI = $8920;
+  GL_REG_0_ATI = $8921;
+  GL_REG_1_ATI = $8922;
+  GL_REG_2_ATI = $8923;
+  GL_REG_3_ATI = $8924;
+  GL_REG_4_ATI = $8925;
+  GL_REG_5_ATI = $8926;
+  GL_CON_0_ATI = $8941;
+  GL_CON_1_ATI = $8942;
+  GL_CON_2_ATI = $8943;
+  GL_CON_3_ATI = $8944;
+  GL_CON_4_ATI = $8945;
+  GL_CON_5_ATI = $8946;
+  GL_CON_6_ATI = $8947;
+  GL_CON_7_ATI = $8948;
+  GL_MOV_ATI = $8961;
+  GL_ADD_ATI = $8963;
+  GL_MUL_ATI = $8964;
+  GL_SUB_ATI = $8965;
+  GL_DOT3_ATI = $8966;
+  GL_DOT4_ATI = $8967;
+  GL_MAD_ATI = $8968;
+  GL_LERP_ATI = $8969;
+  GL_CND_ATI = $896A;
+  GL_CND0_ATI = $896B;
+  GL_DOT2_ADD_ATI = $896C;
+  GL_SECONDARY_INTERPOLATOR_ATI = $896D;
+  GL_SWIZZLE_STR_ATI = $8976;
+  GL_SWIZZLE_STQ_ATI = $8977;
+  GL_SWIZZLE_STR_DR_ATI = $8978;
+  GL_SWIZZLE_STQ_DQ_ATI = $8979;
+  GL_RED_BIT_ATI = $0001;
+  GL_GREEN_BIT_ATI = $0002;
+  GL_BLUE_BIT_ATI = $0004;
+  GL_2X_BIT_ATI = $0001;
+  GL_4X_BIT_ATI = $0002;
+  GL_8X_BIT_ATI = $0004;
+  GL_HALF_BIT_ATI = $0008;
+  GL_QUARTER_BIT_ATI = $0010;
+  GL_EIGHTH_BIT_ATI = $0020;
+  GL_SATURATE_BIT_ATI = $0040;
+  // GL_2X_BIT_ATI  { already defined }
+  GL_COMP_BIT_ATI = $0002;
+  GL_NEGATE_BIT_ATI = $0004;
+  GL_BIAS_BIT_ATI = $0008;
+var
+  glGenFragmentShadersATI: function(range: GLuint): GLuint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBindFragmentShaderATI: procedure(id: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteFragmentShaderATI: procedure(id: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBeginFragmentShaderATI: procedure(); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEndFragmentShaderATI: procedure(); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPassTexCoordATI: procedure(dst: GLuint; coord: GLuint; swizzle: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSampleMapATI: procedure(dst: GLuint; interp: GLuint; swizzle: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorFragmentOp1ATI: procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorFragmentOp2ATI: procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorFragmentOp3ATI: procedure(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); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glAlphaFragmentOp1ATI: procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glAlphaFragmentOp2ATI: procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glAlphaFragmentOp3ATI: procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint; arg3: GLuint; arg3Rep: GLuint; arg3Mod: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSetFragmentShaderConstantATI: procedure(dst: GLuint; const value: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ATI_fragment_shader: Boolean;
+
+//***** GL_ATI_pn_triangles *****//
+const
+  GL_PN_TRIANGLES_ATI = $87F0;
+  GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F1;
+  GL_PN_TRIANGLES_POINT_MODE_ATI = $87F2;
+  GL_PN_TRIANGLES_NORMAL_MODE_ATI = $87F3;
+  GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F4;
+  GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = $87F5;
+  GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = $87F6;
+  GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = $87F7;
+  GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = $87F8;
+var
+  glPNTrianglesiATI: procedure(pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPNTrianglesfATI: procedure(pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ATI_pn_triangles: Boolean;
+
+//***** GL_ATI_texture_mirror_once *****//
+const
+  GL_MIRROR_CLAMP_ATI = $8742;
+  GL_MIRROR_CLAMP_TO_EDGE_ATI = $8743;
+
+function Load_GL_ATI_texture_mirror_once: Boolean;
+
+//***** GL_ATI_vertex_array_object *****//
+const
+  GL_STATIC_ATI = $8760;
+  GL_DYNAMIC_ATI = $8761;
+  GL_PRESERVE_ATI = $8762;
+  GL_DISCARD_ATI = $8763;
+  GL_OBJECT_BUFFER_SIZE_ATI = $8764;
+  GL_OBJECT_BUFFER_USAGE_ATI = $8765;
+  GL_ARRAY_OBJECT_BUFFER_ATI = $8766;
+  GL_ARRAY_OBJECT_OFFSET_ATI = $8767;
+var
+  glNewObjectBufferATI: function(size: GLsizei; const pointer: PGLvoid; usage: GLenum): GLuint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsObjectBufferATI: function(buffer: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUpdateObjectBufferATI: procedure(buffer: GLuint; offset: GLuint; size: GLsizei; const pointer: PGLvoid; preserve: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetObjectBufferfvATI: procedure(buffer: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetObjectBufferivATI: procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteObjectBufferATI: procedure(buffer: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glArrayObjectATI: procedure(_array: GLenum; size: GLint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetArrayObjectfvATI: procedure(_array: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetArrayObjectivATI: procedure(_array: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVariantArrayObjectATI: procedure(id: GLuint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVariantArrayObjectfvATI: procedure(id: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVariantArrayObjectivATI: procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ATI_vertex_array_object: Boolean;
+
+//***** GL_ATI_vertex_streams *****//
+const
+  GL_MAX_VERTEX_STREAMS_ATI = $876B;
+  GL_VERTEX_STREAM0_ATI = $876C;
+  GL_VERTEX_STREAM1_ATI = $876D;
+  GL_VERTEX_STREAM2_ATI = $876E;
+  GL_VERTEX_STREAM3_ATI = $876F;
+  GL_VERTEX_STREAM4_ATI = $8770;
+  GL_VERTEX_STREAM5_ATI = $8771;
+  GL_VERTEX_STREAM6_ATI = $8772;
+  GL_VERTEX_STREAM7_ATI = $8773;
+  GL_VERTEX_SOURCE_ATI = $8774;
+var
+  glVertexStream1s: procedure(stream: GLenum; coords: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream1i: procedure(stream: GLenum; coords: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream1f: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream1d: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream1sv: procedure(stream: GLenum; coords: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream1iv: procedure(stream: GLenum; coords: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream1fv: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream1dv: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream2s: procedure(stream: GLenum; coords: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream2i: procedure(stream: GLenum; coords: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream2f: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream2d: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream2sv: procedure(stream: GLenum; coords: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream2iv: procedure(stream: GLenum; coords: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream2fv: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream2dv: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream3s: procedure(stream: GLenum; coords: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream3i: procedure(stream: GLenum; coords: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream3f: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream3d: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream3sv: procedure(stream: GLenum; coords: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream3iv: procedure(stream: GLenum; coords: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream3fv: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream3dv: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream4s: procedure(stream: GLenum; coords: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream4i: procedure(stream: GLenum; coords: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream4f: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream4d: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream4sv: procedure(stream: GLenum; coords: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream4iv: procedure(stream: GLenum; coords: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream4fv: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexStream4dv: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalStream3b: procedure(stream: GLenum; coords: GLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalStream3s: procedure(stream: GLenum; coords: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalStream3i: procedure(stream: GLenum; coords: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalStream3f: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalStream3d: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalStream3bv: procedure(stream: GLenum; coords: GLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalStream3sv: procedure(stream: GLenum; coords: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalStream3iv: procedure(stream: GLenum; coords: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalStream3fv: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalStream3dv: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glClientActiveVertexStream: procedure(stream: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexBlendEnvi: procedure(pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexBlendEnvf: procedure(pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ATI_vertex_streams: Boolean;
+
+{$IFDEF Win32}
+//***** WGL_I3D_image_buffer *****//
+const
+  WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = $0001;
+  WGL_IMAGE_BUFFER_LOCK_I3D = $0002;
+var
+  wglCreateImageBufferI3D: function(hDC: HDC; dwSize: DWORD; uFlags: UINT): PGLvoid; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglDestroyImageBufferI3D: function(hDC: HDC; pAddress: PGLvoid): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglAssociateImageBufferEventsI3D: function(hdc: HDC; pEvent: PHandle; pAddress: PGLvoid; pSize: PDWORD; count: UINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglReleaseImageBufferEventsI3D: function(hdc: HDC; pAddress: PGLvoid; count: UINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_I3D_image_buffer: Boolean;
+
+//***** WGL_I3D_swap_frame_lock *****//
+var
+  wglEnableFrameLockI3D: function(): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglDisableFrameLockI3D: function(): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglIsEnabledFrameLockI3D: function(pFlag: PBOOL): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglQueryFrameLockMasterI3D: function(pFlag: PBOOL): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_I3D_swap_frame_lock: Boolean;
+
+//***** WGL_I3D_swap_frame_usage *****//
+var
+  wglGetFrameUsageI3D: function(pUsage: PGLfloat): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglBeginFrameTrackingI3D: function(): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglEndFrameTrackingI3D: function(): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglQueryFrameTrackingI3D: function(pFrameCount: PDWORD; pMissedFrames: PDWORD; pLastMissedUsage: PGLfloat): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_I3D_swap_frame_usage: Boolean;
+{$ENDIF}
+
+//***** GL_3DFX_texture_compression_FXT1 *****//
+const
+  GL_COMPRESSED_RGB_FXT1_3DFX = $86B0;
+  GL_COMPRESSED_RGBA_FXT1_3DFX = $86B1;
+
+function Load_GL_3DFX_texture_compression_FXT1: Boolean;
+
+//***** GL_IBM_cull_vertex *****//
+const
+  GL_CULL_VERTEX_IBM = $1928A;
+
+function Load_GL_IBM_cull_vertex: Boolean;
+
+//***** GL_IBM_multimode_draw_arrays *****//
+var
+  glMultiModeDrawArraysIBM: procedure(mode: PGLenum; first: PGLint; count: PGLsizei; primcount: GLsizei; modestride: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiModeDrawElementsIBM: procedure(mode: PGLenum; count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei; modestride: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_IBM_multimode_draw_arrays: Boolean;
+
+//***** GL_IBM_raster_pos_clip *****//
+const
+  GL_RASTER_POSITION_UNCLIPPED_IBM = $19262;
+
+function Load_GL_IBM_raster_pos_clip: Boolean;
+
+//***** GL_IBM_texture_mirrored_repeat *****//
+const
+  GL_MIRRORED_REPEAT_IBM = $8370;
+
+function Load_GL_IBM_texture_mirrored_repeat: Boolean;
+
+//***** GL_IBM_vertex_array_lists *****//
+const
+  GL_VERTEX_ARRAY_LIST_IBM = $1929E;
+  GL_NORMAL_ARRAY_LIST_IBM = $1929F;
+  GL_COLOR_ARRAY_LIST_IBM = $192A0;
+  GL_INDEX_ARRAY_LIST_IBM = $192A1;
+  GL_TEXTURE_COORD_ARRAY_LIST_IBM = $192A2;
+  GL_EDGE_FLAG_ARRAY_LIST_IBM = $192A3;
+  GL_FOG_COORDINATE_ARRAY_LIST_IBM = $192A4;
+  GL_SECONDARY_COLOR_ARRAY_LIST_IBM = $192A5;
+  GL_VERTEX_ARRAY_LIST_STRIDE_IBM = $192A8;
+  GL_NORMAL_ARRAY_LIST_STRIDE_IBM = $192A9;
+  GL_COLOR_ARRAY_LIST_STRIDE_IBM = $192AA;
+  GL_INDEX_ARRAY_LIST_STRIDE_IBM = $192AB;
+  GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = $192AC;
+  GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = $192AD;
+  GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = $192AE;
+  GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = $192AF;
+var
+  glColorPointerListIBM: procedure(size: GLint; _type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColorPointerListIBM: procedure(size: GLint; _type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEdgeFlagPointerListIBM: procedure(stride: GLint; const pointer: PGLboolean; ptrstride: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogCoordPointerListIBM: procedure(_type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormalPointerListIBM: procedure(_type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoordPointerListIBM: procedure(size: GLint; _type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexPointerListIBM: procedure(size: GLint; _type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_IBM_vertex_array_lists: Boolean;
+
+//***** GL_MESA_resize_buffers *****//
+var
+  glResizeBuffersMESA: procedure(); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_MESA_resize_buffers: Boolean;
+
+//***** GL_MESA_window_pos *****//
+var
+  glWindowPos2dMESA: procedure(x: GLdouble; y: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2fMESA: procedure(x: GLfloat; y: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2iMESA: procedure(x: GLint; y: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2sMESA: procedure(x: GLshort; y: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2ivMESA: procedure(const p: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2svMESA: procedure(const p: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2fvMESA: procedure(const p: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos2dvMESA: procedure(const p: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3iMESA: procedure(x: GLint; y: GLint; z: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3sMESA: procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3fMESA: procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3dMESA: procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3ivMESA: procedure(const p: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3svMESA: procedure(const p: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3fvMESA: procedure(const p: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos3dvMESA: procedure(const p: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos4iMESA: procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos4sMESA: procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos4fMESA: procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos4dMESA: procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos4ivMESA: procedure(const p: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos4svMESA: procedure(const p: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos4fvMESA: procedure(const p: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glWindowPos4dvMESA: procedure(const p: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_MESA_window_pos: Boolean;
+
+//***** GL_OML_interlace *****//
+const
+  GL_INTERLACE_OML = $8980;
+  GL_INTERLACE_READ_OML = $8981;
+
+function Load_GL_OML_interlace: Boolean;
+
+//***** GL_OML_resample *****//
+const
+  GL_PACK_RESAMPLE_OML = $8984;
+  GL_UNPACK_RESAMPLE_OML = $8985;
+  GL_RESAMPLE_REPLICATE_OML = $8986;
+  GL_RESAMPLE_ZERO_FILL_OML = $8987;
+  GL_RESAMPLE_AVERAGE_OML = $8988;
+  GL_RESAMPLE_DECIMATE_OML = $8989;
+  // GL_RESAMPLE_AVERAGE_OML  { already defined }
+
+function Load_GL_OML_resample: Boolean;
+
+//***** GL_OML_subsample *****//
+const
+  GL_FORMAT_SUBSAMPLE_24_24_OML = $8982;
+  GL_FORMAT_SUBSAMPLE_244_244_OML = $8983;
+
+function Load_GL_OML_subsample: Boolean;
+
+//***** GL_SGIS_generate_mipmap *****//
+const
+  GL_GENERATE_MIPMAP_SGIS = $8191;
+  GL_GENERATE_MIPMAP_HINT_SGIS = $8192;
+
+function Load_GL_SGIS_generate_mipmap: Boolean;
+
+//***** GL_SGIS_multisample *****//
+const
+  GLX_SAMPLE_BUFFERS_SGIS = $186A0;
+  GLX_SAMPLES_SGIS = $186A1;
+  GL_MULTISAMPLE_SGIS = $809D;
+  GL_SAMPLE_ALPHA_TO_MASK_SGIS = $809E;
+  GL_SAMPLE_ALPHA_TO_ONE_SGIS = $809F;
+  GL_SAMPLE_MASK_SGIS = $80A0;
+  GL_MULTISAMPLE_BIT_EXT = $20000000;
+  GL_1PASS_SGIS = $80A1;
+  GL_2PASS_0_SGIS = $80A2;
+  GL_2PASS_1_SGIS = $80A3;
+  GL_4PASS_0_SGIS = $80A4;
+  GL_4PASS_1_SGIS = $80A5;
+  GL_4PASS_2_SGIS = $80A6;
+  GL_4PASS_3_SGIS = $80A7;
+  GL_SAMPLE_BUFFERS_SGIS = $80A8;
+  GL_SAMPLES_SGIS = $80A9;
+  GL_SAMPLE_MASK_VALUE_SGIS = $80AA;
+  GL_SAMPLE_MASK_INVERT_SGIS = $80AB;
+  GL_SAMPLE_PATTERN_SGIS = $80AC;
+var
+  glSampleMaskSGIS: procedure(value: GLclampf; invert: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSamplePatternSGIS: procedure(pattern: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_SGIS_multisample: Boolean;
+
+//***** GL_SGIS_pixel_texture *****//
+const
+  GL_PIXEL_TEXTURE_SGIS = $8353;
+  GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = $8354;
+  GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = $8355;
+  GL_PIXEL_GROUP_COLOR_SGIS = $8356;
+var
+  glPixelTexGenParameteriSGIS: procedure(pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPixelTexGenParameterfSGIS: procedure(pname: GLenum; param: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetPixelTexGenParameterivSGIS: procedure(pname: GLenum; params: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetPixelTexGenParameterfvSGIS: procedure(pname: GLenum; params: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_SGIS_pixel_texture: Boolean;
+
+//***** GL_SGIS_texture_border_clamp *****//
+  // GL_CLAMP_TO_BORDER_SGIS  { already defined }
+
+function Load_GL_SGIS_texture_border_clamp: Boolean;
+
+//***** GL_SGIS_texture_color_mask *****//
+const
+  GL_TEXTURE_COLOR_WRITEMASK_SGIS = $81EF;
+var
+  glTextureColorMaskSGIS: procedure(r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_SGIS_texture_color_mask: Boolean;
+
+//***** GL_SGIS_texture_edge_clamp *****//
+const
+  GL_CLAMP_TO_EDGE_SGIS = $812F;
+
+function Load_GL_SGIS_texture_edge_clamp: Boolean;
+
+//***** GL_SGIS_texture_lod *****//
+const
+  GL_TEXTURE_MIN_LOD_SGIS = $813A;
+  GL_TEXTURE_MAX_LOD_SGIS = $813B;
+  GL_TEXTURE_BASE_LEVEL_SGIS = $813C;
+  GL_TEXTURE_MAX_LEVEL_SGIS = $813D;
+
+function Load_GL_SGIS_texture_lod: Boolean;
+
+//***** GL_SGIS_depth_texture *****//
+const
+  GL_DEPTH_COMPONENT16_SGIX = $81A5;
+  GL_DEPTH_COMPONENT24_SGIX = $81A6;
+  GL_DEPTH_COMPONENT32_SGIX = $81A7;
+
+function Load_GL_SGIS_depth_texture: Boolean;
+
+//***** GL_SGIX_fog_offset *****//
+const
+  GL_FOG_OFFSET_SGIX = $8198;
+  GL_FOG_OFFSET_VALUE_SGIX = $8199;
+
+function Load_GL_SGIX_fog_offset: Boolean;
+
+//***** GL_SGIX_interlace *****//
+const
+  GL_INTERLACE_SGIX = $8094;
+
+function Load_GL_SGIX_interlace: Boolean;
+
+//***** GL_SGIX_shadow_ambient *****//
+const
+  GL_SHADOW_AMBIENT_SGIX = $80BF;
+
+function Load_GL_SGIX_shadow_ambient: Boolean;
+
+//***** GL_SGI_color_matrix *****//
+const
+  GL_COLOR_MATRIX_SGI = $80B1;
+  GL_COLOR_MATRIX_STACK_DEPTH_SGI = $80B2;
+  GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = $80B3;
+  GL_POST_COLOR_MATRIX_RED_SCALE_SGI = $80B4;
+  GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = $80B5;
+  GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = $80B6;
+  GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = $80B7;
+  GL_POST_COLOR_MATRIX_RED_BIAS_SGI = $80B8;
+  GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = $80B9;
+  GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = $80BA;
+  GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = $80BB;
+
+function Load_GL_SGI_color_matrix: Boolean;
+
+//***** GL_SGI_color_table *****//
+const
+  GL_COLOR_TABLE_SGI = $80D0;
+  GL_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D1;
+  GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D2;
+  GL_PROXY_COLOR_TABLE_SGI = $80D3;
+  GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D4;
+  GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D5;
+  GL_COLOR_TABLE_SCALE_SGI = $80D6;
+  GL_COLOR_TABLE_BIAS_SGI = $80D7;
+  GL_COLOR_TABLE_FORMAT_SGI = $80D8;
+  GL_COLOR_TABLE_WIDTH_SGI = $80D9;
+  GL_COLOR_TABLE_RED_SIZE_SGI = $80DA;
+  GL_COLOR_TABLE_GREEN_SIZE_SGI = $80DB;
+  GL_COLOR_TABLE_BLUE_SIZE_SGI = $80DC;
+  GL_COLOR_TABLE_ALPHA_SIZE_SGI = $80DD;
+  GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = $80DE;
+  GL_COLOR_TABLE_INTENSITY_SIZE_SGI = $80DF;
+var
+  glColorTableSGI: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCopyColorTableSGI: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorTableParameterivSGI: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColorTableParameterfvSGI: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetColorTableSGI: procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetColorTableParameterivSGI: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetColorTableParameterfvSGI: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_SGI_color_table: Boolean;
+
+//***** GL_SGI_texture_color_table *****//
+const
+  GL_TEXTURE_COLOR_TABLE_SGI = $80BC;
+  GL_PROXY_TEXTURE_COLOR_TABLE_SGI = $80BD;
+
+function Load_GL_SGI_texture_color_table: Boolean;
+
+//***** GL_SUN_vertex *****//
+var
+  glColor4ubVertex2fSUN: procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4ubVertex2fvSUN: procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4ubVertex3fSUN: procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4ubVertex3fvSUN: procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3fVertex3fSUN: procedure(r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3fVertex3fvSUN: procedure(const c: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3fVertex3fSUN: procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3fVertex3fvSUN: procedure(const n: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4fNormal3fVertex3fSUN: procedure(r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4fNormal3fVertex3fvSUN: procedure(const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fVertex3fSUN: procedure(s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fVertex3fvSUN: procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4fVertex4fSUN: procedure(s: GLfloat; t: GLfloat; p: GLfloat; q: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4fVertex4fvSUN: procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fColor4ubVertex3fSUN: procedure(s: GLfloat; t: GLfloat; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fColor4ubVertex3fvSUN: procedure(const tc: PGLfloat; const c: PGLubyte; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fColor3fVertex3fSUN: procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fColor3fVertex3fvSUN: procedure(const tc: PGLfloat; const c: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fNormal3fVertex3fSUN: procedure(s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fNormal3fVertex3fvSUN: procedure(const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fColor4fNormal3fVertex3fSUN: procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2fColor4fNormal3fVertex3fvSUN: procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4fColor4fNormal3fVertex4fSUN: procedure(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); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4fColor4fNormal3fVertex4fvSUN: procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiVertex3fSUN: procedure(rc: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiVertex3fvSUN: procedure(const rc: PGLuint; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiColor4ubVertex3fSUN: procedure(rc: GLuint; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiColor4ubVertex3fvSUN: procedure(const rc: PGLuint; const c: PGLubyte; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiColor3fVertex3fSUN: procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiColor3fVertex3fvSUN: procedure(const rc: PGLuint; const c: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiNormal3fVertex3fSUN: procedure(rc: GLuint; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiNormal3fVertex3fvSUN: procedure(const rc: PGLuint; const n: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiColor4fNormal3fVertex3fSUN: procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiColor4fNormal3fVertex3fvSUN: procedure(const rc: PGLuint; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiTexCoord2fVertex3fSUN: procedure(rc: GLuint; s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiTexCoord2fVertex3fvSUN: procedure(const rc: PGLuint; const tc: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN: procedure(rc: GLuint; s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN: procedure(const rc: PGLuint; const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN: procedure(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); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN: procedure(const rc: PGLuint; const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_SUN_vertex: Boolean;
+
+//***** GL_ARB_fragment_program *****//
+const
+  GL_FRAGMENT_PROGRAM_ARB = $8804;
+  // GL_PROGRAM_FORMAT_ASCII_ARB  { already defined }
+  // GL_PROGRAM_LENGTH_ARB  { already defined }
+  // GL_PROGRAM_FORMAT_ARB  { already defined }
+  // GL_PROGRAM_BINDING_ARB  { already defined }
+  // GL_PROGRAM_INSTRUCTIONS_ARB  { already defined }
+  // GL_MAX_PROGRAM_INSTRUCTIONS_ARB  { already defined }
+  // GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB  { already defined }
+  // GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB  { already defined }
+  // GL_PROGRAM_TEMPORARIES_ARB  { already defined }
+  // GL_MAX_PROGRAM_TEMPORARIES_ARB  { already defined }
+  // GL_PROGRAM_NATIVE_TEMPORARIES_ARB  { already defined }
+  // GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB  { already defined }
+  // GL_PROGRAM_PARAMETERS_ARB  { already defined }
+  // GL_MAX_PROGRAM_PARAMETERS_ARB  { already defined }
+  // GL_PROGRAM_NATIVE_PARAMETERS_ARB  { already defined }
+  // GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB  { already defined }
+  // GL_PROGRAM_ATTRIBS_ARB  { already defined }
+  // GL_MAX_PROGRAM_ATTRIBS_ARB  { already defined }
+  // GL_PROGRAM_NATIVE_ATTRIBS_ARB  { already defined }
+  // GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB  { already defined }
+  // GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB  { already defined }
+  // GL_MAX_PROGRAM_ENV_PARAMETERS_ARB  { already defined }
+  // GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB  { already defined }
+  GL_PROGRAM_ALU_INSTRUCTIONS_ARB = $8805;
+  GL_PROGRAM_TEX_INSTRUCTIONS_ARB = $8806;
+  GL_PROGRAM_TEX_INDIRECTIONS_ARB = $8807;
+  GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $8808;
+  GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $8809;
+  GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $880A;
+  GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = $880B;
+  GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = $880C;
+  GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = $880D;
+  GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $880E;
+  GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $880F;
+  GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $8810;
+  // GL_PROGRAM_STRING_ARB  { already defined }
+  // GL_PROGRAM_ERROR_POSITION_ARB  { already defined }
+  // GL_CURRENT_MATRIX_ARB  { already defined }
+  // GL_TRANSPOSE_CURRENT_MATRIX_ARB  { already defined }
+  // GL_CURRENT_MATRIX_STACK_DEPTH_ARB  { already defined }
+  // GL_MAX_PROGRAM_MATRICES_ARB  { already defined }
+  // GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB  { already defined }
+  GL_MAX_TEXTURE_COORDS_ARB = $8871;
+  GL_MAX_TEXTURE_IMAGE_UNITS_ARB = $8872;
+  // GL_PROGRAM_ERROR_STRING_ARB  { already defined }
+  // GL_MATRIX0_ARB  { already defined }
+  // GL_MATRIX1_ARB  { already defined }
+  // GL_MATRIX2_ARB  { already defined }
+  // GL_MATRIX3_ARB  { already defined }
+  // GL_MATRIX4_ARB  { already defined }
+  // GL_MATRIX5_ARB  { already defined }
+  // GL_MATRIX6_ARB  { already defined }
+  // GL_MATRIX7_ARB  { already defined }
+  // GL_MATRIX8_ARB  { already defined }
+  // GL_MATRIX9_ARB  { already defined }
+  // GL_MATRIX10_ARB  { already defined }
+  // GL_MATRIX11_ARB  { already defined }
+  // GL_MATRIX12_ARB  { already defined }
+  // GL_MATRIX13_ARB  { already defined }
+  // GL_MATRIX14_ARB  { already defined }
+  // GL_MATRIX15_ARB  { already defined }
+  // GL_MATRIX16_ARB  { already defined }
+  // GL_MATRIX17_ARB  { already defined }
+  // GL_MATRIX18_ARB  { already defined }
+  // GL_MATRIX19_ARB  { already defined }
+  // GL_MATRIX20_ARB  { already defined }
+  // GL_MATRIX21_ARB  { already defined }
+  // GL_MATRIX22_ARB  { already defined }
+  // GL_MATRIX23_ARB  { already defined }
+  // GL_MATRIX24_ARB  { already defined }
+  // GL_MATRIX25_ARB  { already defined }
+  // GL_MATRIX26_ARB  { already defined }
+  // GL_MATRIX27_ARB  { already defined }
+  // GL_MATRIX28_ARB  { already defined }
+  // GL_MATRIX29_ARB  { already defined }
+  // GL_MATRIX30_ARB  { already defined }
+  // GL_MATRIX31_ARB  { already defined }
+  // glProgramStringARB  { already defined }
+  // glBindProgramARB  { already defined }
+  // glDeleteProgramsARB  { already defined }
+  // glGenProgramsARB  { already defined }
+  // glProgramEnvParameter4dARB  { already defined }
+  // glProgramEnvParameter4dvARB  { already defined }
+  // glProgramEnvParameter4fARB  { already defined }
+  // glProgramEnvParameter4fvARB  { already defined }
+  // glProgramLocalParameter4dARB  { already defined }
+  // glProgramLocalParameter4dvARB  { already defined }
+  // glProgramLocalParameter4fARB  { already defined }
+  // glProgramLocalParameter4fvARB  { already defined }
+  // glGetProgramEnvParameterdvARB  { already defined }
+  // glGetProgramEnvParameterfvARB  { already defined }
+  // glGetProgramLocalParameterdvARB  { already defined }
+  // glGetProgramLocalParameterfvARB  { already defined }
+  // glGetProgramivARB  { already defined }
+  // glGetProgramStringARB  { already defined }
+  // glIsProgramARB  { already defined }
+
+function Load_GL_ARB_fragment_program: Boolean;
+
+//***** GL_ATI_text_fragment_shader *****//
+const
+  GL_TEXT_FRAGMENT_SHADER_ATI = $8200;
+
+function Load_GL_ATI_text_fragment_shader: Boolean;
+
+//***** GL_APPLE_client_storage *****//
+const
+  GL_UNPACK_CLIENT_STORAGE_APPLE = $85B2;
+
+function Load_GL_APPLE_client_storage: Boolean;
+
+//***** GL_APPLE_element_array *****//
+const
+  GL_ELEMENT_ARRAY_APPLE = $8768;
+  GL_ELEMENT_ARRAY_TYPE_APPLE = $8769;
+  GL_ELEMENT_ARRAY_POINTER_APPLE = $876A;
+var
+  glElementPointerAPPLE: procedure(_type: GLenum; const pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawElementArrayAPPLE: procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawRangeElementArrayAPPLE: procedure(mode: GLenum; start: GLuint; _end: GLuint; first: GLint; count: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiDrawElementArrayAPPLE: procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiDrawRangeElementArrayAPPLE: procedure(mode: GLenum; start: GLuint; _end: GLuint; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_APPLE_element_array: Boolean;
+
+//***** GL_APPLE_fence *****//
+const
+  GL_DRAW_PIXELS_APPLE = $8A0A;
+  GL_FENCE_APPLE = $8A0B;
+var
+  glGenFencesAPPLE: procedure(n: GLsizei; fences: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteFencesAPPLE: procedure(n: GLsizei; const fences: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSetFenceAPPLE: procedure(fence: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsFenceAPPLE: function(fence: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTestFenceAPPLE: function(fence: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFinishFenceAPPLE: procedure(fence: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTestObjectAPPLE: function(_object: GLenum; name: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFinishObjectAPPLE: procedure(_object: GLenum; name: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_APPLE_fence: Boolean;
+
+//***** GL_APPLE_vertex_array_object *****//
+const
+  GL_VERTEX_ARRAY_BINDING_APPLE = $85B5;
+var
+  glBindVertexArrayAPPLE: procedure(_array: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteVertexArraysAPPLE: procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGenVertexArraysAPPLE: procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsVertexArrayAPPLE: function(_array: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_APPLE_vertex_array_object: Boolean;
+
+//***** GL_APPLE_vertex_array_range *****//
+const
+  GL_VERTEX_ARRAY_RANGE_APPLE = $851D;
+  GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = $851E;
+  GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_APPLE = $8520;
+  GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = $8521;
+  GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = $851F;
+  GL_STORAGE_CACHED_APPLE = $85BE;
+  GL_STORAGE_SHARED_APPLE = $85BF;
+var
+  glVertexArrayRangeAPPLE: procedure(length: GLsizei; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFlushVertexArrayRangeAPPLE: procedure(length: GLsizei; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexArrayParameteriAPPLE: procedure(pname: GLenum; param: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_APPLE_vertex_array_range: Boolean;
+
+{$IFDEF Win32}
+//***** WGL_ARB_pixel_format *****//
+const
+  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;
+var
+  wglGetPixelFormatAttribivARB: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; piValues: PGLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetPixelFormatAttribfvARB: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; pfValues: PGLfloat): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglChoosePixelFormatARB: function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_ARB_pixel_format: Boolean;
+
+//***** WGL_ARB_make_current_read *****//
+const
+  WGL_ERROR_INVALID_PIXEL_TYPE_ARB = $2043;
+  WGL_ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = $2054;
+var
+  wglMakeContextCurrentARB: function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetCurrentReadDCARB: function(): HDC; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_ARB_make_current_read: Boolean;
+
+//***** WGL_ARB_pbuffer *****//
+const
+  WGL_DRAW_TO_PBUFFER_ARB = $202D;
+  // WGL_DRAW_TO_PBUFFER_ARB  { already defined }
+  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;
+var
+  wglCreatePbufferARB: function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): THandle; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetPbufferDCARB: function(hPbuffer: THandle): HDC; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglReleasePbufferDCARB: function(hPbuffer: THandle; hDC: HDC): GLint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglDestroyPbufferARB: function(hPbuffer: THandle): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglQueryPbufferARB: function(hPbuffer: THandle; iAttribute: GLint; piValue: PGLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_ARB_pbuffer: Boolean;
+
+//***** WGL_EXT_swap_control *****//
+var
+  wglSwapIntervalEXT: function(interval: GLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetSwapIntervalEXT: function(): GLint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_EXT_swap_control: Boolean;
+
+//***** WGL_ARB_render_texture *****//
+const
+  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_NO_TEXTURE_ARB  { already defined }
+  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;
+var
+  wglBindTexImageARB: function(hPbuffer: THandle; iBuffer: GLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglReleaseTexImageARB: function(hPbuffer: THandle; iBuffer: GLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglSetPbufferAttribARB: function(hPbuffer: THandle; const piAttribList: PGLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_ARB_render_texture: Boolean;
+
+//***** WGL_EXT_extensions_string *****//
+var
+  wglGetExtensionsStringEXT: function(): Pchar; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_EXT_extensions_string: Boolean;
+
+//***** WGL_EXT_make_current_read *****//
+var
+  wglMakeContextCurrentEXT: function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetCurrentReadDCEXT: function(): HDC; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_EXT_make_current_read: Boolean;
+
+//***** WGL_EXT_pbuffer *****//
+const
+  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;
+var
+  wglCreatePbufferEXT: function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): THandle; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetPbufferDCEXT: function(hPbuffer: THandle): HDC; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglReleasePbufferDCEXT: function(hPbuffer: THandle; hDC: HDC): GLint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglDestroyPbufferEXT: function(hPbuffer: THandle): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglQueryPbufferEXT: function(hPbuffer: THandle; iAttribute: GLint; piValue: PGLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_EXT_pbuffer: Boolean;
+
+//***** WGL_EXT_pixel_format *****//
+const
+  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;
+var
+  wglGetPixelFormatAttribivEXT: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; piValues: PGLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetPixelFormatAttribfvEXT: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; pfValues: PGLfloat): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglChoosePixelFormatEXT: function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_EXT_pixel_format: Boolean;
+
+//***** WGL_I3D_digital_video_control *****//
+const
+  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;
+var
+  wglGetDigitalVideoParametersI3D: function(hDC: HDC; iAttribute: GLint; piValue: PGLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglSetDigitalVideoParametersI3D: function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_I3D_digital_video_control: Boolean;
+
+//***** WGL_I3D_gamma *****//
+const
+  WGL_GAMMA_TABLE_SIZE_I3D = $204E;
+  WGL_GAMMA_EXCLUDE_DESKTOP_I3D = $204F;
+  // WGL_GAMMA_EXCLUDE_DESKTOP_I3D  { already defined }
+var
+  wglGetGammaTableParametersI3D: function(hDC: HDC; iAttribute: GLint; piValue: PGLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglSetGammaTableParametersI3D: function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetGammaTableI3D: function(hDC: HDC; iEntries: GLint; puRed: PGLUSHORT; puGreen: PGLUSHORT; puBlue: PGLUSHORT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglSetGammaTableI3D: function(hDC: HDC; iEntries: GLint; const puRed: PGLUSHORT; const puGreen: PGLUSHORT; const puBlue: PGLUSHORT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_I3D_gamma: Boolean;
+
+//***** WGL_I3D_genlock *****//
+const
+  WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = $2044;
+  WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D = $2045;
+  WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D = $2046;
+  WGL_GENLOCK_SOURCE_EXTERNAL_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;
+var
+  wglEnableGenlockI3D: function(hDC: HDC): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglDisableGenlockI3D: function(hDC: HDC): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglIsEnabledGenlockI3D: function(hDC: HDC; pFlag: PBOOL): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGenlockSourceI3D: function(hDC: HDC; uSource: GLUINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetGenlockSourceI3D: function(hDC: HDC; uSource: PGLUINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGenlockSourceEdgeI3D: function(hDC: HDC; uEdge: GLUINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetGenlockSourceEdgeI3D: function(hDC: HDC; uEdge: PGLUINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGenlockSampleRateI3D: function(hDC: HDC; uRate: GLUINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetGenlockSampleRateI3D: function(hDC: HDC; uRate: PGLUINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGenlockSourceDelayI3D: function(hDC: HDC; uDelay: GLUINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglGetGenlockSourceDelayI3D: function(hDC: HDC; uDelay: PGLUINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  wglQueryGenlockMaxSourceDelayI3D: function(hDC: HDC; uMaxLineDelay: PGLUINT; uMaxPixelDelay: PGLUINT): BOOL; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_WGL_I3D_genlock: Boolean;
+{$ENDIF}
+
+//***** GL_ARB_matrix_palette *****//
+const
+  GL_MATRIX_PALETTE_ARB = $8840;
+  GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = $8841;
+  GL_MAX_PALETTE_MATRICES_ARB = $8842;
+  GL_CURRENT_PALETTE_MATRIX_ARB = $8843;
+  GL_MATRIX_INDEX_ARRAY_ARB = $8844;
+  GL_CURRENT_MATRIX_INDEX_ARB = $8845;
+  GL_MATRIX_INDEX_ARRAY_SIZE_ARB = $8846;
+  GL_MATRIX_INDEX_ARRAY_TYPE_ARB = $8847;
+  GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = $8848;
+  GL_MATRIX_INDEX_ARRAY_POINTER_ARB = $8849;
+var
+  glCurrentPaletteMatrixARB: procedure(index: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMatrixIndexubvARB: procedure(size: GLint; indices: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMatrixIndexusvARB: procedure(size: GLint; indices: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMatrixIndexuivARB: procedure(size: GLint; indices: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMatrixIndexPointerARB: procedure(size: GLint; _type: GLenum; stride: GLsizei; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_matrix_palette: Boolean;
+
+//***** GL_NV_element_array *****//
+const
+  GL_ELEMENT_ARRAY_TYPE_NV = $8769;
+  GL_ELEMENT_ARRAY_POINTER_NV = $876A;
+var
+  glElementPointerNV: procedure(_type: GLenum; const pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawElementArrayNV: procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDrawRangeElementArrayNV: procedure(mode: GLenum; start: GLuint; _end: GLuint; first: GLint; count: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiDrawElementArrayNV: procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiDrawRangeElementArrayNV: procedure(mode: GLenum; start: GLuint; _end: GLuint; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_NV_element_array: Boolean;
+
+//***** GL_NV_float_buffer *****//
+const
+  GL_FLOAT_R_NV = $8880;
+  GL_FLOAT_RG_NV = $8881;
+  GL_FLOAT_RGB_NV = $8882;
+  GL_FLOAT_RGBA_NV = $8883;
+  GL_FLOAT_R16_NV = $8884;
+  GL_FLOAT_R32_NV = $8885;
+  GL_FLOAT_RG16_NV = $8886;
+  GL_FLOAT_RG32_NV = $8887;
+  GL_FLOAT_RGB16_NV = $8888;
+  GL_FLOAT_RGB32_NV = $8889;
+  GL_FLOAT_RGBA16_NV = $888A;
+  GL_FLOAT_RGBA32_NV = $888B;
+  GL_TEXTURE_FLOAT_COMPONENTS_NV = $888C;
+  GL_FLOAT_CLEAR_COLOR_VALUE_NV = $888D;
+  GL_FLOAT_RGBA_MODE_NV = $888E;
+{$IFDEF Win32}
+  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;
+{$ENDIF}
+
+function Load_GL_NV_float_buffer: Boolean;
+
+//***** GL_NV_fragment_program *****//
+const
+  GL_FRAGMENT_PROGRAM_NV = $8870;
+  GL_MAX_TEXTURE_COORDS_NV = $8871;
+  GL_MAX_TEXTURE_IMAGE_UNITS_NV = $8872;
+  GL_FRAGMENT_PROGRAM_BINDING_NV = $8873;
+  GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = $8868;
+  GL_PROGRAM_ERROR_STRING_NV = $8874;
+var
+  glProgramNamedParameter4fNV: procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glProgramNamedParameter4dNV: procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramNamedParameterfvNV: procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetProgramNamedParameterdvNV: procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  // glProgramLocalParameter4dARB  { already defined }
+  // glProgramLocalParameter4dvARB  { already defined }
+  // glProgramLocalParameter4fARB  { already defined }
+  // glProgramLocalParameter4fvARB  { already defined }
+  // glGetProgramLocalParameterdvARB  { already defined }
+  // glGetProgramLocalParameterfvARB  { already defined }
+
+function Load_GL_NV_fragment_program: Boolean;
+
+//***** GL_NV_primitive_restart *****//
+const
+  GL_PRIMITIVE_RESTART_NV = $8558;
+  GL_PRIMITIVE_RESTART_INDEX_NV = $8559;
+var
+  glPrimitiveRestartNV: procedure(); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glPrimitiveRestartIndexNV: procedure(index: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_NV_primitive_restart: Boolean;
+
+//***** GL_NV_vertex_program2 *****//
+
+function Load_GL_NV_vertex_program2: Boolean;
+
+//***** WGL_NV_render_texture_rectangle *****//
+const
+  WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = $20A0;
+  WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = $20A1;
+  WGL_TEXTURE_RECTANGLE_NV = $20A2;
+
+function Load_WGL_NV_render_texture_rectangle: Boolean;
+
+//***** GL_NV_pixel_data_range *****//
+const
+  GL_WRITE_PIXEL_DATA_RANGE_NV = $8878;
+  GL_READ_PIXEL_DATA_RANGE_NV = $8879;
+  GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = $887A;
+  GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = $887B;
+  GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = $887C;
+  GL_READ_PIXEL_DATA_RANGE_POINTER_NV = $887D;
+var
+  glPixelDataRangeNV: procedure(target: GLenum; length: GLsizei; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFlushPixelDataRangeNV: procedure(target: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  // wglAllocateMemoryNV  { already defined }
+  // wglFreeMemoryNV  { already defined }
+
+function Load_GL_NV_pixel_data_range: Boolean;
+
+//***** GL_EXT_texture_rectangle *****//
+const
+  GL_TEXTURE_RECTANGLE_EXT = $84F5;
+  GL_TEXTURE_BINDING_RECTANGLE_EXT = $84F6;
+  GL_PROXY_TEXTURE_RECTANGLE_EXT = $84F7;
+  GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = $84F8;
+
+function Load_GL_EXT_texture_rectangle: Boolean;
+
+//***** GL_S3_s3tc *****//
+const
+  GL_RGB_S3TC = $83A0;
+  GL_RGB4_S3TC = $83A1;
+  GL_RGBA_S3TC = $83A2;
+  GL_RGBA4_S3TC = $83A3;
+
+function Load_GL_S3_s3tc: Boolean;
+
+//***** GL_ATI_draw_buffers *****//
+const
+  GL_MAX_DRAW_BUFFERS_ATI = $8824;
+  GL_DRAW_BUFFER0_ATI = $8825;
+  GL_DRAW_BUFFER1_ATI = $8826;
+  GL_DRAW_BUFFER2_ATI = $8827;
+  GL_DRAW_BUFFER3_ATI = $8828;
+  GL_DRAW_BUFFER4_ATI = $8829;
+  GL_DRAW_BUFFER5_ATI = $882A;
+  GL_DRAW_BUFFER6_ATI = $882B;
+  GL_DRAW_BUFFER7_ATI = $882C;
+  GL_DRAW_BUFFER8_ATI = $882D;
+  GL_DRAW_BUFFER9_ATI = $882E;
+  GL_DRAW_BUFFER10_ATI = $882F;
+  GL_DRAW_BUFFER11_ATI = $8830;
+  GL_DRAW_BUFFER12_ATI = $8831;
+  GL_DRAW_BUFFER13_ATI = $8832;
+  GL_DRAW_BUFFER14_ATI = $8833;
+  GL_DRAW_BUFFER15_ATI = $8834;
+var
+  glDrawBuffersATI: procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ATI_draw_buffers: Boolean;
+
+//***** WGL_ATI_pixel_format_float *****//
+const
+  WGL_RGBA_FLOAT_MODE_ATI = $8820;
+  WGL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = $8835;
+  WGL_TYPE_RGBA_FLOAT_ATI = $21A0;
+
+function Load_WGL_ATI_pixel_format_float: Boolean;
+
+//***** GL_ATI_texture_env_combine3 *****//
+const
+  GL_MODULATE_ADD_ATI = $8744;
+  GL_MODULATE_SIGNED_ADD_ATI = $8745;
+  GL_MODULATE_SUBTRACT_ATI = $8746;
+
+function Load_GL_ATI_texture_env_combine3: Boolean;
+
+//***** GL_ATI_texture_float *****//
+const
+  GL_RGBA_FLOAT32_ATI = $8814;
+  GL_RGB_FLOAT32_ATI = $8815;
+  GL_ALPHA_FLOAT32_ATI = $8816;
+  GL_INTENSITY_FLOAT32_ATI = $8817;
+  GL_LUMINANCE_FLOAT32_ATI = $8818;
+  GL_LUMINANCE_ALPHA_FLOAT32_ATI = $8819;
+  GL_RGBA_FLOAT16_ATI = $881A;
+  GL_RGB_FLOAT16_ATI = $881B;
+  GL_ALPHA_FLOAT16_ATI = $881C;
+  GL_INTENSITY_FLOAT16_ATI = $881D;
+  GL_LUMINANCE_FLOAT16_ATI = $881E;
+  GL_LUMINANCE_ALPHA_FLOAT16_ATI = $881F;
+
+function Load_GL_ATI_texture_float: Boolean;
+
+//***** GL_NV_texture_expand_normal *****//
+const
+  GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = $888F;
+
+function Load_GL_NV_texture_expand_normal: Boolean;
+
+//***** GL_NV_half_float *****//
+const
+  GL_HALF_FLOAT_NV = $140B;
+var
+  glVertex2hNV: procedure(x: GLushort; y: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex2hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex3hNV: procedure(x: GLushort; y: GLushort; z: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex3hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex4hNV: procedure(x: GLushort; y: GLushort; z: GLushort; w: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertex4hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3hNV: procedure(nx: GLushort; ny: GLushort; nz: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glNormal3hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3hNV: procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor3hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4hNV: procedure(red: GLushort; green: GLushort; blue: GLushort; alpha: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glColor4hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord1hNV: procedure(s: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord1hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2hNV: procedure(s: GLushort; t: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord2hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord3hNV: procedure(s: GLushort; t: GLushort; r: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord3hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4hNV: procedure(s: GLushort; t: GLushort; r: GLushort; q: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glTexCoord4hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1hNV: procedure(target: GLenum; s: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord1hvNV: procedure(target: GLenum; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2hNV: procedure(target: GLenum; s: GLushort; t: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord2hvNV: procedure(target: GLenum; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3hNV: procedure(target: GLenum; s: GLushort; t: GLushort; r: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord3hvNV: procedure(target: GLenum; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4hNV: procedure(target: GLenum; s: GLushort; t: GLushort; r: GLushort; q: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMultiTexCoord4hvNV: procedure(target: GLenum; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogCoordhNV: procedure(fog: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogCoordhvNV: procedure(const fog: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3hNV: procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3hvNV: procedure(const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexWeighthNV: procedure(weight: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexWeighthvNV: procedure(const weight: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1hNV: procedure(index: GLuint; x: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib1hvNV: procedure(index: GLuint; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2hNV: procedure(index: GLuint; x: GLushort; y: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib2hvNV: procedure(index: GLuint; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3hNV: procedure(index: GLuint; x: GLushort; y: GLushort; z: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib3hvNV: procedure(index: GLuint; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4hNV: procedure(index: GLuint; x: GLushort; y: GLushort; z: GLushort; w: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttrib4hvNV: procedure(index: GLuint; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs1hvNV: procedure(index: GLuint; n: GLsizei; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs2hvNV: procedure(index: GLuint; n: GLsizei; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs3hvNV: procedure(index: GLuint; n: GLsizei; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glVertexAttribs4hvNV: procedure(index: GLuint; n: GLsizei; const v: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_NV_half_float: Boolean;
+
+//***** GL_ATI_map_object_buffer *****//
+var
+  glMapObjectBufferATI: function(buffer: GLuint): PGLvoid; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUnmapObjectBufferATI: procedure(buffer: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ATI_map_object_buffer: Boolean;
+
+//***** GL_ATI_separate_stencil *****//
+const
+  GL_KEEP = $1E00;
+  GL_ZERO = $0000;
+  GL_REPLACE = $1E01;
+  GL_INCR = $1E02;
+  GL_DECR = $1E03;
+  GL_INVERT = $150A;
+  GL_NEVER = $0200;
+  GL_LESS = $0201;
+  GL_LEQUAL = $0203;
+  GL_GREATER = $0204;
+  GL_GEQUAL = $0206;
+  GL_EQUAL = $0202;
+  GL_NOTEQUAL = $0205;
+  GL_ALWAYS = $0207;
+  GL_FRONT = $0404;
+  GL_BACK = $0405;
+  GL_FRONT_AND_BACK = $0408;
+  GL_STENCIL_BACK_FUNC_ATI = $8800;
+  GL_STENCIL_BACK_FAIL_ATI = $8801;
+  GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = $8802;
+  GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = $8803;
+var
+  glStencilOpSeparateATI: procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glStencilFuncSeparateATI: procedure(frontfunc: GLenum; backfunc: GLenum; ref: GLint; mask: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ATI_separate_stencil: Boolean;
+
+//***** GL_ATI_vertex_attrib_array_object *****//
+var
+  glVertexAttribArrayObjectATI: procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVertexAttribArrayObjectfvATI: procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetVertexAttribArrayObjectivATI: procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ATI_vertex_attrib_array_object: Boolean;
+
+//***** GL_ARB_vertex_buffer_object *****//
+const
+  GL_ARRAY_BUFFER_ARB = $8892;
+  GL_ELEMENT_ARRAY_BUFFER_ARB = $8893;
+  GL_ARRAY_BUFFER_BINDING_ARB = $8894;
+  GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = $8895;
+  GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = $8896;
+  GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = $8897;
+  GL_COLOR_ARRAY_BUFFER_BINDING_ARB = $8898;
+  GL_INDEX_ARRAY_BUFFER_BINDING_ARB = $8899;
+  GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = $889A;
+  GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = $889B;
+  GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = $889C;
+  GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = $889D;
+  GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = $889E;
+  GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = $889F;
+  GL_STREAM_DRAW_ARB = $88E0;
+  GL_STREAM_READ_ARB = $88E1;
+  GL_STREAM_COPY_ARB = $88E2;
+  GL_STATIC_DRAW_ARB = $88E4;
+  GL_STATIC_READ_ARB = $88E5;
+  GL_STATIC_COPY_ARB = $88E6;
+  GL_DYNAMIC_DRAW_ARB = $88E8;
+  GL_DYNAMIC_READ_ARB = $88E9;
+  GL_DYNAMIC_COPY_ARB = $88EA;
+  GL_READ_ONLY_ARB = $88B8;
+  GL_WRITE_ONLY_ARB = $88B9;
+  GL_READ_WRITE_ARB = $88BA;
+  GL_BUFFER_SIZE_ARB = $8764;
+  GL_BUFFER_USAGE_ARB = $8765;
+  GL_BUFFER_ACCESS_ARB = $88BB;
+  GL_BUFFER_MAPPED_ARB = $88BC;
+  GL_BUFFER_MAP_POINTER_ARB = $88BD;
+var
+  glBindBufferARB: procedure(target: GLenum; buffer: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteBuffersARB: procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGenBuffersARB: procedure(n: GLsizei; buffers: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsBufferARB: function(buffer: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBufferDataARB: procedure(target: GLenum; size: GLsizeiptrARB; const data: PGLvoid; usage: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBufferSubDataARB: procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; const data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetBufferSubDataARB: procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; data: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glMapBufferARB: function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUnmapBufferARB: function(target: GLenum): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetBufferParameterivARB: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetBufferPointervARB: procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_vertex_buffer_object: Boolean;
+
+//***** GL_ARB_occlusion_query *****//
+const
+  GL_SAMPLES_PASSED_ARB = $8914;
+  GL_QUERY_COUNTER_BITS_ARB = $8864;
+  GL_CURRENT_QUERY_ARB = $8865;
+  GL_QUERY_RESULT_ARB = $8866;
+  GL_QUERY_RESULT_AVAILABLE_ARB = $8867;
+var
+  glGenQueriesARB: procedure(n: GLsizei; ids: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDeleteQueriesARB: procedure(n: GLsizei; const ids: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glIsQueryARB: function(id: GLuint): GLboolean; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glBeginQueryARB: procedure(target: GLenum; id: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glEndQueryARB: procedure(target: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetQueryivARB: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetQueryObjectivARB: procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetQueryObjectuivARB: procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_occlusion_query: Boolean;
+
+//***** GL_ARB_shader_objects *****//
+const
+  GL_PROGRAM_OBJECT_ARB = $8B40;
+  GL_OBJECT_TYPE_ARB = $8B4E;
+  GL_OBJECT_SUBTYPE_ARB = $8B4F;
+  GL_OBJECT_DELETE_STATUS_ARB = $8B80;
+  GL_OBJECT_COMPILE_STATUS_ARB = $8B81;
+  GL_OBJECT_LINK_STATUS_ARB = $8B82;
+  GL_OBJECT_VALIDATE_STATUS_ARB = $8B83;
+  GL_OBJECT_INFO_LOG_LENGTH_ARB = $8B84;
+  GL_OBJECT_ATTACHED_OBJECTS_ARB = $8B85;
+  GL_OBJECT_ACTIVE_UNIFORMS_ARB = $8B86;
+  GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = $8B87;
+  GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = $8B88;
+  GL_SHADER_OBJECT_ARB = $8B48;
+  GL_FLOAT = $1406;
+  GL_FLOAT_VEC2_ARB = $8B50;
+  GL_FLOAT_VEC3_ARB = $8B51;
+  GL_FLOAT_VEC4_ARB = $8B52;
+  GL_INT = $1404;
+  GL_INT_VEC2_ARB = $8B53;
+  GL_INT_VEC3_ARB = $8B54;
+  GL_INT_VEC4_ARB = $8B55;
+  GL_BOOL_ARB = $8B56;
+  GL_BOOL_VEC2_ARB = $8B57;
+  GL_BOOL_VEC3_ARB = $8B58;
+  GL_BOOL_VEC4_ARB = $8B59;
+  GL_FLOAT_MAT2_ARB = $8B5A;
+  GL_FLOAT_MAT3_ARB = $8B5B;
+  GL_FLOAT_MAT4_ARB = $8B5C;
+var
+  glDeleteObjectARB: procedure(obj: GLhandleARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetHandleARB: function(pname: GLenum): GLhandleARB; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glDetachObjectARB: procedure(containerObj: GLhandleARB; attachedObj: GLhandleARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCreateShaderObjectARB: function(shaderType: GLenum): GLhandleARB; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glShaderSourceARB: procedure(shaderObj: GLhandleARB; count: GLsizei; const _string: PGLvoid; const length: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCompileShaderARB: procedure(shaderObj: GLhandleARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glCreateProgramObjectARB: function(): GLhandleARB; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glAttachObjectARB: procedure(containerObj: GLhandleARB; obj: GLhandleARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glLinkProgramARB: procedure(programObj: GLhandleARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUseProgramObjectARB: procedure(programObj: GLhandleARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glValidateProgramARB: procedure(programObj: GLhandleARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform1fARB: procedure(location: GLint; v0: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform2fARB: procedure(location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform3fARB: procedure(location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform4fARB: procedure(location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform1iARB: procedure(location: GLint; v0: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform2iARB: procedure(location: GLint; v0: GLint; v1: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform3iARB: procedure(location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform4iARB: procedure(location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform1fvARB: procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform2fvARB: procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform3fvARB: procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform4fvARB: procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform1ivARB: procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform2ivARB: procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform3ivARB: procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniform4ivARB: procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniformMatrix2fvARB: procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniformMatrix3fvARB: procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glUniformMatrix4fvARB: procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetObjectParameterfvARB: procedure(obj: GLhandleARB; pname: GLenum; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetObjectParameterivARB: procedure(obj: GLhandleARB; pname: GLenum; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetInfoLogARB: procedure(obj: GLhandleARB; maxLength: GLsizei; length: PGLsizei; infoLog: PGLcharARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetAttachedObjectsARB: procedure(containerObj: GLhandleARB; maxCount: GLsizei; count: PGLsizei; obj: PGLhandleARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetUniformLocationARB: function(programObj: GLhandleARB; const name: PGLcharARB): GLint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetActiveUniformARB: procedure(programObj: GLhandleARB; index: GLuint; maxLength: GLsizei; length: PGLsizei; size: PGLint; _type: PGLenum; name: PGLcharARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetUniformfvARB: procedure(programObj: GLhandleARB; location: GLint; params: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetUniformivARB: procedure(programObj: GLhandleARB; location: GLint; params: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetShaderSourceARB: procedure(obj: GLhandleARB; maxLength: GLsizei; length: PGLsizei; source: PGLcharARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_ARB_shader_objects: Boolean;
+
+//***** GL_ARB_vertex_shader *****//
+const
+  GL_VERTEX_SHADER_ARB = $8B31;
+  GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = $8B4A;
+  GL_MAX_VARYING_FLOATS_ARB = $8B4B;
+  // GL_MAX_VERTEX_ATTRIBS_ARB  { already defined }
+  // GL_MAX_TEXTURE_IMAGE_UNITS_ARB  { already defined }
+  GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C;
+  GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = $8B4D;
+  // GL_MAX_TEXTURE_COORDS_ARB  { already defined }
+  // GL_VERTEX_PROGRAM_POINT_SIZE_ARB  { already defined }
+  // GL_VERTEX_PROGRAM_TWO_SIDE_ARB  { already defined }
+  // GL_OBJECT_TYPE_ARB  { already defined }
+  // GL_OBJECT_SUBTYPE_ARB  { already defined }
+  GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = $8B89;
+  GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = $8B8A;
+  // GL_SHADER_OBJECT_ARB  { already defined }
+  // GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB  { already defined }
+  // GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB  { already defined }
+  // GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB  { already defined }
+  // GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB  { already defined }
+  // GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB  { already defined }
+  // GL_CURRENT_VERTEX_ATTRIB_ARB  { already defined }
+  // GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB  { already defined }
+  // GL_FLOAT  { already defined }
+  // GL_FLOAT_VEC2_ARB  { already defined }
+  // GL_FLOAT_VEC3_ARB  { already defined }
+  // GL_FLOAT_VEC4_ARB  { already defined }
+  // GL_FLOAT_MAT2_ARB  { already defined }
+  // GL_FLOAT_MAT3_ARB  { already defined }
+  // GL_FLOAT_MAT4_ARB  { already defined }
+  // glVertexAttrib1fARB  { already defined }
+  // glVertexAttrib1sARB  { already defined }
+  // glVertexAttrib1dARB  { already defined }
+  // glVertexAttrib2fARB  { already defined }
+  // glVertexAttrib2sARB  { already defined }
+  // glVertexAttrib2dARB  { already defined }
+  // glVertexAttrib3fARB  { already defined }
+  // glVertexAttrib3sARB  { already defined }
+  // glVertexAttrib3dARB  { already defined }
+  // glVertexAttrib4fARB  { already defined }
+  // glVertexAttrib4sARB  { already defined }
+  // glVertexAttrib4dARB  { already defined }
+  // glVertexAttrib4NubARB  { already defined }
+  // glVertexAttrib1fvARB  { already defined }
+  // glVertexAttrib1svARB  { already defined }
+  // glVertexAttrib1dvARB  { already defined }
+  // glVertexAttrib2fvARB  { already defined }
+  // glVertexAttrib2svARB  { already defined }
+  // glVertexAttrib2dvARB  { already defined }
+  // glVertexAttrib3fvARB  { already defined }
+  // glVertexAttrib3svARB  { already defined }
+  // glVertexAttrib3dvARB  { already defined }
+  // glVertexAttrib4fvARB  { already defined }
+  // glVertexAttrib4svARB  { already defined }
+  // glVertexAttrib4dvARB  { already defined }
+  // glVertexAttrib4ivARB  { already defined }
+  // glVertexAttrib4bvARB  { already defined }
+  // glVertexAttrib4ubvARB  { already defined }
+  // glVertexAttrib4usvARB  { already defined }
+  // glVertexAttrib4uivARB  { already defined }
+  // glVertexAttrib4NbvARB  { already defined }
+  // glVertexAttrib4NsvARB  { already defined }
+  // glVertexAttrib4NivARB  { already defined }
+  // glVertexAttrib4NubvARB  { already defined }
+  // glVertexAttrib4NusvARB  { already defined }
+  // glVertexAttrib4NuivARB  { already defined }
+  // glVertexAttribPointerARB  { already defined }
+  // glEnableVertexAttribArrayARB  { already defined }
+  // glDisableVertexAttribArrayARB  { already defined }
+var
+  glBindAttribLocationARB: procedure(programObj: GLhandleARB; index: GLuint; const name: PGLcharARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetActiveAttribARB: procedure(programObj: GLhandleARB; index: GLuint; maxLength: GLsizei; length: PGLsizei; size: PGLint; _type: PGLenum; name: PGLcharARB); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glGetAttribLocationARB: function(programObj: GLhandleARB; const name: PGLcharARB): GLint; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  // glGetVertexAttribdvARB  { already defined }
+  // glGetVertexAttribfvARB  { already defined }
+  // glGetVertexAttribivARB  { already defined }
+  // glGetVertexAttribPointervARB  { already defined }
+
+function Load_GL_ARB_vertex_shader: Boolean;
+
+//***** GL_ARB_fragment_shader *****//
+const
+  GL_FRAGMENT_SHADER_ARB = $8B30;
+  GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = $8B49;
+  // GL_MAX_TEXTURE_COORDS_ARB  { already defined }
+  // GL_MAX_TEXTURE_IMAGE_UNITS_ARB  { already defined }
+  // GL_OBJECT_TYPE_ARB  { already defined }
+  // GL_OBJECT_SUBTYPE_ARB  { already defined }
+  // GL_SHADER_OBJECT_ARB  { already defined }
+
+function Load_GL_ARB_fragment_shader: Boolean;
+
+//***** GL_ARB_shading_language_100 *****//
+
+function Load_GL_ARB_shading_language_100: Boolean;
+
+//***** GL_ARB_texture_non_power_of_two *****//
+
+function Load_GL_ARB_texture_non_power_of_two: Boolean;
+
+//***** GL_ARB_point_sprite *****//
+const
+  GL_POINT_SPRITE_ARB = $8861;
+  GL_COORD_REPLACE_ARB = $8862;
+
+function Load_GL_ARB_point_sprite: Boolean;
+
+//***** GL_EXT_depth_bounds_test *****//
+const
+  GL_DEPTH_BOUNDS_TEST_EXT = $8890;
+  GL_DEPTH_BOUNDS_EXT = $8891;
+var
+  glDepthBoundsEXT: procedure(zmin: GLclampd; zmax: GLclampd); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_depth_bounds_test: Boolean;
+
+//***** GL_EXT_secondary_color *****//
+const
+  GL_COLOR_SUM_EXT = $8458;
+  GL_CURRENT_SECONDARY_COLOR_EXT = $8459;
+  GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = $845A;
+  GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = $845B;
+  GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = $845C;
+  GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = $845D;
+  GL_SECONDARY_COLOR_ARRAY_EXT = $845E;
+var
+  glSecondaryColor3bEXT: procedure(r: GLbyte; g: GLbyte; b: GLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3sEXT: procedure(r: GLshort; g: GLshort; b: GLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3iEXT: procedure(r: GLint; g: GLint; b: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3fEXT: procedure(r: GLfloat; g: GLfloat; b: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3dEXT: procedure(r: GLdouble; g: GLdouble; b: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3ubEXT: procedure(r: GLubyte; g: GLubyte; b: GLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3usEXT: procedure(r: GLushort; g: GLushort; b: GLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3uiEXT: procedure(r: GLuint; g: GLuint; b: GLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3bvEXT: procedure(components: PGLbyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3svEXT: procedure(components: PGLshort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3ivEXT: procedure(components: PGLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3fvEXT: procedure(components: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3dvEXT: procedure(components: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3ubvEXT: procedure(components: PGLubyte); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3usvEXT: procedure(components: PGLushort); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColor3uivEXT: procedure(components: PGLuint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glSecondaryColorPointerEXT: procedure(size: GLint; _type: GLenum; stride: GLsizei; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_secondary_color: Boolean;
+
+//***** GL_EXT_texture_mirror_clamp *****//
+const
+  GL_MIRROR_CLAMP_EXT = $8742;
+  GL_MIRROR_CLAMP_TO_EDGE_EXT = $8743;
+  GL_MIRROR_CLAMP_TO_BORDER_EXT = $8912;
+
+function Load_GL_EXT_texture_mirror_clamp: Boolean;
+
+//***** GL_EXT_blend_equation_separate *****//
+const
+  GL_BLEND_EQUATION_RGB_EXT = $8009;
+  GL_BLEND_EQUATION_ALPHA_EXT = $883D;
+var
+  glBlendEquationSeparateEXT: procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_blend_equation_separate: Boolean;
+
+//***** GL_MESA_pack_invert *****//
+const
+  GL_PACK_INVERT_MESA = $8758;
+
+function Load_GL_MESA_pack_invert: Boolean;
+
+//***** GL_MESA_ycbcr_texture *****//
+const
+  GL_YCBCR_MESA = $8757;
+  GL_UNSIGNED_SHORT_8_8_MESA = $85BA;
+  GL_UNSIGNED_SHORT_8_8_REV_MESA = $85BB;
+
+function Load_GL_MESA_ycbcr_texture: Boolean;
+
+//***** GL_ARB_fragment_program_shadow *****//
+
+function Load_GL_ARB_fragment_program_shadow: Boolean;
+
+//***** GL_EXT_fog_coord *****//
+const
+  GL_FOG_COORDINATE_SOURCE_EXT = $8450;
+  GL_FOG_COORDINATE_EXT = $8451;
+  GL_FRAGMENT_DEPTH_EXT = $8452;
+  GL_CURRENT_FOG_COORDINATE_EXT = $8453;
+  GL_FOG_COORDINATE_ARRAY_TYPE_EXT = $8454;
+  GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = $8455;
+  GL_FOG_COORDINATE_ARRAY_POINTER_EXT = $8456;
+  GL_FOG_COORDINATE_ARRAY_EXT = $8457;
+var
+  glFogCoordfEXT: procedure(coord: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogCoorddEXT: procedure(coord: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogCoordfvEXT: procedure(coord: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogCoorddvEXT: procedure(coord: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glFogCoordPointerEXT: procedure(_type: GLenum; stride: GLsizei; pointer: PGLvoid); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+function Load_GL_EXT_fog_coord: Boolean;
+
+//***** GL_NV_fragment_program_option *****//
+
+function Load_GL_NV_fragment_program_option: Boolean;
+
+//***** GL_EXT_pixel_buffer_object *****//
+const
+  GL_PIXEL_PACK_BUFFER_EXT = $88EB;
+  GL_PIXEL_UNPACK_BUFFER_EXT = $88EC;
+  GL_PIXEL_PACK_BUFFER_BINDING_EXT = $88ED;
+  GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = $88EF;
+
+function Load_GL_EXT_pixel_buffer_object: Boolean;
+
+//***** GL_NV_fragment_program2 *****//
+const
+  GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = $88F4;
+  GL_MAX_PROGRAM_CALL_DEPTH_NV = $88F5;
+  GL_MAX_PROGRAM_IF_DEPTH_NV = $88F6;
+  GL_MAX_PROGRAM_LOOP_DEPTH_NV = $88F7;
+  GL_MAX_PROGRAM_LOOP_COUNT_NV = $88F8;
+
+function Load_GL_NV_fragment_program2: Boolean;
+
+//***** GL_NV_vertex_program2_option *****//
+  // GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV  { already defined }
+  // GL_MAX_PROGRAM_CALL_DEPTH_NV  { already defined }
+
+function Load_GL_NV_vertex_program2_option: Boolean;
+
+//***** GL_NV_vertex_program3 *****//
+  // GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB  { already defined }
+
+function Load_GL_NV_vertex_program3: Boolean;
+
+implementation
+
+uses
+  sdl;
+
+function glext_ExtensionSupported(const extension: PChar; const searchIn: PChar): Boolean;
+var
+  extensions: PChar;
+  start: PChar;
+  where, terminator: PChar;
+begin
+
+  if (Pos(' ', extension) <> 0) or (extension = '') then
+  begin
+    Result := FALSE;
+    Exit;
+  end;
+
+  if searchIn = '' then
+    extensions := glGetString(GL_EXTENSIONS)
+  else
+    //StrLCopy( extensions, searchIn, StrLen(searchIn)+1 );
+    extensions := searchIn;
+  start := extensions;
+  while TRUE do
+  begin
+    where := StrPos(start, extension );
+    if where = nil then Break;
+    terminator := Pointer(Integer(where) + Integer( strlen( extension ) ) );
+    if (where = start) or (PChar(Integer(where) - 1)^ = ' ') then
+    begin
+      if (terminator^ = ' ') or (terminator^ = #0) then
+      begin
+	Result := TRUE;
+	Exit;
+      end;
+    end;
+    start := terminator;
+  end;
+  Result := FALSE;
+
+end;
+
+function Load_GL_version_1_2: Boolean;
+{var
+  extstring : PChar;}
+begin
+
+  Result := FALSE;
+  //extstring := glGetString( GL_EXTENSIONS );
+
+  @glCopyTexSubImage3D := SDL_GL_GetProcAddress('glCopyTexSubImage3D');
+  if not Assigned(glCopyTexSubImage3D) then Exit;
+  @glDrawRangeElements := SDL_GL_GetProcAddress('glDrawRangeElements');
+  if not Assigned(glDrawRangeElements) then Exit;
+  @glTexImage3D := SDL_GL_GetProcAddress('glTexImage3D');
+  if not Assigned(glTexImage3D) then Exit;
+  @glTexSubImage3D := SDL_GL_GetProcAddress('glTexSubImage3D');
+  if not Assigned(glTexSubImage3D) then Exit;
+    
+  Result := TRUE;
+
+end;
+
+function Load_GL_ARB_imaging: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_imaging', extstring) then
+  begin
+    @glColorTable := SDL_GL_GetProcAddress('glColorTable');
+    if not Assigned(glColorTable) then Exit;
+    @glColorTableParameterfv := SDL_GL_GetProcAddress('glColorTableParameterfv');
+    if not Assigned(glColorTableParameterfv) then Exit;
+    @glColorTableParameteriv := SDL_GL_GetProcAddress('glColorTableParameteriv');
+    if not Assigned(glColorTableParameteriv) then Exit;
+    @glCopyColorTable := SDL_GL_GetProcAddress('glCopyColorTable');
+    if not Assigned(glCopyColorTable) then Exit;
+    @glGetColorTable := SDL_GL_GetProcAddress('glGetColorTable');
+    if not Assigned(glGetColorTable) then Exit;
+    @glGetColorTableParameterfv := SDL_GL_GetProcAddress('glGetColorTableParameterfv');
+    if not Assigned(glGetColorTableParameterfv) then Exit;
+    @glGetColorTableParameteriv := SDL_GL_GetProcAddress('glGetColorTableParameteriv');
+    if not Assigned(glGetColorTableParameteriv) then Exit;
+    @glColorSubTable := SDL_GL_GetProcAddress('glColorSubTable');
+    if not Assigned(glColorSubTable) then Exit;
+    @glCopyColorSubTable := SDL_GL_GetProcAddress('glCopyColorSubTable');
+    if not Assigned(glCopyColorSubTable) then Exit;
+    @glConvolutionFilter1D := SDL_GL_GetProcAddress('glConvolutionFilter1D');
+    if not Assigned(glConvolutionFilter1D) then Exit;
+    @glConvolutionFilter2D := SDL_GL_GetProcAddress('glConvolutionFilter2D');
+    if not Assigned(glConvolutionFilter2D) then Exit;
+    @glConvolutionParameterf := SDL_GL_GetProcAddress('glConvolutionParameterf');
+    if not Assigned(glConvolutionParameterf) then Exit;
+    @glConvolutionParameterfv := SDL_GL_GetProcAddress('glConvolutionParameterfv');
+    if not Assigned(glConvolutionParameterfv) then Exit;
+    @glConvolutionParameteri := SDL_GL_GetProcAddress('glConvolutionParameteri');
+    if not Assigned(glConvolutionParameteri) then Exit;
+    @glConvolutionParameteriv := SDL_GL_GetProcAddress('glConvolutionParameteriv');
+    if not Assigned(glConvolutionParameteriv) then Exit;
+    @glCopyConvolutionFilter1D := SDL_GL_GetProcAddress('glCopyConvolutionFilter1D');
+    if not Assigned(glCopyConvolutionFilter1D) then Exit;
+    @glCopyConvolutionFilter2D := SDL_GL_GetProcAddress('glCopyConvolutionFilter2D');
+    if not Assigned(glCopyConvolutionFilter2D) then Exit;
+    @glGetConvolutionFilter := SDL_GL_GetProcAddress('glGetConvolutionFilter');
+    if not Assigned(glGetConvolutionFilter) then Exit;
+    @glGetConvolutionParameterfv := SDL_GL_GetProcAddress('glGetConvolutionParameterfv');
+    if not Assigned(glGetConvolutionParameterfv) then Exit;
+    @glGetConvolutionParameteriv := SDL_GL_GetProcAddress('glGetConvolutionParameteriv');
+    if not Assigned(glGetConvolutionParameteriv) then Exit;
+    @glGetSeparableFilter := SDL_GL_GetProcAddress('glGetSeparableFilter');
+    if not Assigned(glGetSeparableFilter) then Exit;
+    @glSeparableFilter2D := SDL_GL_GetProcAddress('glSeparableFilter2D');
+    if not Assigned(glSeparableFilter2D) then Exit;
+    @glGetHistogram := SDL_GL_GetProcAddress('glGetHistogram');
+    if not Assigned(glGetHistogram) then Exit;
+    @glGetHistogramParameterfv := SDL_GL_GetProcAddress('glGetHistogramParameterfv');
+    if not Assigned(glGetHistogramParameterfv) then Exit;
+    @glGetHistogramParameteriv := SDL_GL_GetProcAddress('glGetHistogramParameteriv');
+    if not Assigned(glGetHistogramParameteriv) then Exit;
+    @glGetMinmax := SDL_GL_GetProcAddress('glGetMinmax');
+    if not Assigned(glGetMinmax) then Exit;
+    @glGetMinmaxParameterfv := SDL_GL_GetProcAddress('glGetMinmaxParameterfv');
+    if not Assigned(glGetMinmaxParameterfv) then Exit;
+    @glGetMinmaxParameteriv := SDL_GL_GetProcAddress('glGetMinmaxParameteriv');
+    if not Assigned(glGetMinmaxParameteriv) then Exit;
+    @glHistogram := SDL_GL_GetProcAddress('glHistogram');
+    if not Assigned(glHistogram) then Exit;
+    @glMinmax := SDL_GL_GetProcAddress('glMinmax');
+    if not Assigned(glMinmax) then Exit;
+    @glResetHistogram := SDL_GL_GetProcAddress('glResetHistogram');
+    if not Assigned(glResetHistogram) then Exit;
+    @glResetMinmax := SDL_GL_GetProcAddress('glResetMinmax');
+    if not Assigned(glResetMinmax) then Exit;
+    @glBlendEquation := SDL_GL_GetProcAddress('glBlendEquation');
+    if not Assigned(glBlendEquation) then Exit;
+    @glBlendColor := SDL_GL_GetProcAddress('glBlendColor');
+    if not Assigned(glBlendColor) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_version_1_3: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+    @glActiveTexture := SDL_GL_GetProcAddress('glActiveTexture');
+    if not Assigned(glActiveTexture) then Exit;
+    @glClientActiveTexture := SDL_GL_GetProcAddress('glClientActiveTexture');
+    if not Assigned(glClientActiveTexture) then Exit;
+    @glMultiTexCoord1d := SDL_GL_GetProcAddress('glMultiTexCoord1d');
+    if not Assigned(glMultiTexCoord1d) then Exit;
+    @glMultiTexCoord1dv := SDL_GL_GetProcAddress('glMultiTexCoord1dv');
+    if not Assigned(glMultiTexCoord1dv) then Exit;
+    @glMultiTexCoord1f := SDL_GL_GetProcAddress('glMultiTexCoord1f');
+    if not Assigned(glMultiTexCoord1f) then Exit;
+    @glMultiTexCoord1fv := SDL_GL_GetProcAddress('glMultiTexCoord1fv');
+    if not Assigned(glMultiTexCoord1fv) then Exit;
+    @glMultiTexCoord1i := SDL_GL_GetProcAddress('glMultiTexCoord1i');
+    if not Assigned(glMultiTexCoord1i) then Exit;
+    @glMultiTexCoord1iv := SDL_GL_GetProcAddress('glMultiTexCoord1iv');
+    if not Assigned(glMultiTexCoord1iv) then Exit;
+    @glMultiTexCoord1s := SDL_GL_GetProcAddress('glMultiTexCoord1s');
+    if not Assigned(glMultiTexCoord1s) then Exit;
+    @glMultiTexCoord1sv := SDL_GL_GetProcAddress('glMultiTexCoord1sv');
+    if not Assigned(glMultiTexCoord1sv) then Exit;
+    @glMultiTexCoord2d := SDL_GL_GetProcAddress('glMultiTexCoord2d');
+    if not Assigned(glMultiTexCoord2d) then Exit;
+    @glMultiTexCoord2dv := SDL_GL_GetProcAddress('glMultiTexCoord2dv');
+    if not Assigned(glMultiTexCoord2dv) then Exit;
+    @glMultiTexCoord2f := SDL_GL_GetProcAddress('glMultiTexCoord2f');
+    if not Assigned(glMultiTexCoord2f) then Exit;
+    @glMultiTexCoord2fv := SDL_GL_GetProcAddress('glMultiTexCoord2fv');
+    if not Assigned(glMultiTexCoord2fv) then Exit;
+    @glMultiTexCoord2i := SDL_GL_GetProcAddress('glMultiTexCoord2i');
+    if not Assigned(glMultiTexCoord2i) then Exit;
+    @glMultiTexCoord2iv := SDL_GL_GetProcAddress('glMultiTexCoord2iv');
+    if not Assigned(glMultiTexCoord2iv) then Exit;
+    @glMultiTexCoord2s := SDL_GL_GetProcAddress('glMultiTexCoord2s');
+    if not Assigned(glMultiTexCoord2s) then Exit;
+    @glMultiTexCoord2sv := SDL_GL_GetProcAddress('glMultiTexCoord2sv');
+    if not Assigned(glMultiTexCoord2sv) then Exit;
+    @glMultiTexCoord3d := SDL_GL_GetProcAddress('glMultiTexCoord3d');
+    if not Assigned(glMultiTexCoord3d) then Exit;
+    @glMultiTexCoord3dv := SDL_GL_GetProcAddress('glMultiTexCoord3dv');
+    if not Assigned(glMultiTexCoord3dv) then Exit;
+    @glMultiTexCoord3f := SDL_GL_GetProcAddress('glMultiTexCoord3f');
+    if not Assigned(glMultiTexCoord3f) then Exit;
+    @glMultiTexCoord3fv := SDL_GL_GetProcAddress('glMultiTexCoord3fv');
+    if not Assigned(glMultiTexCoord3fv) then Exit;
+    @glMultiTexCoord3i := SDL_GL_GetProcAddress('glMultiTexCoord3i');
+    if not Assigned(glMultiTexCoord3i) then Exit;
+    @glMultiTexCoord3iv := SDL_GL_GetProcAddress('glMultiTexCoord3iv');
+    if not Assigned(glMultiTexCoord3iv) then Exit;
+    @glMultiTexCoord3s := SDL_GL_GetProcAddress('glMultiTexCoord3s');
+    if not Assigned(glMultiTexCoord3s) then Exit;
+    @glMultiTexCoord3sv := SDL_GL_GetProcAddress('glMultiTexCoord3sv');
+    if not Assigned(glMultiTexCoord3sv) then Exit;
+    @glMultiTexCoord4d := SDL_GL_GetProcAddress('glMultiTexCoord4d');
+    if not Assigned(glMultiTexCoord4d) then Exit;
+    @glMultiTexCoord4dv := SDL_GL_GetProcAddress('glMultiTexCoord4dv');
+    if not Assigned(glMultiTexCoord4dv) then Exit;
+    @glMultiTexCoord4f := SDL_GL_GetProcAddress('glMultiTexCoord4f');
+    if not Assigned(glMultiTexCoord4f) then Exit;
+    @glMultiTexCoord4fv := SDL_GL_GetProcAddress('glMultiTexCoord4fv');
+    if not Assigned(glMultiTexCoord4fv) then Exit;
+    @glMultiTexCoord4i := SDL_GL_GetProcAddress('glMultiTexCoord4i');
+    if not Assigned(glMultiTexCoord4i) then Exit;
+    @glMultiTexCoord4iv := SDL_GL_GetProcAddress('glMultiTexCoord4iv');
+    if not Assigned(glMultiTexCoord4iv) then Exit;
+    @glMultiTexCoord4s := SDL_GL_GetProcAddress('glMultiTexCoord4s');
+    if not Assigned(glMultiTexCoord4s) then Exit;
+    @glMultiTexCoord4sv := SDL_GL_GetProcAddress('glMultiTexCoord4sv');
+    if not Assigned(glMultiTexCoord4sv) then Exit;
+    @glLoadTransposeMatrixf := SDL_GL_GetProcAddress('glLoadTransposeMatrixf');
+    if not Assigned(glLoadTransposeMatrixf) then Exit;
+    @glLoadTransposeMatrixd := SDL_GL_GetProcAddress('glLoadTransposeMatrixd');
+    if not Assigned(glLoadTransposeMatrixd) then Exit;
+    @glMultTransposeMatrixf := SDL_GL_GetProcAddress('glMultTransposeMatrixf');
+    if not Assigned(glMultTransposeMatrixf) then Exit;
+    @glMultTransposeMatrixd := SDL_GL_GetProcAddress('glMultTransposeMatrixd');
+    if not Assigned(glMultTransposeMatrixd) then Exit;
+    @glSampleCoverage := SDL_GL_GetProcAddress('glSampleCoverage');
+    if not Assigned(glSampleCoverage) then Exit;
+    @glCompressedTexImage3D := SDL_GL_GetProcAddress('glCompressedTexImage3D');
+    if not Assigned(glCompressedTexImage3D) then Exit;
+    @glCompressedTexImage2D := SDL_GL_GetProcAddress('glCompressedTexImage2D');
+    if not Assigned(glCompressedTexImage2D) then Exit;
+    @glCompressedTexImage1D := SDL_GL_GetProcAddress('glCompressedTexImage1D');
+    if not Assigned(glCompressedTexImage1D) then Exit;
+    @glCompressedTexSubImage3D := SDL_GL_GetProcAddress('glCompressedTexSubImage3D');
+    if not Assigned(glCompressedTexSubImage3D) then Exit;
+    @glCompressedTexSubImage2D := SDL_GL_GetProcAddress('glCompressedTexSubImage2D');
+    if not Assigned(glCompressedTexSubImage2D) then Exit;
+    @glCompressedTexSubImage1D := SDL_GL_GetProcAddress('glCompressedTexSubImage1D');
+    if not Assigned(glCompressedTexSubImage1D) then Exit;
+    @glGetCompressedTexImage := SDL_GL_GetProcAddress('glGetCompressedTexImage');
+    if not Assigned(glGetCompressedTexImage) then Exit;
+    Result := TRUE;
+
+end;
+
+function Load_GL_ARB_multitexture: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_multitexture', extstring) then
+  begin
+    @glActiveTextureARB := SDL_GL_GetProcAddress('glActiveTextureARB');
+    if not Assigned(glActiveTextureARB) then Exit;
+    @glClientActiveTextureARB := SDL_GL_GetProcAddress('glClientActiveTextureARB');
+    if not Assigned(glClientActiveTextureARB) then Exit;
+    @glMultiTexCoord1dARB := SDL_GL_GetProcAddress('glMultiTexCoord1dARB');
+    if not Assigned(glMultiTexCoord1dARB) then Exit;
+    @glMultiTexCoord1dvARB := SDL_GL_GetProcAddress('glMultiTexCoord1dvARB');
+    if not Assigned(glMultiTexCoord1dvARB) then Exit;
+    @glMultiTexCoord1fARB := SDL_GL_GetProcAddress('glMultiTexCoord1fARB');
+    if not Assigned(glMultiTexCoord1fARB) then Exit;
+    @glMultiTexCoord1fvARB := SDL_GL_GetProcAddress('glMultiTexCoord1fvARB');
+    if not Assigned(glMultiTexCoord1fvARB) then Exit;
+    @glMultiTexCoord1iARB := SDL_GL_GetProcAddress('glMultiTexCoord1iARB');
+    if not Assigned(glMultiTexCoord1iARB) then Exit;
+    @glMultiTexCoord1ivARB := SDL_GL_GetProcAddress('glMultiTexCoord1ivARB');
+    if not Assigned(glMultiTexCoord1ivARB) then Exit;
+    @glMultiTexCoord1sARB := SDL_GL_GetProcAddress('glMultiTexCoord1sARB');
+    if not Assigned(glMultiTexCoord1sARB) then Exit;
+    @glMultiTexCoord1svARB := SDL_GL_GetProcAddress('glMultiTexCoord1svARB');
+    if not Assigned(glMultiTexCoord1svARB) then Exit;
+    @glMultiTexCoord2dARB := SDL_GL_GetProcAddress('glMultiTexCoord2dARB');
+    if not Assigned(glMultiTexCoord2dARB) then Exit;
+    @glMultiTexCoord2dvARB := SDL_GL_GetProcAddress('glMultiTexCoord2dvARB');
+    if not Assigned(glMultiTexCoord2dvARB) then Exit;
+    @glMultiTexCoord2fARB := SDL_GL_GetProcAddress('glMultiTexCoord2fARB');
+    if not Assigned(glMultiTexCoord2fARB) then Exit;
+    @glMultiTexCoord2fvARB := SDL_GL_GetProcAddress('glMultiTexCoord2fvARB');
+    if not Assigned(glMultiTexCoord2fvARB) then Exit;
+    @glMultiTexCoord2iARB := SDL_GL_GetProcAddress('glMultiTexCoord2iARB');
+    if not Assigned(glMultiTexCoord2iARB) then Exit;
+    @glMultiTexCoord2ivARB := SDL_GL_GetProcAddress('glMultiTexCoord2ivARB');
+    if not Assigned(glMultiTexCoord2ivARB) then Exit;
+    @glMultiTexCoord2sARB := SDL_GL_GetProcAddress('glMultiTexCoord2sARB');
+    if not Assigned(glMultiTexCoord2sARB) then Exit;
+    @glMultiTexCoord2svARB := SDL_GL_GetProcAddress('glMultiTexCoord2svARB');
+    if not Assigned(glMultiTexCoord2svARB) then Exit;
+    @glMultiTexCoord3dARB := SDL_GL_GetProcAddress('glMultiTexCoord3dARB');
+    if not Assigned(glMultiTexCoord3dARB) then Exit;
+    @glMultiTexCoord3dvARB := SDL_GL_GetProcAddress('glMultiTexCoord3dvARB');
+    if not Assigned(glMultiTexCoord3dvARB) then Exit;
+    @glMultiTexCoord3fARB := SDL_GL_GetProcAddress('glMultiTexCoord3fARB');
+    if not Assigned(glMultiTexCoord3fARB) then Exit;
+    @glMultiTexCoord3fvARB := SDL_GL_GetProcAddress('glMultiTexCoord3fvARB');
+    if not Assigned(glMultiTexCoord3fvARB) then Exit;
+    @glMultiTexCoord3iARB := SDL_GL_GetProcAddress('glMultiTexCoord3iARB');
+    if not Assigned(glMultiTexCoord3iARB) then Exit;
+    @glMultiTexCoord3ivARB := SDL_GL_GetProcAddress('glMultiTexCoord3ivARB');
+    if not Assigned(glMultiTexCoord3ivARB) then Exit;
+    @glMultiTexCoord3sARB := SDL_GL_GetProcAddress('glMultiTexCoord3sARB');
+    if not Assigned(glMultiTexCoord3sARB) then Exit;
+    @glMultiTexCoord3svARB := SDL_GL_GetProcAddress('glMultiTexCoord3svARB');
+    if not Assigned(glMultiTexCoord3svARB) then Exit;
+    @glMultiTexCoord4dARB := SDL_GL_GetProcAddress('glMultiTexCoord4dARB');
+    if not Assigned(glMultiTexCoord4dARB) then Exit;
+    @glMultiTexCoord4dvARB := SDL_GL_GetProcAddress('glMultiTexCoord4dvARB');
+    if not Assigned(glMultiTexCoord4dvARB) then Exit;
+    @glMultiTexCoord4fARB := SDL_GL_GetProcAddress('glMultiTexCoord4fARB');
+    if not Assigned(glMultiTexCoord4fARB) then Exit;
+    @glMultiTexCoord4fvARB := SDL_GL_GetProcAddress('glMultiTexCoord4fvARB');
+    if not Assigned(glMultiTexCoord4fvARB) then Exit;
+    @glMultiTexCoord4iARB := SDL_GL_GetProcAddress('glMultiTexCoord4iARB');
+    if not Assigned(glMultiTexCoord4iARB) then Exit;
+    @glMultiTexCoord4ivARB := SDL_GL_GetProcAddress('glMultiTexCoord4ivARB');
+    if not Assigned(glMultiTexCoord4ivARB) then Exit;
+    @glMultiTexCoord4sARB := SDL_GL_GetProcAddress('glMultiTexCoord4sARB');
+    if not Assigned(glMultiTexCoord4sARB) then Exit;
+    @glMultiTexCoord4svARB := SDL_GL_GetProcAddress('glMultiTexCoord4svARB');
+    if not Assigned(glMultiTexCoord4svARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_transpose_matrix: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_transpose_matrix', extstring) then
+  begin
+    @glLoadTransposeMatrixfARB := SDL_GL_GetProcAddress('glLoadTransposeMatrixfARB');
+    if not Assigned(glLoadTransposeMatrixfARB) then Exit;
+    @glLoadTransposeMatrixdARB := SDL_GL_GetProcAddress('glLoadTransposeMatrixdARB');
+    if not Assigned(glLoadTransposeMatrixdARB) then Exit;
+    @glMultTransposeMatrixfARB := SDL_GL_GetProcAddress('glMultTransposeMatrixfARB');
+    if not Assigned(glMultTransposeMatrixfARB) then Exit;
+    @glMultTransposeMatrixdARB := SDL_GL_GetProcAddress('glMultTransposeMatrixdARB');
+    if not Assigned(glMultTransposeMatrixdARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_multisample: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_multisample', extstring) then
+  begin
+    @glSampleCoverageARB := SDL_GL_GetProcAddress('glSampleCoverageARB');
+    if not Assigned(glSampleCoverageARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_texture_env_add: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_texture_env_add', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+{$IFDEF Win32}
+function Load_WGL_ARB_extensions_string: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_ARB_extensions_string', extstring) then
+  begin
+    @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+    if not Assigned(wglGetExtensionsStringARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_ARB_buffer_region: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_ARB_buffer_region', extstring) then
+  begin
+    @wglCreateBufferRegionARB := SDL_GL_GetProcAddress('wglCreateBufferRegionARB');
+    if not Assigned(wglCreateBufferRegionARB) then Exit;
+    @wglDeleteBufferRegionARB := SDL_GL_GetProcAddress('wglDeleteBufferRegionARB');
+    if not Assigned(wglDeleteBufferRegionARB) then Exit;
+    @wglSaveBufferRegionARB := SDL_GL_GetProcAddress('wglSaveBufferRegionARB');
+    if not Assigned(wglSaveBufferRegionARB) then Exit;
+    @wglRestoreBufferRegionARB := SDL_GL_GetProcAddress('wglRestoreBufferRegionARB');
+    if not Assigned(wglRestoreBufferRegionARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+{$ENDIF}
+
+function Load_GL_ARB_texture_cube_map: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_texture_cube_map', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_depth_texture: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_depth_texture', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_point_parameters: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_point_parameters', extstring) then
+  begin
+    @glPointParameterfARB := SDL_GL_GetProcAddress('glPointParameterfARB');
+    if not Assigned(glPointParameterfARB) then Exit;
+    @glPointParameterfvARB := SDL_GL_GetProcAddress('glPointParameterfvARB');
+    if not Assigned(glPointParameterfvARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_shadow: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_shadow', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_shadow_ambient: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_shadow_ambient', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_texture_border_clamp: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_texture_border_clamp', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_texture_compression: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_texture_compression', extstring) then
+  begin
+    @glCompressedTexImage3DARB := SDL_GL_GetProcAddress('glCompressedTexImage3DARB');
+    if not Assigned(glCompressedTexImage3DARB) then Exit;
+    @glCompressedTexImage2DARB := SDL_GL_GetProcAddress('glCompressedTexImage2DARB');
+    if not Assigned(glCompressedTexImage2DARB) then Exit;
+    @glCompressedTexImage1DARB := SDL_GL_GetProcAddress('glCompressedTexImage1DARB');
+    if not Assigned(glCompressedTexImage1DARB) then Exit;
+    @glCompressedTexSubImage3DARB := SDL_GL_GetProcAddress('glCompressedTexSubImage3DARB');
+    if not Assigned(glCompressedTexSubImage3DARB) then Exit;
+    @glCompressedTexSubImage2DARB := SDL_GL_GetProcAddress('glCompressedTexSubImage2DARB');
+    if not Assigned(glCompressedTexSubImage2DARB) then Exit;
+    @glCompressedTexSubImage1DARB := SDL_GL_GetProcAddress('glCompressedTexSubImage1DARB');
+    if not Assigned(glCompressedTexSubImage1DARB) then Exit;
+    @glGetCompressedTexImageARB := SDL_GL_GetProcAddress('glGetCompressedTexImageARB');
+    if not Assigned(glGetCompressedTexImageARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_texture_env_combine: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_texture_env_combine', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_texture_env_crossbar: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_texture_env_crossbar', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_texture_env_dot3: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_texture_env_dot3', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_texture_mirrored_repeat: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_texture_mirrored_repeat', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_vertex_blend: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_vertex_blend', extstring) then
+  begin
+    @glWeightbvARB := SDL_GL_GetProcAddress('glWeightbvARB');
+    if not Assigned(glWeightbvARB) then Exit;
+    @glWeightsvARB := SDL_GL_GetProcAddress('glWeightsvARB');
+    if not Assigned(glWeightsvARB) then Exit;
+    @glWeightivARB := SDL_GL_GetProcAddress('glWeightivARB');
+    if not Assigned(glWeightivARB) then Exit;
+    @glWeightfvARB := SDL_GL_GetProcAddress('glWeightfvARB');
+    if not Assigned(glWeightfvARB) then Exit;
+    @glWeightdvARB := SDL_GL_GetProcAddress('glWeightdvARB');
+    if not Assigned(glWeightdvARB) then Exit;
+    @glWeightvARB := SDL_GL_GetProcAddress('glWeightvARB');
+    if not Assigned(glWeightvARB) then Exit;
+    @glWeightubvARB := SDL_GL_GetProcAddress('glWeightubvARB');
+    if not Assigned(glWeightubvARB) then Exit;
+    @glWeightusvARB := SDL_GL_GetProcAddress('glWeightusvARB');
+    if not Assigned(glWeightusvARB) then Exit;
+    @glWeightuivARB := SDL_GL_GetProcAddress('glWeightuivARB');
+    if not Assigned(glWeightuivARB) then Exit;
+    @glWeightPointerARB := SDL_GL_GetProcAddress('glWeightPointerARB');
+    if not Assigned(glWeightPointerARB) then Exit;
+    @glVertexBlendARB := SDL_GL_GetProcAddress('glVertexBlendARB');
+    if not Assigned(glVertexBlendARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_vertex_program: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_vertex_program', extstring) then
+  begin
+    @glVertexAttrib1sARB := SDL_GL_GetProcAddress('glVertexAttrib1sARB');
+    if not Assigned(glVertexAttrib1sARB) then Exit;
+    @glVertexAttrib1fARB := SDL_GL_GetProcAddress('glVertexAttrib1fARB');
+    if not Assigned(glVertexAttrib1fARB) then Exit;
+    @glVertexAttrib1dARB := SDL_GL_GetProcAddress('glVertexAttrib1dARB');
+    if not Assigned(glVertexAttrib1dARB) then Exit;
+    @glVertexAttrib2sARB := SDL_GL_GetProcAddress('glVertexAttrib2sARB');
+    if not Assigned(glVertexAttrib2sARB) then Exit;
+    @glVertexAttrib2fARB := SDL_GL_GetProcAddress('glVertexAttrib2fARB');
+    if not Assigned(glVertexAttrib2fARB) then Exit;
+    @glVertexAttrib2dARB := SDL_GL_GetProcAddress('glVertexAttrib2dARB');
+    if not Assigned(glVertexAttrib2dARB) then Exit;
+    @glVertexAttrib3sARB := SDL_GL_GetProcAddress('glVertexAttrib3sARB');
+    if not Assigned(glVertexAttrib3sARB) then Exit;
+    @glVertexAttrib3fARB := SDL_GL_GetProcAddress('glVertexAttrib3fARB');
+    if not Assigned(glVertexAttrib3fARB) then Exit;
+    @glVertexAttrib3dARB := SDL_GL_GetProcAddress('glVertexAttrib3dARB');
+    if not Assigned(glVertexAttrib3dARB) then Exit;
+    @glVertexAttrib4sARB := SDL_GL_GetProcAddress('glVertexAttrib4sARB');
+    if not Assigned(glVertexAttrib4sARB) then Exit;
+    @glVertexAttrib4fARB := SDL_GL_GetProcAddress('glVertexAttrib4fARB');
+    if not Assigned(glVertexAttrib4fARB) then Exit;
+    @glVertexAttrib4dARB := SDL_GL_GetProcAddress('glVertexAttrib4dARB');
+    if not Assigned(glVertexAttrib4dARB) then Exit;
+    @glVertexAttrib4NubARB := SDL_GL_GetProcAddress('glVertexAttrib4NubARB');
+    if not Assigned(glVertexAttrib4NubARB) then Exit;
+    @glVertexAttrib1svARB := SDL_GL_GetProcAddress('glVertexAttrib1svARB');
+    if not Assigned(glVertexAttrib1svARB) then Exit;
+    @glVertexAttrib1fvARB := SDL_GL_GetProcAddress('glVertexAttrib1fvARB');
+    if not Assigned(glVertexAttrib1fvARB) then Exit;
+    @glVertexAttrib1dvARB := SDL_GL_GetProcAddress('glVertexAttrib1dvARB');
+    if not Assigned(glVertexAttrib1dvARB) then Exit;
+    @glVertexAttrib2svARB := SDL_GL_GetProcAddress('glVertexAttrib2svARB');
+    if not Assigned(glVertexAttrib2svARB) then Exit;
+    @glVertexAttrib2fvARB := SDL_GL_GetProcAddress('glVertexAttrib2fvARB');
+    if not Assigned(glVertexAttrib2fvARB) then Exit;
+    @glVertexAttrib2dvARB := SDL_GL_GetProcAddress('glVertexAttrib2dvARB');
+    if not Assigned(glVertexAttrib2dvARB) then Exit;
+    @glVertexAttrib3svARB := SDL_GL_GetProcAddress('glVertexAttrib3svARB');
+    if not Assigned(glVertexAttrib3svARB) then Exit;
+    @glVertexAttrib3fvARB := SDL_GL_GetProcAddress('glVertexAttrib3fvARB');
+    if not Assigned(glVertexAttrib3fvARB) then Exit;
+    @glVertexAttrib3dvARB := SDL_GL_GetProcAddress('glVertexAttrib3dvARB');
+    if not Assigned(glVertexAttrib3dvARB) then Exit;
+    @glVertexAttrib4bvARB := SDL_GL_GetProcAddress('glVertexAttrib4bvARB');
+    if not Assigned(glVertexAttrib4bvARB) then Exit;
+    @glVertexAttrib4svARB := SDL_GL_GetProcAddress('glVertexAttrib4svARB');
+    if not Assigned(glVertexAttrib4svARB) then Exit;
+    @glVertexAttrib4ivARB := SDL_GL_GetProcAddress('glVertexAttrib4ivARB');
+    if not Assigned(glVertexAttrib4ivARB) then Exit;
+    @glVertexAttrib4ubvARB := SDL_GL_GetProcAddress('glVertexAttrib4ubvARB');
+    if not Assigned(glVertexAttrib4ubvARB) then Exit;
+    @glVertexAttrib4usvARB := SDL_GL_GetProcAddress('glVertexAttrib4usvARB');
+    if not Assigned(glVertexAttrib4usvARB) then Exit;
+    @glVertexAttrib4uivARB := SDL_GL_GetProcAddress('glVertexAttrib4uivARB');
+    if not Assigned(glVertexAttrib4uivARB) then Exit;
+    @glVertexAttrib4fvARB := SDL_GL_GetProcAddress('glVertexAttrib4fvARB');
+    if not Assigned(glVertexAttrib4fvARB) then Exit;
+    @glVertexAttrib4dvARB := SDL_GL_GetProcAddress('glVertexAttrib4dvARB');
+    if not Assigned(glVertexAttrib4dvARB) then Exit;
+    @glVertexAttrib4NbvARB := SDL_GL_GetProcAddress('glVertexAttrib4NbvARB');
+    if not Assigned(glVertexAttrib4NbvARB) then Exit;
+    @glVertexAttrib4NsvARB := SDL_GL_GetProcAddress('glVertexAttrib4NsvARB');
+    if not Assigned(glVertexAttrib4NsvARB) then Exit;
+    @glVertexAttrib4NivARB := SDL_GL_GetProcAddress('glVertexAttrib4NivARB');
+    if not Assigned(glVertexAttrib4NivARB) then Exit;
+    @glVertexAttrib4NubvARB := SDL_GL_GetProcAddress('glVertexAttrib4NubvARB');
+    if not Assigned(glVertexAttrib4NubvARB) then Exit;
+    @glVertexAttrib4NusvARB := SDL_GL_GetProcAddress('glVertexAttrib4NusvARB');
+    if not Assigned(glVertexAttrib4NusvARB) then Exit;
+    @glVertexAttrib4NuivARB := SDL_GL_GetProcAddress('glVertexAttrib4NuivARB');
+    if not Assigned(glVertexAttrib4NuivARB) then Exit;
+    @glVertexAttribPointerARB := SDL_GL_GetProcAddress('glVertexAttribPointerARB');
+    if not Assigned(glVertexAttribPointerARB) then Exit;
+    @glEnableVertexAttribArrayARB := SDL_GL_GetProcAddress('glEnableVertexAttribArrayARB');
+    if not Assigned(glEnableVertexAttribArrayARB) then Exit;
+    @glDisableVertexAttribArrayARB := SDL_GL_GetProcAddress('glDisableVertexAttribArrayARB');
+    if not Assigned(glDisableVertexAttribArrayARB) then Exit;
+    @glProgramStringARB := SDL_GL_GetProcAddress('glProgramStringARB');
+    if not Assigned(glProgramStringARB) then Exit;
+    @glBindProgramARB := SDL_GL_GetProcAddress('glBindProgramARB');
+    if not Assigned(glBindProgramARB) then Exit;
+    @glDeleteProgramsARB := SDL_GL_GetProcAddress('glDeleteProgramsARB');
+    if not Assigned(glDeleteProgramsARB) then Exit;
+    @glGenProgramsARB := SDL_GL_GetProcAddress('glGenProgramsARB');
+    if not Assigned(glGenProgramsARB) then Exit;
+    @glProgramEnvParameter4dARB := SDL_GL_GetProcAddress('glProgramEnvParameter4dARB');
+    if not Assigned(glProgramEnvParameter4dARB) then Exit;
+    @glProgramEnvParameter4dvARB := SDL_GL_GetProcAddress('glProgramEnvParameter4dvARB');
+    if not Assigned(glProgramEnvParameter4dvARB) then Exit;
+    @glProgramEnvParameter4fARB := SDL_GL_GetProcAddress('glProgramEnvParameter4fARB');
+    if not Assigned(glProgramEnvParameter4fARB) then Exit;
+    @glProgramEnvParameter4fvARB := SDL_GL_GetProcAddress('glProgramEnvParameter4fvARB');
+    if not Assigned(glProgramEnvParameter4fvARB) then Exit;
+    @glProgramLocalParameter4dARB := SDL_GL_GetProcAddress('glProgramLocalParameter4dARB');
+    if not Assigned(glProgramLocalParameter4dARB) then Exit;
+    @glProgramLocalParameter4dvARB := SDL_GL_GetProcAddress('glProgramLocalParameter4dvARB');
+    if not Assigned(glProgramLocalParameter4dvARB) then Exit;
+    @glProgramLocalParameter4fARB := SDL_GL_GetProcAddress('glProgramLocalParameter4fARB');
+    if not Assigned(glProgramLocalParameter4fARB) then Exit;
+    @glProgramLocalParameter4fvARB := SDL_GL_GetProcAddress('glProgramLocalParameter4fvARB');
+    if not Assigned(glProgramLocalParameter4fvARB) then Exit;
+    @glGetProgramEnvParameterdvARB := SDL_GL_GetProcAddress('glGetProgramEnvParameterdvARB');
+    if not Assigned(glGetProgramEnvParameterdvARB) then Exit;
+    @glGetProgramEnvParameterfvARB := SDL_GL_GetProcAddress('glGetProgramEnvParameterfvARB');
+    if not Assigned(glGetProgramEnvParameterfvARB) then Exit;
+    @glGetProgramLocalParameterdvARB := SDL_GL_GetProcAddress('glGetProgramLocalParameterdvARB');
+    if not Assigned(glGetProgramLocalParameterdvARB) then Exit;
+    @glGetProgramLocalParameterfvARB := SDL_GL_GetProcAddress('glGetProgramLocalParameterfvARB');
+    if not Assigned(glGetProgramLocalParameterfvARB) then Exit;
+    @glGetProgramivARB := SDL_GL_GetProcAddress('glGetProgramivARB');
+    if not Assigned(glGetProgramivARB) then Exit;
+    @glGetProgramStringARB := SDL_GL_GetProcAddress('glGetProgramStringARB');
+    if not Assigned(glGetProgramStringARB) then Exit;
+    @glGetVertexAttribdvARB := SDL_GL_GetProcAddress('glGetVertexAttribdvARB');
+    if not Assigned(glGetVertexAttribdvARB) then Exit;
+    @glGetVertexAttribfvARB := SDL_GL_GetProcAddress('glGetVertexAttribfvARB');
+    if not Assigned(glGetVertexAttribfvARB) then Exit;
+    @glGetVertexAttribivARB := SDL_GL_GetProcAddress('glGetVertexAttribivARB');
+    if not Assigned(glGetVertexAttribivARB) then Exit;
+    @glGetVertexAttribPointervARB := SDL_GL_GetProcAddress('glGetVertexAttribPointervARB');
+    if not Assigned(glGetVertexAttribPointervARB) then Exit;
+    @glIsProgramARB := SDL_GL_GetProcAddress('glIsProgramARB');
+    if not Assigned(glIsProgramARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_window_pos: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_window_pos', extstring) then
+  begin
+    @glWindowPos2dARB := SDL_GL_GetProcAddress('glWindowPos2dARB');
+    if not Assigned(glWindowPos2dARB) then Exit;
+    @glWindowPos2fARB := SDL_GL_GetProcAddress('glWindowPos2fARB');
+    if not Assigned(glWindowPos2fARB) then Exit;
+    @glWindowPos2iARB := SDL_GL_GetProcAddress('glWindowPos2iARB');
+    if not Assigned(glWindowPos2iARB) then Exit;
+    @glWindowPos2sARB := SDL_GL_GetProcAddress('glWindowPos2sARB');
+    if not Assigned(glWindowPos2sARB) then Exit;
+    @glWindowPos2dvARB := SDL_GL_GetProcAddress('glWindowPos2dvARB');
+    if not Assigned(glWindowPos2dvARB) then Exit;
+    @glWindowPos2fvARB := SDL_GL_GetProcAddress('glWindowPos2fvARB');
+    if not Assigned(glWindowPos2fvARB) then Exit;
+    @glWindowPos2ivARB := SDL_GL_GetProcAddress('glWindowPos2ivARB');
+    if not Assigned(glWindowPos2ivARB) then Exit;
+    @glWindowPos2svARB := SDL_GL_GetProcAddress('glWindowPos2svARB');
+    if not Assigned(glWindowPos2svARB) then Exit;
+    @glWindowPos3dARB := SDL_GL_GetProcAddress('glWindowPos3dARB');
+    if not Assigned(glWindowPos3dARB) then Exit;
+    @glWindowPos3fARB := SDL_GL_GetProcAddress('glWindowPos3fARB');
+    if not Assigned(glWindowPos3fARB) then Exit;
+    @glWindowPos3iARB := SDL_GL_GetProcAddress('glWindowPos3iARB');
+    if not Assigned(glWindowPos3iARB) then Exit;
+    @glWindowPos3sARB := SDL_GL_GetProcAddress('glWindowPos3sARB');
+    if not Assigned(glWindowPos3sARB) then Exit;
+    @glWindowPos3dvARB := SDL_GL_GetProcAddress('glWindowPos3dvARB');
+    if not Assigned(glWindowPos3dvARB) then Exit;
+    @glWindowPos3fvARB := SDL_GL_GetProcAddress('glWindowPos3fvARB');
+    if not Assigned(glWindowPos3fvARB) then Exit;
+    @glWindowPos3ivARB := SDL_GL_GetProcAddress('glWindowPos3ivARB');
+    if not Assigned(glWindowPos3ivARB) then Exit;
+    @glWindowPos3svARB := SDL_GL_GetProcAddress('glWindowPos3svARB');
+    if not Assigned(glWindowPos3svARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_422_pixels: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_422_pixels', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_abgr: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_abgr', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_bgra: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_bgra', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_blend_color: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_blend_color', extstring) then
+  begin
+    @glBlendColorEXT := SDL_GL_GetProcAddress('glBlendColorEXT');
+    if not Assigned(glBlendColorEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_blend_func_separate: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_blend_func_separate', extstring) then
+  begin
+    @glBlendFuncSeparateEXT := SDL_GL_GetProcAddress('glBlendFuncSeparateEXT');
+    if not Assigned(glBlendFuncSeparateEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_blend_logic_op: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_blend_logic_op', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_blend_minmax: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_blend_minmax', extstring) then
+  begin
+    @glBlendEquationEXT := SDL_GL_GetProcAddress('glBlendEquationEXT');
+    if not Assigned(glBlendEquationEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_blend_subtract: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_blend_subtract', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_clip_volume_hint: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_clip_volume_hint', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_color_subtable: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_color_subtable', extstring) then
+  begin
+    @glColorSubTableEXT := SDL_GL_GetProcAddress('glColorSubTableEXT');
+    if not Assigned(glColorSubTableEXT) then Exit;
+    @glCopyColorSubTableEXT := SDL_GL_GetProcAddress('glCopyColorSubTableEXT');
+    if not Assigned(glCopyColorSubTableEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_compiled_vertex_array: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_compiled_vertex_array', extstring) then
+  begin
+    @glLockArraysEXT := SDL_GL_GetProcAddress('glLockArraysEXT');
+    if not Assigned(glLockArraysEXT) then Exit;
+    @glUnlockArraysEXT := SDL_GL_GetProcAddress('glUnlockArraysEXT');
+    if not Assigned(glUnlockArraysEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_convolution: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_convolution', extstring) then
+  begin
+    @glConvolutionFilter1DEXT := SDL_GL_GetProcAddress('glConvolutionFilter1DEXT');
+    if not Assigned(glConvolutionFilter1DEXT) then Exit;
+    @glConvolutionFilter2DEXT := SDL_GL_GetProcAddress('glConvolutionFilter2DEXT');
+    if not Assigned(glConvolutionFilter2DEXT) then Exit;
+    @glCopyConvolutionFilter1DEXT := SDL_GL_GetProcAddress('glCopyConvolutionFilter1DEXT');
+    if not Assigned(glCopyConvolutionFilter1DEXT) then Exit;
+    @glCopyConvolutionFilter2DEXT := SDL_GL_GetProcAddress('glCopyConvolutionFilter2DEXT');
+    if not Assigned(glCopyConvolutionFilter2DEXT) then Exit;
+    @glGetConvolutionFilterEXT := SDL_GL_GetProcAddress('glGetConvolutionFilterEXT');
+    if not Assigned(glGetConvolutionFilterEXT) then Exit;
+    @glSeparableFilter2DEXT := SDL_GL_GetProcAddress('glSeparableFilter2DEXT');
+    if not Assigned(glSeparableFilter2DEXT) then Exit;
+    @glGetSeparableFilterEXT := SDL_GL_GetProcAddress('glGetSeparableFilterEXT');
+    if not Assigned(glGetSeparableFilterEXT) then Exit;
+    @glConvolutionParameteriEXT := SDL_GL_GetProcAddress('glConvolutionParameteriEXT');
+    if not Assigned(glConvolutionParameteriEXT) then Exit;
+    @glConvolutionParameterivEXT := SDL_GL_GetProcAddress('glConvolutionParameterivEXT');
+    if not Assigned(glConvolutionParameterivEXT) then Exit;
+    @glConvolutionParameterfEXT := SDL_GL_GetProcAddress('glConvolutionParameterfEXT');
+    if not Assigned(glConvolutionParameterfEXT) then Exit;
+    @glConvolutionParameterfvEXT := SDL_GL_GetProcAddress('glConvolutionParameterfvEXT');
+    if not Assigned(glConvolutionParameterfvEXT) then Exit;
+    @glGetConvolutionParameterivEXT := SDL_GL_GetProcAddress('glGetConvolutionParameterivEXT');
+    if not Assigned(glGetConvolutionParameterivEXT) then Exit;
+    @glGetConvolutionParameterfvEXT := SDL_GL_GetProcAddress('glGetConvolutionParameterfvEXT');
+    if not Assigned(glGetConvolutionParameterfvEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_histogram: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_histogram', extstring) then
+  begin
+    @glHistogramEXT := SDL_GL_GetProcAddress('glHistogramEXT');
+    if not Assigned(glHistogramEXT) then Exit;
+    @glResetHistogramEXT := SDL_GL_GetProcAddress('glResetHistogramEXT');
+    if not Assigned(glResetHistogramEXT) then Exit;
+    @glGetHistogramEXT := SDL_GL_GetProcAddress('glGetHistogramEXT');
+    if not Assigned(glGetHistogramEXT) then Exit;
+    @glGetHistogramParameterivEXT := SDL_GL_GetProcAddress('glGetHistogramParameterivEXT');
+    if not Assigned(glGetHistogramParameterivEXT) then Exit;
+    @glGetHistogramParameterfvEXT := SDL_GL_GetProcAddress('glGetHistogramParameterfvEXT');
+    if not Assigned(glGetHistogramParameterfvEXT) then Exit;
+    @glMinmaxEXT := SDL_GL_GetProcAddress('glMinmaxEXT');
+    if not Assigned(glMinmaxEXT) then Exit;
+    @glResetMinmaxEXT := SDL_GL_GetProcAddress('glResetMinmaxEXT');
+    if not Assigned(glResetMinmaxEXT) then Exit;
+    @glGetMinmaxEXT := SDL_GL_GetProcAddress('glGetMinmaxEXT');
+    if not Assigned(glGetMinmaxEXT) then Exit;
+    @glGetMinmaxParameterivEXT := SDL_GL_GetProcAddress('glGetMinmaxParameterivEXT');
+    if not Assigned(glGetMinmaxParameterivEXT) then Exit;
+    @glGetMinmaxParameterfvEXT := SDL_GL_GetProcAddress('glGetMinmaxParameterfvEXT');
+    if not Assigned(glGetMinmaxParameterfvEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_multi_draw_arrays: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_multi_draw_arrays', extstring) then
+  begin
+    @glMultiDrawArraysEXT := SDL_GL_GetProcAddress('glMultiDrawArraysEXT');
+    if not Assigned(glMultiDrawArraysEXT) then Exit;
+    @glMultiDrawElementsEXT := SDL_GL_GetProcAddress('glMultiDrawElementsEXT');
+    if not Assigned(glMultiDrawElementsEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_packed_pixels: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_packed_pixels', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_paletted_texture: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_paletted_texture', extstring) then
+  begin
+    @glColorTableEXT := SDL_GL_GetProcAddress('glColorTableEXT');
+    if not Assigned(glColorTableEXT) then Exit;
+    @glColorSubTableEXT := SDL_GL_GetProcAddress('glColorSubTableEXT');
+    if not Assigned(glColorSubTableEXT) then Exit;
+    @glGetColorTableEXT := SDL_GL_GetProcAddress('glGetColorTableEXT');
+    if not Assigned(glGetColorTableEXT) then Exit;
+    @glGetColorTableParameterivEXT := SDL_GL_GetProcAddress('glGetColorTableParameterivEXT');
+    if not Assigned(glGetColorTableParameterivEXT) then Exit;
+    @glGetColorTableParameterfvEXT := SDL_GL_GetProcAddress('glGetColorTableParameterfvEXT');
+    if not Assigned(glGetColorTableParameterfvEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_point_parameters: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_point_parameters', extstring) then
+  begin
+    @glPointParameterfEXT := SDL_GL_GetProcAddress('glPointParameterfEXT');
+    if not Assigned(glPointParameterfEXT) then Exit;
+    @glPointParameterfvEXT := SDL_GL_GetProcAddress('glPointParameterfvEXT');
+    if not Assigned(glPointParameterfvEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_polygon_offset: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_polygon_offset', extstring) then
+  begin
+    @glPolygonOffsetEXT := SDL_GL_GetProcAddress('glPolygonOffsetEXT');
+    if not Assigned(glPolygonOffsetEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_separate_specular_color: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_separate_specular_color', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_shadow_funcs: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_shadow_funcs', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_shared_texture_palette: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_shared_texture_palette', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_stencil_two_side: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_stencil_two_side', extstring) then
+  begin
+    @glActiveStencilFaceEXT := SDL_GL_GetProcAddress('glActiveStencilFaceEXT');
+    if not Assigned(glActiveStencilFaceEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_stencil_wrap: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_stencil_wrap', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_subtexture: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_subtexture', extstring) then
+  begin
+    @glTexSubImage1DEXT := SDL_GL_GetProcAddress('glTexSubImage1DEXT');
+    if not Assigned(glTexSubImage1DEXT) then Exit;
+    @glTexSubImage2DEXT := SDL_GL_GetProcAddress('glTexSubImage2DEXT');
+    if not Assigned(glTexSubImage2DEXT) then Exit;
+    @glTexSubImage3DEXT := SDL_GL_GetProcAddress('glTexSubImage3DEXT');
+    if not Assigned(glTexSubImage3DEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_texture3D: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_texture3D', extstring) then
+  begin
+    glTexImage3DEXT := SDL_GL_GetProcAddress('glTexImage3DEXT');
+    if not Assigned(glTexImage3DEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_texture_compression_s3tc: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_texture_compression_s3tc', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_texture_env_add: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_texture_env_add', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_texture_env_combine: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_texture_env_combine', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_texture_env_dot3: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_texture_env_dot3', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_texture_filter_anisotropic: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_texture_filter_anisotropic', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_texture_lod_bias: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_texture_lod_bias', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_texture_object: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_texture_object', extstring) then
+  begin
+    @glGenTexturesEXT := SDL_GL_GetProcAddress('glGenTexturesEXT');
+    if not Assigned(glGenTexturesEXT) then Exit;
+    @glDeleteTexturesEXT := SDL_GL_GetProcAddress('glDeleteTexturesEXT');
+    if not Assigned(glDeleteTexturesEXT) then Exit;
+    @glBindTextureEXT := SDL_GL_GetProcAddress('glBindTextureEXT');
+    if not Assigned(glBindTextureEXT) then Exit;
+    @glPrioritizeTexturesEXT := SDL_GL_GetProcAddress('glPrioritizeTexturesEXT');
+    if not Assigned(glPrioritizeTexturesEXT) then Exit;
+    @glAreTexturesResidentEXT := SDL_GL_GetProcAddress('glAreTexturesResidentEXT');
+    if not Assigned(glAreTexturesResidentEXT) then Exit;
+    @glIsTextureEXT := SDL_GL_GetProcAddress('glIsTextureEXT');
+    if not Assigned(glIsTextureEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_vertex_array: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_vertex_array', extstring) then
+  begin
+    @glArrayElementEXT := SDL_GL_GetProcAddress('glArrayElementEXT');
+    if not Assigned(glArrayElementEXT) then Exit;
+    @glDrawArraysEXT := SDL_GL_GetProcAddress('glDrawArraysEXT');
+    if not Assigned(glDrawArraysEXT) then Exit;
+    @glVertexPointerEXT := SDL_GL_GetProcAddress('glVertexPointerEXT');
+    if not Assigned(glVertexPointerEXT) then Exit;
+    @glNormalPointerEXT := SDL_GL_GetProcAddress('glNormalPointerEXT');
+    if not Assigned(glNormalPointerEXT) then Exit;
+    @glColorPointerEXT := SDL_GL_GetProcAddress('glColorPointerEXT');
+    if not Assigned(glColorPointerEXT) then Exit;
+    @glIndexPointerEXT := SDL_GL_GetProcAddress('glIndexPointerEXT');
+    if not Assigned(glIndexPointerEXT) then Exit;
+    @glTexCoordPointerEXT := SDL_GL_GetProcAddress('glTexCoordPointerEXT');
+    if not Assigned(glTexCoordPointerEXT) then Exit;
+    @glEdgeFlagPointerEXT := SDL_GL_GetProcAddress('glEdgeFlagPointerEXT');
+    if not Assigned(glEdgeFlagPointerEXT) then Exit;
+    @glGetPointervEXT := SDL_GL_GetProcAddress('glGetPointervEXT');
+    if not Assigned(glGetPointervEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_vertex_shader: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_vertex_shader', extstring) then
+  begin
+    @glBeginVertexShaderEXT := SDL_GL_GetProcAddress('glBeginVertexShaderEXT');
+    if not Assigned(glBeginVertexShaderEXT) then Exit;
+    @glEndVertexShaderEXT := SDL_GL_GetProcAddress('glEndVertexShaderEXT');
+    if not Assigned(glEndVertexShaderEXT) then Exit;
+    @glBindVertexShaderEXT := SDL_GL_GetProcAddress('glBindVertexShaderEXT');
+    if not Assigned(glBindVertexShaderEXT) then Exit;
+    @glGenVertexShadersEXT := SDL_GL_GetProcAddress('glGenVertexShadersEXT');
+    if not Assigned(glGenVertexShadersEXT) then Exit;
+    @glDeleteVertexShaderEXT := SDL_GL_GetProcAddress('glDeleteVertexShaderEXT');
+    if not Assigned(glDeleteVertexShaderEXT) then Exit;
+    @glShaderOp1EXT := SDL_GL_GetProcAddress('glShaderOp1EXT');
+    if not Assigned(glShaderOp1EXT) then Exit;
+    @glShaderOp2EXT := SDL_GL_GetProcAddress('glShaderOp2EXT');
+    if not Assigned(glShaderOp2EXT) then Exit;
+    @glShaderOp3EXT := SDL_GL_GetProcAddress('glShaderOp3EXT');
+    if not Assigned(glShaderOp3EXT) then Exit;
+    @glSwizzleEXT := SDL_GL_GetProcAddress('glSwizzleEXT');
+    if not Assigned(glSwizzleEXT) then Exit;
+    @glWriteMaskEXT := SDL_GL_GetProcAddress('glWriteMaskEXT');
+    if not Assigned(glWriteMaskEXT) then Exit;
+    @glInsertComponentEXT := SDL_GL_GetProcAddress('glInsertComponentEXT');
+    if not Assigned(glInsertComponentEXT) then Exit;
+    @glExtractComponentEXT := SDL_GL_GetProcAddress('glExtractComponentEXT');
+    if not Assigned(glExtractComponentEXT) then Exit;
+    @glGenSymbolsEXT := SDL_GL_GetProcAddress('glGenSymbolsEXT');
+    if not Assigned(glGenSymbolsEXT) then Exit;
+    @glSetInvariantEXT := SDL_GL_GetProcAddress('glSetInvariantEXT');
+    if not Assigned(glSetInvariantEXT) then Exit;
+    @glSetLocalConstantEXT := SDL_GL_GetProcAddress('glSetLocalConstantEXT');
+    if not Assigned(glSetLocalConstantEXT) then Exit;
+    @glVariantbvEXT := SDL_GL_GetProcAddress('glVariantbvEXT');
+    if not Assigned(glVariantbvEXT) then Exit;
+    @glVariantsvEXT := SDL_GL_GetProcAddress('glVariantsvEXT');
+    if not Assigned(glVariantsvEXT) then Exit;
+    @glVariantivEXT := SDL_GL_GetProcAddress('glVariantivEXT');
+    if not Assigned(glVariantivEXT) then Exit;
+    @glVariantfvEXT := SDL_GL_GetProcAddress('glVariantfvEXT');
+    if not Assigned(glVariantfvEXT) then Exit;
+    @glVariantdvEXT := SDL_GL_GetProcAddress('glVariantdvEXT');
+    if not Assigned(glVariantdvEXT) then Exit;
+    @glVariantubvEXT := SDL_GL_GetProcAddress('glVariantubvEXT');
+    if not Assigned(glVariantubvEXT) then Exit;
+    @glVariantusvEXT := SDL_GL_GetProcAddress('glVariantusvEXT');
+    if not Assigned(glVariantusvEXT) then Exit;
+    @glVariantuivEXT := SDL_GL_GetProcAddress('glVariantuivEXT');
+    if not Assigned(glVariantuivEXT) then Exit;
+    @glVariantPointerEXT := SDL_GL_GetProcAddress('glVariantPointerEXT');
+    if not Assigned(glVariantPointerEXT) then Exit;
+    @glEnableVariantClientStateEXT := SDL_GL_GetProcAddress('glEnableVariantClientStateEXT');
+    if not Assigned(glEnableVariantClientStateEXT) then Exit;
+    @glDisableVariantClientStateEXT := SDL_GL_GetProcAddress('glDisableVariantClientStateEXT');
+    if not Assigned(glDisableVariantClientStateEXT) then Exit;
+    @glBindLightParameterEXT := SDL_GL_GetProcAddress('glBindLightParameterEXT');
+    if not Assigned(glBindLightParameterEXT) then Exit;
+    @glBindMaterialParameterEXT := SDL_GL_GetProcAddress('glBindMaterialParameterEXT');
+    if not Assigned(glBindMaterialParameterEXT) then Exit;
+    @glBindTexGenParameterEXT := SDL_GL_GetProcAddress('glBindTexGenParameterEXT');
+    if not Assigned(glBindTexGenParameterEXT) then Exit;
+    @glBindTextureUnitParameterEXT := SDL_GL_GetProcAddress('glBindTextureUnitParameterEXT');
+    if not Assigned(glBindTextureUnitParameterEXT) then Exit;
+    @glBindParameterEXT := SDL_GL_GetProcAddress('glBindParameterEXT');
+    if not Assigned(glBindParameterEXT) then Exit;
+    @glIsVariantEnabledEXT := SDL_GL_GetProcAddress('glIsVariantEnabledEXT');
+    if not Assigned(glIsVariantEnabledEXT) then Exit;
+    @glGetVariantBooleanvEXT := SDL_GL_GetProcAddress('glGetVariantBooleanvEXT');
+    if not Assigned(glGetVariantBooleanvEXT) then Exit;
+    @glGetVariantIntegervEXT := SDL_GL_GetProcAddress('glGetVariantIntegervEXT');
+    if not Assigned(glGetVariantIntegervEXT) then Exit;
+    @glGetVariantFloatvEXT := SDL_GL_GetProcAddress('glGetVariantFloatvEXT');
+    if not Assigned(glGetVariantFloatvEXT) then Exit;
+    @glGetVariantPointervEXT := SDL_GL_GetProcAddress('glGetVariantPointervEXT');
+    if not Assigned(glGetVariantPointervEXT) then Exit;
+    @glGetInvariantBooleanvEXT := SDL_GL_GetProcAddress('glGetInvariantBooleanvEXT');
+    if not Assigned(glGetInvariantBooleanvEXT) then Exit;
+    @glGetInvariantIntegervEXT := SDL_GL_GetProcAddress('glGetInvariantIntegervEXT');
+    if not Assigned(glGetInvariantIntegervEXT) then Exit;
+    @glGetInvariantFloatvEXT := SDL_GL_GetProcAddress('glGetInvariantFloatvEXT');
+    if not Assigned(glGetInvariantFloatvEXT) then Exit;
+    @glGetLocalConstantBooleanvEXT := SDL_GL_GetProcAddress('glGetLocalConstantBooleanvEXT');
+    if not Assigned(glGetLocalConstantBooleanvEXT) then Exit;
+    @glGetLocalConstantIntegervEXT := SDL_GL_GetProcAddress('glGetLocalConstantIntegervEXT');
+    if not Assigned(glGetLocalConstantIntegervEXT) then Exit;
+    @glGetLocalConstantFloatvEXT := SDL_GL_GetProcAddress('glGetLocalConstantFloatvEXT');
+    if not Assigned(glGetLocalConstantFloatvEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_vertex_weighting: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_vertex_weighting', extstring) then
+  begin
+    @glVertexWeightfEXT := SDL_GL_GetProcAddress('glVertexWeightfEXT');
+    if not Assigned(glVertexWeightfEXT) then Exit;
+    @glVertexWeightfvEXT := SDL_GL_GetProcAddress('glVertexWeightfvEXT');
+    if not Assigned(glVertexWeightfvEXT) then Exit;
+    @glVertexWeightPointerEXT := SDL_GL_GetProcAddress('glVertexWeightPointerEXT');
+    if not Assigned(glVertexWeightPointerEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_HP_occlusion_test: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_HP_occlusion_test', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_blend_square: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_blend_square', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_copy_depth_to_color: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_copy_depth_to_color', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_depth_clamp: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_depth_clamp', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_evaluators: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_evaluators', extstring) then
+  begin
+    @glMapControlPointsNV := SDL_GL_GetProcAddress('glMapControlPointsNV');
+    if not Assigned(glMapControlPointsNV) then Exit;
+    @glMapParameterivNV := SDL_GL_GetProcAddress('glMapParameterivNV');
+    if not Assigned(glMapParameterivNV) then Exit;
+    @glMapParameterfvNV := SDL_GL_GetProcAddress('glMapParameterfvNV');
+    if not Assigned(glMapParameterfvNV) then Exit;
+    @glGetMapControlPointsNV := SDL_GL_GetProcAddress('glGetMapControlPointsNV');
+    if not Assigned(glGetMapControlPointsNV) then Exit;
+    @glGetMapParameterivNV := SDL_GL_GetProcAddress('glGetMapParameterivNV');
+    if not Assigned(glGetMapParameterivNV) then Exit;
+    @glGetMapParameterfvNV := SDL_GL_GetProcAddress('glGetMapParameterfvNV');
+    if not Assigned(glGetMapParameterfvNV) then Exit;
+    @glGetMapAttribParameterivNV := SDL_GL_GetProcAddress('glGetMapAttribParameterivNV');
+    if not Assigned(glGetMapAttribParameterivNV) then Exit;
+    @glGetMapAttribParameterfvNV := SDL_GL_GetProcAddress('glGetMapAttribParameterfvNV');
+    if not Assigned(glGetMapAttribParameterfvNV) then Exit;
+    @glEvalMapsNV := SDL_GL_GetProcAddress('glEvalMapsNV');
+    if not Assigned(glEvalMapsNV) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_fence: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_fence', extstring) then
+  begin
+    @glGenFencesNV := SDL_GL_GetProcAddress('glGenFencesNV');
+    if not Assigned(glGenFencesNV) then Exit;
+    @glDeleteFencesNV := SDL_GL_GetProcAddress('glDeleteFencesNV');
+    if not Assigned(glDeleteFencesNV) then Exit;
+    @glSetFenceNV := SDL_GL_GetProcAddress('glSetFenceNV');
+    if not Assigned(glSetFenceNV) then Exit;
+    @glTestFenceNV := SDL_GL_GetProcAddress('glTestFenceNV');
+    if not Assigned(glTestFenceNV) then Exit;
+    @glFinishFenceNV := SDL_GL_GetProcAddress('glFinishFenceNV');
+    if not Assigned(glFinishFenceNV) then Exit;
+    @glIsFenceNV := SDL_GL_GetProcAddress('glIsFenceNV');
+    if not Assigned(glIsFenceNV) then Exit;
+    @glGetFenceivNV := SDL_GL_GetProcAddress('glGetFenceivNV');
+    if not Assigned(glGetFenceivNV) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_fog_distance: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_fog_distance', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_light_max_exponent: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_light_max_exponent', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_multisample_filter_hint: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_multisample_filter_hint', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_occlusion_query: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_occlusion_query', extstring) then
+  begin
+    @glGenOcclusionQueriesNV := SDL_GL_GetProcAddress('glGenOcclusionQueriesNV');
+    if not Assigned(glGenOcclusionQueriesNV) then Exit;
+    @glDeleteOcclusionQueriesNV := SDL_GL_GetProcAddress('glDeleteOcclusionQueriesNV');
+    if not Assigned(glDeleteOcclusionQueriesNV) then Exit;
+    @glIsOcclusionQueryNV := SDL_GL_GetProcAddress('glIsOcclusionQueryNV');
+    if not Assigned(glIsOcclusionQueryNV) then Exit;
+    @glBeginOcclusionQueryNV := SDL_GL_GetProcAddress('glBeginOcclusionQueryNV');
+    if not Assigned(glBeginOcclusionQueryNV) then Exit;
+    @glEndOcclusionQueryNV := SDL_GL_GetProcAddress('glEndOcclusionQueryNV');
+    if not Assigned(glEndOcclusionQueryNV) then Exit;
+    @glGetOcclusionQueryivNV := SDL_GL_GetProcAddress('glGetOcclusionQueryivNV');
+    if not Assigned(glGetOcclusionQueryivNV) then Exit;
+    @glGetOcclusionQueryuivNV := SDL_GL_GetProcAddress('glGetOcclusionQueryuivNV');
+    if not Assigned(glGetOcclusionQueryuivNV) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_packed_depth_stencil: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_packed_depth_stencil', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_point_sprite: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_point_sprite', extstring) then
+  begin
+    @glPointParameteriNV := SDL_GL_GetProcAddress('glPointParameteriNV');
+    if not Assigned(glPointParameteriNV) then Exit;
+    @glPointParameterivNV := SDL_GL_GetProcAddress('glPointParameterivNV');
+    if not Assigned(glPointParameterivNV) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_register_combiners: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_register_combiners', extstring) then
+  begin
+    @glCombinerParameterfvNV := SDL_GL_GetProcAddress('glCombinerParameterfvNV');
+    if not Assigned(glCombinerParameterfvNV) then Exit;
+    @glCombinerParameterivNV := SDL_GL_GetProcAddress('glCombinerParameterivNV');
+    if not Assigned(glCombinerParameterivNV) then Exit;
+    @glCombinerParameterfNV := SDL_GL_GetProcAddress('glCombinerParameterfNV');
+    if not Assigned(glCombinerParameterfNV) then Exit;
+    @glCombinerParameteriNV := SDL_GL_GetProcAddress('glCombinerParameteriNV');
+    if not Assigned(glCombinerParameteriNV) then Exit;
+    @glCombinerInputNV := SDL_GL_GetProcAddress('glCombinerInputNV');
+    if not Assigned(glCombinerInputNV) then Exit;
+    @glCombinerOutputNV := SDL_GL_GetProcAddress('glCombinerOutputNV');
+    if not Assigned(glCombinerOutputNV) then Exit;
+    @glFinalCombinerInputNV := SDL_GL_GetProcAddress('glFinalCombinerInputNV');
+    if not Assigned(glFinalCombinerInputNV) then Exit;
+    @glGetCombinerInputParameterfvNV := SDL_GL_GetProcAddress('glGetCombinerInputParameterfvNV');
+    if not Assigned(glGetCombinerInputParameterfvNV) then Exit;
+    @glGetCombinerInputParameterivNV := SDL_GL_GetProcAddress('glGetCombinerInputParameterivNV');
+    if not Assigned(glGetCombinerInputParameterivNV) then Exit;
+    @glGetCombinerOutputParameterfvNV := SDL_GL_GetProcAddress('glGetCombinerOutputParameterfvNV');
+    if not Assigned(glGetCombinerOutputParameterfvNV) then Exit;
+    @glGetCombinerOutputParameterivNV := SDL_GL_GetProcAddress('glGetCombinerOutputParameterivNV');
+    if not Assigned(glGetCombinerOutputParameterivNV) then Exit;
+    @glGetFinalCombinerInputParameterfvNV := SDL_GL_GetProcAddress('glGetFinalCombinerInputParameterfvNV');
+    if not Assigned(glGetFinalCombinerInputParameterfvNV) then Exit;
+    @glGetFinalCombinerInputParameterivNV := SDL_GL_GetProcAddress('glGetFinalCombinerInputParameterivNV');
+    if not Assigned(glGetFinalCombinerInputParameterivNV) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_register_combiners2: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_register_combiners2', extstring) then
+  begin
+    @glCombinerStageParameterfvNV := SDL_GL_GetProcAddress('glCombinerStageParameterfvNV');
+    if not Assigned(glCombinerStageParameterfvNV) then Exit;
+    @glGetCombinerStageParameterfvNV := SDL_GL_GetProcAddress('glGetCombinerStageParameterfvNV');
+    if not Assigned(glGetCombinerStageParameterfvNV) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_texgen_emboss: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_texgen_emboss', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_texgen_reflection: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_texgen_reflection', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_texture_compression_vtc: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_texture_compression_vtc', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_texture_env_combine4: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_texture_env_combine4', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_texture_rectangle: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_texture_rectangle', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_texture_shader: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_texture_shader', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_texture_shader2: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_texture_shader2', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_texture_shader3: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_texture_shader3', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_vertex_array_range: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_vertex_array_range', extstring) then
+  begin
+    @glVertexArrayRangeNV := SDL_GL_GetProcAddress('glVertexArrayRangeNV');
+    if not Assigned(glVertexArrayRangeNV) then Exit;
+    @glFlushVertexArrayRangeNV := SDL_GL_GetProcAddress('glFlushVertexArrayRangeNV');
+    if not Assigned(glFlushVertexArrayRangeNV) then Exit;
+    {$IFDEF WIN32}
+    @wglAllocateMemoryNV := SDL_GL_GetProcAddress('wglAllocateMemoryNV');
+    if not Assigned(wglAllocateMemoryNV) then Exit;
+    @wglFreeMemoryNV := SDL_GL_GetProcAddress('wglFreeMemoryNV');
+    if not Assigned(wglFreeMemoryNV) then Exit;
+    {$ENDIF}
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_vertex_array_range2: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_vertex_array_range2', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_vertex_program: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_vertex_program', extstring) then
+  begin
+    @glBindProgramNV := SDL_GL_GetProcAddress('glBindProgramNV');
+    if not Assigned(glBindProgramNV) then Exit;
+    @glDeleteProgramsNV := SDL_GL_GetProcAddress('glDeleteProgramsNV');
+    if not Assigned(glDeleteProgramsNV) then Exit;
+    @glExecuteProgramNV := SDL_GL_GetProcAddress('glExecuteProgramNV');
+    if not Assigned(glExecuteProgramNV) then Exit;
+    @glGenProgramsNV := SDL_GL_GetProcAddress('glGenProgramsNV');
+    if not Assigned(glGenProgramsNV) then Exit;
+    @glAreProgramsResidentNV := SDL_GL_GetProcAddress('glAreProgramsResidentNV');
+    if not Assigned(glAreProgramsResidentNV) then Exit;
+    @glRequestResidentProgramsNV := SDL_GL_GetProcAddress('glRequestResidentProgramsNV');
+    if not Assigned(glRequestResidentProgramsNV) then Exit;
+    @glGetProgramParameterfvNV := SDL_GL_GetProcAddress('glGetProgramParameterfvNV');
+    if not Assigned(glGetProgramParameterfvNV) then Exit;
+    @glGetProgramParameterdvNV := SDL_GL_GetProcAddress('glGetProgramParameterdvNV');
+    if not Assigned(glGetProgramParameterdvNV) then Exit;
+    @glGetProgramivNV := SDL_GL_GetProcAddress('glGetProgramivNV');
+    if not Assigned(glGetProgramivNV) then Exit;
+    @glGetProgramStringNV := SDL_GL_GetProcAddress('glGetProgramStringNV');
+    if not Assigned(glGetProgramStringNV) then Exit;
+    @glGetTrackMatrixivNV := SDL_GL_GetProcAddress('glGetTrackMatrixivNV');
+    if not Assigned(glGetTrackMatrixivNV) then Exit;
+    @glGetVertexAttribdvNV := SDL_GL_GetProcAddress('glGetVertexAttribdvNV');
+    if not Assigned(glGetVertexAttribdvNV) then Exit;
+    @glGetVertexAttribfvNV := SDL_GL_GetProcAddress('glGetVertexAttribfvNV');
+    if not Assigned(glGetVertexAttribfvNV) then Exit;
+    @glGetVertexAttribivNV := SDL_GL_GetProcAddress('glGetVertexAttribivNV');
+    if not Assigned(glGetVertexAttribivNV) then Exit;
+    @glGetVertexAttribPointervNV := SDL_GL_GetProcAddress('glGetVertexAttribPointervNV');
+    if not Assigned(glGetVertexAttribPointervNV) then Exit;
+    @glIsProgramNV := SDL_GL_GetProcAddress('glIsProgramNV');
+    if not Assigned(glIsProgramNV) then Exit;
+    @glLoadProgramNV := SDL_GL_GetProcAddress('glLoadProgramNV');
+    if not Assigned(glLoadProgramNV) then Exit;
+    @glProgramParameter4fNV := SDL_GL_GetProcAddress('glProgramParameter4fNV');
+    if not Assigned(glProgramParameter4fNV) then Exit;
+    @glProgramParameter4fvNV := SDL_GL_GetProcAddress('glProgramParameter4fvNV');
+    if not Assigned(glProgramParameter4fvNV) then Exit;
+    @glProgramParameters4dvNV := SDL_GL_GetProcAddress('glProgramParameters4dvNV');
+    if not Assigned(glProgramParameters4dvNV) then Exit;
+    @glProgramParameters4fvNV := SDL_GL_GetProcAddress('glProgramParameters4fvNV');
+    if not Assigned(glProgramParameters4fvNV) then Exit;
+    @glTrackMatrixNV := SDL_GL_GetProcAddress('glTrackMatrixNV');
+    if not Assigned(glTrackMatrixNV) then Exit;
+    @glVertexAttribPointerNV := SDL_GL_GetProcAddress('glVertexAttribPointerNV');
+    if not Assigned(glVertexAttribPointerNV) then Exit;
+    @glVertexAttrib1sNV := SDL_GL_GetProcAddress('glVertexAttrib1sNV');
+    if not Assigned(glVertexAttrib1sNV) then Exit;
+    @glVertexAttrib1fNV := SDL_GL_GetProcAddress('glVertexAttrib1fNV');
+    if not Assigned(glVertexAttrib1fNV) then Exit;
+    @glVertexAttrib1dNV := SDL_GL_GetProcAddress('glVertexAttrib1dNV');
+    if not Assigned(glVertexAttrib1dNV) then Exit;
+    @glVertexAttrib2sNV := SDL_GL_GetProcAddress('glVertexAttrib2sNV');
+    if not Assigned(glVertexAttrib2sNV) then Exit;
+    @glVertexAttrib2fNV := SDL_GL_GetProcAddress('glVertexAttrib2fNV');
+    if not Assigned(glVertexAttrib2fNV) then Exit;
+    @glVertexAttrib2dNV := SDL_GL_GetProcAddress('glVertexAttrib2dNV');
+    if not Assigned(glVertexAttrib2dNV) then Exit;
+    @glVertexAttrib3sNV := SDL_GL_GetProcAddress('glVertexAttrib3sNV');
+    if not Assigned(glVertexAttrib3sNV) then Exit;
+    @glVertexAttrib3fNV := SDL_GL_GetProcAddress('glVertexAttrib3fNV');
+    if not Assigned(glVertexAttrib3fNV) then Exit;
+    @glVertexAttrib3dNV := SDL_GL_GetProcAddress('glVertexAttrib3dNV');
+    if not Assigned(glVertexAttrib3dNV) then Exit;
+    @glVertexAttrib4sNV := SDL_GL_GetProcAddress('glVertexAttrib4sNV');
+    if not Assigned(glVertexAttrib4sNV) then Exit;
+    @glVertexAttrib4fNV := SDL_GL_GetProcAddress('glVertexAttrib4fNV');
+    if not Assigned(glVertexAttrib4fNV) then Exit;
+    @glVertexAttrib4dNV := SDL_GL_GetProcAddress('glVertexAttrib4dNV');
+    if not Assigned(glVertexAttrib4dNV) then Exit;
+    @glVertexAttrib4ubNV := SDL_GL_GetProcAddress('glVertexAttrib4ubNV');
+    if not Assigned(glVertexAttrib4ubNV) then Exit;
+    @glVertexAttrib1svNV := SDL_GL_GetProcAddress('glVertexAttrib1svNV');
+    if not Assigned(glVertexAttrib1svNV) then Exit;
+    @glVertexAttrib1fvNV := SDL_GL_GetProcAddress('glVertexAttrib1fvNV');
+    if not Assigned(glVertexAttrib1fvNV) then Exit;
+    @glVertexAttrib1dvNV := SDL_GL_GetProcAddress('glVertexAttrib1dvNV');
+    if not Assigned(glVertexAttrib1dvNV) then Exit;
+    @glVertexAttrib2svNV := SDL_GL_GetProcAddress('glVertexAttrib2svNV');
+    if not Assigned(glVertexAttrib2svNV) then Exit;
+    @glVertexAttrib2fvNV := SDL_GL_GetProcAddress('glVertexAttrib2fvNV');
+    if not Assigned(glVertexAttrib2fvNV) then Exit;
+    @glVertexAttrib2dvNV := SDL_GL_GetProcAddress('glVertexAttrib2dvNV');
+    if not Assigned(glVertexAttrib2dvNV) then Exit;
+    @glVertexAttrib3svNV := SDL_GL_GetProcAddress('glVertexAttrib3svNV');
+    if not Assigned(glVertexAttrib3svNV) then Exit;
+    @glVertexAttrib3fvNV := SDL_GL_GetProcAddress('glVertexAttrib3fvNV');
+    if not Assigned(glVertexAttrib3fvNV) then Exit;
+    @glVertexAttrib3dvNV := SDL_GL_GetProcAddress('glVertexAttrib3dvNV');
+    if not Assigned(glVertexAttrib3dvNV) then Exit;
+    @glVertexAttrib4svNV := SDL_GL_GetProcAddress('glVertexAttrib4svNV');
+    if not Assigned(glVertexAttrib4svNV) then Exit;
+    @glVertexAttrib4fvNV := SDL_GL_GetProcAddress('glVertexAttrib4fvNV');
+    if not Assigned(glVertexAttrib4fvNV) then Exit;
+    @glVertexAttrib4dvNV := SDL_GL_GetProcAddress('glVertexAttrib4dvNV');
+    if not Assigned(glVertexAttrib4dvNV) then Exit;
+    @glVertexAttrib4ubvNV := SDL_GL_GetProcAddress('glVertexAttrib4ubvNV');
+    if not Assigned(glVertexAttrib4ubvNV) then Exit;
+    @glVertexAttribs1svNV := SDL_GL_GetProcAddress('glVertexAttribs1svNV');
+    if not Assigned(glVertexAttribs1svNV) then Exit;
+    @glVertexAttribs1fvNV := SDL_GL_GetProcAddress('glVertexAttribs1fvNV');
+    if not Assigned(glVertexAttribs1fvNV) then Exit;
+    @glVertexAttribs1dvNV := SDL_GL_GetProcAddress('glVertexAttribs1dvNV');
+    if not Assigned(glVertexAttribs1dvNV) then Exit;
+    @glVertexAttribs2svNV := SDL_GL_GetProcAddress('glVertexAttribs2svNV');
+    if not Assigned(glVertexAttribs2svNV) then Exit;
+    @glVertexAttribs2fvNV := SDL_GL_GetProcAddress('glVertexAttribs2fvNV');
+    if not Assigned(glVertexAttribs2fvNV) then Exit;
+    @glVertexAttribs2dvNV := SDL_GL_GetProcAddress('glVertexAttribs2dvNV');
+    if not Assigned(glVertexAttribs2dvNV) then Exit;
+    @glVertexAttribs3svNV := SDL_GL_GetProcAddress('glVertexAttribs3svNV');
+    if not Assigned(glVertexAttribs3svNV) then Exit;
+    @glVertexAttribs3fvNV := SDL_GL_GetProcAddress('glVertexAttribs3fvNV');
+    if not Assigned(glVertexAttribs3fvNV) then Exit;
+    @glVertexAttribs3dvNV := SDL_GL_GetProcAddress('glVertexAttribs3dvNV');
+    if not Assigned(glVertexAttribs3dvNV) then Exit;
+    @glVertexAttribs4svNV := SDL_GL_GetProcAddress('glVertexAttribs4svNV');
+    if not Assigned(glVertexAttribs4svNV) then Exit;
+    @glVertexAttribs4fvNV := SDL_GL_GetProcAddress('glVertexAttribs4fvNV');
+    if not Assigned(glVertexAttribs4fvNV) then Exit;
+    @glVertexAttribs4dvNV := SDL_GL_GetProcAddress('glVertexAttribs4dvNV');
+    if not Assigned(glVertexAttribs4dvNV) then Exit;
+    @glVertexAttribs4ubvNV := SDL_GL_GetProcAddress('glVertexAttribs4ubvNV');
+    if not Assigned(glVertexAttribs4ubvNV) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_vertex_program1_1: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_vertex_program1_1', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_element_array: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_element_array', extstring) then
+  begin
+    @glElementPointerATI := SDL_GL_GetProcAddress('glElementPointerATI');
+    if not Assigned(glElementPointerATI) then Exit;
+    @glDrawElementArrayATI := SDL_GL_GetProcAddress('glDrawElementArrayATI');
+    if not Assigned(glDrawElementArrayATI) then Exit;
+    @glDrawRangeElementArrayATI := SDL_GL_GetProcAddress('glDrawRangeElementArrayATI');
+    if not Assigned(glDrawRangeElementArrayATI) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_envmap_bumpmap: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_envmap_bumpmap', extstring) then
+  begin
+    @glTexBumpParameterivATI := SDL_GL_GetProcAddress('glTexBumpParameterivATI');
+    if not Assigned(glTexBumpParameterivATI) then Exit;
+    @glTexBumpParameterfvATI := SDL_GL_GetProcAddress('glTexBumpParameterfvATI');
+    if not Assigned(glTexBumpParameterfvATI) then Exit;
+    @glGetTexBumpParameterivATI := SDL_GL_GetProcAddress('glGetTexBumpParameterivATI');
+    if not Assigned(glGetTexBumpParameterivATI) then Exit;
+    @glGetTexBumpParameterfvATI := SDL_GL_GetProcAddress('glGetTexBumpParameterfvATI');
+    if not Assigned(glGetTexBumpParameterfvATI) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_fragment_shader: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_fragment_shader', extstring) then
+  begin
+    @glGenFragmentShadersATI := SDL_GL_GetProcAddress('glGenFragmentShadersATI');
+    if not Assigned(glGenFragmentShadersATI) then Exit;
+    @glBindFragmentShaderATI := SDL_GL_GetProcAddress('glBindFragmentShaderATI');
+    if not Assigned(glBindFragmentShaderATI) then Exit;
+    @glDeleteFragmentShaderATI := SDL_GL_GetProcAddress('glDeleteFragmentShaderATI');
+    if not Assigned(glDeleteFragmentShaderATI) then Exit;
+    @glBeginFragmentShaderATI := SDL_GL_GetProcAddress('glBeginFragmentShaderATI');
+    if not Assigned(glBeginFragmentShaderATI) then Exit;
+    @glEndFragmentShaderATI := SDL_GL_GetProcAddress('glEndFragmentShaderATI');
+    if not Assigned(glEndFragmentShaderATI) then Exit;
+    @glPassTexCoordATI := SDL_GL_GetProcAddress('glPassTexCoordATI');
+    if not Assigned(glPassTexCoordATI) then Exit;
+    @glSampleMapATI := SDL_GL_GetProcAddress('glSampleMapATI');
+    if not Assigned(glSampleMapATI) then Exit;
+    @glColorFragmentOp1ATI := SDL_GL_GetProcAddress('glColorFragmentOp1ATI');
+    if not Assigned(glColorFragmentOp1ATI) then Exit;
+    @glColorFragmentOp2ATI := SDL_GL_GetProcAddress('glColorFragmentOp2ATI');
+    if not Assigned(glColorFragmentOp2ATI) then Exit;
+    @glColorFragmentOp3ATI := SDL_GL_GetProcAddress('glColorFragmentOp3ATI');
+    if not Assigned(glColorFragmentOp3ATI) then Exit;
+    @glAlphaFragmentOp1ATI := SDL_GL_GetProcAddress('glAlphaFragmentOp1ATI');
+    if not Assigned(glAlphaFragmentOp1ATI) then Exit;
+    @glAlphaFragmentOp2ATI := SDL_GL_GetProcAddress('glAlphaFragmentOp2ATI');
+    if not Assigned(glAlphaFragmentOp2ATI) then Exit;
+    @glAlphaFragmentOp3ATI := SDL_GL_GetProcAddress('glAlphaFragmentOp3ATI');
+    if not Assigned(glAlphaFragmentOp3ATI) then Exit;
+    @glSetFragmentShaderConstantATI := SDL_GL_GetProcAddress('glSetFragmentShaderConstantATI');
+    if not Assigned(glSetFragmentShaderConstantATI) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_pn_triangles: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_pn_triangles', extstring) then
+  begin
+    @glPNTrianglesiATI := SDL_GL_GetProcAddress('glPNTrianglesiATI');
+    if not Assigned(glPNTrianglesiATI) then Exit;
+    @glPNTrianglesfATI := SDL_GL_GetProcAddress('glPNTrianglesfATI');
+    if not Assigned(glPNTrianglesfATI) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_texture_mirror_once: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_texture_mirror_once', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_vertex_array_object: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_vertex_array_object', extstring) then
+  begin
+    @glNewObjectBufferATI := SDL_GL_GetProcAddress('glNewObjectBufferATI');
+    if not Assigned(glNewObjectBufferATI) then Exit;
+    @glIsObjectBufferATI := SDL_GL_GetProcAddress('glIsObjectBufferATI');
+    if not Assigned(glIsObjectBufferATI) then Exit;
+    @glUpdateObjectBufferATI := SDL_GL_GetProcAddress('glUpdateObjectBufferATI');
+    if not Assigned(glUpdateObjectBufferATI) then Exit;
+    @glGetObjectBufferfvATI := SDL_GL_GetProcAddress('glGetObjectBufferfvATI');
+    if not Assigned(glGetObjectBufferfvATI) then Exit;
+    @glGetObjectBufferivATI := SDL_GL_GetProcAddress('glGetObjectBufferivATI');
+    if not Assigned(glGetObjectBufferivATI) then Exit;
+    @glDeleteObjectBufferATI := SDL_GL_GetProcAddress('glDeleteObjectBufferATI');
+    if not Assigned(glDeleteObjectBufferATI) then Exit;
+    @glArrayObjectATI := SDL_GL_GetProcAddress('glArrayObjectATI');
+    if not Assigned(glArrayObjectATI) then Exit;
+    @glGetArrayObjectfvATI := SDL_GL_GetProcAddress('glGetArrayObjectfvATI');
+    if not Assigned(glGetArrayObjectfvATI) then Exit;
+    @glGetArrayObjectivATI := SDL_GL_GetProcAddress('glGetArrayObjectivATI');
+    if not Assigned(glGetArrayObjectivATI) then Exit;
+    @glVariantArrayObjectATI := SDL_GL_GetProcAddress('glVariantArrayObjectATI');
+    if not Assigned(glVariantArrayObjectATI) then Exit;
+    @glGetVariantArrayObjectfvATI := SDL_GL_GetProcAddress('glGetVariantArrayObjectfvATI');
+    if not Assigned(glGetVariantArrayObjectfvATI) then Exit;
+    @glGetVariantArrayObjectivATI := SDL_GL_GetProcAddress('glGetVariantArrayObjectivATI');
+    if not Assigned(glGetVariantArrayObjectivATI) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_vertex_streams: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_vertex_streams', extstring) then
+  begin
+    @glVertexStream1s := SDL_GL_GetProcAddress('glVertexStream1s');
+    if not Assigned(glVertexStream1s) then Exit;
+    @glVertexStream1i := SDL_GL_GetProcAddress('glVertexStream1i');
+    if not Assigned(glVertexStream1i) then Exit;
+    @glVertexStream1f := SDL_GL_GetProcAddress('glVertexStream1f');
+    if not Assigned(glVertexStream1f) then Exit;
+    @glVertexStream1d := SDL_GL_GetProcAddress('glVertexStream1d');
+    if not Assigned(glVertexStream1d) then Exit;
+    @glVertexStream1sv := SDL_GL_GetProcAddress('glVertexStream1sv');
+    if not Assigned(glVertexStream1sv) then Exit;
+    @glVertexStream1iv := SDL_GL_GetProcAddress('glVertexStream1iv');
+    if not Assigned(glVertexStream1iv) then Exit;
+    @glVertexStream1fv := SDL_GL_GetProcAddress('glVertexStream1fv');
+    if not Assigned(glVertexStream1fv) then Exit;
+    @glVertexStream1dv := SDL_GL_GetProcAddress('glVertexStream1dv');
+    if not Assigned(glVertexStream1dv) then Exit;
+    @glVertexStream2s := SDL_GL_GetProcAddress('glVertexStream2s');
+    if not Assigned(glVertexStream2s) then Exit;
+    @glVertexStream2i := SDL_GL_GetProcAddress('glVertexStream2i');
+    if not Assigned(glVertexStream2i) then Exit;
+    @glVertexStream2f := SDL_GL_GetProcAddress('glVertexStream2f');
+    if not Assigned(glVertexStream2f) then Exit;
+    @glVertexStream2d := SDL_GL_GetProcAddress('glVertexStream2d');
+    if not Assigned(glVertexStream2d) then Exit;
+    @glVertexStream2sv := SDL_GL_GetProcAddress('glVertexStream2sv');
+    if not Assigned(glVertexStream2sv) then Exit;
+    @glVertexStream2iv := SDL_GL_GetProcAddress('glVertexStream2iv');
+    if not Assigned(glVertexStream2iv) then Exit;
+    @glVertexStream2fv := SDL_GL_GetProcAddress('glVertexStream2fv');
+    if not Assigned(glVertexStream2fv) then Exit;
+    @glVertexStream2dv := SDL_GL_GetProcAddress('glVertexStream2dv');
+    if not Assigned(glVertexStream2dv) then Exit;
+    @glVertexStream3s := SDL_GL_GetProcAddress('glVertexStream3s');
+    if not Assigned(glVertexStream3s) then Exit;
+    @glVertexStream3i := SDL_GL_GetProcAddress('glVertexStream3i');
+    if not Assigned(glVertexStream3i) then Exit;
+    @glVertexStream3f := SDL_GL_GetProcAddress('glVertexStream3f');
+    if not Assigned(glVertexStream3f) then Exit;
+    @glVertexStream3d := SDL_GL_GetProcAddress('glVertexStream3d');
+    if not Assigned(glVertexStream3d) then Exit;
+    @glVertexStream3sv := SDL_GL_GetProcAddress('glVertexStream3sv');
+    if not Assigned(glVertexStream3sv) then Exit;
+    @glVertexStream3iv := SDL_GL_GetProcAddress('glVertexStream3iv');
+    if not Assigned(glVertexStream3iv) then Exit;
+    @glVertexStream3fv := SDL_GL_GetProcAddress('glVertexStream3fv');
+    if not Assigned(glVertexStream3fv) then Exit;
+    @glVertexStream3dv := SDL_GL_GetProcAddress('glVertexStream3dv');
+    if not Assigned(glVertexStream3dv) then Exit;
+    @glVertexStream4s := SDL_GL_GetProcAddress('glVertexStream4s');
+    if not Assigned(glVertexStream4s) then Exit;
+    @glVertexStream4i := SDL_GL_GetProcAddress('glVertexStream4i');
+    if not Assigned(glVertexStream4i) then Exit;
+    @glVertexStream4f := SDL_GL_GetProcAddress('glVertexStream4f');
+    if not Assigned(glVertexStream4f) then Exit;
+    @glVertexStream4d := SDL_GL_GetProcAddress('glVertexStream4d');
+    if not Assigned(glVertexStream4d) then Exit;
+    @glVertexStream4sv := SDL_GL_GetProcAddress('glVertexStream4sv');
+    if not Assigned(glVertexStream4sv) then Exit;
+    @glVertexStream4iv := SDL_GL_GetProcAddress('glVertexStream4iv');
+    if not Assigned(glVertexStream4iv) then Exit;
+    @glVertexStream4fv := SDL_GL_GetProcAddress('glVertexStream4fv');
+    if not Assigned(glVertexStream4fv) then Exit;
+    @glVertexStream4dv := SDL_GL_GetProcAddress('glVertexStream4dv');
+    if not Assigned(glVertexStream4dv) then Exit;
+    @glNormalStream3b := SDL_GL_GetProcAddress('glNormalStream3b');
+    if not Assigned(glNormalStream3b) then Exit;
+    @glNormalStream3s := SDL_GL_GetProcAddress('glNormalStream3s');
+    if not Assigned(glNormalStream3s) then Exit;
+    @glNormalStream3i := SDL_GL_GetProcAddress('glNormalStream3i');
+    if not Assigned(glNormalStream3i) then Exit;
+    @glNormalStream3f := SDL_GL_GetProcAddress('glNormalStream3f');
+    if not Assigned(glNormalStream3f) then Exit;
+    @glNormalStream3d := SDL_GL_GetProcAddress('glNormalStream3d');
+    if not Assigned(glNormalStream3d) then Exit;
+    @glNormalStream3bv := SDL_GL_GetProcAddress('glNormalStream3bv');
+    if not Assigned(glNormalStream3bv) then Exit;
+    @glNormalStream3sv := SDL_GL_GetProcAddress('glNormalStream3sv');
+    if not Assigned(glNormalStream3sv) then Exit;
+    @glNormalStream3iv := SDL_GL_GetProcAddress('glNormalStream3iv');
+    if not Assigned(glNormalStream3iv) then Exit;
+    @glNormalStream3fv := SDL_GL_GetProcAddress('glNormalStream3fv');
+    if not Assigned(glNormalStream3fv) then Exit;
+    @glNormalStream3dv := SDL_GL_GetProcAddress('glNormalStream3dv');
+    if not Assigned(glNormalStream3dv) then Exit;
+    @glClientActiveVertexStream := SDL_GL_GetProcAddress('glClientActiveVertexStream');
+    if not Assigned(glClientActiveVertexStream) then Exit;
+    @glVertexBlendEnvi := SDL_GL_GetProcAddress('glVertexBlendEnvi');
+    if not Assigned(glVertexBlendEnvi) then Exit;
+    @glVertexBlendEnvf := SDL_GL_GetProcAddress('glVertexBlendEnvf');
+    if not Assigned(glVertexBlendEnvf) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+{$IFDEF WIN32}
+function Load_WGL_I3D_image_buffer: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_I3D_image_buffer', extstring) then
+  begin
+    @wglCreateImageBufferI3D := SDL_GL_GetProcAddress('wglCreateImageBufferI3D');
+    if not Assigned(wglCreateImageBufferI3D) then Exit;
+    @wglDestroyImageBufferI3D := SDL_GL_GetProcAddress('wglDestroyImageBufferI3D');
+    if not Assigned(wglDestroyImageBufferI3D) then Exit;
+    @wglAssociateImageBufferEventsI3D := SDL_GL_GetProcAddress('wglAssociateImageBufferEventsI3D');
+    if not Assigned(wglAssociateImageBufferEventsI3D) then Exit;
+    @wglReleaseImageBufferEventsI3D := SDL_GL_GetProcAddress('wglReleaseImageBufferEventsI3D');
+    if not Assigned(wglReleaseImageBufferEventsI3D) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_I3D_swap_frame_lock: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_I3D_swap_frame_lock', extstring) then
+  begin
+    @wglEnableFrameLockI3D := SDL_GL_GetProcAddress('wglEnableFrameLockI3D');
+    if not Assigned(wglEnableFrameLockI3D) then Exit;
+    @wglDisableFrameLockI3D := SDL_GL_GetProcAddress('wglDisableFrameLockI3D');
+    if not Assigned(wglDisableFrameLockI3D) then Exit;
+    @wglIsEnabledFrameLockI3D := SDL_GL_GetProcAddress('wglIsEnabledFrameLockI3D');
+    if not Assigned(wglIsEnabledFrameLockI3D) then Exit;
+    @wglQueryFrameLockMasterI3D := SDL_GL_GetProcAddress('wglQueryFrameLockMasterI3D');
+    if not Assigned(wglQueryFrameLockMasterI3D) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_I3D_swap_frame_usage: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_I3D_swap_frame_usage', extstring) then
+  begin
+    @wglGetFrameUsageI3D := SDL_GL_GetProcAddress('wglGetFrameUsageI3D');
+    if not Assigned(wglGetFrameUsageI3D) then Exit;
+    @wglBeginFrameTrackingI3D := SDL_GL_GetProcAddress('wglBeginFrameTrackingI3D');
+    if not Assigned(wglBeginFrameTrackingI3D) then Exit;
+    @wglEndFrameTrackingI3D := SDL_GL_GetProcAddress('wglEndFrameTrackingI3D');
+    if not Assigned(wglEndFrameTrackingI3D) then Exit;
+    @wglQueryFrameTrackingI3D := SDL_GL_GetProcAddress('wglQueryFrameTrackingI3D');
+    if not Assigned(wglQueryFrameTrackingI3D) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+{$ENDIF}
+
+function Load_GL_3DFX_texture_compression_FXT1: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_3DFX_texture_compression_FXT1', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_IBM_cull_vertex: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_IBM_cull_vertex', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_IBM_multimode_draw_arrays: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_IBM_multimode_draw_arrays', extstring) then
+  begin
+    @glMultiModeDrawArraysIBM := SDL_GL_GetProcAddress('glMultiModeDrawArraysIBM');
+    if not Assigned(glMultiModeDrawArraysIBM) then Exit;
+    @glMultiModeDrawElementsIBM := SDL_GL_GetProcAddress('glMultiModeDrawElementsIBM');
+    if not Assigned(glMultiModeDrawElementsIBM) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_IBM_raster_pos_clip: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_IBM_raster_pos_clip', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_IBM_texture_mirrored_repeat: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_IBM_texture_mirrored_repeat', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_IBM_vertex_array_lists: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_IBM_vertex_array_lists', extstring) then
+  begin
+    @glColorPointerListIBM := SDL_GL_GetProcAddress('glColorPointerListIBM');
+    if not Assigned(glColorPointerListIBM) then Exit;
+    @glSecondaryColorPointerListIBM := SDL_GL_GetProcAddress('glSecondaryColorPointerListIBM');
+    if not Assigned(glSecondaryColorPointerListIBM) then Exit;
+    @glEdgeFlagPointerListIBM := SDL_GL_GetProcAddress('glEdgeFlagPointerListIBM');
+    if not Assigned(glEdgeFlagPointerListIBM) then Exit;
+    @glFogCoordPointerListIBM := SDL_GL_GetProcAddress('glFogCoordPointerListIBM');
+    if not Assigned(glFogCoordPointerListIBM) then Exit;
+    @glNormalPointerListIBM := SDL_GL_GetProcAddress('glNormalPointerListIBM');
+    if not Assigned(glNormalPointerListIBM) then Exit;
+    @glTexCoordPointerListIBM := SDL_GL_GetProcAddress('glTexCoordPointerListIBM');
+    if not Assigned(glTexCoordPointerListIBM) then Exit;
+    @glVertexPointerListIBM := SDL_GL_GetProcAddress('glVertexPointerListIBM');
+    if not Assigned(glVertexPointerListIBM) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_MESA_resize_buffers: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_MESA_resize_buffers', extstring) then
+  begin
+    @glResizeBuffersMESA := SDL_GL_GetProcAddress('glResizeBuffersMESA');
+    if not Assigned(glResizeBuffersMESA) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_MESA_window_pos: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_MESA_window_pos', extstring) then
+  begin
+    @glWindowPos2dMESA := SDL_GL_GetProcAddress('glWindowPos2dMESA');
+    if not Assigned(glWindowPos2dMESA) then Exit;
+    @glWindowPos2fMESA := SDL_GL_GetProcAddress('glWindowPos2fMESA');
+    if not Assigned(glWindowPos2fMESA) then Exit;
+    @glWindowPos2iMESA := SDL_GL_GetProcAddress('glWindowPos2iMESA');
+    if not Assigned(glWindowPos2iMESA) then Exit;
+    @glWindowPos2sMESA := SDL_GL_GetProcAddress('glWindowPos2sMESA');
+    if not Assigned(glWindowPos2sMESA) then Exit;
+    @glWindowPos2ivMESA := SDL_GL_GetProcAddress('glWindowPos2ivMESA');
+    if not Assigned(glWindowPos2ivMESA) then Exit;
+    @glWindowPos2svMESA := SDL_GL_GetProcAddress('glWindowPos2svMESA');
+    if not Assigned(glWindowPos2svMESA) then Exit;
+    @glWindowPos2fvMESA := SDL_GL_GetProcAddress('glWindowPos2fvMESA');
+    if not Assigned(glWindowPos2fvMESA) then Exit;
+    @glWindowPos2dvMESA := SDL_GL_GetProcAddress('glWindowPos2dvMESA');
+    if not Assigned(glWindowPos2dvMESA) then Exit;
+    @glWindowPos3iMESA := SDL_GL_GetProcAddress('glWindowPos3iMESA');
+    if not Assigned(glWindowPos3iMESA) then Exit;
+    @glWindowPos3sMESA := SDL_GL_GetProcAddress('glWindowPos3sMESA');
+    if not Assigned(glWindowPos3sMESA) then Exit;
+    @glWindowPos3fMESA := SDL_GL_GetProcAddress('glWindowPos3fMESA');
+    if not Assigned(glWindowPos3fMESA) then Exit;
+    @glWindowPos3dMESA := SDL_GL_GetProcAddress('glWindowPos3dMESA');
+    if not Assigned(glWindowPos3dMESA) then Exit;
+    @glWindowPos3ivMESA := SDL_GL_GetProcAddress('glWindowPos3ivMESA');
+    if not Assigned(glWindowPos3ivMESA) then Exit;
+    @glWindowPos3svMESA := SDL_GL_GetProcAddress('glWindowPos3svMESA');
+    if not Assigned(glWindowPos3svMESA) then Exit;
+    @glWindowPos3fvMESA := SDL_GL_GetProcAddress('glWindowPos3fvMESA');
+    if not Assigned(glWindowPos3fvMESA) then Exit;
+    @glWindowPos3dvMESA := SDL_GL_GetProcAddress('glWindowPos3dvMESA');
+    if not Assigned(glWindowPos3dvMESA) then Exit;
+    @glWindowPos4iMESA := SDL_GL_GetProcAddress('glWindowPos4iMESA');
+    if not Assigned(glWindowPos4iMESA) then Exit;
+    @glWindowPos4sMESA := SDL_GL_GetProcAddress('glWindowPos4sMESA');
+    if not Assigned(glWindowPos4sMESA) then Exit;
+    @glWindowPos4fMESA := SDL_GL_GetProcAddress('glWindowPos4fMESA');
+    if not Assigned(glWindowPos4fMESA) then Exit;
+    @glWindowPos4dMESA := SDL_GL_GetProcAddress('glWindowPos4dMESA');
+    if not Assigned(glWindowPos4dMESA) then Exit;
+    @glWindowPos4ivMESA := SDL_GL_GetProcAddress('glWindowPos4ivMESA');
+    if not Assigned(glWindowPos4ivMESA) then Exit;
+    @glWindowPos4svMESA := SDL_GL_GetProcAddress('glWindowPos4svMESA');
+    if not Assigned(glWindowPos4svMESA) then Exit;
+    @glWindowPos4fvMESA := SDL_GL_GetProcAddress('glWindowPos4fvMESA');
+    if not Assigned(glWindowPos4fvMESA) then Exit;
+    @glWindowPos4dvMESA := SDL_GL_GetProcAddress('glWindowPos4dvMESA');
+    if not Assigned(glWindowPos4dvMESA) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_OML_interlace: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_OML_interlace', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_OML_resample: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_OML_resample', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_OML_subsample: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_OML_subsample', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIS_generate_mipmap: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIS_generate_mipmap', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIS_multisample: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIS_multisample', extstring) then
+  begin
+    @glSampleMaskSGIS := SDL_GL_GetProcAddress('glSampleMaskSGIS');
+    if not Assigned(glSampleMaskSGIS) then Exit;
+    @glSamplePatternSGIS := SDL_GL_GetProcAddress('glSamplePatternSGIS');
+    if not Assigned(glSamplePatternSGIS) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIS_pixel_texture: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIS_pixel_texture', extstring) then
+  begin
+    @glPixelTexGenParameteriSGIS := SDL_GL_GetProcAddress('glPixelTexGenParameteriSGIS');
+    if not Assigned(glPixelTexGenParameteriSGIS) then Exit;
+    @glPixelTexGenParameterfSGIS := SDL_GL_GetProcAddress('glPixelTexGenParameterfSGIS');
+    if not Assigned(glPixelTexGenParameterfSGIS) then Exit;
+    @glGetPixelTexGenParameterivSGIS := SDL_GL_GetProcAddress('glGetPixelTexGenParameterivSGIS');
+    if not Assigned(glGetPixelTexGenParameterivSGIS) then Exit;
+    @glGetPixelTexGenParameterfvSGIS := SDL_GL_GetProcAddress('glGetPixelTexGenParameterfvSGIS');
+    if not Assigned(glGetPixelTexGenParameterfvSGIS) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIS_texture_border_clamp: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIS_texture_border_clamp', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIS_texture_color_mask: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIS_texture_color_mask', extstring) then
+  begin
+    @glTextureColorMaskSGIS := SDL_GL_GetProcAddress('glTextureColorMaskSGIS');
+    if not Assigned(glTextureColorMaskSGIS) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIS_texture_edge_clamp: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIS_texture_edge_clamp', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIS_texture_lod: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIS_texture_lod', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIS_depth_texture: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIS_depth_texture', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIX_fog_offset: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIX_fog_offset', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIX_interlace: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIX_interlace', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGIX_shadow_ambient: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGIX_shadow_ambient', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGI_color_matrix: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGI_color_matrix', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGI_color_table: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGI_color_table', extstring) then
+  begin
+    @glColorTableSGI := SDL_GL_GetProcAddress('glColorTableSGI');
+    if not Assigned(glColorTableSGI) then Exit;
+    @glCopyColorTableSGI := SDL_GL_GetProcAddress('glCopyColorTableSGI');
+    if not Assigned(glCopyColorTableSGI) then Exit;
+    @glColorTableParameterivSGI := SDL_GL_GetProcAddress('glColorTableParameterivSGI');
+    if not Assigned(glColorTableParameterivSGI) then Exit;
+    @glColorTableParameterfvSGI := SDL_GL_GetProcAddress('glColorTableParameterfvSGI');
+    if not Assigned(glColorTableParameterfvSGI) then Exit;
+    @glGetColorTableSGI := SDL_GL_GetProcAddress('glGetColorTableSGI');
+    if not Assigned(glGetColorTableSGI) then Exit;
+    @glGetColorTableParameterivSGI := SDL_GL_GetProcAddress('glGetColorTableParameterivSGI');
+    if not Assigned(glGetColorTableParameterivSGI) then Exit;
+    @glGetColorTableParameterfvSGI := SDL_GL_GetProcAddress('glGetColorTableParameterfvSGI');
+    if not Assigned(glGetColorTableParameterfvSGI) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SGI_texture_color_table: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SGI_texture_color_table', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_SUN_vertex: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_SUN_vertex', extstring) then
+  begin
+    @glColor4ubVertex2fSUN := SDL_GL_GetProcAddress('glColor4ubVertex2fSUN');
+    if not Assigned(glColor4ubVertex2fSUN) then Exit;
+    @glColor4ubVertex2fvSUN := SDL_GL_GetProcAddress('glColor4ubVertex2fvSUN');
+    if not Assigned(glColor4ubVertex2fvSUN) then Exit;
+    @glColor4ubVertex3fSUN := SDL_GL_GetProcAddress('glColor4ubVertex3fSUN');
+    if not Assigned(glColor4ubVertex3fSUN) then Exit;
+    @glColor4ubVertex3fvSUN := SDL_GL_GetProcAddress('glColor4ubVertex3fvSUN');
+    if not Assigned(glColor4ubVertex3fvSUN) then Exit;
+    @glColor3fVertex3fSUN := SDL_GL_GetProcAddress('glColor3fVertex3fSUN');
+    if not Assigned(glColor3fVertex3fSUN) then Exit;
+    @glColor3fVertex3fvSUN := SDL_GL_GetProcAddress('glColor3fVertex3fvSUN');
+    if not Assigned(glColor3fVertex3fvSUN) then Exit;
+    @glNormal3fVertex3fSUN := SDL_GL_GetProcAddress('glNormal3fVertex3fSUN');
+    if not Assigned(glNormal3fVertex3fSUN) then Exit;
+    @glNormal3fVertex3fvSUN := SDL_GL_GetProcAddress('glNormal3fVertex3fvSUN');
+    if not Assigned(glNormal3fVertex3fvSUN) then Exit;
+    @glColor4fNormal3fVertex3fSUN := SDL_GL_GetProcAddress('glColor4fNormal3fVertex3fSUN');
+    if not Assigned(glColor4fNormal3fVertex3fSUN) then Exit;
+    @glColor4fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress('glColor4fNormal3fVertex3fvSUN');
+    if not Assigned(glColor4fNormal3fVertex3fvSUN) then Exit;
+    @glTexCoord2fVertex3fSUN := SDL_GL_GetProcAddress('glTexCoord2fVertex3fSUN');
+    if not Assigned(glTexCoord2fVertex3fSUN) then Exit;
+    @glTexCoord2fVertex3fvSUN := SDL_GL_GetProcAddress('glTexCoord2fVertex3fvSUN');
+    if not Assigned(glTexCoord2fVertex3fvSUN) then Exit;
+    @glTexCoord4fVertex4fSUN := SDL_GL_GetProcAddress('glTexCoord4fVertex4fSUN');
+    if not Assigned(glTexCoord4fVertex4fSUN) then Exit;
+    @glTexCoord4fVertex4fvSUN := SDL_GL_GetProcAddress('glTexCoord4fVertex4fvSUN');
+    if not Assigned(glTexCoord4fVertex4fvSUN) then Exit;
+    @glTexCoord2fColor4ubVertex3fSUN := SDL_GL_GetProcAddress('glTexCoord2fColor4ubVertex3fSUN');
+    if not Assigned(glTexCoord2fColor4ubVertex3fSUN) then Exit;
+    @glTexCoord2fColor4ubVertex3fvSUN := SDL_GL_GetProcAddress('glTexCoord2fColor4ubVertex3fvSUN');
+    if not Assigned(glTexCoord2fColor4ubVertex3fvSUN) then Exit;
+    @glTexCoord2fColor3fVertex3fSUN := SDL_GL_GetProcAddress('glTexCoord2fColor3fVertex3fSUN');
+    if not Assigned(glTexCoord2fColor3fVertex3fSUN) then Exit;
+    @glTexCoord2fColor3fVertex3fvSUN := SDL_GL_GetProcAddress('glTexCoord2fColor3fVertex3fvSUN');
+    if not Assigned(glTexCoord2fColor3fVertex3fvSUN) then Exit;
+    @glTexCoord2fNormal3fVertex3fSUN := SDL_GL_GetProcAddress('glTexCoord2fNormal3fVertex3fSUN');
+    if not Assigned(glTexCoord2fNormal3fVertex3fSUN) then Exit;
+    @glTexCoord2fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress('glTexCoord2fNormal3fVertex3fvSUN');
+    if not Assigned(glTexCoord2fNormal3fVertex3fvSUN) then Exit;
+    @glTexCoord2fColor4fNormal3fVertex3fSUN := SDL_GL_GetProcAddress('glTexCoord2fColor4fNormal3fVertex3fSUN');
+    if not Assigned(glTexCoord2fColor4fNormal3fVertex3fSUN) then Exit;
+    @glTexCoord2fColor4fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress('glTexCoord2fColor4fNormal3fVertex3fvSUN');
+    if not Assigned(glTexCoord2fColor4fNormal3fVertex3fvSUN) then Exit;
+    @glTexCoord4fColor4fNormal3fVertex4fSUN := SDL_GL_GetProcAddress('glTexCoord4fColor4fNormal3fVertex4fSUN');
+    if not Assigned(glTexCoord4fColor4fNormal3fVertex4fSUN) then Exit;
+    @glTexCoord4fColor4fNormal3fVertex4fvSUN := SDL_GL_GetProcAddress('glTexCoord4fColor4fNormal3fVertex4fvSUN');
+    if not Assigned(glTexCoord4fColor4fNormal3fVertex4fvSUN) then Exit;
+    @glReplacementCodeuiVertex3fSUN := SDL_GL_GetProcAddress('glReplacementCodeuiVertex3fSUN');
+    if not Assigned(glReplacementCodeuiVertex3fSUN) then Exit;
+    @glReplacementCodeuiVertex3fvSUN := SDL_GL_GetProcAddress('glReplacementCodeuiVertex3fvSUN');
+    if not Assigned(glReplacementCodeuiVertex3fvSUN) then Exit;
+    @glReplacementCodeuiColor4ubVertex3fSUN := SDL_GL_GetProcAddress('glReplacementCodeuiColor4ubVertex3fSUN');
+    if not Assigned(glReplacementCodeuiColor4ubVertex3fSUN) then Exit;
+    @glReplacementCodeuiColor4ubVertex3fvSUN := SDL_GL_GetProcAddress('glReplacementCodeuiColor4ubVertex3fvSUN');
+    if not Assigned(glReplacementCodeuiColor4ubVertex3fvSUN) then Exit;
+    @glReplacementCodeuiColor3fVertex3fSUN := SDL_GL_GetProcAddress('glReplacementCodeuiColor3fVertex3fSUN');
+    if not Assigned(glReplacementCodeuiColor3fVertex3fSUN) then Exit;
+    @glReplacementCodeuiColor3fVertex3fvSUN := SDL_GL_GetProcAddress('glReplacementCodeuiColor3fVertex3fvSUN');
+    if not Assigned(glReplacementCodeuiColor3fVertex3fvSUN) then Exit;
+    @glReplacementCodeuiNormal3fVertex3fSUN := SDL_GL_GetProcAddress('glReplacementCodeuiNormal3fVertex3fSUN');
+    if not Assigned(glReplacementCodeuiNormal3fVertex3fSUN) then Exit;
+    @glReplacementCodeuiNormal3fVertex3fvSUN := SDL_GL_GetProcAddress('glReplacementCodeuiNormal3fVertex3fvSUN');
+    if not Assigned(glReplacementCodeuiNormal3fVertex3fvSUN) then Exit;
+    @glReplacementCodeuiColor4fNormal3fVertex3fSUN := SDL_GL_GetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fSUN');
+    if not Assigned(glReplacementCodeuiColor4fNormal3fVertex3fSUN) then Exit;
+    @glReplacementCodeuiColor4fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fvSUN');
+    if not Assigned(glReplacementCodeuiColor4fNormal3fVertex3fvSUN) then Exit;
+    @glReplacementCodeuiTexCoord2fVertex3fSUN := SDL_GL_GetProcAddress('glReplacementCodeuiTexCoord2fVertex3fSUN');
+    if not Assigned(glReplacementCodeuiTexCoord2fVertex3fSUN) then Exit;
+    @glReplacementCodeuiTexCoord2fVertex3fvSUN := SDL_GL_GetProcAddress('glReplacementCodeuiTexCoord2fVertex3fvSUN');
+    if not Assigned(glReplacementCodeuiTexCoord2fVertex3fvSUN) then Exit;
+    @glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN := SDL_GL_GetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN');
+    if not Assigned(glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN) then Exit;
+    @glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN');
+    if not Assigned(glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN) then Exit;
+    @glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN := SDL_GL_GetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN');
+    if not Assigned(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN) then Exit;
+    @glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN');
+    if not Assigned(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_fragment_program: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_fragment_program', extstring) then
+  begin
+    @glProgramStringARB := SDL_GL_GetProcAddress('glProgramStringARB');
+    if not Assigned(glProgramStringARB) then Exit;
+    @glBindProgramARB := SDL_GL_GetProcAddress('glBindProgramARB');
+    if not Assigned(glBindProgramARB) then Exit;
+    @glDeleteProgramsARB := SDL_GL_GetProcAddress('glDeleteProgramsARB');
+    if not Assigned(glDeleteProgramsARB) then Exit;
+    @glGenProgramsARB := SDL_GL_GetProcAddress('glGenProgramsARB');
+    if not Assigned(glGenProgramsARB) then Exit;
+    @glProgramEnvParameter4dARB := SDL_GL_GetProcAddress('glProgramEnvParameter4dARB');
+    if not Assigned(glProgramEnvParameter4dARB) then Exit;
+    @glProgramEnvParameter4dvARB := SDL_GL_GetProcAddress('glProgramEnvParameter4dvARB');
+    if not Assigned(glProgramEnvParameter4dvARB) then Exit;
+    @glProgramEnvParameter4fARB := SDL_GL_GetProcAddress('glProgramEnvParameter4fARB');
+    if not Assigned(glProgramEnvParameter4fARB) then Exit;
+    @glProgramEnvParameter4fvARB := SDL_GL_GetProcAddress('glProgramEnvParameter4fvARB');
+    if not Assigned(glProgramEnvParameter4fvARB) then Exit;
+    @glProgramLocalParameter4dARB := SDL_GL_GetProcAddress('glProgramLocalParameter4dARB');
+    if not Assigned(glProgramLocalParameter4dARB) then Exit;
+    @glProgramLocalParameter4dvARB := SDL_GL_GetProcAddress('glProgramLocalParameter4dvARB');
+    if not Assigned(glProgramLocalParameter4dvARB) then Exit;
+    @glProgramLocalParameter4fARB := SDL_GL_GetProcAddress('glProgramLocalParameter4fARB');
+    if not Assigned(glProgramLocalParameter4fARB) then Exit;
+    @glProgramLocalParameter4fvARB := SDL_GL_GetProcAddress('glProgramLocalParameter4fvARB');
+    if not Assigned(glProgramLocalParameter4fvARB) then Exit;
+    @glGetProgramEnvParameterdvARB := SDL_GL_GetProcAddress('glGetProgramEnvParameterdvARB');
+    if not Assigned(glGetProgramEnvParameterdvARB) then Exit;
+    @glGetProgramEnvParameterfvARB := SDL_GL_GetProcAddress('glGetProgramEnvParameterfvARB');
+    if not Assigned(glGetProgramEnvParameterfvARB) then Exit;
+    @glGetProgramLocalParameterdvARB := SDL_GL_GetProcAddress('glGetProgramLocalParameterdvARB');
+    if not Assigned(glGetProgramLocalParameterdvARB) then Exit;
+    @glGetProgramLocalParameterfvARB := SDL_GL_GetProcAddress('glGetProgramLocalParameterfvARB');
+    if not Assigned(glGetProgramLocalParameterfvARB) then Exit;
+    @glGetProgramivARB := SDL_GL_GetProcAddress('glGetProgramivARB');
+    if not Assigned(glGetProgramivARB) then Exit;
+    @glGetProgramStringARB := SDL_GL_GetProcAddress('glGetProgramStringARB');
+    if not Assigned(glGetProgramStringARB) then Exit;
+    @glIsProgramARB := SDL_GL_GetProcAddress('glIsProgramARB');
+    if not Assigned(glIsProgramARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_text_fragment_shader: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_text_fragment_shader', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_APPLE_client_storage: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_APPLE_client_storage', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_APPLE_element_array: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_APPLE_element_array', extstring) then
+  begin
+    @glElementPointerAPPLE := SDL_GL_GetProcAddress('glElementPointerAPPLE');
+    if not Assigned(glElementPointerAPPLE) then Exit;
+    @glDrawElementArrayAPPLE := SDL_GL_GetProcAddress('glDrawElementArrayAPPLE');
+    if not Assigned(glDrawElementArrayAPPLE) then Exit;
+    @glDrawRangeElementArrayAPPLE := SDL_GL_GetProcAddress('glDrawRangeElementArrayAPPLE');
+    if not Assigned(glDrawRangeElementArrayAPPLE) then Exit;
+    @glMultiDrawElementArrayAPPLE := SDL_GL_GetProcAddress('glMultiDrawElementArrayAPPLE');
+    if not Assigned(glMultiDrawElementArrayAPPLE) then Exit;
+    @glMultiDrawRangeElementArrayAPPLE := SDL_GL_GetProcAddress('glMultiDrawRangeElementArrayAPPLE');
+    if not Assigned(glMultiDrawRangeElementArrayAPPLE) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_APPLE_fence: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_APPLE_fence', extstring) then
+  begin
+    @glGenFencesAPPLE := SDL_GL_GetProcAddress('glGenFencesAPPLE');
+    if not Assigned(glGenFencesAPPLE) then Exit;
+    @glDeleteFencesAPPLE := SDL_GL_GetProcAddress('glDeleteFencesAPPLE');
+    if not Assigned(glDeleteFencesAPPLE) then Exit;
+    @glSetFenceAPPLE := SDL_GL_GetProcAddress('glSetFenceAPPLE');
+    if not Assigned(glSetFenceAPPLE) then Exit;
+    @glIsFenceAPPLE := SDL_GL_GetProcAddress('glIsFenceAPPLE');
+    if not Assigned(glIsFenceAPPLE) then Exit;
+    @glTestFenceAPPLE := SDL_GL_GetProcAddress('glTestFenceAPPLE');
+    if not Assigned(glTestFenceAPPLE) then Exit;
+    @glFinishFenceAPPLE := SDL_GL_GetProcAddress('glFinishFenceAPPLE');
+    if not Assigned(glFinishFenceAPPLE) then Exit;
+    @glTestObjectAPPLE := SDL_GL_GetProcAddress('glTestObjectAPPLE');
+    if not Assigned(glTestObjectAPPLE) then Exit;
+    @glFinishObjectAPPLE := SDL_GL_GetProcAddress('glFinishObjectAPPLE');
+    if not Assigned(glFinishObjectAPPLE) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_APPLE_vertex_array_object: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_APPLE_vertex_array_object', extstring) then
+  begin
+    @glBindVertexArrayAPPLE := SDL_GL_GetProcAddress('glBindVertexArrayAPPLE');
+    if not Assigned(glBindVertexArrayAPPLE) then Exit;
+    @glDeleteVertexArraysAPPLE := SDL_GL_GetProcAddress('glDeleteVertexArraysAPPLE');
+    if not Assigned(glDeleteVertexArraysAPPLE) then Exit;
+    @glGenVertexArraysAPPLE := SDL_GL_GetProcAddress('glGenVertexArraysAPPLE');
+    if not Assigned(glGenVertexArraysAPPLE) then Exit;
+    @glIsVertexArrayAPPLE := SDL_GL_GetProcAddress('glIsVertexArrayAPPLE');
+    if not Assigned(glIsVertexArrayAPPLE) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_APPLE_vertex_array_range: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_APPLE_vertex_array_range', extstring) then
+  begin
+    @glVertexArrayRangeAPPLE := SDL_GL_GetProcAddress('glVertexArrayRangeAPPLE');
+    if not Assigned(glVertexArrayRangeAPPLE) then Exit;
+    @glFlushVertexArrayRangeAPPLE := SDL_GL_GetProcAddress('glFlushVertexArrayRangeAPPLE');
+    if not Assigned(glFlushVertexArrayRangeAPPLE) then Exit;
+    @glVertexArrayParameteriAPPLE := SDL_GL_GetProcAddress('glVertexArrayParameteriAPPLE');
+    if not Assigned(glVertexArrayParameteriAPPLE) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+{$IFDEF WIN32}
+function Load_WGL_ARB_pixel_format: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_ARB_pixel_format', extstring) then
+  begin
+    @wglGetPixelFormatAttribivARB := SDL_GL_GetProcAddress('wglGetPixelFormatAttribivARB');
+    if not Assigned(wglGetPixelFormatAttribivARB) then Exit;
+    @wglGetPixelFormatAttribfvARB := SDL_GL_GetProcAddress('wglGetPixelFormatAttribfvARB');
+    if not Assigned(wglGetPixelFormatAttribfvARB) then Exit;
+    @wglChoosePixelFormatARB := SDL_GL_GetProcAddress('wglChoosePixelFormatARB');
+    if not Assigned(wglChoosePixelFormatARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_ARB_make_current_read: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_ARB_make_current_read', extstring) then
+  begin
+    @wglMakeContextCurrentARB := SDL_GL_GetProcAddress('wglMakeContextCurrentARB');
+    if not Assigned(wglMakeContextCurrentARB) then Exit;
+    @wglGetCurrentReadDCARB := SDL_GL_GetProcAddress('wglGetCurrentReadDCARB');
+    if not Assigned(wglGetCurrentReadDCARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_ARB_pbuffer: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_ARB_pbuffer', extstring) then
+  begin
+    @wglCreatePbufferARB := SDL_GL_GetProcAddress('wglCreatePbufferARB');
+    if not Assigned(wglCreatePbufferARB) then Exit;
+    @wglGetPbufferDCARB := SDL_GL_GetProcAddress('wglGetPbufferDCARB');
+    if not Assigned(wglGetPbufferDCARB) then Exit;
+    @wglReleasePbufferDCARB := SDL_GL_GetProcAddress('wglReleasePbufferDCARB');
+    if not Assigned(wglReleasePbufferDCARB) then Exit;
+    @wglDestroyPbufferARB := SDL_GL_GetProcAddress('wglDestroyPbufferARB');
+    if not Assigned(wglDestroyPbufferARB) then Exit;
+    @wglQueryPbufferARB := SDL_GL_GetProcAddress('wglQueryPbufferARB');
+    if not Assigned(wglQueryPbufferARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_EXT_swap_control: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_EXT_swap_control', extstring) then
+  begin
+    @wglSwapIntervalEXT := SDL_GL_GetProcAddress('wglSwapIntervalEXT');
+    if not Assigned(wglSwapIntervalEXT) then Exit;
+    @wglGetSwapIntervalEXT := SDL_GL_GetProcAddress('wglGetSwapIntervalEXT');
+    if not Assigned(wglGetSwapIntervalEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_ARB_render_texture: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_ARB_render_texture', extstring) then
+  begin
+    @wglBindTexImageARB := SDL_GL_GetProcAddress('wglBindTexImageARB');
+    if not Assigned(wglBindTexImageARB) then Exit;
+    @wglReleaseTexImageARB := SDL_GL_GetProcAddress('wglReleaseTexImageARB');
+    if not Assigned(wglReleaseTexImageARB) then Exit;
+    @wglSetPbufferAttribARB := SDL_GL_GetProcAddress('wglSetPbufferAttribARB');
+    if not Assigned(wglSetPbufferAttribARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_EXT_extensions_string: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_EXT_extensions_string', extstring) then
+  begin
+    @wglGetExtensionsStringEXT := SDL_GL_GetProcAddress('wglGetExtensionsStringEXT');
+    if not Assigned(wglGetExtensionsStringEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_EXT_make_current_read: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_EXT_make_current_read', extstring) then
+  begin
+    @wglMakeContextCurrentEXT := SDL_GL_GetProcAddress('wglMakeContextCurrentEXT');
+    if not Assigned(wglMakeContextCurrentEXT) then Exit;
+    @wglGetCurrentReadDCEXT := SDL_GL_GetProcAddress('wglGetCurrentReadDCEXT');
+    if not Assigned(wglGetCurrentReadDCEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_EXT_pbuffer: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_EXT_pbuffer', extstring) then
+  begin
+    @wglCreatePbufferEXT := SDL_GL_GetProcAddress('wglCreatePbufferEXT');
+    if not Assigned(wglCreatePbufferEXT) then Exit;
+    @wglGetPbufferDCEXT := SDL_GL_GetProcAddress('wglGetPbufferDCEXT');
+    if not Assigned(wglGetPbufferDCEXT) then Exit;
+    @wglReleasePbufferDCEXT := SDL_GL_GetProcAddress('wglReleasePbufferDCEXT');
+    if not Assigned(wglReleasePbufferDCEXT) then Exit;
+    @wglDestroyPbufferEXT := SDL_GL_GetProcAddress('wglDestroyPbufferEXT');
+    if not Assigned(wglDestroyPbufferEXT) then Exit;
+    @wglQueryPbufferEXT := SDL_GL_GetProcAddress('wglQueryPbufferEXT');
+    if not Assigned(wglQueryPbufferEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_EXT_pixel_format: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_EXT_pixel_format', extstring) then
+  begin
+    @wglGetPixelFormatAttribivEXT := SDL_GL_GetProcAddress('wglGetPixelFormatAttribivEXT');
+    if not Assigned(wglGetPixelFormatAttribivEXT) then Exit;
+    @wglGetPixelFormatAttribfvEXT := SDL_GL_GetProcAddress('wglGetPixelFormatAttribfvEXT');
+    if not Assigned(wglGetPixelFormatAttribfvEXT) then Exit;
+    @wglChoosePixelFormatEXT := SDL_GL_GetProcAddress('wglChoosePixelFormatEXT');
+    if not Assigned(wglChoosePixelFormatEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_I3D_digital_video_control: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_I3D_digital_video_control', extstring) then
+  begin
+    @wglGetDigitalVideoParametersI3D := SDL_GL_GetProcAddress('wglGetDigitalVideoParametersI3D');
+    if not Assigned(wglGetDigitalVideoParametersI3D) then Exit;
+    @wglSetDigitalVideoParametersI3D := SDL_GL_GetProcAddress('wglSetDigitalVideoParametersI3D');
+    if not Assigned(wglSetDigitalVideoParametersI3D) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_I3D_gamma: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_I3D_gamma', extstring) then
+  begin
+    @wglGetGammaTableParametersI3D := SDL_GL_GetProcAddress('wglGetGammaTableParametersI3D');
+    if not Assigned(wglGetGammaTableParametersI3D) then Exit;
+    @wglSetGammaTableParametersI3D := SDL_GL_GetProcAddress('wglSetGammaTableParametersI3D');
+    if not Assigned(wglSetGammaTableParametersI3D) then Exit;
+    @wglGetGammaTableI3D := SDL_GL_GetProcAddress('wglGetGammaTableI3D');
+    if not Assigned(wglGetGammaTableI3D) then Exit;
+    @wglSetGammaTableI3D := SDL_GL_GetProcAddress('wglSetGammaTableI3D');
+    if not Assigned(wglSetGammaTableI3D) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_WGL_I3D_genlock: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_I3D_genlock', extstring) then
+  begin
+    @wglEnableGenlockI3D := SDL_GL_GetProcAddress('wglEnableGenlockI3D');
+    if not Assigned(wglEnableGenlockI3D) then Exit;
+    @wglDisableGenlockI3D := SDL_GL_GetProcAddress('wglDisableGenlockI3D');
+    if not Assigned(wglDisableGenlockI3D) then Exit;
+    @wglIsEnabledGenlockI3D := SDL_GL_GetProcAddress('wglIsEnabledGenlockI3D');
+    if not Assigned(wglIsEnabledGenlockI3D) then Exit;
+    @wglGenlockSourceI3D := SDL_GL_GetProcAddress('wglGenlockSourceI3D');
+    if not Assigned(wglGenlockSourceI3D) then Exit;
+    @wglGetGenlockSourceI3D := SDL_GL_GetProcAddress('wglGetGenlockSourceI3D');
+    if not Assigned(wglGetGenlockSourceI3D) then Exit;
+    @wglGenlockSourceEdgeI3D := SDL_GL_GetProcAddress('wglGenlockSourceEdgeI3D');
+    if not Assigned(wglGenlockSourceEdgeI3D) then Exit;
+    @wglGetGenlockSourceEdgeI3D := SDL_GL_GetProcAddress('wglGetGenlockSourceEdgeI3D');
+    if not Assigned(wglGetGenlockSourceEdgeI3D) then Exit;
+    @wglGenlockSampleRateI3D := SDL_GL_GetProcAddress('wglGenlockSampleRateI3D');
+    if not Assigned(wglGenlockSampleRateI3D) then Exit;
+    @wglGetGenlockSampleRateI3D := SDL_GL_GetProcAddress('wglGetGenlockSampleRateI3D');
+    if not Assigned(wglGetGenlockSampleRateI3D) then Exit;
+    @wglGenlockSourceDelayI3D := SDL_GL_GetProcAddress('wglGenlockSourceDelayI3D');
+    if not Assigned(wglGenlockSourceDelayI3D) then Exit;
+    @wglGetGenlockSourceDelayI3D := SDL_GL_GetProcAddress('wglGetGenlockSourceDelayI3D');
+    if not Assigned(wglGetGenlockSourceDelayI3D) then Exit;
+    @wglQueryGenlockMaxSourceDelayI3D := SDL_GL_GetProcAddress('wglQueryGenlockMaxSourceDelayI3D');
+    if not Assigned(wglQueryGenlockMaxSourceDelayI3D) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+{$ENDIF}
+
+function Load_GL_ARB_matrix_palette: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_matrix_palette', extstring) then
+  begin
+    @glCurrentPaletteMatrixARB := SDL_GL_GetProcAddress('glCurrentPaletteMatrixARB');
+    if not Assigned(glCurrentPaletteMatrixARB) then Exit;
+    @glMatrixIndexubvARB := SDL_GL_GetProcAddress('glMatrixIndexubvARB');
+    if not Assigned(glMatrixIndexubvARB) then Exit;
+    @glMatrixIndexusvARB := SDL_GL_GetProcAddress('glMatrixIndexusvARB');
+    if not Assigned(glMatrixIndexusvARB) then Exit;
+    @glMatrixIndexuivARB := SDL_GL_GetProcAddress('glMatrixIndexuivARB');
+    if not Assigned(glMatrixIndexuivARB) then Exit;
+    @glMatrixIndexPointerARB := SDL_GL_GetProcAddress('glMatrixIndexPointerARB');
+    if not Assigned(glMatrixIndexPointerARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_element_array: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_element_array', extstring) then
+  begin
+    @glElementPointerNV := SDL_GL_GetProcAddress('glElementPointerNV');
+    if not Assigned(glElementPointerNV) then Exit;
+    @glDrawElementArrayNV := SDL_GL_GetProcAddress('glDrawElementArrayNV');
+    if not Assigned(glDrawElementArrayNV) then Exit;
+    @glDrawRangeElementArrayNV := SDL_GL_GetProcAddress('glDrawRangeElementArrayNV');
+    if not Assigned(glDrawRangeElementArrayNV) then Exit;
+    @glMultiDrawElementArrayNV := SDL_GL_GetProcAddress('glMultiDrawElementArrayNV');
+    if not Assigned(glMultiDrawElementArrayNV) then Exit;
+    @glMultiDrawRangeElementArrayNV := SDL_GL_GetProcAddress('glMultiDrawRangeElementArrayNV');
+    if not Assigned(glMultiDrawRangeElementArrayNV) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_float_buffer: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_float_buffer', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_fragment_program: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_fragment_program', extstring) then
+  begin
+    @glProgramNamedParameter4fNV := SDL_GL_GetProcAddress('glProgramNamedParameter4fNV');
+    if not Assigned(glProgramNamedParameter4fNV) then Exit;
+    @glProgramNamedParameter4dNV := SDL_GL_GetProcAddress('glProgramNamedParameter4dNV');
+    if not Assigned(glProgramNamedParameter4dNV) then Exit;
+    @glGetProgramNamedParameterfvNV := SDL_GL_GetProcAddress('glGetProgramNamedParameterfvNV');
+    if not Assigned(glGetProgramNamedParameterfvNV) then Exit;
+    @glGetProgramNamedParameterdvNV := SDL_GL_GetProcAddress('glGetProgramNamedParameterdvNV');
+    if not Assigned(glGetProgramNamedParameterdvNV) then Exit;
+    @glProgramLocalParameter4dARB := SDL_GL_GetProcAddress('glProgramLocalParameter4dARB');
+    if not Assigned(glProgramLocalParameter4dARB) then Exit;
+    @glProgramLocalParameter4dvARB := SDL_GL_GetProcAddress('glProgramLocalParameter4dvARB');
+    if not Assigned(glProgramLocalParameter4dvARB) then Exit;
+    @glProgramLocalParameter4fARB := SDL_GL_GetProcAddress('glProgramLocalParameter4fARB');
+    if not Assigned(glProgramLocalParameter4fARB) then Exit;
+    @glProgramLocalParameter4fvARB := SDL_GL_GetProcAddress('glProgramLocalParameter4fvARB');
+    if not Assigned(glProgramLocalParameter4fvARB) then Exit;
+    @glGetProgramLocalParameterdvARB := SDL_GL_GetProcAddress('glGetProgramLocalParameterdvARB');
+    if not Assigned(glGetProgramLocalParameterdvARB) then Exit;
+    @glGetProgramLocalParameterfvARB := SDL_GL_GetProcAddress('glGetProgramLocalParameterfvARB');
+    if not Assigned(glGetProgramLocalParameterfvARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_primitive_restart: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_primitive_restart', extstring) then
+  begin
+    @glPrimitiveRestartNV := SDL_GL_GetProcAddress('glPrimitiveRestartNV');
+    if not Assigned(glPrimitiveRestartNV) then Exit;
+    @glPrimitiveRestartIndexNV := SDL_GL_GetProcAddress('glPrimitiveRestartIndexNV');
+    if not Assigned(glPrimitiveRestartIndexNV) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_vertex_program2: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_vertex_program2', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+{$IFDEF WIN32}
+function Load_WGL_NV_render_texture_rectangle: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_NV_render_texture_rectangle', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+{$ENDIF}
+
+function Load_GL_NV_pixel_data_range: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_pixel_data_range', extstring) then
+  begin
+    @glPixelDataRangeNV := SDL_GL_GetProcAddress('glPixelDataRangeNV');
+    if not Assigned(glPixelDataRangeNV) then Exit;
+    @glFlushPixelDataRangeNV := SDL_GL_GetProcAddress('glFlushPixelDataRangeNV');
+    if not Assigned(glFlushPixelDataRangeNV) then Exit;
+    {$IFDEF WIN32}
+    @wglAllocateMemoryNV := SDL_GL_GetProcAddress('wglAllocateMemoryNV');
+    if not Assigned(wglAllocateMemoryNV) then Exit;
+    @wglFreeMemoryNV := SDL_GL_GetProcAddress('wglFreeMemoryNV');
+    if not Assigned(wglFreeMemoryNV) then Exit;
+    {$ENDIF}
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_texture_rectangle: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_texture_rectangle', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_S3_s3tc: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_S3_s3tc', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_draw_buffers: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_draw_buffers', extstring) then
+  begin
+    @glDrawBuffersATI := SDL_GL_GetProcAddress('glDrawBuffersATI');
+    if not Assigned(glDrawBuffersATI) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+{$IFDEF WIN32}
+function Load_WGL_ATI_pixel_format_float: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  @wglGetExtensionsStringARB := SDL_GL_GetProcAddress('wglGetExtensionsStringARB');
+  if not Assigned(wglGetExtensionsStringARB) then Exit;
+  extstring := wglGetExtensionsStringARB(wglGetCurrentDC);
+
+  if glext_ExtensionSupported('WGL_ATI_pixel_format_float', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+{$ENDIF}
+
+function Load_GL_ATI_texture_env_combine3: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_texture_env_combine3', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_texture_float: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_texture_float', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_texture_expand_normal: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_texture_expand_normal', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_half_float: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_half_float', extstring) then
+  begin
+    @glVertex2hNV := SDL_GL_GetProcAddress('glVertex2hNV');
+    if not Assigned(glVertex2hNV) then Exit;
+    @glVertex2hvNV := SDL_GL_GetProcAddress('glVertex2hvNV');
+    if not Assigned(glVertex2hvNV) then Exit;
+    @glVertex3hNV := SDL_GL_GetProcAddress('glVertex3hNV');
+    if not Assigned(glVertex3hNV) then Exit;
+    @glVertex3hvNV := SDL_GL_GetProcAddress('glVertex3hvNV');
+    if not Assigned(glVertex3hvNV) then Exit;
+    @glVertex4hNV := SDL_GL_GetProcAddress('glVertex4hNV');
+    if not Assigned(glVertex4hNV) then Exit;
+    @glVertex4hvNV := SDL_GL_GetProcAddress('glVertex4hvNV');
+    if not Assigned(glVertex4hvNV) then Exit;
+    @glNormal3hNV := SDL_GL_GetProcAddress('glNormal3hNV');
+    if not Assigned(glNormal3hNV) then Exit;
+    @glNormal3hvNV := SDL_GL_GetProcAddress('glNormal3hvNV');
+    if not Assigned(glNormal3hvNV) then Exit;
+    @glColor3hNV := SDL_GL_GetProcAddress('glColor3hNV');
+    if not Assigned(glColor3hNV) then Exit;
+    @glColor3hvNV := SDL_GL_GetProcAddress('glColor3hvNV');
+    if not Assigned(glColor3hvNV) then Exit;
+    @glColor4hNV := SDL_GL_GetProcAddress('glColor4hNV');
+    if not Assigned(glColor4hNV) then Exit;
+    @glColor4hvNV := SDL_GL_GetProcAddress('glColor4hvNV');
+    if not Assigned(glColor4hvNV) then Exit;
+    @glTexCoord1hNV := SDL_GL_GetProcAddress('glTexCoord1hNV');
+    if not Assigned(glTexCoord1hNV) then Exit;
+    @glTexCoord1hvNV := SDL_GL_GetProcAddress('glTexCoord1hvNV');
+    if not Assigned(glTexCoord1hvNV) then Exit;
+    @glTexCoord2hNV := SDL_GL_GetProcAddress('glTexCoord2hNV');
+    if not Assigned(glTexCoord2hNV) then Exit;
+    @glTexCoord2hvNV := SDL_GL_GetProcAddress('glTexCoord2hvNV');
+    if not Assigned(glTexCoord2hvNV) then Exit;
+    @glTexCoord3hNV := SDL_GL_GetProcAddress('glTexCoord3hNV');
+    if not Assigned(glTexCoord3hNV) then Exit;
+    @glTexCoord3hvNV := SDL_GL_GetProcAddress('glTexCoord3hvNV');
+    if not Assigned(glTexCoord3hvNV) then Exit;
+    @glTexCoord4hNV := SDL_GL_GetProcAddress('glTexCoord4hNV');
+    if not Assigned(glTexCoord4hNV) then Exit;
+    @glTexCoord4hvNV := SDL_GL_GetProcAddress('glTexCoord4hvNV');
+    if not Assigned(glTexCoord4hvNV) then Exit;
+    @glMultiTexCoord1hNV := SDL_GL_GetProcAddress('glMultiTexCoord1hNV');
+    if not Assigned(glMultiTexCoord1hNV) then Exit;
+    @glMultiTexCoord1hvNV := SDL_GL_GetProcAddress('glMultiTexCoord1hvNV');
+    if not Assigned(glMultiTexCoord1hvNV) then Exit;
+    @glMultiTexCoord2hNV := SDL_GL_GetProcAddress('glMultiTexCoord2hNV');
+    if not Assigned(glMultiTexCoord2hNV) then Exit;
+    @glMultiTexCoord2hvNV := SDL_GL_GetProcAddress('glMultiTexCoord2hvNV');
+    if not Assigned(glMultiTexCoord2hvNV) then Exit;
+    @glMultiTexCoord3hNV := SDL_GL_GetProcAddress('glMultiTexCoord3hNV');
+    if not Assigned(glMultiTexCoord3hNV) then Exit;
+    @glMultiTexCoord3hvNV := SDL_GL_GetProcAddress('glMultiTexCoord3hvNV');
+    if not Assigned(glMultiTexCoord3hvNV) then Exit;
+    @glMultiTexCoord4hNV := SDL_GL_GetProcAddress('glMultiTexCoord4hNV');
+    if not Assigned(glMultiTexCoord4hNV) then Exit;
+    @glMultiTexCoord4hvNV := SDL_GL_GetProcAddress('glMultiTexCoord4hvNV');
+    if not Assigned(glMultiTexCoord4hvNV) then Exit;
+    @glFogCoordhNV := SDL_GL_GetProcAddress('glFogCoordhNV');
+    if not Assigned(glFogCoordhNV) then Exit;
+    @glFogCoordhvNV := SDL_GL_GetProcAddress('glFogCoordhvNV');
+    if not Assigned(glFogCoordhvNV) then Exit;
+    @glSecondaryColor3hNV := SDL_GL_GetProcAddress('glSecondaryColor3hNV');
+    if not Assigned(glSecondaryColor3hNV) then Exit;
+    @glSecondaryColor3hvNV := SDL_GL_GetProcAddress('glSecondaryColor3hvNV');
+    if not Assigned(glSecondaryColor3hvNV) then Exit;
+    @glVertexWeighthNV := SDL_GL_GetProcAddress('glVertexWeighthNV');
+    if not Assigned(glVertexWeighthNV) then Exit;
+    @glVertexWeighthvNV := SDL_GL_GetProcAddress('glVertexWeighthvNV');
+    if not Assigned(glVertexWeighthvNV) then Exit;
+    @glVertexAttrib1hNV := SDL_GL_GetProcAddress('glVertexAttrib1hNV');
+    if not Assigned(glVertexAttrib1hNV) then Exit;
+    @glVertexAttrib1hvNV := SDL_GL_GetProcAddress('glVertexAttrib1hvNV');
+    if not Assigned(glVertexAttrib1hvNV) then Exit;
+    @glVertexAttrib2hNV := SDL_GL_GetProcAddress('glVertexAttrib2hNV');
+    if not Assigned(glVertexAttrib2hNV) then Exit;
+    @glVertexAttrib2hvNV := SDL_GL_GetProcAddress('glVertexAttrib2hvNV');
+    if not Assigned(glVertexAttrib2hvNV) then Exit;
+    @glVertexAttrib3hNV := SDL_GL_GetProcAddress('glVertexAttrib3hNV');
+    if not Assigned(glVertexAttrib3hNV) then Exit;
+    @glVertexAttrib3hvNV := SDL_GL_GetProcAddress('glVertexAttrib3hvNV');
+    if not Assigned(glVertexAttrib3hvNV) then Exit;
+    @glVertexAttrib4hNV := SDL_GL_GetProcAddress('glVertexAttrib4hNV');
+    if not Assigned(glVertexAttrib4hNV) then Exit;
+    @glVertexAttrib4hvNV := SDL_GL_GetProcAddress('glVertexAttrib4hvNV');
+    if not Assigned(glVertexAttrib4hvNV) then Exit;
+    @glVertexAttribs1hvNV := SDL_GL_GetProcAddress('glVertexAttribs1hvNV');
+    if not Assigned(glVertexAttribs1hvNV) then Exit;
+    @glVertexAttribs2hvNV := SDL_GL_GetProcAddress('glVertexAttribs2hvNV');
+    if not Assigned(glVertexAttribs2hvNV) then Exit;
+    @glVertexAttribs3hvNV := SDL_GL_GetProcAddress('glVertexAttribs3hvNV');
+    if not Assigned(glVertexAttribs3hvNV) then Exit;
+    @glVertexAttribs4hvNV := SDL_GL_GetProcAddress('glVertexAttribs4hvNV');
+    if not Assigned(glVertexAttribs4hvNV) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_map_object_buffer: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_map_object_buffer', extstring) then
+  begin
+    @glMapObjectBufferATI := SDL_GL_GetProcAddress('glMapObjectBufferATI');
+    if not Assigned(glMapObjectBufferATI) then Exit;
+    @glUnmapObjectBufferATI := SDL_GL_GetProcAddress('glUnmapObjectBufferATI');
+    if not Assigned(glUnmapObjectBufferATI) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_separate_stencil: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_separate_stencil', extstring) then
+  begin
+    @glStencilOpSeparateATI := SDL_GL_GetProcAddress('glStencilOpSeparateATI');
+    if not Assigned(glStencilOpSeparateATI) then Exit;
+    @glStencilFuncSeparateATI := SDL_GL_GetProcAddress('glStencilFuncSeparateATI');
+    if not Assigned(glStencilFuncSeparateATI) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ATI_vertex_attrib_array_object: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ATI_vertex_attrib_array_object', extstring) then
+  begin
+    @glVertexAttribArrayObjectATI := SDL_GL_GetProcAddress('glVertexAttribArrayObjectATI');
+    if not Assigned(glVertexAttribArrayObjectATI) then Exit;
+    @glGetVertexAttribArrayObjectfvATI := SDL_GL_GetProcAddress('glGetVertexAttribArrayObjectfvATI');
+    if not Assigned(glGetVertexAttribArrayObjectfvATI) then Exit;
+    @glGetVertexAttribArrayObjectivATI := SDL_GL_GetProcAddress('glGetVertexAttribArrayObjectivATI');
+    if not Assigned(glGetVertexAttribArrayObjectivATI) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_vertex_buffer_object: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_vertex_buffer_object', extstring) then
+  begin
+    @glBindBufferARB := SDL_GL_GetProcAddress('glBindBufferARB');
+    if not Assigned(glBindBufferARB) then Exit;
+    @glDeleteBuffersARB := SDL_GL_GetProcAddress('glDeleteBuffersARB');
+    if not Assigned(glDeleteBuffersARB) then Exit;
+    @glGenBuffersARB := SDL_GL_GetProcAddress('glGenBuffersARB');
+    if not Assigned(glGenBuffersARB) then Exit;
+    @glIsBufferARB := SDL_GL_GetProcAddress('glIsBufferARB');
+    if not Assigned(glIsBufferARB) then Exit;
+    @glBufferDataARB := SDL_GL_GetProcAddress('glBufferDataARB');
+    if not Assigned(glBufferDataARB) then Exit;
+    @glBufferSubDataARB := SDL_GL_GetProcAddress('glBufferSubDataARB');
+    if not Assigned(glBufferSubDataARB) then Exit;
+    @glGetBufferSubDataARB := SDL_GL_GetProcAddress('glGetBufferSubDataARB');
+    if not Assigned(glGetBufferSubDataARB) then Exit;
+    @glMapBufferARB := SDL_GL_GetProcAddress('glMapBufferARB');
+    if not Assigned(glMapBufferARB) then Exit;
+    @glUnmapBufferARB := SDL_GL_GetProcAddress('glUnmapBufferARB');
+    if not Assigned(glUnmapBufferARB) then Exit;
+    @glGetBufferParameterivARB := SDL_GL_GetProcAddress('glGetBufferParameterivARB');
+    if not Assigned(glGetBufferParameterivARB) then Exit;
+    @glGetBufferPointervARB := SDL_GL_GetProcAddress('glGetBufferPointervARB');
+    if not Assigned(glGetBufferPointervARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_occlusion_query: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_occlusion_query', extstring) then
+  begin
+    @glGenQueriesARB := SDL_GL_GetProcAddress('glGenQueriesARB');
+    if not Assigned(glGenQueriesARB) then Exit;
+    @glDeleteQueriesARB := SDL_GL_GetProcAddress('glDeleteQueriesARB');
+    if not Assigned(glDeleteQueriesARB) then Exit;
+    @glIsQueryARB := SDL_GL_GetProcAddress('glIsQueryARB');
+    if not Assigned(glIsQueryARB) then Exit;
+    @glBeginQueryARB := SDL_GL_GetProcAddress('glBeginQueryARB');
+    if not Assigned(glBeginQueryARB) then Exit;
+    @glEndQueryARB := SDL_GL_GetProcAddress('glEndQueryARB');
+    if not Assigned(glEndQueryARB) then Exit;
+    @glGetQueryivARB := SDL_GL_GetProcAddress('glGetQueryivARB');
+    if not Assigned(glGetQueryivARB) then Exit;
+    @glGetQueryObjectivARB := SDL_GL_GetProcAddress('glGetQueryObjectivARB');
+    if not Assigned(glGetQueryObjectivARB) then Exit;
+    @glGetQueryObjectuivARB := SDL_GL_GetProcAddress('glGetQueryObjectuivARB');
+    if not Assigned(glGetQueryObjectuivARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_shader_objects: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_shader_objects', extstring) then
+  begin
+    @glDeleteObjectARB := SDL_GL_GetProcAddress('glDeleteObjectARB');
+    if not Assigned(glDeleteObjectARB) then Exit;
+    @glGetHandleARB := SDL_GL_GetProcAddress('glGetHandleARB');
+    if not Assigned(glGetHandleARB) then Exit;
+    @glDetachObjectARB := SDL_GL_GetProcAddress('glDetachObjectARB');
+    if not Assigned(glDetachObjectARB) then Exit;
+    @glCreateShaderObjectARB := SDL_GL_GetProcAddress('glCreateShaderObjectARB');
+    if not Assigned(glCreateShaderObjectARB) then Exit;
+    @glShaderSourceARB := SDL_GL_GetProcAddress('glShaderSourceARB');
+    if not Assigned(glShaderSourceARB) then Exit;
+    @glCompileShaderARB := SDL_GL_GetProcAddress('glCompileShaderARB');
+    if not Assigned(glCompileShaderARB) then Exit;
+    @glCreateProgramObjectARB := SDL_GL_GetProcAddress('glCreateProgramObjectARB');
+    if not Assigned(glCreateProgramObjectARB) then Exit;
+    @glAttachObjectARB := SDL_GL_GetProcAddress('glAttachObjectARB');
+    if not Assigned(glAttachObjectARB) then Exit;
+    @glLinkProgramARB := SDL_GL_GetProcAddress('glLinkProgramARB');
+    if not Assigned(glLinkProgramARB) then Exit;
+    @glUseProgramObjectARB := SDL_GL_GetProcAddress('glUseProgramObjectARB');
+    if not Assigned(glUseProgramObjectARB) then Exit;
+    @glValidateProgramARB := SDL_GL_GetProcAddress('glValidateProgramARB');
+    if not Assigned(glValidateProgramARB) then Exit;
+    @glUniform1fARB := SDL_GL_GetProcAddress('glUniform1fARB');
+    if not Assigned(glUniform1fARB) then Exit;
+    @glUniform2fARB := SDL_GL_GetProcAddress('glUniform2fARB');
+    if not Assigned(glUniform2fARB) then Exit;
+    @glUniform3fARB := SDL_GL_GetProcAddress('glUniform3fARB');
+    if not Assigned(glUniform3fARB) then Exit;
+    @glUniform4fARB := SDL_GL_GetProcAddress('glUniform4fARB');
+    if not Assigned(glUniform4fARB) then Exit;
+    @glUniform1iARB := SDL_GL_GetProcAddress('glUniform1iARB');
+    if not Assigned(glUniform1iARB) then Exit;
+    @glUniform2iARB := SDL_GL_GetProcAddress('glUniform2iARB');
+    if not Assigned(glUniform2iARB) then Exit;
+    @glUniform3iARB := SDL_GL_GetProcAddress('glUniform3iARB');
+    if not Assigned(glUniform3iARB) then Exit;
+    @glUniform4iARB := SDL_GL_GetProcAddress('glUniform4iARB');
+    if not Assigned(glUniform4iARB) then Exit;
+    @glUniform1fvARB := SDL_GL_GetProcAddress('glUniform1fvARB');
+    if not Assigned(glUniform1fvARB) then Exit;
+    @glUniform2fvARB := SDL_GL_GetProcAddress('glUniform2fvARB');
+    if not Assigned(glUniform2fvARB) then Exit;
+    @glUniform3fvARB := SDL_GL_GetProcAddress('glUniform3fvARB');
+    if not Assigned(glUniform3fvARB) then Exit;
+    @glUniform4fvARB := SDL_GL_GetProcAddress('glUniform4fvARB');
+    if not Assigned(glUniform4fvARB) then Exit;
+    @glUniform1ivARB := SDL_GL_GetProcAddress('glUniform1ivARB');
+    if not Assigned(glUniform1ivARB) then Exit;
+    @glUniform2ivARB := SDL_GL_GetProcAddress('glUniform2ivARB');
+    if not Assigned(glUniform2ivARB) then Exit;
+    @glUniform3ivARB := SDL_GL_GetProcAddress('glUniform3ivARB');
+    if not Assigned(glUniform3ivARB) then Exit;
+    @glUniform4ivARB := SDL_GL_GetProcAddress('glUniform4ivARB');
+    if not Assigned(glUniform4ivARB) then Exit;
+    @glUniformMatrix2fvARB := SDL_GL_GetProcAddress('glUniformMatrix2fvARB');
+    if not Assigned(glUniformMatrix2fvARB) then Exit;
+    @glUniformMatrix3fvARB := SDL_GL_GetProcAddress('glUniformMatrix3fvARB');
+    if not Assigned(glUniformMatrix3fvARB) then Exit;
+    @glUniformMatrix4fvARB := SDL_GL_GetProcAddress('glUniformMatrix4fvARB');
+    if not Assigned(glUniformMatrix4fvARB) then Exit;
+    @glGetObjectParameterfvARB := SDL_GL_GetProcAddress('glGetObjectParameterfvARB');
+    if not Assigned(glGetObjectParameterfvARB) then Exit;
+    @glGetObjectParameterivARB := SDL_GL_GetProcAddress('glGetObjectParameterivARB');
+    if not Assigned(glGetObjectParameterivARB) then Exit;
+    @glGetInfoLogARB := SDL_GL_GetProcAddress('glGetInfoLogARB');
+    if not Assigned(glGetInfoLogARB) then Exit;
+    @glGetAttachedObjectsARB := SDL_GL_GetProcAddress('glGetAttachedObjectsARB');
+    if not Assigned(glGetAttachedObjectsARB) then Exit;
+    @glGetUniformLocationARB := SDL_GL_GetProcAddress('glGetUniformLocationARB');
+    if not Assigned(glGetUniformLocationARB) then Exit;
+    @glGetActiveUniformARB := SDL_GL_GetProcAddress('glGetActiveUniformARB');
+    if not Assigned(glGetActiveUniformARB) then Exit;
+    @glGetUniformfvARB := SDL_GL_GetProcAddress('glGetUniformfvARB');
+    if not Assigned(glGetUniformfvARB) then Exit;
+    @glGetUniformivARB := SDL_GL_GetProcAddress('glGetUniformivARB');
+    if not Assigned(glGetUniformivARB) then Exit;
+    @glGetShaderSourceARB := SDL_GL_GetProcAddress('glGetShaderSourceARB');
+    if not Assigned(glGetShaderSourceARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_vertex_shader: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_vertex_shader', extstring) then
+  begin
+    @glVertexAttrib1fARB := SDL_GL_GetProcAddress('glVertexAttrib1fARB');
+    if not Assigned(glVertexAttrib1fARB) then Exit;
+    @glVertexAttrib1sARB := SDL_GL_GetProcAddress('glVertexAttrib1sARB');
+    if not Assigned(glVertexAttrib1sARB) then Exit;
+    @glVertexAttrib1dARB := SDL_GL_GetProcAddress('glVertexAttrib1dARB');
+    if not Assigned(glVertexAttrib1dARB) then Exit;
+    @glVertexAttrib2fARB := SDL_GL_GetProcAddress('glVertexAttrib2fARB');
+    if not Assigned(glVertexAttrib2fARB) then Exit;
+    @glVertexAttrib2sARB := SDL_GL_GetProcAddress('glVertexAttrib2sARB');
+    if not Assigned(glVertexAttrib2sARB) then Exit;
+    @glVertexAttrib2dARB := SDL_GL_GetProcAddress('glVertexAttrib2dARB');
+    if not Assigned(glVertexAttrib2dARB) then Exit;
+    @glVertexAttrib3fARB := SDL_GL_GetProcAddress('glVertexAttrib3fARB');
+    if not Assigned(glVertexAttrib3fARB) then Exit;
+    @glVertexAttrib3sARB := SDL_GL_GetProcAddress('glVertexAttrib3sARB');
+    if not Assigned(glVertexAttrib3sARB) then Exit;
+    @glVertexAttrib3dARB := SDL_GL_GetProcAddress('glVertexAttrib3dARB');
+    if not Assigned(glVertexAttrib3dARB) then Exit;
+    @glVertexAttrib4fARB := SDL_GL_GetProcAddress('glVertexAttrib4fARB');
+    if not Assigned(glVertexAttrib4fARB) then Exit;
+    @glVertexAttrib4sARB := SDL_GL_GetProcAddress('glVertexAttrib4sARB');
+    if not Assigned(glVertexAttrib4sARB) then Exit;
+    @glVertexAttrib4dARB := SDL_GL_GetProcAddress('glVertexAttrib4dARB');
+    if not Assigned(glVertexAttrib4dARB) then Exit;
+    @glVertexAttrib4NubARB := SDL_GL_GetProcAddress('glVertexAttrib4NubARB');
+    if not Assigned(glVertexAttrib4NubARB) then Exit;
+    @glVertexAttrib1fvARB := SDL_GL_GetProcAddress('glVertexAttrib1fvARB');
+    if not Assigned(glVertexAttrib1fvARB) then Exit;
+    @glVertexAttrib1svARB := SDL_GL_GetProcAddress('glVertexAttrib1svARB');
+    if not Assigned(glVertexAttrib1svARB) then Exit;
+    @glVertexAttrib1dvARB := SDL_GL_GetProcAddress('glVertexAttrib1dvARB');
+    if not Assigned(glVertexAttrib1dvARB) then Exit;
+    @glVertexAttrib2fvARB := SDL_GL_GetProcAddress('glVertexAttrib2fvARB');
+    if not Assigned(glVertexAttrib2fvARB) then Exit;
+    @glVertexAttrib2svARB := SDL_GL_GetProcAddress('glVertexAttrib2svARB');
+    if not Assigned(glVertexAttrib2svARB) then Exit;
+    @glVertexAttrib2dvARB := SDL_GL_GetProcAddress('glVertexAttrib2dvARB');
+    if not Assigned(glVertexAttrib2dvARB) then Exit;
+    @glVertexAttrib3fvARB := SDL_GL_GetProcAddress('glVertexAttrib3fvARB');
+    if not Assigned(glVertexAttrib3fvARB) then Exit;
+    @glVertexAttrib3svARB := SDL_GL_GetProcAddress('glVertexAttrib3svARB');
+    if not Assigned(glVertexAttrib3svARB) then Exit;
+    @glVertexAttrib3dvARB := SDL_GL_GetProcAddress('glVertexAttrib3dvARB');
+    if not Assigned(glVertexAttrib3dvARB) then Exit;
+    @glVertexAttrib4fvARB := SDL_GL_GetProcAddress('glVertexAttrib4fvARB');
+    if not Assigned(glVertexAttrib4fvARB) then Exit;
+    @glVertexAttrib4svARB := SDL_GL_GetProcAddress('glVertexAttrib4svARB');
+    if not Assigned(glVertexAttrib4svARB) then Exit;
+    @glVertexAttrib4dvARB := SDL_GL_GetProcAddress('glVertexAttrib4dvARB');
+    if not Assigned(glVertexAttrib4dvARB) then Exit;
+    @glVertexAttrib4ivARB := SDL_GL_GetProcAddress('glVertexAttrib4ivARB');
+    if not Assigned(glVertexAttrib4ivARB) then Exit;
+    @glVertexAttrib4bvARB := SDL_GL_GetProcAddress('glVertexAttrib4bvARB');
+    if not Assigned(glVertexAttrib4bvARB) then Exit;
+    @glVertexAttrib4ubvARB := SDL_GL_GetProcAddress('glVertexAttrib4ubvARB');
+    if not Assigned(glVertexAttrib4ubvARB) then Exit;
+    @glVertexAttrib4usvARB := SDL_GL_GetProcAddress('glVertexAttrib4usvARB');
+    if not Assigned(glVertexAttrib4usvARB) then Exit;
+    @glVertexAttrib4uivARB := SDL_GL_GetProcAddress('glVertexAttrib4uivARB');
+    if not Assigned(glVertexAttrib4uivARB) then Exit;
+    @glVertexAttrib4NbvARB := SDL_GL_GetProcAddress('glVertexAttrib4NbvARB');
+    if not Assigned(glVertexAttrib4NbvARB) then Exit;
+    @glVertexAttrib4NsvARB := SDL_GL_GetProcAddress('glVertexAttrib4NsvARB');
+    if not Assigned(glVertexAttrib4NsvARB) then Exit;
+    @glVertexAttrib4NivARB := SDL_GL_GetProcAddress('glVertexAttrib4NivARB');
+    if not Assigned(glVertexAttrib4NivARB) then Exit;
+    @glVertexAttrib4NubvARB := SDL_GL_GetProcAddress('glVertexAttrib4NubvARB');
+    if not Assigned(glVertexAttrib4NubvARB) then Exit;
+    @glVertexAttrib4NusvARB := SDL_GL_GetProcAddress('glVertexAttrib4NusvARB');
+    if not Assigned(glVertexAttrib4NusvARB) then Exit;
+    @glVertexAttrib4NuivARB := SDL_GL_GetProcAddress('glVertexAttrib4NuivARB');
+    if not Assigned(glVertexAttrib4NuivARB) then Exit;
+    @glVertexAttribPointerARB := SDL_GL_GetProcAddress('glVertexAttribPointerARB');
+    if not Assigned(glVertexAttribPointerARB) then Exit;
+    @glEnableVertexAttribArrayARB := SDL_GL_GetProcAddress('glEnableVertexAttribArrayARB');
+    if not Assigned(glEnableVertexAttribArrayARB) then Exit;
+    @glDisableVertexAttribArrayARB := SDL_GL_GetProcAddress('glDisableVertexAttribArrayARB');
+    if not Assigned(glDisableVertexAttribArrayARB) then Exit;
+    @glBindAttribLocationARB := SDL_GL_GetProcAddress('glBindAttribLocationARB');
+    if not Assigned(glBindAttribLocationARB) then Exit;
+    @glGetActiveAttribARB := SDL_GL_GetProcAddress('glGetActiveAttribARB');
+    if not Assigned(glGetActiveAttribARB) then Exit;
+    @glGetAttribLocationARB := SDL_GL_GetProcAddress('glGetAttribLocationARB');
+    if not Assigned(glGetAttribLocationARB) then Exit;
+    @glGetVertexAttribdvARB := SDL_GL_GetProcAddress('glGetVertexAttribdvARB');
+    if not Assigned(glGetVertexAttribdvARB) then Exit;
+    @glGetVertexAttribfvARB := SDL_GL_GetProcAddress('glGetVertexAttribfvARB');
+    if not Assigned(glGetVertexAttribfvARB) then Exit;
+    @glGetVertexAttribivARB := SDL_GL_GetProcAddress('glGetVertexAttribivARB');
+    if not Assigned(glGetVertexAttribivARB) then Exit;
+    @glGetVertexAttribPointervARB := SDL_GL_GetProcAddress('glGetVertexAttribPointervARB');
+    if not Assigned(glGetVertexAttribPointervARB) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_fragment_shader: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_fragment_shader', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_shading_language_100: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_shading_language_100', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_texture_non_power_of_two: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_texture_non_power_of_two', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_point_sprite: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_point_sprite', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_depth_bounds_test: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_depth_bounds_test', extstring) then
+  begin
+    @glDepthBoundsEXT := SDL_GL_GetProcAddress('glDepthBoundsEXT');
+    if not Assigned(glDepthBoundsEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_secondary_color: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_secondary_color', extstring) then
+  begin
+    @glSecondaryColor3bEXT := SDL_GL_GetProcAddress('glSecondaryColor3bEXT');
+    if not Assigned(glSecondaryColor3bEXT) then Exit;
+    @glSecondaryColor3sEXT := SDL_GL_GetProcAddress('glSecondaryColor3sEXT');
+    if not Assigned(glSecondaryColor3sEXT) then Exit;
+    @glSecondaryColor3iEXT := SDL_GL_GetProcAddress('glSecondaryColor3iEXT');
+    if not Assigned(glSecondaryColor3iEXT) then Exit;
+    @glSecondaryColor3fEXT := SDL_GL_GetProcAddress('glSecondaryColor3fEXT');
+    if not Assigned(glSecondaryColor3fEXT) then Exit;
+    @glSecondaryColor3dEXT := SDL_GL_GetProcAddress('glSecondaryColor3dEXT');
+    if not Assigned(glSecondaryColor3dEXT) then Exit;
+    @glSecondaryColor3ubEXT := SDL_GL_GetProcAddress('glSecondaryColor3ubEXT');
+    if not Assigned(glSecondaryColor3ubEXT) then Exit;
+    @glSecondaryColor3usEXT := SDL_GL_GetProcAddress('glSecondaryColor3usEXT');
+    if not Assigned(glSecondaryColor3usEXT) then Exit;
+    @glSecondaryColor3uiEXT := SDL_GL_GetProcAddress('glSecondaryColor3uiEXT');
+    if not Assigned(glSecondaryColor3uiEXT) then Exit;
+    @glSecondaryColor3bvEXT := SDL_GL_GetProcAddress('glSecondaryColor3bvEXT');
+    if not Assigned(glSecondaryColor3bvEXT) then Exit;
+    @glSecondaryColor3svEXT := SDL_GL_GetProcAddress('glSecondaryColor3svEXT');
+    if not Assigned(glSecondaryColor3svEXT) then Exit;
+    @glSecondaryColor3ivEXT := SDL_GL_GetProcAddress('glSecondaryColor3ivEXT');
+    if not Assigned(glSecondaryColor3ivEXT) then Exit;
+    @glSecondaryColor3fvEXT := SDL_GL_GetProcAddress('glSecondaryColor3fvEXT');
+    if not Assigned(glSecondaryColor3fvEXT) then Exit;
+    @glSecondaryColor3dvEXT := SDL_GL_GetProcAddress('glSecondaryColor3dvEXT');
+    if not Assigned(glSecondaryColor3dvEXT) then Exit;
+    @glSecondaryColor3ubvEXT := SDL_GL_GetProcAddress('glSecondaryColor3ubvEXT');
+    if not Assigned(glSecondaryColor3ubvEXT) then Exit;
+    @glSecondaryColor3usvEXT := SDL_GL_GetProcAddress('glSecondaryColor3usvEXT');
+    if not Assigned(glSecondaryColor3usvEXT) then Exit;
+    @glSecondaryColor3uivEXT := SDL_GL_GetProcAddress('glSecondaryColor3uivEXT');
+    if not Assigned(glSecondaryColor3uivEXT) then Exit;
+    @glSecondaryColorPointerEXT := SDL_GL_GetProcAddress('glSecondaryColorPointerEXT');
+    if not Assigned(glSecondaryColorPointerEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_texture_mirror_clamp: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_texture_mirror_clamp', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_blend_equation_separate: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_blend_equation_separate', extstring) then
+  begin
+    @glBlendEquationSeparateEXT := SDL_GL_GetProcAddress('glBlendEquationSeparateEXT');
+    if not Assigned(glBlendEquationSeparateEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_MESA_pack_invert: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_MESA_pack_invert', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_MESA_ycbcr_texture: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_MESA_ycbcr_texture', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_ARB_fragment_program_shadow: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_ARB_fragment_program_shadow', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_fog_coord: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_fog_coord', extstring) then
+  begin
+    @glFogCoordfEXT := SDL_GL_GetProcAddress('glFogCoordfEXT');
+    if not Assigned(glFogCoordfEXT) then Exit;
+    @glFogCoorddEXT := SDL_GL_GetProcAddress('glFogCoorddEXT');
+    if not Assigned(glFogCoorddEXT) then Exit;
+    @glFogCoordfvEXT := SDL_GL_GetProcAddress('glFogCoordfvEXT');
+    if not Assigned(glFogCoordfvEXT) then Exit;
+    @glFogCoorddvEXT := SDL_GL_GetProcAddress('glFogCoorddvEXT');
+    if not Assigned(glFogCoorddvEXT) then Exit;
+    @glFogCoordPointerEXT := SDL_GL_GetProcAddress('glFogCoordPointerEXT');
+    if not Assigned(glFogCoordPointerEXT) then Exit;
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_fragment_program_option: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_fragment_program_option', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_EXT_pixel_buffer_object: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_EXT_pixel_buffer_object', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_fragment_program2: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_fragment_program2', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_vertex_program2_option: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_vertex_program2_option', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function Load_GL_NV_vertex_program3: Boolean;
+var
+  extstring : PChar;
+begin
+
+  Result := FALSE;
+  extstring := glGetString( GL_EXTENSIONS );
+
+  if glext_ExtensionSupported('GL_NV_vertex_program3', extstring) then
+  begin
+    Result := TRUE;
+  end;
+
+end;
+
+function glext_LoadExtension(ext: PChar): Boolean;
+begin
+
+  Result := FALSE;
+
+  if ext = 'GL_version_1_2' then Result := Load_GL_version_1_2
+  else if ext = 'GL_ARB_imaging' then Result := Load_GL_ARB_imaging
+  else if ext = 'GL_version_1_3' then Result := Load_GL_version_1_3
+  else if ext = 'GL_ARB_multitexture' then Result := Load_GL_ARB_multitexture
+  else if ext = 'GL_ARB_transpose_matrix' then Result := Load_GL_ARB_transpose_matrix
+  else if ext = 'GL_ARB_multisample' then Result := Load_GL_ARB_multisample
+  else if ext = 'GL_ARB_texture_env_add' then Result := Load_GL_ARB_texture_env_add
+  {$IFDEF WIN32}
+  else if ext = 'WGL_ARB_extensions_string' then Result := Load_WGL_ARB_extensions_string
+  else if ext = 'WGL_ARB_buffer_region' then Result := Load_WGL_ARB_buffer_region
+  {$ENDIF}
+  else if ext = 'GL_ARB_texture_cube_map' then Result := Load_GL_ARB_texture_cube_map
+  else if ext = 'GL_ARB_depth_texture' then Result := Load_GL_ARB_depth_texture
+  else if ext = 'GL_ARB_point_parameters' then Result := Load_GL_ARB_point_parameters
+  else if ext = 'GL_ARB_shadow' then Result := Load_GL_ARB_shadow
+  else if ext = 'GL_ARB_shadow_ambient' then Result := Load_GL_ARB_shadow_ambient
+  else if ext = 'GL_ARB_texture_border_clamp' then Result := Load_GL_ARB_texture_border_clamp
+  else if ext = 'GL_ARB_texture_compression' then Result := Load_GL_ARB_texture_compression
+  else if ext = 'GL_ARB_texture_env_combine' then Result := Load_GL_ARB_texture_env_combine
+  else if ext = 'GL_ARB_texture_env_crossbar' then Result := Load_GL_ARB_texture_env_crossbar
+  else if ext = 'GL_ARB_texture_env_dot3' then Result := Load_GL_ARB_texture_env_dot3
+  else if ext = 'GL_ARB_texture_mirrored_repeat' then Result := Load_GL_ARB_texture_mirrored_repeat
+  else if ext = 'GL_ARB_vertex_blend' then Result := Load_GL_ARB_vertex_blend
+  else if ext = 'GL_ARB_vertex_program' then Result := Load_GL_ARB_vertex_program
+  else if ext = 'GL_ARB_window_pos' then Result := Load_GL_ARB_window_pos
+  else if ext = 'GL_EXT_422_pixels' then Result := Load_GL_EXT_422_pixels
+  else if ext = 'GL_EXT_abgr' then Result := Load_GL_EXT_abgr
+  else if ext = 'GL_EXT_bgra' then Result := Load_GL_EXT_bgra
+  else if ext = 'GL_EXT_blend_color' then Result := Load_GL_EXT_blend_color
+  else if ext = 'GL_EXT_blend_func_separate' then Result := Load_GL_EXT_blend_func_separate
+  else if ext = 'GL_EXT_blend_logic_op' then Result := Load_GL_EXT_blend_logic_op
+  else if ext = 'GL_EXT_blend_minmax' then Result := Load_GL_EXT_blend_minmax
+  else if ext = 'GL_EXT_blend_subtract' then Result := Load_GL_EXT_blend_subtract
+  else if ext = 'GL_EXT_clip_volume_hint' then Result := Load_GL_EXT_clip_volume_hint
+  else if ext = 'GL_EXT_color_subtable' then Result := Load_GL_EXT_color_subtable
+  else if ext = 'GL_EXT_compiled_vertex_array' then Result := Load_GL_EXT_compiled_vertex_array
+  else if ext = 'GL_EXT_convolution' then Result := Load_GL_EXT_convolution
+  else if ext = 'GL_EXT_histogram' then Result := Load_GL_EXT_histogram
+  else if ext = 'GL_EXT_multi_draw_arrays' then Result := Load_GL_EXT_multi_draw_arrays
+  else if ext = 'GL_EXT_packed_pixels' then Result := Load_GL_EXT_packed_pixels
+  else if ext = 'GL_EXT_paletted_texture' then Result := Load_GL_EXT_paletted_texture
+  else if ext = 'GL_EXT_point_parameters' then Result := Load_GL_EXT_point_parameters
+  else if ext = 'GL_EXT_polygon_offset' then Result := Load_GL_EXT_polygon_offset
+  else if ext = 'GL_EXT_separate_specular_color' then Result := Load_GL_EXT_separate_specular_color
+  else if ext = 'GL_EXT_shadow_funcs' then Result := Load_GL_EXT_shadow_funcs
+  else if ext = 'GL_EXT_shared_texture_palette' then Result := Load_GL_EXT_shared_texture_palette
+  else if ext = 'GL_EXT_stencil_two_side' then Result := Load_GL_EXT_stencil_two_side
+  else if ext = 'GL_EXT_stencil_wrap' then Result := Load_GL_EXT_stencil_wrap
+  else if ext = 'GL_EXT_subtexture' then Result := Load_GL_EXT_subtexture
+  else if ext = 'GL_EXT_texture3D' then Result := Load_GL_EXT_texture3D
+  else if ext = 'GL_EXT_texture_compression_s3tc' then Result := Load_GL_EXT_texture_compression_s3tc
+  else if ext = 'GL_EXT_texture_env_add' then Result := Load_GL_EXT_texture_env_add
+  else if ext = 'GL_EXT_texture_env_combine' then Result := Load_GL_EXT_texture_env_combine
+  else if ext = 'GL_EXT_texture_env_dot3' then Result := Load_GL_EXT_texture_env_dot3
+  else if ext = 'GL_EXT_texture_filter_anisotropic' then Result := Load_GL_EXT_texture_filter_anisotropic
+  else if ext = 'GL_EXT_texture_lod_bias' then Result := Load_GL_EXT_texture_lod_bias
+  else if ext = 'GL_EXT_texture_object' then Result := Load_GL_EXT_texture_object
+  else if ext = 'GL_EXT_vertex_array' then Result := Load_GL_EXT_vertex_array
+  else if ext = 'GL_EXT_vertex_shader' then Result := Load_GL_EXT_vertex_shader
+  else if ext = 'GL_EXT_vertex_weighting' then Result := Load_GL_EXT_vertex_weighting
+  else if ext = 'GL_HP_occlusion_test' then Result := Load_GL_HP_occlusion_test
+  else if ext = 'GL_NV_blend_square' then Result := Load_GL_NV_blend_square
+  else if ext = 'GL_NV_copy_depth_to_color' then Result := Load_GL_NV_copy_depth_to_color
+  else if ext = 'GL_NV_depth_clamp' then Result := Load_GL_NV_depth_clamp
+  else if ext = 'GL_NV_evaluators' then Result := Load_GL_NV_evaluators
+  else if ext = 'GL_NV_fence' then Result := Load_GL_NV_fence
+  else if ext = 'GL_NV_fog_distance' then Result := Load_GL_NV_fog_distance
+  else if ext = 'GL_NV_light_max_exponent' then Result := Load_GL_NV_light_max_exponent
+  else if ext = 'GL_NV_multisample_filter_hint' then Result := Load_GL_NV_multisample_filter_hint
+  else if ext = 'GL_NV_occlusion_query' then Result := Load_GL_NV_occlusion_query
+  else if ext = 'GL_NV_packed_depth_stencil' then Result := Load_GL_NV_packed_depth_stencil
+  else if ext = 'GL_NV_point_sprite' then Result := Load_GL_NV_point_sprite
+  else if ext = 'GL_NV_register_combiners' then Result := Load_GL_NV_register_combiners
+  else if ext = 'GL_NV_register_combiners2' then Result := Load_GL_NV_register_combiners2
+  else if ext = 'GL_NV_texgen_emboss' then Result := Load_GL_NV_texgen_emboss
+  else if ext = 'GL_NV_texgen_reflection' then Result := Load_GL_NV_texgen_reflection
+  else if ext = 'GL_NV_texture_compression_vtc' then Result := Load_GL_NV_texture_compression_vtc
+  else if ext = 'GL_NV_texture_env_combine4' then Result := Load_GL_NV_texture_env_combine4
+  else if ext = 'GL_NV_texture_rectangle' then Result := Load_GL_NV_texture_rectangle
+  else if ext = 'GL_NV_texture_shader' then Result := Load_GL_NV_texture_shader
+  else if ext = 'GL_NV_texture_shader2' then Result := Load_GL_NV_texture_shader2
+  else if ext = 'GL_NV_texture_shader3' then Result := Load_GL_NV_texture_shader3
+  else if ext = 'GL_NV_vertex_array_range' then Result := Load_GL_NV_vertex_array_range
+  else if ext = 'GL_NV_vertex_array_range2' then Result := Load_GL_NV_vertex_array_range2
+  else if ext = 'GL_NV_vertex_program' then Result := Load_GL_NV_vertex_program
+  else if ext = 'GL_NV_vertex_program1_1' then Result := Load_GL_NV_vertex_program1_1
+  else if ext = 'GL_ATI_element_array' then Result := Load_GL_ATI_element_array
+  else if ext = 'GL_ATI_envmap_bumpmap' then Result := Load_GL_ATI_envmap_bumpmap
+  else if ext = 'GL_ATI_fragment_shader' then Result := Load_GL_ATI_fragment_shader
+  else if ext = 'GL_ATI_pn_triangles' then Result := Load_GL_ATI_pn_triangles
+  else if ext = 'GL_ATI_texture_mirror_once' then Result := Load_GL_ATI_texture_mirror_once
+  else if ext = 'GL_ATI_vertex_array_object' then Result := Load_GL_ATI_vertex_array_object
+  else if ext = 'GL_ATI_vertex_streams' then Result := Load_GL_ATI_vertex_streams
+  {$IFDEF WIN32}
+  else if ext = 'WGL_I3D_image_buffer' then Result := Load_WGL_I3D_image_buffer
+  else if ext = 'WGL_I3D_swap_frame_lock' then Result := Load_WGL_I3D_swap_frame_lock
+  else if ext = 'WGL_I3D_swap_frame_usage' then Result := Load_WGL_I3D_swap_frame_usage
+  {$ENDIF}
+  else if ext = 'GL_3DFX_texture_compression_FXT1' then Result := Load_GL_3DFX_texture_compression_FXT1
+  else if ext = 'GL_IBM_cull_vertex' then Result := Load_GL_IBM_cull_vertex
+  else if ext = 'GL_IBM_multimode_draw_arrays' then Result := Load_GL_IBM_multimode_draw_arrays
+  else if ext = 'GL_IBM_raster_pos_clip' then Result := Load_GL_IBM_raster_pos_clip
+  else if ext = 'GL_IBM_texture_mirrored_repeat' then Result := Load_GL_IBM_texture_mirrored_repeat
+  else if ext = 'GL_IBM_vertex_array_lists' then Result := Load_GL_IBM_vertex_array_lists
+  else if ext = 'GL_MESA_resize_buffers' then Result := Load_GL_MESA_resize_buffers
+  else if ext = 'GL_MESA_window_pos' then Result := Load_GL_MESA_window_pos
+  else if ext = 'GL_OML_interlace' then Result := Load_GL_OML_interlace
+  else if ext = 'GL_OML_resample' then Result := Load_GL_OML_resample
+  else if ext = 'GL_OML_subsample' then Result := Load_GL_OML_subsample
+  else if ext = 'GL_SGIS_generate_mipmap' then Result := Load_GL_SGIS_generate_mipmap
+  else if ext = 'GL_SGIS_multisample' then Result := Load_GL_SGIS_multisample
+  else if ext = 'GL_SGIS_pixel_texture' then Result := Load_GL_SGIS_pixel_texture
+  else if ext = 'GL_SGIS_texture_border_clamp' then Result := Load_GL_SGIS_texture_border_clamp
+  else if ext = 'GL_SGIS_texture_color_mask' then Result := Load_GL_SGIS_texture_color_mask
+  else if ext = 'GL_SGIS_texture_edge_clamp' then Result := Load_GL_SGIS_texture_edge_clamp
+  else if ext = 'GL_SGIS_texture_lod' then Result := Load_GL_SGIS_texture_lod
+  else if ext = 'GL_SGIS_depth_texture' then Result := Load_GL_SGIS_depth_texture
+  else if ext = 'GL_SGIX_fog_offset' then Result := Load_GL_SGIX_fog_offset
+  else if ext = 'GL_SGIX_interlace' then Result := Load_GL_SGIX_interlace
+  else if ext = 'GL_SGIX_shadow_ambient' then Result := Load_GL_SGIX_shadow_ambient
+  else if ext = 'GL_SGI_color_matrix' then Result := Load_GL_SGI_color_matrix
+  else if ext = 'GL_SGI_color_table' then Result := Load_GL_SGI_color_table
+  else if ext = 'GL_SGI_texture_color_table' then Result := Load_GL_SGI_texture_color_table
+  else if ext = 'GL_SUN_vertex' then Result := Load_GL_SUN_vertex
+  else if ext = 'GL_ARB_fragment_program' then Result := Load_GL_ARB_fragment_program
+  else if ext = 'GL_ATI_text_fragment_shader' then Result := Load_GL_ATI_text_fragment_shader
+  else if ext = 'GL_APPLE_client_storage' then Result := Load_GL_APPLE_client_storage
+  else if ext = 'GL_APPLE_element_array' then Result := Load_GL_APPLE_element_array
+  else if ext = 'GL_APPLE_fence' then Result := Load_GL_APPLE_fence
+  else if ext = 'GL_APPLE_vertex_array_object' then Result := Load_GL_APPLE_vertex_array_object
+  else if ext = 'GL_APPLE_vertex_array_range' then Result := Load_GL_APPLE_vertex_array_range
+  {$IFDEF WIN32}
+  else if ext = 'WGL_ARB_pixel_format' then Result := Load_WGL_ARB_pixel_format
+  else if ext = 'WGL_ARB_make_current_read' then Result := Load_WGL_ARB_make_current_read
+  else if ext = 'WGL_ARB_pbuffer' then Result := Load_WGL_ARB_pbuffer
+  else if ext = 'WGL_EXT_swap_control' then Result := Load_WGL_EXT_swap_control
+  else if ext = 'WGL_ARB_render_texture' then Result := Load_WGL_ARB_render_texture
+  else if ext = 'WGL_EXT_extensions_string' then Result := Load_WGL_EXT_extensions_string
+  else if ext = 'WGL_EXT_make_current_read' then Result := Load_WGL_EXT_make_current_read
+  else if ext = 'WGL_EXT_pbuffer' then Result := Load_WGL_EXT_pbuffer
+  else if ext = 'WGL_EXT_pixel_format' then Result := Load_WGL_EXT_pixel_format
+  else if ext = 'WGL_I3D_digital_video_control' then Result := Load_WGL_I3D_digital_video_control
+  else if ext = 'WGL_I3D_gamma' then Result := Load_WGL_I3D_gamma
+  else if ext = 'WGL_I3D_genlock' then Result := Load_WGL_I3D_genlock
+  {$ENDIF}
+  else if ext = 'GL_ARB_matrix_palette' then Result := Load_GL_ARB_matrix_palette
+  else if ext = 'GL_NV_element_array' then Result := Load_GL_NV_element_array
+  else if ext = 'GL_NV_float_buffer' then Result := Load_GL_NV_float_buffer
+  else if ext = 'GL_NV_fragment_program' then Result := Load_GL_NV_fragment_program
+  else if ext = 'GL_NV_primitive_restart' then Result := Load_GL_NV_primitive_restart
+  else if ext = 'GL_NV_vertex_program2' then Result := Load_GL_NV_vertex_program2
+  {$IFDEF WIN32}
+  else if ext = 'WGL_NV_render_texture_rectangle' then Result := Load_WGL_NV_render_texture_rectangle
+  {$ENDIF}
+  else if ext = 'GL_NV_pixel_data_range' then Result := Load_GL_NV_pixel_data_range
+  else if ext = 'GL_EXT_texture_rectangle' then Result := Load_GL_EXT_texture_rectangle
+  else if ext = 'GL_S3_s3tc' then Result := Load_GL_S3_s3tc
+  else if ext = 'GL_ATI_draw_buffers' then Result := Load_GL_ATI_draw_buffers
+  {$IFDEF WIN32}
+  else if ext = 'WGL_ATI_pixel_format_float' then Result := Load_WGL_ATI_pixel_format_float
+  {$ENDIF}
+  else if ext = 'GL_ATI_texture_env_combine3' then Result := Load_GL_ATI_texture_env_combine3
+  else if ext = 'GL_ATI_texture_float' then Result := Load_GL_ATI_texture_float
+  else if ext = 'GL_NV_texture_expand_normal' then Result := Load_GL_NV_texture_expand_normal
+  else if ext = 'GL_NV_half_float' then Result := Load_GL_NV_half_float
+  else if ext = 'GL_ATI_map_object_buffer' then Result := Load_GL_ATI_map_object_buffer
+  else if ext = 'GL_ATI_separate_stencil' then Result := Load_GL_ATI_separate_stencil
+  else if ext = 'GL_ATI_vertex_attrib_array_object' then Result := Load_GL_ATI_vertex_attrib_array_object
+  else if ext = 'GL_ARB_vertex_buffer_object' then Result := Load_GL_ARB_vertex_buffer_object
+  else if ext = 'GL_ARB_occlusion_query' then Result := Load_GL_ARB_occlusion_query
+  else if ext = 'GL_ARB_shader_objects' then Result := Load_GL_ARB_shader_objects
+  else if ext = 'GL_ARB_vertex_shader' then Result := Load_GL_ARB_vertex_shader
+  else if ext = 'GL_ARB_fragment_shader' then Result := Load_GL_ARB_fragment_shader
+  else if ext = 'GL_ARB_shading_language_100' then Result := Load_GL_ARB_shading_language_100
+  else if ext = 'GL_ARB_texture_non_power_of_two' then Result := Load_GL_ARB_texture_non_power_of_two
+  else if ext = 'GL_ARB_point_sprite' then Result := Load_GL_ARB_point_sprite
+  else if ext = 'GL_EXT_depth_bounds_test' then Result := Load_GL_EXT_depth_bounds_test
+  else if ext = 'GL_EXT_secondary_color' then Result := Load_GL_EXT_secondary_color
+  else if ext = 'GL_EXT_texture_mirror_clamp' then Result := Load_GL_EXT_texture_mirror_clamp
+  else if ext = 'GL_EXT_blend_equation_separate' then Result := Load_GL_EXT_blend_equation_separate
+  else if ext = 'GL_MESA_pack_invert' then Result := Load_GL_MESA_pack_invert
+  else if ext = 'GL_MESA_ycbcr_texture' then Result := Load_GL_MESA_ycbcr_texture
+  else if ext = 'GL_ARB_fragment_program_shadow' then Result := Load_GL_ARB_fragment_program_shadow
+  else if ext = 'GL_EXT_fog_coord' then Result := Load_GL_EXT_fog_coord
+  else if ext = 'GL_NV_fragment_program_option' then Result := Load_GL_NV_fragment_program_option
+  else if ext = 'GL_EXT_pixel_buffer_object' then Result := Load_GL_EXT_pixel_buffer_object
+  else if ext = 'GL_NV_fragment_program2' then Result := Load_GL_NV_fragment_program2
+  else if ext = 'GL_NV_vertex_program2_option' then Result := Load_GL_NV_vertex_program2_option
+  else if ext = 'GL_NV_vertex_program3' then Result := Load_GL_NV_vertex_program3
+
+end;
+
+end.
diff --git a/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glu.pas b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glu.pas
new file mode 100644
index 00000000..fb48f65d
--- /dev/null
+++ b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glu.pas
@@ -0,0 +1,563 @@
+unit glu;
+{
+  $Id: glu.pas,v 1.3 2004/10/07 21:01:29 savage Exp $
+
+  Adaption of the delphi3d.net OpenGL units to FreePascal
+  Sebastian Guenther (sg@freepascal.org) in 2002
+  These units are free to use
+}
+
+(*++ BUILD Version: 0004    // Increment this if a change has global effects
+
+Copyright (c) 1985-95, Microsoft Corporation
+
+Module Name:
+
+    glu.h
+
+Abstract:
+
+    Procedure declarations, constant definitions and macros for the OpenGL
+    Utility Library.
+
+--*)
+
+(*
+** Copyright 1991-1993, Silicon Graphics, Inc.
+** All Rights Reserved.
+**
+** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
+** the contents of this file may not be disclosed to third parties, copied or
+** duplicated in any form, in whole or in part, without the prior written
+** permission of Silicon Graphics, Inc.
+**
+** RESTRICTED RIGHTS LEGEND:
+** Use, duplication or disclosure by the Government is subject to restrictions
+** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
+** and Computer Software clause at DFARS 252.227-7013, and/or in similar or
+** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
+** rights reserved under the Copyright Laws of the United States.
+*)
+
+(*
+** Return the error string associated with a particular error code.
+** This will return 0 for an invalid error code.
+**
+** The generic function prototype that can be compiled for ANSI or Unicode
+** is defined as follows:
+**
+** LPCTSTR APIENTRY gluErrorStringWIN (GLenum errCode);
+*)
+
+{******************************************************************************}
+{                                                                              }
+{ Converted to Delphi by Tom Nuydens (tom@delphi3d.net)                        }
+{ For the latest updates, visit Delphi3D: http://www.delphi3d.net              }
+{                                                                              }
+{ Modified for Delphi/Kylix and FreePascal                                     }
+{    by Dominique Louis ( Dominique@Savagesoftware.com.au)                     }
+{ For the latest updates, visit JEDI-SDL : http://www.sf.net/projects/jedi-sdl }
+{                                                                              }
+{******************************************************************************}
+
+{
+  $Log: glu.pas,v $
+  Revision 1.3  2004/10/07 21:01:29  savage
+  Fix for FPC
+
+  Revision 1.2  2004/08/14 22:54:30  savage
+  Updated so that Library name defines are correctly defined for MacOS X.
+
+  Revision 1.1  2004/03/30 21:53:54  savage
+  Moved to it's own folder.
+
+  Revision 1.4  2004/02/20 17:09:55  savage
+  Code tidied up in gl, glu and glut, while extensions in glext.pas are now loaded using SDL_GL_GetProcAddress, thus making it more cross-platform compatible, but now more tied to SDL.
+
+  Revision 1.3  2004/02/14 00:23:39  savage
+  As UNIX is defined in jedi-sdl.inc this will be used to check linux compatability as well. Units have been changed to reflect this change.
+
+  Revision 1.2  2004/02/14 00:09:19  savage
+  Changed uses to now make use of moduleloader.pas rather than dllfuncs.pas
+
+  Revision 1.1  2004/02/05 00:08:19  savage
+  Module 1.0 release
+
+  Revision 1.4  2003/06/02 12:32:13  savage
+  Modified Sources to avoid warnings with Delphi by moving CVS Logging to the top of the header files. Hopefully CVS Logging still works.
+
+  Revision 1.3  2003/05/29 22:55:00  savage
+  Make use of new DLLFunctions
+
+  Revision 1.2  2003/05/27 09:39:53  savage
+  Added better Gnu Pascal support.
+
+  Revision 1.1  2003/05/11 13:18:03  savage
+  Newest OpenGL Headers For Delphi, Kylix and FPC
+
+  Revision 1.2  2002/10/13 14:36:47  sg
+  * Win32 fix: The OS symbol is called "Win32", not "Windows"
+
+  Revision 1.1  2002/10/13 13:57:31  sg
+  * Finally, the new units are available: Match the C headers more closely;
+    support for OpenGL extensions, and much more. Based on the Delphi units
+    by Tom Nuydens of delphi3d.net
+
+}
+
+interface
+
+{$I jedi-sdl.inc}
+
+uses
+{$IFDEF __GPC__}
+  gpc,
+{$ENDIF}
+  moduleloader,
+  gl;
+
+const
+{$IFDEF WIN32}
+  GLuLibName = 'glu32.dll';
+{$ENDIF}
+
+{$IFDEF UNIX}
+{$IFDEF DARWIN}
+  GLuLibName = 'libGLU.dylib';
+{$ELSE}
+  GLuLibName = 'libGLU.so';
+{$ENDIF}
+{$ENDIF}
+
+type
+  TViewPortArray = array [0..3] of GLint;
+  T16dArray = array [0..15] of GLdouble;
+  TCallBack = procedure;
+  T3dArray = array [0..2] of GLdouble;
+  T4pArray = array [0..3] of Pointer;
+  T4fArray = array [0..3] of GLfloat;
+  {$IFNDEF __GPC__}
+  PPointer = ^Pointer;
+  {$ENDIF}
+
+var
+  gluErrorString: function(errCode: GLenum): PGLubyte; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluErrorUnicodeStringEXT: function(errCode: GLenum): PWideChar; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluGetString: function(name: GLenum): PGLubyte; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluOrtho2D: procedure(left,right, bottom, top: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluPerspective: procedure(fovy, aspect, zNear, zFar: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluPickMatrix: procedure(x, y, width, height: GLdouble; viewport: TViewPortArray); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluLookAt: procedure(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluProject: function(objx, objy, objz: GLdouble; const modelMatrix, projMatrix: T16dArray; viewport: TViewPortArray; winx, winy, winz: PGLdouble): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluUnProject: function(winx, winy, winz: GLdouble; const modelMatrix, projMatrix: T16dArray; viewport: TViewPortArray; objx, objy, objz: PGLdouble): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluScaleImage: function(format: GLenum; widthin, heightin: GLint; typein: GLenum; const datain: Pointer; widthout, heightout: GLint; typeout: GLenum; dataout: Pointer): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluBuild1DMipmaps: function(target: GLenum; components, width: GLint; format, atype: GLenum; const data: Pointer): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluBuild2DMipmaps: function(target: GLenum; components, width, height: GLint; format, atype: GLenum; const data: Pointer): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+type
+  GLUnurbs = record end;                PGLUnurbs = ^GLUnurbs;
+  GLUquadric = record end;              PGLUquadric = ^GLUquadric;
+  GLUtesselator = record end;           PGLUtesselator = ^GLUtesselator;
+
+  // backwards compatibility:
+  GLUnurbsObj = GLUnurbs;               PGLUnurbsObj = PGLUnurbs;
+  GLUquadricObj = GLUquadric;           PGLUquadricObj = PGLUquadric;
+  GLUtesselatorObj = GLUtesselator;     PGLUtesselatorObj = PGLUtesselator;
+  GLUtriangulatorObj = GLUtesselator;   PGLUtriangulatorObj = PGLUtesselator;
+
+var
+  gluNewQuadric: function: PGLUquadric; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluDeleteQuadric: procedure(state: PGLUquadric); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluQuadricNormals: procedure(quadObject: PGLUquadric; normals: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluQuadricTexture: procedure(quadObject: PGLUquadric; textureCoords: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluQuadricOrientation: procedure(quadObject: PGLUquadric; orientation: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluQuadricDrawStyle: procedure(quadObject: PGLUquadric; drawStyle: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluCylinder: procedure(qobj: PGLUquadric; baseRadius, topRadius, height: GLdouble; slices, stacks: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluDisk: procedure(qobj: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluPartialDisk: procedure(qobj: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint; startAngle, sweepAngle: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluSphere: procedure(qobj: PGLuquadric; radius: GLdouble; slices, stacks: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluQuadricCallback: procedure(qobj: PGLUquadric; which: GLenum; fn: TCallBack); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluNewTess: function: PGLUtesselator; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluDeleteTess: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluTessBeginPolygon: procedure(tess: PGLUtesselator; polygon_data: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluTessBeginContour: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluTessVertex: procedure(tess: PGLUtesselator; coords: T3dArray; data: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluTessEndContour: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluTessEndPolygon: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluTessProperty: procedure(tess: PGLUtesselator; which: GLenum; value: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluTessNormal: procedure(tess: PGLUtesselator; x, y, z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluTessCallback: procedure(tess: PGLUtesselator; which: GLenum;fn: TCallBack); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluGetTessProperty: procedure(tess: PGLUtesselator; which: GLenum; value: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluNewNurbsRenderer: function: PGLUnurbs; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluDeleteNurbsRenderer: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluBeginSurface: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluBeginCurve: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluEndCurve: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluEndSurface: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluBeginTrim: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluEndTrim: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluPwlCurve: procedure(nobj: PGLUnurbs; count: GLint; aarray: PGLfloat; stride: GLint; atype: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluNurbsCurve: procedure(nobj: PGLUnurbs; nknots: GLint; knot: PGLfloat; stride: GLint; ctlarray: PGLfloat; order: GLint; atype: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluNurbsSurface: procedure(nobj: PGLUnurbs; sknot_count: GLint; sknot: PGLfloat; tknot_count: GLint; tknot: PGLfloat; s_stride, t_stride: GLint; ctlarray: PGLfloat; sorder, torder: GLint; atype: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluLoadSamplingMatrices: procedure(nobj: PGLUnurbs; const modelMatrix, projMatrix: T16dArray; viewport: TViewPortArray); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluNurbsProperty: procedure(nobj: PGLUnurbs; aproperty: GLenum; value: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluGetNurbsProperty: procedure(nobj: PGLUnurbs; aproperty: GLenum; value: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluNurbsCallback: procedure(nobj: PGLUnurbs; which: GLenum; fn: TCallBack); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+(**** Callback function prototypes ****)
+
+type
+  // gluQuadricCallback
+  GLUquadricErrorProc = procedure(p: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+  // gluTessCallback
+  GLUtessBeginProc = procedure(p: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessEdgeFlagProc = procedure(p: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessVertexProc = procedure(p: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessEndProc = procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessErrorProc = procedure(p: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessCombineProc = procedure(p1: T3dArray; p2: T4pArray; p3: T4fArray; p4: PPointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessBeginDataProc = procedure(p1: GLenum; p2: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessEdgeFlagDataProc = procedure(p1: GLboolean; p2: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessVertexDataProc = procedure(p1, p2: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessEndDataProc = procedure(p: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessErrorDataProc = procedure(p1: GLenum; p2: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  GLUtessCombineDataProc = procedure(p1: T3dArray; p2: T4pArray; p3: T4fArray;
+                                     p4: PPointer; p5: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+  // gluNurbsCallback
+  GLUnurbsErrorProc = procedure(p: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+
+//***           Generic constants               ****/
+
+const
+  // Version
+  GLU_VERSION_1_1                 = 1;
+  GLU_VERSION_1_2                 = 1;
+
+  // Errors: (return value 0 = no error)
+  GLU_INVALID_ENUM                = 100900;
+  GLU_INVALID_VALUE               = 100901;
+  GLU_OUT_OF_MEMORY               = 100902;
+  GLU_INCOMPATIBLE_GL_VERSION     = 100903;
+
+  // StringName
+  GLU_VERSION                     = 100800;
+  GLU_EXTENSIONS                  = 100801;
+
+  // Boolean
+  GLU_TRUE                        = GL_TRUE;
+  GLU_FALSE                       = GL_FALSE;
+
+
+  //***           Quadric constants               ****/
+
+  // QuadricNormal
+  GLU_SMOOTH              = 100000;
+  GLU_FLAT                = 100001;
+  GLU_NONE                = 100002;
+
+  // QuadricDrawStyle
+  GLU_POINT               = 100010;
+  GLU_LINE                = 100011;
+  GLU_FILL                = 100012;
+  GLU_SILHOUETTE          = 100013;
+
+  // QuadricOrientation
+  GLU_OUTSIDE             = 100020;
+  GLU_INSIDE              = 100021;
+
+  // Callback types:
+  //      GLU_ERROR       = 100103;
+
+
+  //***           Tesselation constants           ****/
+
+  GLU_TESS_MAX_COORD              = 1.0e150;
+
+  // TessProperty
+  GLU_TESS_WINDING_RULE           = 100140;
+  GLU_TESS_BOUNDARY_ONLY          = 100141;
+  GLU_TESS_TOLERANCE              = 100142;
+
+  // TessWinding
+  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;
+
+  // TessCallback
+  GLU_TESS_BEGIN          = 100100;    // void (CALLBACK*)(GLenum    type)
+  GLU_TESS_VERTEX         = 100101;    // void (CALLBACK*)(void      *data)
+  GLU_TESS_END            = 100102;    // void (CALLBACK*)(void)
+  GLU_TESS_ERROR          = 100103;    // void (CALLBACK*)(GLenum    errno)
+  GLU_TESS_EDGE_FLAG      = 100104;    // void (CALLBACK*)(GLboolean boundaryEdge)
+  GLU_TESS_COMBINE        = 100105;    { void (CALLBACK*)(GLdouble  coords[3],
+                                                            void      *data[4],
+                                                            GLfloat   weight[4],
+                                                            void      **dataOut) }
+  GLU_TESS_BEGIN_DATA     = 100106;    { void (CALLBACK*)(GLenum    type,
+                                                            void      *polygon_data) }
+  GLU_TESS_VERTEX_DATA    = 100107;    { void (CALLBACK*)(void      *data,
+                                                            void      *polygon_data) }
+  GLU_TESS_END_DATA       = 100108;    // void (CALLBACK*)(void      *polygon_data)
+  GLU_TESS_ERROR_DATA     = 100109;    { void (CALLBACK*)(GLenum    errno,
+                                                            void      *polygon_data) }
+  GLU_TESS_EDGE_FLAG_DATA = 100110;    { void (CALLBACK*)(GLboolean boundaryEdge,
+                                                            void      *polygon_data) }
+  GLU_TESS_COMBINE_DATA   = 100111;    { void (CALLBACK*)(GLdouble  coords[3],
+                                                            void      *data[4],
+                                                            GLfloat   weight[4],
+                                                            void      **dataOut,
+                                                            void      *polygon_data) }
+
+  // TessError
+  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;
+
+  //***           NURBS constants                 ****/
+
+  // NurbsProperty
+  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;
+
+  // NurbsSampling
+  GLU_PATH_LENGTH                 = 100215;
+  GLU_PARAMETRIC_ERROR            = 100216;
+  GLU_DOMAIN_DISTANCE             = 100217;
+
+
+  // NurbsTrim
+  GLU_MAP1_TRIM_2                 = 100210;
+  GLU_MAP1_TRIM_3                 = 100211;
+
+  // NurbsDisplay
+  //      GLU_FILL                = 100012;
+  GLU_OUTLINE_POLYGON             = 100240;
+  GLU_OUTLINE_PATCH               = 100241;
+
+  // NurbsCallback
+  //      GLU_ERROR               = 100103;
+
+  // NurbsErrors
+  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;
+
+//***           Backwards compatibility for old tesselator           ****/
+
+var
+  gluBeginPolygon: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluNextContour: procedure(tess: PGLUtesselator; atype: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  gluEndPolygon: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+const
+  // Contours types -- obsolete!
+  GLU_CW          = 100120;
+  GLU_CCW         = 100121;
+  GLU_INTERIOR    = 100122;
+  GLU_EXTERIOR    = 100123;
+  GLU_UNKNOWN     = 100124;
+
+  // Names without "TESS_" prefix
+  GLU_BEGIN       = GLU_TESS_BEGIN;
+  GLU_VERTEX      = GLU_TESS_VERTEX;
+  GLU_END         = GLU_TESS_END;
+  GLU_ERROR       = GLU_TESS_ERROR;
+  GLU_EDGE_FLAG   = GLU_TESS_EDGE_FLAG;
+
+procedure LoadGLu(const dll: PChar);
+procedure FreeGLu;
+
+implementation
+
+var
+  LibGlu: TModuleHandle;
+  
+procedure FreeGLu;
+begin
+
+  @gluErrorString := nil;
+  @gluErrorUnicodeStringEXT := nil;
+  @gluGetString := nil;
+  @gluOrtho2D := nil;
+  @gluPerspective := nil;
+  @gluPickMatrix := nil;
+  @gluLookAt := nil;
+  @gluProject := nil;
+  @gluUnProject := nil;
+  @gluScaleImage := nil;
+  @gluBuild1DMipmaps := nil;
+  @gluBuild2DMipmaps := nil;
+  @gluNewQuadric := nil;
+  @gluDeleteQuadric := nil;
+  @gluQuadricNormals := nil;
+  @gluQuadricTexture := nil;
+  @gluQuadricOrientation := nil;
+  @gluQuadricDrawStyle := nil;
+  @gluCylinder := nil;
+  @gluDisk := nil;
+  @gluPartialDisk := nil;
+  @gluSphere := nil;
+  @gluQuadricCallback := nil;
+  @gluNewTess := nil;
+  @gluDeleteTess := nil;
+  @gluTessBeginPolygon := nil;
+  @gluTessBeginContour := nil;
+  @gluTessVertex := nil;
+  @gluTessEndContour := nil;
+  @gluTessEndPolygon := nil;
+  @gluTessProperty := nil;
+  @gluTessNormal := nil;
+  @gluTessCallback := nil;
+  @gluGetTessProperty := nil;
+  @gluNewNurbsRenderer := nil;
+  @gluDeleteNurbsRenderer := nil;
+  @gluBeginSurface := nil;
+  @gluBeginCurve := nil;
+  @gluEndCurve := nil;
+  @gluEndSurface := nil;
+  @gluBeginTrim := nil;
+  @gluEndTrim := nil;
+  @gluPwlCurve := nil;
+  @gluNurbsCurve := nil;
+  @gluNurbsSurface := nil;
+  @gluLoadSamplingMatrices := nil;
+  @gluNurbsProperty := nil;
+  @gluGetNurbsProperty := nil;
+  @gluNurbsCallback := nil;
+  @gluBeginPolygon := nil;
+  @gluNextContour := nil;
+  @gluEndPolygon := nil;
+
+  UnLoadModule(LibGlu);
+
+end;
+
+procedure LoadGLu(const dll: PChar);
+begin
+
+  FreeGLu;
+  
+  if LoadModule( LibGlu, dll ) then
+  begin
+    @gluErrorString := GetModuleSymbol(LibGlu, 'gluErrorString');
+    @gluErrorUnicodeStringEXT := GetModuleSymbol(LibGlu, 'gluErrorUnicodeStringEXT');
+    @gluGetString := GetModuleSymbol(LibGlu, 'gluGetString');
+    @gluOrtho2D := GetModuleSymbol(LibGlu, 'gluOrtho2D');
+    @gluPerspective := GetModuleSymbol(LibGlu, 'gluPerspective');
+    @gluPickMatrix := GetModuleSymbol(LibGlu, 'gluPickMatrix');
+    @gluLookAt := GetModuleSymbol(LibGlu, 'gluLookAt');
+    @gluProject := GetModuleSymbol(LibGlu, 'gluProject');
+    @gluUnProject := GetModuleSymbol(LibGlu, 'gluUnProject');
+    @gluScaleImage := GetModuleSymbol(LibGlu, 'gluScaleImage');
+    @gluBuild1DMipmaps := GetModuleSymbol(LibGlu, 'gluBuild1DMipmaps');
+    @gluBuild2DMipmaps := GetModuleSymbol(LibGlu, 'gluBuild2DMipmaps');
+    @gluNewQuadric := GetModuleSymbol(LibGlu, 'gluNewQuadric');
+    @gluDeleteQuadric := GetModuleSymbol(LibGlu, 'gluDeleteQuadric');
+    @gluQuadricNormals := GetModuleSymbol(LibGlu, 'gluQuadricNormals');
+    @gluQuadricTexture := GetModuleSymbol(LibGlu, 'gluQuadricTexture');
+    @gluQuadricOrientation := GetModuleSymbol(LibGlu, 'gluQuadricOrientation');
+    @gluQuadricDrawStyle := GetModuleSymbol(LibGlu, 'gluQuadricDrawStyle');
+    @gluCylinder := GetModuleSymbol(LibGlu, 'gluCylinder');
+    @gluDisk := GetModuleSymbol(LibGlu, 'gluDisk');
+    @gluPartialDisk := GetModuleSymbol(LibGlu, 'gluPartialDisk');
+    @gluSphere := GetModuleSymbol(LibGlu, 'gluSphere');
+    @gluQuadricCallback := GetModuleSymbol(LibGlu, 'gluQuadricCallback');
+    @gluNewTess := GetModuleSymbol(LibGlu, 'gluNewTess');
+    @gluDeleteTess := GetModuleSymbol(LibGlu, 'gluDeleteTess');
+    @gluTessBeginPolygon := GetModuleSymbol(LibGlu, 'gluTessBeginPolygon');
+    @gluTessBeginContour := GetModuleSymbol(LibGlu, 'gluTessBeginContour');
+    @gluTessVertex := GetModuleSymbol(LibGlu, 'gluTessVertex');
+    @gluTessEndContour := GetModuleSymbol(LibGlu, 'gluTessEndContour');
+    @gluTessEndPolygon := GetModuleSymbol(LibGlu, 'gluTessEndPolygon');
+    @gluTessProperty := GetModuleSymbol(LibGlu, 'gluTessProperty');
+    @gluTessNormal := GetModuleSymbol(LibGlu, 'gluTessNormal');
+    @gluTessCallback := GetModuleSymbol(LibGlu, 'gluTessCallback');
+    @gluGetTessProperty := GetModuleSymbol(LibGlu, 'gluGetTessProperty');
+    @gluNewNurbsRenderer := GetModuleSymbol(LibGlu, 'gluNewNurbsRenderer');
+    @gluDeleteNurbsRenderer := GetModuleSymbol(LibGlu, 'gluDeleteNurbsRenderer');
+    @gluBeginSurface := GetModuleSymbol(LibGlu, 'gluBeginSurface');
+    @gluBeginCurve := GetModuleSymbol(LibGlu, 'gluBeginCurve');
+    @gluEndCurve := GetModuleSymbol(LibGlu, 'gluEndCurve');
+    @gluEndSurface := GetModuleSymbol(LibGlu, 'gluEndSurface');
+    @gluBeginTrim := GetModuleSymbol(LibGlu, 'gluBeginTrim');
+    @gluEndTrim := GetModuleSymbol(LibGlu, 'gluEndTrim');
+    @gluPwlCurve := GetModuleSymbol(LibGlu, 'gluPwlCurve');
+    @gluNurbsCurve := GetModuleSymbol(LibGlu, 'gluNurbsCurve');
+    @gluNurbsSurface := GetModuleSymbol(LibGlu, 'gluNurbsSurface');
+    @gluLoadSamplingMatrices := GetModuleSymbol(LibGlu, 'gluLoadSamplingMatrices');
+    @gluNurbsProperty := GetModuleSymbol(LibGlu, 'gluNurbsProperty');
+    @gluGetNurbsProperty := GetModuleSymbol(LibGlu, 'gluGetNurbsProperty');
+    @gluNurbsCallback := GetModuleSymbol(LibGlu, 'gluNurbsCallback');
+
+    @gluBeginPolygon := GetModuleSymbol(LibGlu, 'gluBeginPolygon');
+    @gluNextContour := GetModuleSymbol(LibGlu, 'gluNextContour');
+    @gluEndPolygon := GetModuleSymbol(LibGlu, 'gluEndPolygon');
+  end;
+end;
+
+initialization
+
+  LoadGLu( GLuLibName );
+
+finalization
+
+  FreeGLu;
+
+end.
diff --git a/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glut.pas b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glut.pas
new file mode 100644
index 00000000..2a882a20
--- /dev/null
+++ b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glut.pas
@@ -0,0 +1,682 @@
+unit glut;
+{
+  $Id: glut.pas,v 1.2 2004/08/14 22:54:30 savage Exp $
+
+  Adaption of the delphi3d.net OpenGL units to FreePascal
+  Sebastian Guenther (sg@freepascal.org) in 2002
+  These units are free to use
+}
+
+// Copyright (c) Mark J. Kilgard, 1994, 1995, 1996. */
+
+(* This program is freely distributable without licensing fees  and is
+   provided without guarantee or warrantee expressed or  implied. This
+   program is -not- in the public domain. *)
+
+{******************************************************************************}
+{                                                                              }
+{ Converted to Delphi by Tom Nuydens (tom@delphi3d.net)                        }
+{ For the latest updates, visit Delphi3D: http://www.delphi3d.net              }
+{                                                                              }
+{ Modified for Delphi/Kylix and FreePascal                                     }
+{    by Dominique Louis ( Dominique@Savagesoftware.com.au)                     }
+{ For the latest updates, visit JEDI-SDL : http://www.sf.net/projects/jedi-sdl }
+{                                                                              }
+{******************************************************************************}
+
+{
+  $Log: glut.pas,v $
+  Revision 1.2  2004/08/14 22:54:30  savage
+  Updated so that Library name defines are correctly defined for MacOS X.
+
+  Revision 1.1  2004/03/30 21:53:54  savage
+  Moved to it's own folder.
+
+  Revision 1.5  2004/02/20 17:09:55  savage
+  Code tidied up in gl, glu and glut, while extensions in glext.pas are now loaded using SDL_GL_GetProcAddress, thus making it more cross-platform compatible, but now more tied to SDL.
+
+  Revision 1.4  2004/02/14 22:36:29  savage
+  Fixed inconsistencies of using LoadLibrary and LoadModule.
+  Now all units make use of LoadModule rather than LoadLibrary and other dynamic proc procedures.
+
+  Revision 1.3  2004/02/14 00:23:39  savage
+  As UNIX is defined in jedi-sdl.inc this will be used to check linux compatability as well. Units have been changed to reflect this change.
+
+  Revision 1.2  2004/02/14 00:09:19  savage
+  Changed uses to now make use of moduleloader.pas rather than dllfuncs.pas
+
+  Revision 1.1  2004/02/05 00:08:19  savage
+  Module 1.0 release
+
+  Revision 1.4  2003/06/02 12:32:13  savage
+  Modified Sources to avoid warnings with Delphi by moving CVS Logging to the top of the header files. Hopefully CVS Logging still works.
+
+}
+
+interface
+
+{$I jedi-sdl.inc}
+
+uses
+{$IFDEF __GPC__}
+  system,
+  gpc,
+{$ENDIF}
+
+{$IFDEF WIN32}
+  Windows,
+{$ENDIF}
+  moduleloader,
+  gl;
+
+type
+  {$IFNDEF __GPC__}
+  PInteger = ^Integer;
+  PPChar = ^PChar;
+  {$ENDIF}
+  TGlutVoidCallback = procedure; {$IFNDEF __GPC__}{$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}
+  TGlut1IntCallback = procedure(value: Integer); {$IFNDEF __GPC__}{$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}
+  TGlut2IntCallback = procedure(v1, v2: Integer); {$IFNDEF __GPC__}{$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}
+  TGlut3IntCallback = procedure(v1, v2, v3: Integer); {$IFNDEF __GPC__}{$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}
+  TGlut4IntCallback = procedure(v1, v2, v3, v4: Integer); {$IFNDEF __GPC__}{$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}
+  TGlut1Char2IntCallback = procedure(c: Byte; v1, v2: Integer); {$IFNDEF __GPC__}{$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}
+
+const
+{$IFDEF WIN32}
+  GlutLibName = 'glut32.dll';
+{$ENDIF}
+
+{$IFDEF UNIX}
+{$IFDEF DARWIN}
+  GlutLibName = 'libglut.dylib';
+{$ELSE}
+  GlutLibName = 'libglut.so';
+{$ENDIF}
+{$ENDIF}
+
+  GLUT_API_VERSION                = 3;
+  GLUT_XLIB_IMPLEMENTATION        = 12;
+  // Display mode bit masks.
+  GLUT_RGB                        = 0;
+  GLUT_RGBA                       = GLUT_RGB;
+  GLUT_INDEX                      = 1;
+  GLUT_SINGLE                     = 0;
+  GLUT_DOUBLE                     = 2;
+  GLUT_ACCUM                      = 4;
+  GLUT_ALPHA                      = 8;
+  GLUT_DEPTH                      = 16;
+  GLUT_STENCIL                    = 32;
+  GLUT_MULTISAMPLE                = 128;
+  GLUT_STEREO                     = 256;
+  GLUT_LUMINANCE                  = 512;
+
+  // Mouse buttons.
+  GLUT_LEFT_BUTTON                = 0;
+  GLUT_MIDDLE_BUTTON              = 1;
+  GLUT_RIGHT_BUTTON               = 2;
+
+  // Mouse button state.
+  GLUT_DOWN                       = 0;
+  GLUT_UP                         = 1;
+
+  // function keys
+  GLUT_KEY_F1                     = 1;
+  GLUT_KEY_F2                     = 2;
+  GLUT_KEY_F3                     = 3;
+  GLUT_KEY_F4                     = 4;
+  GLUT_KEY_F5                     = 5;
+  GLUT_KEY_F6                     = 6;
+  GLUT_KEY_F7                     = 7;
+  GLUT_KEY_F8                     = 8;
+  GLUT_KEY_F9                     = 9;
+  GLUT_KEY_F10                    = 10;
+  GLUT_KEY_F11                    = 11;
+  GLUT_KEY_F12                    = 12;
+  // directional keys
+  GLUT_KEY_LEFT                   = 100;
+  GLUT_KEY_UP                     = 101;
+  GLUT_KEY_RIGHT                  = 102;
+  GLUT_KEY_DOWN                   = 103;
+  GLUT_KEY_PAGE_UP                = 104;
+  GLUT_KEY_PAGE_DOWN              = 105;
+  GLUT_KEY_HOME                   = 106;
+  GLUT_KEY_END                    = 107;
+  GLUT_KEY_INSERT                 = 108;
+
+  // Entry/exit  state.
+  GLUT_LEFT                       = 0;
+  GLUT_ENTERED                    = 1;
+
+  // Menu usage state.
+  GLUT_MENU_NOT_IN_USE            = 0;
+  GLUT_MENU_IN_USE                = 1;
+
+  // Visibility  state.
+  GLUT_NOT_VISIBLE                = 0;
+  GLUT_VISIBLE                    = 1;
+
+  // Window status  state.
+  GLUT_HIDDEN                     = 0;
+  GLUT_FULLY_RETAINED             = 1;
+  GLUT_PARTIALLY_RETAINED         = 2;
+  GLUT_FULLY_COVERED              = 3;
+
+  // Color index component selection values.
+  GLUT_RED                        = 0;
+  GLUT_GREEN                      = 1;
+  GLUT_BLUE                       = 2;
+
+  // Layers for use.
+  GLUT_NORMAL                     = 0;
+  GLUT_OVERLAY                    = 1;
+
+  // Stroke font constants (use these in GLUT program).
+  GLUT_STROKE_ROMAN		  = Pointer(0);
+  GLUT_STROKE_MONO_ROMAN	  = Pointer(1);
+
+  // Bitmap font constants (use these in GLUT program).
+  GLUT_BITMAP_9_BY_15		  = Pointer(2);
+  GLUT_BITMAP_8_BY_13		  = Pointer(3);
+  GLUT_BITMAP_TIMES_ROMAN_10	  = Pointer(4);
+  GLUT_BITMAP_TIMES_ROMAN_24	  = Pointer(5);
+  GLUT_BITMAP_HELVETICA_10	  = Pointer(6);
+  GLUT_BITMAP_HELVETICA_12	  = Pointer(7);
+  GLUT_BITMAP_HELVETICA_18	  = Pointer(8);
+
+  // glutGet parameters.
+  GLUT_WINDOW_X                   = 100;
+  GLUT_WINDOW_Y                   = 101;
+  GLUT_WINDOW_WIDTH               = 102;
+  GLUT_WINDOW_HEIGHT              = 103;
+  GLUT_WINDOW_BUFFER_SIZE         = 104;
+  GLUT_WINDOW_STENCIL_SIZE        = 105;
+  GLUT_WINDOW_DEPTH_SIZE          = 106;
+  GLUT_WINDOW_RED_SIZE            = 107;
+  GLUT_WINDOW_GREEN_SIZE          = 108;
+  GLUT_WINDOW_BLUE_SIZE           = 109;
+  GLUT_WINDOW_ALPHA_SIZE          = 110;
+  GLUT_WINDOW_ACCUM_RED_SIZE      = 111;
+  GLUT_WINDOW_ACCUM_GREEN_SIZE    = 112;
+  GLUT_WINDOW_ACCUM_BLUE_SIZE     = 113;
+  GLUT_WINDOW_ACCUM_ALPHA_SIZE    = 114;
+  GLUT_WINDOW_DOUBLEBUFFER        = 115;
+  GLUT_WINDOW_RGBA                = 116;
+  GLUT_WINDOW_PARENT              = 117;
+  GLUT_WINDOW_NUM_CHILDREN        = 118;
+  GLUT_WINDOW_COLORMAP_SIZE       = 119;
+  GLUT_WINDOW_NUM_SAMPLES         = 120;
+  GLUT_WINDOW_STEREO              = 121;
+  GLUT_WINDOW_CURSOR              = 122;
+  GLUT_SCREEN_WIDTH               = 200;
+  GLUT_SCREEN_HEIGHT              = 201;
+  GLUT_SCREEN_WIDTH_MM            = 202;
+  GLUT_SCREEN_HEIGHT_MM           = 203;
+  GLUT_MENU_NUM_ITEMS             = 300;
+  GLUT_DISPLAY_MODE_POSSIBLE      = 400;
+  GLUT_INIT_WINDOW_X              = 500;
+  GLUT_INIT_WINDOW_Y              = 501;
+  GLUT_INIT_WINDOW_WIDTH          = 502;
+  GLUT_INIT_WINDOW_HEIGHT         = 503;
+  GLUT_INIT_DISPLAY_MODE          = 504;
+  GLUT_ELAPSED_TIME               = 700;
+
+  // glutDeviceGet parameters.
+  GLUT_HAS_KEYBOARD               = 600;
+  GLUT_HAS_MOUSE                  = 601;
+  GLUT_HAS_SPACEBALL              = 602;
+  GLUT_HAS_DIAL_AND_BUTTON_BOX    = 603;
+  GLUT_HAS_TABLET                 = 604;
+  GLUT_NUM_MOUSE_BUTTONS          = 605;
+  GLUT_NUM_SPACEBALL_BUTTONS      = 606;
+  GLUT_NUM_BUTTON_BOX_BUTTONS     = 607;
+  GLUT_NUM_DIALS                  = 608;
+  GLUT_NUM_TABLET_BUTTONS         = 609;
+
+  // glutLayerGet parameters.
+  GLUT_OVERLAY_POSSIBLE           = 800;
+  GLUT_LAYER_IN_USE               = 801;
+  GLUT_HAS_OVERLAY                = 802;
+  GLUT_TRANSPARENT_INDEX          = 803;
+  GLUT_NORMAL_DAMAGED             = 804;
+  GLUT_OVERLAY_DAMAGED            = 805;
+
+  // glutVideoResizeGet parameters.
+  GLUT_VIDEO_RESIZE_POSSIBLE       = 900;
+  GLUT_VIDEO_RESIZE_IN_USE         = 901;
+  GLUT_VIDEO_RESIZE_X_DELTA        = 902;
+  GLUT_VIDEO_RESIZE_Y_DELTA        = 903;
+  GLUT_VIDEO_RESIZE_WIDTH_DELTA    = 904;
+  GLUT_VIDEO_RESIZE_HEIGHT_DELTA   = 905;
+  GLUT_VIDEO_RESIZE_X              = 906;
+  GLUT_VIDEO_RESIZE_Y              = 907;
+  GLUT_VIDEO_RESIZE_WIDTH          = 908;
+  GLUT_VIDEO_RESIZE_HEIGHT         = 909;
+
+  // glutGetModifiers return mask.
+  GLUT_ACTIVE_SHIFT                = 1;
+  GLUT_ACTIVE_CTRL                 = 2;
+  GLUT_ACTIVE_ALT                  = 4;
+
+  // glutSetCursor parameters.
+  // Basic arrows.
+  GLUT_CURSOR_RIGHT_ARROW          = 0;
+  GLUT_CURSOR_LEFT_ARROW           = 1;
+  // Symbolic cursor shapes.
+  GLUT_CURSOR_INFO                 = 2;
+  GLUT_CURSOR_DESTROY              = 3;
+  GLUT_CURSOR_HELP                 = 4;
+  GLUT_CURSOR_CYCLE                = 5;
+  GLUT_CURSOR_SPRAY                = 6;
+  GLUT_CURSOR_WAIT                 = 7;
+  GLUT_CURSOR_TEXT                 = 8;
+  GLUT_CURSOR_CROSSHAIR            = 9;
+  // Directional cursors.
+  GLUT_CURSOR_UP_DOWN              = 10;
+  GLUT_CURSOR_LEFT_RIGHT           = 11;
+  // Sizing cursors.
+  GLUT_CURSOR_TOP_SIDE             = 12;
+  GLUT_CURSOR_BOTTOM_SIDE          = 13;
+  GLUT_CURSOR_LEFT_SIDE            = 14;
+  GLUT_CURSOR_RIGHT_SIDE           = 15;
+  GLUT_CURSOR_TOP_LEFT_CORNER      = 16;
+  GLUT_CURSOR_TOP_RIGHT_CORNER     = 17;
+  GLUT_CURSOR_BOTTOM_RIGHT_CORNER  = 18;
+  GLUT_CURSOR_BOTTOM_LEFT_CORNER   = 19;
+  // Inherit from parent window.
+  GLUT_CURSOR_INHERIT              = 100;
+  // Blank cursor.
+  GLUT_CURSOR_NONE                 = 101;
+  // Fullscreen crosshair (if available).
+  GLUT_CURSOR_FULL_CROSSHAIR       = 102;
+
+  // GLUT game mode sub-API.
+  // glutGameModeGet.
+  GLUT_GAME_MODE_ACTIVE           = 0;
+  GLUT_GAME_MODE_POSSIBLE         = 1;
+  GLUT_GAME_MODE_WIDTH            = 2;
+  GLUT_GAME_MODE_HEIGHT           = 3;
+  GLUT_GAME_MODE_PIXEL_DEPTH      = 4;
+  GLUT_GAME_MODE_REFRESH_RATE     = 5;
+  GLUT_GAME_MODE_DISPLAY_CHANGED  = 6;
+
+var
+// GLUT initialization sub-API.
+  glutInit: procedure(argcp: PInteger; argv: PPChar); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutInitDisplayMode: procedure(mode: Word); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutInitDisplayString: procedure(const str: PChar); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutInitWindowPosition: procedure(x, y: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutInitWindowSize: procedure(width, height: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutMainLoop: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUT window sub-API.
+  glutCreateWindow: function(const title: PChar): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutCreateSubWindow: function(win, x, y, width, height: Integer): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutDestroyWindow: procedure(win: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutPostRedisplay: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutPostWindowRedisplay: procedure(win: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSwapBuffers: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutGetWindow: function: Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSetWindow: procedure(win: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSetWindowTitle: procedure(const title: PChar); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSetIconTitle: procedure(const title: PChar); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutPositionWindow: procedure(x, y: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutReshapeWindow: procedure(width, height: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutPopWindow: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutPushWindow: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutIconifyWindow: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutShowWindow: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutHideWindow: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutFullScreen: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSetCursor: procedure(cursor: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutWarpPointer: procedure(x, y: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUT overlay sub-API.
+  glutEstablishOverlay: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutRemoveOverlay: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutUseLayer: procedure(layer: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutPostOverlayRedisplay: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutPostWindowOverlayRedisplay: procedure(win: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutShowOverlay: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutHideOverlay: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUT menu sub-API.
+  glutCreateMenu: function(callback: TGlut1IntCallback): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutDestroyMenu: procedure(menu: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutGetMenu: function: Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSetMenu: procedure(menu: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutAddMenuEntry: procedure(const caption: PChar; value: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutAddSubMenu: procedure(const caption: PChar; submenu: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutChangeToMenuEntry: procedure(item: Integer; const caption: PChar; value: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutChangeToSubMenu: procedure(item: Integer; const caption: PChar; submenu: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutRemoveMenuItem: procedure(item: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutAttachMenu: procedure(button: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutDetachMenu: procedure(button: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUTsub-API.
+  glutDisplayFunc: procedure(f: TGlutVoidCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutReshapeFunc: procedure(f: TGlut2IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutKeyboardFunc: procedure(f: TGlut1Char2IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutMouseFunc: procedure(f: TGlut4IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutMotionFunc: procedure(f: TGlut2IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutPassiveMotionFunc: procedure(f: TGlut2IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutEntryFunc: procedure(f: TGlut1IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutVisibilityFunc: procedure(f: TGlut1IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutIdleFunc: procedure(f: TGlutVoidCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutTimerFunc: procedure(millis: Word; f: TGlut1IntCallback; value: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutMenuStateFunc: procedure(f: TGlut1IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSpecialFunc: procedure(f: TGlut3IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSpaceballMotionFunc: procedure(f: TGlut3IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSpaceballRotateFunc: procedure(f: TGlut3IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSpaceballButtonFunc: procedure(f: TGlut2IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutButtonBoxFunc: procedure(f: TGlut2IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutDialsFunc: procedure(f: TGlut2IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutTabletMotionFunc: procedure(f: TGlut2IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutTabletButtonFunc: procedure(f: TGlut4IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutMenuStatusFunc: procedure(f: TGlut3IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutOverlayDisplayFunc: procedure(f:TGlutVoidCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutWindowStatusFunc: procedure(f: TGlut1IntCallback); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUT color index sub-API.
+  glutSetColor: procedure(cell: Integer; red, green, blue: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutGetColor: function(ndx, component: Integer): GLfloat; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutCopyColormap: procedure(win: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUT state retrieval sub-API.
+  glutGet: function(t: GLenum): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutDeviceGet: function(t: GLenum): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUT extension support sub-API
+  glutExtensionSupported: function(const name: PChar): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutGetModifiers: function: Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutLayerGet: function(t: GLenum): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUT font sub-API
+  glutBitmapCharacter: procedure(font : pointer; character: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutBitmapWidth: function(font : pointer; character: Integer): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutStrokeCharacter: procedure(font : pointer; character: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutStrokeWidth: function(font : pointer; character: Integer): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutBitmapLength: function(font: pointer; const str: PChar): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutStrokeLength: function(font: pointer; const str: PChar): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUT pre-built models sub-API
+  glutWireSphere: procedure(radius: GLdouble; slices, stacks: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSolidSphere: procedure(radius: GLdouble; slices, stacks: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutWireCone: procedure(base, height: GLdouble; slices, stacks: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSolidCone: procedure(base, height: GLdouble; slices, stacks: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutWireCube: procedure(size: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSolidCube: procedure(size: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutWireTorus: procedure(innerRadius, outerRadius: GLdouble; sides, rings: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSolidTorus: procedure(innerRadius, outerRadius: GLdouble; sides, rings: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutWireDodecahedron: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSolidDodecahedron: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutWireTeapot: procedure(size: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSolidTeapot: procedure(size: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutWireOctahedron: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSolidOctahedron: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutWireTetrahedron: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSolidTetrahedron: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutWireIcosahedron: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSolidIcosahedron: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUT video resize sub-API.
+  glutVideoResizeGet: function(param: GLenum): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutSetupVideoResizing: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutStopVideoResizing: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutVideoResize: procedure(x, y, width, height: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutVideoPan: procedure(x, y, width, height: Integer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+// GLUT debugging sub-API.
+  glutReportErrors: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+var
+  //example glutGameModeString('1280x1024:32@75');
+  glutGameModeString : procedure (const AString : PChar); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutEnterGameMode : function : integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutLeaveGameMode : procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}
+  glutGameModeGet : function (mode : GLenum) : integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF} 
+
+procedure LoadGlut(const dll: PChar);
+procedure FreeGlut;
+
+implementation
+
+var
+  LibGLUT : TModuleHandle;
+
+procedure FreeGlut;
+begin
+
+  UnLoadModule( LibGLUT );
+
+  @glutInit := nil;
+  @glutInitDisplayMode := nil;
+  @glutInitDisplayString := nil;
+  @glutInitWindowPosition := nil;
+  @glutInitWindowSize := nil;
+  @glutMainLoop := nil;
+  @glutCreateWindow := nil;
+  @glutCreateSubWindow := nil;
+  @glutDestroyWindow := nil;
+  @glutPostRedisplay := nil;
+  @glutPostWindowRedisplay := nil;
+  @glutSwapBuffers := nil;
+  @glutGetWindow := nil;
+  @glutSetWindow := nil;
+  @glutSetWindowTitle := nil;
+  @glutSetIconTitle := nil;
+  @glutPositionWindow := nil;
+  @glutReshapeWindow := nil;
+  @glutPopWindow := nil;
+  @glutPushWindow := nil;
+  @glutIconifyWindow := nil;
+  @glutShowWindow := nil;
+  @glutHideWindow := nil;
+  @glutFullScreen := nil;
+  @glutSetCursor := nil;
+  @glutWarpPointer := nil;
+  @glutEstablishOverlay := nil;
+  @glutRemoveOverlay := nil;
+  @glutUseLayer := nil;
+  @glutPostOverlayRedisplay := nil;
+  @glutPostWindowOverlayRedisplay := nil;
+  @glutShowOverlay := nil;
+  @glutHideOverlay := nil;
+  @glutCreateMenu := nil;
+  @glutDestroyMenu := nil;
+  @glutGetMenu := nil;
+  @glutSetMenu := nil;
+  @glutAddMenuEntry := nil;
+  @glutAddSubMenu := nil;
+  @glutChangeToMenuEntry := nil;
+  @glutChangeToSubMenu := nil;
+  @glutRemoveMenuItem := nil;
+  @glutAttachMenu := nil;
+  @glutDetachMenu := nil;
+  @glutDisplayFunc := nil;
+  @glutReshapeFunc := nil;
+  @glutKeyboardFunc := nil;
+  @glutMouseFunc := nil;
+  @glutMotionFunc := nil;
+  @glutPassiveMotionFunc := nil;
+  @glutEntryFunc := nil;
+  @glutVisibilityFunc := nil;
+  @glutIdleFunc := nil;
+  @glutTimerFunc := nil;
+  @glutMenuStateFunc := nil;
+  @glutSpecialFunc := nil;
+  @glutSpaceballMotionFunc := nil;
+  @glutSpaceballRotateFunc := nil;
+  @glutSpaceballButtonFunc := nil;
+  @glutButtonBoxFunc := nil;
+  @glutDialsFunc := nil;
+  @glutTabletMotionFunc := nil;
+  @glutTabletButtonFunc := nil;
+  @glutMenuStatusFunc := nil;
+  @glutOverlayDisplayFunc := nil;
+  @glutWindowStatusFunc := nil;
+  @glutSetColor := nil;
+  @glutGetColor := nil;
+  @glutCopyColormap := nil;
+  @glutGet := nil;
+  @glutDeviceGet := nil;
+  @glutExtensionSupported := nil;
+  @glutGetModifiers := nil;
+  @glutLayerGet := nil;
+  @glutBitmapCharacter := nil;
+  @glutBitmapWidth := nil;
+  @glutStrokeCharacter := nil;
+  @glutStrokeWidth := nil;
+  @glutBitmapLength := nil;
+  @glutStrokeLength := nil;
+  @glutWireSphere := nil;
+  @glutSolidSphere := nil;
+  @glutWireCone := nil;
+  @glutSolidCone := nil;
+  @glutWireCube := nil;
+  @glutSolidCube := nil;
+  @glutWireTorus := nil;
+  @glutSolidTorus := nil;
+  @glutWireDodecahedron := nil;
+  @glutSolidDodecahedron := nil;
+  @glutWireTeapot := nil;
+  @glutSolidTeapot := nil;
+  @glutWireOctahedron := nil;
+  @glutSolidOctahedron := nil;
+  @glutWireTetrahedron := nil;
+  @glutSolidTetrahedron := nil;
+  @glutWireIcosahedron := nil;
+  @glutSolidIcosahedron := nil;
+  @glutVideoResizeGet := nil;
+  @glutSetupVideoResizing := nil;
+  @glutStopVideoResizing := nil;
+  @glutVideoResize := nil;
+  @glutVideoPan := nil;
+  @glutReportErrors := nil;
+
+end;
+
+procedure LoadGlut(const dll: PChar);
+begin
+
+  FreeGlut;
+
+  if LoadModule( LibGLUT, dll ) then
+  begin
+    @glutInit := GetModuleSymbol(LibGLUT, 'glutInit');
+    @glutInitDisplayMode := GetModuleSymbol(LibGLUT, 'glutInitDisplayMode');
+    @glutInitDisplayString := GetModuleSymbol(LibGLUT, 'glutInitDisplayString');
+    @glutInitWindowPosition := GetModuleSymbol(LibGLUT, 'glutInitWindowPosition');
+    @glutInitWindowSize := GetModuleSymbol(LibGLUT, 'glutInitWindowSize');
+    @glutMainLoop := GetModuleSymbol(LibGLUT, 'glutMainLoop');
+    @glutCreateWindow := GetModuleSymbol(LibGLUT, 'glutCreateWindow');
+    @glutCreateSubWindow := GetModuleSymbol(LibGLUT, 'glutCreateSubWindow');
+    @glutDestroyWindow := GetModuleSymbol(LibGLUT, 'glutDestroyWindow');
+    @glutPostRedisplay := GetModuleSymbol(LibGLUT, 'glutPostRedisplay');
+    @glutPostWindowRedisplay := GetModuleSymbol(LibGLUT, 'glutPostWindowRedisplay');
+    @glutSwapBuffers := GetModuleSymbol(LibGLUT, 'glutSwapBuffers');
+    @glutGetWindow := GetModuleSymbol(LibGLUT, 'glutGetWindow');
+    @glutSetWindow := GetModuleSymbol(LibGLUT, 'glutSetWindow');
+    @glutSetWindowTitle := GetModuleSymbol(LibGLUT, 'glutSetWindowTitle');
+    @glutSetIconTitle := GetModuleSymbol(LibGLUT, 'glutSetIconTitle');
+    @glutPositionWindow := GetModuleSymbol(LibGLUT, 'glutPositionWindow');
+    @glutReshapeWindow := GetModuleSymbol(LibGLUT, 'glutReshapeWindow');
+    @glutPopWindow := GetModuleSymbol(LibGLUT, 'glutPopWindow');
+    @glutPushWindow := GetModuleSymbol(LibGLUT, 'glutPushWindow');
+    @glutIconifyWindow := GetModuleSymbol(LibGLUT, 'glutIconifyWindow');
+    @glutShowWindow := GetModuleSymbol(LibGLUT, 'glutShowWindow');
+    @glutHideWindow := GetModuleSymbol(LibGLUT, 'glutHideWindow');
+    @glutFullScreen := GetModuleSymbol(LibGLUT, 'glutFullScreen');
+    @glutSetCursor := GetModuleSymbol(LibGLUT, 'glutSetCursor');
+    @glutWarpPointer := GetModuleSymbol(LibGLUT, 'glutWarpPointer');
+    @glutEstablishOverlay := GetModuleSymbol(LibGLUT, 'glutEstablishOverlay');
+    @glutRemoveOverlay := GetModuleSymbol(LibGLUT, 'glutRemoveOverlay');
+    @glutUseLayer := GetModuleSymbol(LibGLUT, 'glutUseLayer');
+    @glutPostOverlayRedisplay := GetModuleSymbol(LibGLUT, 'glutPostOverlayRedisplay');
+    @glutPostWindowOverlayRedisplay := GetModuleSymbol(LibGLUT, 'glutPostWindowOverlayRedisplay');
+    @glutShowOverlay := GetModuleSymbol(LibGLUT, 'glutShowOverlay');
+    @glutHideOverlay := GetModuleSymbol(LibGLUT, 'glutHideOverlay');
+    @glutCreateMenu := GetModuleSymbol(LibGLUT, 'glutCreateMenu');
+    @glutDestroyMenu := GetModuleSymbol(LibGLUT, 'glutDestroyMenu');
+    @glutGetMenu := GetModuleSymbol(LibGLUT, 'glutGetMenu');
+    @glutSetMenu := GetModuleSymbol(LibGLUT, 'glutSetMenu');
+    @glutAddMenuEntry := GetModuleSymbol(LibGLUT, 'glutAddMenuEntry');
+    @glutAddSubMenu := GetModuleSymbol(LibGLUT, 'glutAddSubMenu');
+    @glutChangeToMenuEntry := GetModuleSymbol(LibGLUT, 'glutChangeToMenuEntry');
+    @glutChangeToSubMenu := GetModuleSymbol(LibGLUT, 'glutChangeToSubMenu');
+    @glutRemoveMenuItem := GetModuleSymbol(LibGLUT, 'glutRemoveMenuItem');
+    @glutAttachMenu := GetModuleSymbol(LibGLUT, 'glutAttachMenu');
+    @glutDetachMenu := GetModuleSymbol(LibGLUT, 'glutDetachMenu');
+    @glutDisplayFunc := GetModuleSymbol(LibGLUT, 'glutDisplayFunc');
+    @glutReshapeFunc := GetModuleSymbol(LibGLUT, 'glutReshapeFunc');
+    @glutKeyboardFunc := GetModuleSymbol(LibGLUT, 'glutKeyboardFunc');
+    @glutMouseFunc := GetModuleSymbol(LibGLUT, 'glutMouseFunc');
+    @glutMotionFunc := GetModuleSymbol(LibGLUT, 'glutMotionFunc');
+    @glutPassiveMotionFunc := GetModuleSymbol(LibGLUT, 'glutPassiveMotionFunc');
+    @glutEntryFunc := GetModuleSymbol(LibGLUT, 'glutEntryFunc');
+    @glutVisibilityFunc := GetModuleSymbol(LibGLUT, 'glutVisibilityFunc');
+    @glutIdleFunc := GetModuleSymbol(LibGLUT, 'glutIdleFunc');
+    @glutTimerFunc := GetModuleSymbol(LibGLUT, 'glutTimerFunc');
+    @glutMenuStateFunc := GetModuleSymbol(LibGLUT, 'glutMenuStateFunc');
+    @glutSpecialFunc := GetModuleSymbol(LibGLUT, 'glutSpecialFunc');
+    @glutSpaceballMotionFunc := GetModuleSymbol(LibGLUT, 'glutSpaceballMotionFunc');
+    @glutSpaceballRotateFunc := GetModuleSymbol(LibGLUT, 'glutSpaceballRotateFunc');
+    @glutSpaceballButtonFunc := GetModuleSymbol(LibGLUT, 'glutSpaceballButtonFunc');
+    @glutButtonBoxFunc := GetModuleSymbol(LibGLUT, 'glutButtonBoxFunc');
+    @glutDialsFunc := GetModuleSymbol(LibGLUT, 'glutDialsFunc');
+    @glutTabletMotionFunc := GetModuleSymbol(LibGLUT, 'glutTabletMotionFunc');
+    @glutTabletButtonFunc := GetModuleSymbol(LibGLUT, 'glutTabletButtonFunc');
+    @glutMenuStatusFunc := GetModuleSymbol(LibGLUT, 'glutMenuStatusFunc');
+    @glutOverlayDisplayFunc := GetModuleSymbol(LibGLUT, 'glutOverlayDisplayFunc');
+    @glutWindowStatusFunc := GetModuleSymbol(LibGLUT, 'glutWindowStatusFunc');
+    @glutSetColor := GetModuleSymbol(LibGLUT, 'glutSetColor');
+    @glutGetColor := GetModuleSymbol(LibGLUT, 'glutGetColor');
+    @glutCopyColormap := GetModuleSymbol(LibGLUT, 'glutCopyColormap');
+    @glutGet := GetModuleSymbol(LibGLUT, 'glutGet');
+    @glutDeviceGet := GetModuleSymbol(LibGLUT, 'glutDeviceGet');
+    @glutExtensionSupported := GetModuleSymbol(LibGLUT, 'glutExtensionSupported');
+    @glutGetModifiers := GetModuleSymbol(LibGLUT, 'glutGetModifiers');
+    @glutLayerGet := GetModuleSymbol(LibGLUT, 'glutLayerGet');
+    @glutBitmapCharacter := GetModuleSymbol(LibGLUT, 'glutBitmapCharacter');
+    @glutBitmapWidth := GetModuleSymbol(LibGLUT, 'glutBitmapWidth');
+    @glutStrokeCharacter := GetModuleSymbol(LibGLUT, 'glutStrokeCharacter');
+    @glutStrokeWidth := GetModuleSymbol(LibGLUT, 'glutStrokeWidth');
+    @glutBitmapLength := GetModuleSymbol(LibGLUT, 'glutBitmapLength');
+    @glutStrokeLength := GetModuleSymbol(LibGLUT, 'glutStrokeLength');
+    @glutWireSphere := GetModuleSymbol(LibGLUT, 'glutWireSphere');
+    @glutSolidSphere := GetModuleSymbol(LibGLUT, 'glutSolidSphere');
+    @glutWireCone := GetModuleSymbol(LibGLUT, 'glutWireCone');
+    @glutSolidCone := GetModuleSymbol(LibGLUT, 'glutSolidCone');
+    @glutWireCube := GetModuleSymbol(LibGLUT, 'glutWireCube');
+    @glutSolidCube := GetModuleSymbol(LibGLUT, 'glutSolidCube');
+    @glutWireTorus := GetModuleSymbol(LibGLUT, 'glutWireTorus');
+    @glutSolidTorus := GetModuleSymbol(LibGLUT, 'glutSolidTorus');
+    @glutWireDodecahedron := GetModuleSymbol(LibGLUT, 'glutWireDodecahedron');
+    @glutSolidDodecahedron := GetModuleSymbol(LibGLUT, 'glutSolidDodecahedron');
+    @glutWireTeapot := GetModuleSymbol(LibGLUT, 'glutWireTeapot');
+    @glutSolidTeapot := GetModuleSymbol(LibGLUT, 'glutSolidTeapot');
+    @glutWireOctahedron := GetModuleSymbol(LibGLUT, 'glutWireOctahedron');
+    @glutSolidOctahedron := GetModuleSymbol(LibGLUT, 'glutSolidOctahedron');
+    @glutWireTetrahedron := GetModuleSymbol(LibGLUT, 'glutWireTetrahedron');
+    @glutSolidTetrahedron := GetModuleSymbol(LibGLUT, 'glutSolidTetrahedron');
+    @glutWireIcosahedron := GetModuleSymbol(LibGLUT, 'glutWireIcosahedron');
+    @glutSolidIcosahedron := GetModuleSymbol(LibGLUT, 'glutSolidIcosahedron');
+    @glutVideoResizeGet := GetModuleSymbol(LibGLUT, 'glutVideoResizeGet');
+    @glutSetupVideoResizing := GetModuleSymbol(LibGLUT, 'glutSetupVideoResizing');
+    @glutStopVideoResizing := GetModuleSymbol(LibGLUT, 'glutStopVideoResizing');
+    @glutVideoResize := GetModuleSymbol(LibGLUT, 'glutVideoResize');
+    @glutVideoPan := GetModuleSymbol(LibGLUT, 'glutVideoPan');
+    @glutReportErrors := GetModuleSymbol(LibGLUT, 'glutReportErrors');
+    @glutGameModeString := GetModuleSymbol(LibGLUT, 'glutGameModeString');
+    @glutEnterGameMode  := GetModuleSymbol(LibGLUT, 'glutEnterGameMode');
+    @glutLeaveGameMode  := GetModuleSymbol(LibGLUT, 'glutLeaveGameMode');
+    @glutGameModeGet    := GetModuleSymbol(LibGLUT, 'glutGameModeGet');
+  end;
+end;
+
+initialization
+  LoadGlut( GlutLibName );
+
+finalization
+  FreeGlut;
+
+end.
diff --git a/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glx.pas b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glx.pas
new file mode 100644
index 00000000..e478758f
--- /dev/null
+++ b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glx.pas
@@ -0,0 +1,276 @@
+unit glx;
+{
+  $Id: glx.pas,v 1.1 2004/03/30 21:53:55 savage Exp $
+
+  Translation of the Mesa GLX headers for FreePascal
+  Copyright (C) 1999 Sebastian Guenther
+
+
+  Mesa 3-D graphics library
+  Version:  3.0
+  Copyright (C) 1995-1998  Brian Paul
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not, write to the Free
+  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+}
+
+// {$MODE delphi}  // objfpc would not work because of direct proc var assignments
+
+{You have to enable Macros (compiler switch "-Sm") for compiling this unit!
+ This is necessary for supporting different platforms with different calling
+ conventions via a single unit.}
+
+{
+  $Log: glx.pas,v $
+  Revision 1.1  2004/03/30 21:53:55  savage
+  Moved to it's own folder.
+
+  Revision 1.5  2004/02/15 22:48:35  savage
+  More FPC and FreeBSD support changes.
+
+  Revision 1.4  2004/02/14 22:36:29  savage
+  Fixed inconsistencies of using LoadLibrary and LoadModule.
+  Now all units make use of LoadModule rather than LoadLibrary and other dynamic proc procedures.
+
+  Revision 1.3  2004/02/14 00:23:39  savage
+  As UNIX is defined in jedi-sdl.inc this will be used to check linux compatability as well. Units have been changed to reflect this change.
+
+  Revision 1.2  2004/02/14 00:09:19  savage
+  Changed uses to now make use of moduleloader.pas rather than dllfuncs.pas
+
+  Revision 1.1  2004/02/05 00:08:19  savage
+  Module 1.0 release
+
+  Revision 1.1  2003/05/11 13:18:03  savage
+  Newest OpenGL Headers For Delphi, Kylix and FPC
+
+  Revision 1.1  2002/10/13 13:57:31  sg
+  * Finally, the new units are available: Match the C headers more closely;
+    support for OpenGL extensions, and much more. Based on the Delphi units
+    by Tom Nuydens of delphi3d.net
+
+}
+
+interface
+
+{$I jedi-sdl.inc}
+
+//{$MACRO ON}
+
+{$IFDEF UNIX}
+  uses
+    {$IFDEF FPC}
+    x,
+    xlib,
+    xutil;
+    {$ELSE}
+    xlib;
+    {$ENDIF}
+  {$DEFINE HasGLX}  // Activate GLX stuff
+{$ELSE}
+  {$MESSAGE Unsupported platform.}
+{$ENDIF}
+
+{$IFNDEF HasGLX}
+  {$MESSAGE GLX not present on this platform.}
+{$ENDIF}
+
+
+// =======================================================
+//   Unit specific extensions
+// =======================================================
+
+// Note: Requires that the GL library has already been initialized
+function InitGLX: Boolean;
+
+var
+  GLXDumpUnresolvedFunctions,
+  GLXInitialized: Boolean;
+
+
+// =======================================================
+//   GLX consts, types and functions
+// =======================================================
+
+// Tokens for glXChooseVisual and glXGetConfig:
+const
+  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_EXT_visual_info extension
+  GLX_X_VISUAL_TYPE_EXT                 = $22;
+  GLX_TRANSPARENT_TYPE_EXT              = $23;
+  GLX_TRANSPARENT_INDEX_VALUE_EXT       = $24;
+  GLX_TRANSPARENT_RED_VALUE_EXT         = $25;
+  GLX_TRANSPARENT_GREEN_VALUE_EXT       = $26;
+  GLX_TRANSPARENT_BLUE_VALUE_EXT        = $27;
+  GLX_TRANSPARENT_ALPHA_VALUE_EXT       = $28;
+
+
+  // Error codes returned by glXGetConfig:
+  GLX_BAD_SCREEN                        = 1;
+  GLX_BAD_ATTRIBUTE                     = 2;
+  GLX_NO_EXTENSION                      = 3;
+  GLX_BAD_VISUAL                        = 4;
+  GLX_BAD_CONTEXT                       = 5;
+  GLX_BAD_VALUE                         = 6;
+  GLX_BAD_ENUM                          = 7;
+
+  // GLX 1.1 and later:
+  GLX_VENDOR                            = 1;
+  GLX_VERSION                           = 2;
+  GLX_EXTENSIONS                        = 3;
+
+  // GLX_visual_info extension
+  GLX_TRUE_COLOR_EXT                    = $8002;
+  GLX_DIRECT_COLOR_EXT                  = $8003;
+  GLX_PSEUDO_COLOR_EXT                  = $8004;
+  GLX_STATIC_COLOR_EXT                  = $8005;
+  GLX_GRAY_SCALE_EXT                    = $8006;
+  GLX_STATIC_GRAY_EXT                   = $8007;
+  GLX_NONE_EXT                          = $8000;
+  GLX_TRANSPARENT_RGB_EXT               = $8008;
+  GLX_TRANSPARENT_INDEX_EXT             = $8009;
+
+type
+  // From XLib:
+  {$IFNDEF FPC}
+  TXID = XID;
+  {$ENDIF}
+  XPixmap = TXID;
+  XFont = TXID;
+  XColormap = TXID;
+
+  GLXContext = Pointer;
+  GLXPixmap = TXID;
+  GLXDrawable = TXID;
+  GLXContextID = TXID;
+
+var
+  glXChooseVisual: function(dpy: PDisplay; screen: Integer; var attribList: Integer): PXVisualInfo; cdecl;
+  glXCreateContext: function(dpy: PDisplay; vis: PXVisualInfo; shareList: GLXContext; direct: Boolean): GLXContext; cdecl;
+  glXDestroyContext: procedure(dpy: PDisplay; ctx: GLXContext); cdecl;
+  glXMakeCurrent: function(dpy: PDisplay; drawable: GLXDrawable; ctx: GLXContext): Boolean; cdecl;
+  glXCopyContext: procedure(dpy: PDisplay; src, dst: GLXContext; mask: LongWord); cdecl;
+  glXSwapBuffers: procedure(dpy: PDisplay; drawable: GLXDrawable); cdecl;
+  glXCreateGLXPixmap: function(dpy: PDisplay; visual: PXVisualInfo; pixmap: XPixmap): GLXPixmap; cdecl;
+  glXDestroyGLXPixmap: procedure(dpy: PDisplay; pixmap: GLXPixmap); cdecl;
+  glXQueryExtension: function(dpy: PDisplay; var errorb, event: Integer): Boolean; cdecl;
+  glXQueryVersion: function(dpy: PDisplay; var maj, min: Integer): Boolean; cdecl;
+  glXIsDirect: function(dpy: PDisplay; ctx: GLXContext): Boolean; cdecl;
+  glXGetConfig: function(dpy: PDisplay; visual: PXVisualInfo; attrib: Integer; var value: Integer): Integer; cdecl;
+  glXGetCurrentContext: function: GLXContext; cdecl;
+  glXGetCurrentDrawable: function: GLXDrawable; cdecl;
+  glXWaitGL: procedure; cdecl;
+  glXWaitX: procedure; cdecl;
+  glXUseXFont: procedure(font: XFont; first, count, list: Integer); cdecl;
+
+  // GLX 1.1 and later
+  glXQueryExtensionsString: function(dpy: PDisplay; screen: Integer): PChar; cdecl;
+  glXQueryServerString: function(dpy: PDisplay; screen, name: Integer): PChar; cdecl;
+  glXGetClientString: function(dpy: PDisplay; name: Integer): PChar; cdecl;
+
+  // Mesa GLX Extensions
+  glXCreateGLXPixmapMESA: function(dpy: PDisplay; visual: PXVisualInfo; pixmap: XPixmap; cmap: XColormap): GLXPixmap; cdecl;
+  glXReleaseBufferMESA: function(dpy: PDisplay; d: GLXDrawable): Boolean; cdecl;
+  glXCopySubBufferMESA: procedure(dpy: PDisplay; drawbale: GLXDrawable; x, y, width, height: Integer); cdecl;
+  glXGetVideoSyncSGI: function(var counter: LongWord): Integer; cdecl;
+  glXWaitVideoSyncSGI: function(divisor, remainder: Integer; var count: LongWord): Integer; cdecl;
+
+
+// =======================================================
+//
+// =======================================================
+
+implementation
+
+uses
+  {$IFNDEF __GPC__}
+  SysUtils,
+  {$ENDIF}
+  moduleloader;
+
+(* {$LINKLIB m}  *)
+
+var
+  libGLX: TModuleHandle;
+
+function InitGLXFromLibrary( dll : PChar ): Boolean;
+begin
+  Result := False;
+
+  if LoadModule( libGLX, dll ) then
+    exit;
+
+  glXChooseVisual := GetModuleSymbol(libglx, 'glXChooseVisual');
+  glXCreateContext := GetModuleSymbol(libglx, 'glXCreateContext');
+  glXDestroyContext := GetModuleSymbol(libglx, 'glXDestroyContext');
+  glXMakeCurrent := GetModuleSymbol(libglx, 'glXMakeCurrent');
+  glXCopyContext := GetModuleSymbol(libglx, 'glXCopyContext');
+  glXSwapBuffers := GetModuleSymbol(libglx, 'glXSwapBuffers');
+  glXCreateGLXPixmap := GetModuleSymbol(libglx, 'glXCreateGLXPixmap');
+  glXDestroyGLXPixmap := GetModuleSymbol(libglx, 'glXDestroyGLXPixmap');
+  glXQueryExtension := GetModuleSymbol(libglx, 'glXQueryExtension');
+  glXQueryVersion := GetModuleSymbol(libglx, 'glXQueryVersion');
+  glXIsDirect := GetModuleSymbol(libglx, 'glXIsDirect');
+  glXGetConfig := GetModuleSymbol(libglx, 'glXGetConfig');
+  glXGetCurrentContext := GetModuleSymbol(libglx, 'glXGetCurrentContext');
+  glXGetCurrentDrawable := GetModuleSymbol(libglx, 'glXGetCurrentDrawable');
+  glXWaitGL := GetModuleSymbol(libglx, 'glXWaitGL');
+  glXWaitX := GetModuleSymbol(libglx, 'glXWaitX');
+  glXUseXFont := GetModuleSymbol(libglx, 'glXUseXFont');
+  // GLX 1.1 and later
+  glXQueryExtensionsString := GetModuleSymbol(libglx, 'glXQueryExtensionsString');
+  glXQueryServerString := GetModuleSymbol(libglx, 'glXQueryServerString');
+  glXGetClientString := GetModuleSymbol(libglx, 'glXGetClientString');
+  // Mesa GLX Extensions
+  glXCreateGLXPixmapMESA := GetModuleSymbol(libglx, 'glXCreateGLXPixmapMESA');
+  glXReleaseBufferMESA := GetModuleSymbol(libglx, 'glXReleaseBufferMESA');
+  glXCopySubBufferMESA := GetModuleSymbol(libglx, 'glXCopySubBufferMESA');
+  glXGetVideoSyncSGI := GetModuleSymbol(libglx, 'glXGetVideoSyncSGI');
+  glXWaitVideoSyncSGI := GetModuleSymbol(libglx, 'glXWaitVideoSyncSGI');
+
+  GLXInitialized := True;
+  Result := True;
+end;
+
+function InitGLX: Boolean;
+begin
+  Result := InitGLXFromLibrary('libGL.so') or
+            InitGLXFromLibrary('libGL.so.1') or
+            InitGLXFromLibrary('libMesaGL.so') or
+            InitGLXFromLibrary('libMesaGL.so.3');
+end;
+
+
+initialization
+  InitGLX;
+finalization
+  UnloadModule(libGLX);
+end.
diff --git a/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/opengl12.pas b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/opengl12.pas
new file mode 100644
index 00000000..763edaee
--- /dev/null
+++ b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/opengl12.pas
@@ -0,0 +1,9967 @@
+unit opengl12;
+{
+  $Id: opengl12.pas,v 1.2 2004/04/05 09:59:46 savage Exp $
+  
+}
+{******************************************************************************}
+{                                                       	                     }
+{       Borland Delphi Runtime Library                  		                   }
+{       OpenGL interface unit                                                  }
+{                                                       	                     }
+{                                                       	                     }
+{ This is an interface unit for the use of OpenGL from within Delphi and Kylix.}
+{ It contains the translations of gl.h, glu.h, glx.h as well as context        }
+{ and extension management functions.                                          }
+{                                                                              }
+{ The original Pascal code is: OpenGL12.pas 	                                 }
+{ The initial developer of the Pascal code is Mike Lischke                     }
+{                                                                              }
+{ 									                                                           }
+{ Portions created by Microsoft are 					                                 }
+{ Copyright (C) 1995-2001 Microsoft Corporation. 			                         }
+{ All Rights Reserved. 							                                           }
+{ 									                                                           }
+{ Portions created by Silicon Graphics Incorporated are 		                   }
+{ Copyright (C) 1995-2001 Silicon Graphics Incorporated 		                   }
+{ All Rights Reserved. 							                                           }
+{ 									                                                           }
+{ Portions created by NVidia are                        		                   }
+{ Copyright (C) 1995-2001 NVidia 		                                           }
+{ All Rights Reserved. 							                                           }
+{ 									                                                           }
+{ Portions created by Brian Paul                       		                     }
+{ Copyright (C) 1995-2001 Brian Paul 		                                       }
+{ All Rights Reserved. 							                                           }
+{ 									                                                           }
+{ 									                                                           }
+{ The original file is: gl.h                                                   }
+{ The original file is: glut.h                                                 }
+{ The original file is: glx.h                                                  }
+{ The original file is: glx.h                                                  }
+{ 									                                                           }
+{ Portions created by Mike Lischke are    				                             }
+{ Copyright (C) 2001 Mike Lischke. 					                                   }
+{ 									                                                           }
+{ Portions created by John O'Harrow are    				                             }
+{ Copyright (C) 2001 John O'Harrow. 					                                 } 
+{                                                                              }
+{ Portions created by Eric Grange are    				                               }
+{ Copyright (C) 2001 Eric Grange. 					                                   }
+{                                                                              }
+{ Portions created by Olivier Chatelain    				                             }
+{ Copyright (C) 2001 Olivier Chatelain. 				                               }
+{                                                                              }
+{ Portions created by Tom Nuydens            				                           }
+{ Copyright (C) 2001 Tom Nuydens.       				                               }
+{                                                                              }
+{ Portions created by Matthias Thoma are    				                           }
+{ Copyright (C) 2001 Matthias Thoma. 					                                 }
+{                                                                              }
+{ Portions created by Sven Bobrowski are    				                           }
+{ Copyright (C) 2001 Sven Bobrowski 					                                 }
+{                                                                              }
+{                                                                              }
+{       Obtained through:                               		                   }
+{ 									                                                           }
+{       Joint Endeavour of Delphi Innovators (Project JEDI)                    }
+{									                                                             }
+{ You may retrieve the latest version of this file at the Project              }
+{ JEDI home page, located at http://delphi-jedi.org                            }
+{									                                                             }
+{ 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. 				                           }
+{ 									                                                           }
+{******************************************************************************}
+
+//----------------------------------------------------------------------------------------------------------------------
+//
+//  This is an interface unit for the use of OpenGL from within Delphi and contains
+//  the translations of gl.h, glu.h as well as some support functions.
+//  OpenGL12.pas contains bug fixes and enhancements of Delphi's and other translations
+//  as well as support for extensions.
+//
+//  NOTE: In order to fully support multi thread rendering it is necessary to hold all
+//        extension address in threadvars. For single threaded applications this would be an
+//        unnecessary time penalty, however. Hence there is a compiler switch to
+//        allow single threaded OpenGL application to use vars while multi threaded applications
+//        will use threadvars. By default the switch MULTITHREADOPENGL (see compiler switch under der interface keyword)
+//        is not active and must explicitly enabled to take effect.
+//
+//----------------------------------------------------------------------------------------------------------------------
+//
+// function InitOpenGL: Boolean; 
+//   Needed to load the OpenGL DLLs and all addresses of the standard functions.
+//   In case OpenGL is already initialized this function does nothing. No error
+//   is raised, if something goes wrong, but you need to inspect the result in order
+//   to know if all went okay.
+//   Result: True if successful or already loaded, False otherwise.
+//
+// function InitOpenGLFromLibrary(GL_Name, GLU_Name: String): Boolean; 
+//   Same as InitOpenGL, but you can specify specific DLLs. Useful if you want to
+//   use different DLLs than the default ones. This function closes previously
+//   loaded DLLs before it tries to open the new libraries.
+//   Result: True if successful, False otherwise.
+//
+// procedure CloseOpenGL; 
+//   Unloads the OpenGL DLLs and sets all function addresses to nil, including
+//   extensions. You can load and unload the DLLs as often as you like.
+//
+// procedure ClearExtensions; 
+//   Sets all extension routines to nil. This is needed when you change the Pixelformat
+//   of your OpenGL window, since the availability of these routines changes from
+//   PixelFormat to Pixelformat (and also between various vendors).
+//
+// function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, StencilBits, AccumBits, AuxBuffers: Integer; 
+//   Layer: Integer; var Palette: HPALETTE): HGLRC; 
+//   Sets up a pixel format and creates a new rendering context depending of the
+//   given parameters:
+//     DC          - the device context for which the rc is to be created
+//     Options     - options for the context, which the application would like to have
+//                   (it is not guaranteed they will be available)
+//     ColorBits   - the color depth of the device context (Note: Because of the internal DC handling of the VCL you
+//                   should avoid using GetDeviceCaps for memory DCs which are members of a TBitmap class.
+//                   Translate the Pixelformat member instead!)
+//     StencilBits - requested size of the stencil buffer
+//     AccumBits   - requested size of the accumulation buffer
+//     AuxBuffers  - requested number of auxiliary buffers
+//     Layer       - ID for the layer for which the RC will be created (-1..-15 for underlay planes, 0 for main plane,
+//                   1..15 for overlay planes)
+//                   Note: The layer handling is not yet complete as there is very few information
+//                   available and (until now) no OpenGL implementation with layer support on the low budget market.
+//                   Hence use 0 (for the main plane) as layer ID.
+//     Palette     - Palette Handle created within function (need to use DeleteObject(Palette) to free this if <> 0)
+//   Result: the newly created context or 0 if setup failed
+//
+// procedure ActivateRenderingContext(DC: HDC; RC: HGLRC); 
+//   Makes RC in DC 'current' (wglMakeCurrent(..)) and loads all extension addresses
+//   and flags if necessary.
+//
+// procedure DeactivateRenderingContext; 
+//   Counterpart to ActivateRenderingContext.
+//
+// procedure DestroyRenderingContext(RC: HGLRC); 
+//   RC will be destroyed and must be recreated if you want to use it again.
+//
+// procedure ReadExtensions; 
+//   Determines which extensions for the current rendering context are available and
+//   loads their addresses. This procedure is called from ActivateRenderingContext
+//   if a new pixel format is used, but you can safely call it from where you want
+//   to actualize those values (under the condition that a rendering context MUST be
+//   active).
+//
+// procedure ReadImplementationProperties; 
+//   Determines other properties of the OpenGL DLL (version, availability of extensions).
+//   Again, a valid rendering context must be active.
+//
+// function HasActiveContext: Boolean; 
+//   Determines whether the calling thread has currently an active rendering context.
+//----------------------------------------------------------------------------------------------------------------------
+//
+// This translation is based on different sources:
+//
+// - first translation from Artemis Alliance Inc.
+// - previous versions from Mike Lischke
+// - Alexander Staubo
+// - Borland OpenGL.pas (from Delphi 3)
+// - Microsoft and SGI OpenGL header files
+// - www.opengl.org, www.sgi.com/OpenGL
+// - nVidia extension reference as of December 1999
+// - nVidia extension reference as of January 2001
+// - vertex_array_range sample by Tom Nuydens at Delphi3D
+// - minor bug fixes and greatly extended by John O'Harrow (john@elmcrest.demon.co.uk)
+// - initial context activation balancing by Eric Grange (egrange@infonie.fr)
+// - additional nVidia extensions by Olivier Chatelain (Olivier.Chatelain@xitact.com)
+//
+//  Contact: public@lischke-online.de, www.lischke-online.de
+//
+//  Version: 1.2.11
+//----------------------------------------------------------------------------------------------------------------------
+//
+// 12-Feb-2002 dml :
+//   - Further modifications to allow unit to compile under Free Pascal
+//     as suggested by "QuePasha Pepe" <mrkroket@hotmail.com>
+//
+// 25-OCT-2001 dre :
+//   - Made modifications to allow unit to compile under Free Pascal
+//   - added tMaxLogPalette declaration to Free Pascal
+//   - included fix to ReadExtensions
+//   - Added Set8088CW procedure
+//
+// 13-SEP-2001 ml:
+//   - added PWGLSwap etc. declarations for Delphi 3
+// 18-AUG-2001 ml:
+//   - multi thread support for function addresses (extensions)
+// 28-JUL-2001 ml:
+//   - included original type names (+ $EXTERNALSYM directives)
+// 10-JUL-2001 ml:
+//   - TGLubyte changed to UCHAR
+// 05-JUL-2001 ml:
+//   - own exception type for OpenGL
+//   - TGLboolean is now of type BYTEBOOL
+// 05-MAY-2001 ml:
+//   - correct tracking of RC creation and release as well as multithreaded RC activation
+//   - compatibility routines for users of other OpenGL unit variants
+//   - improved rendering context creation
+//   - bug fixes
+// 01-MAY-2001 ml:
+//   - added more nVidia extensions
+//----------------------------------------------------------------------------------------------------------------------
+{   April   03 2003 - DL : Added jedi-sdl.inc include file to support more     }
+{                          Pascal compilers. Initial support is now included   }
+{                          for GnuPascal, VirtualPascal, TMT and obviously     }
+{                          continue support for Delphi Kylix and FreePascal.   }
+{                                                                              }
+{   May     03 2003 - DL : under instruction from David Mears AKA              }
+{                          Jason Siletto, I have added FPC Linux support.      }
+{                                                                              }
+{******************************************************************************}
+{
+  $Log: opengl12.pas,v $
+  Revision 1.2  2004/04/05 09:59:46  savage
+  Changes for FreePacal as suggested by Marco
+
+  Revision 1.1  2004/03/30 21:53:55  savage
+  Moved to it's own folder.
+
+  Revision 1.6  2004/02/20 17:26:19  savage
+  Extensions are now loaded using SDL_GL_GetProcAddress, thus making it more cross-platform compatible, but now more tied to SDL.
+
+  Revision 1.5  2004/02/15 22:48:36  savage
+  More FPC and FreeBSD support changes.
+
+  Revision 1.4  2004/02/14 22:36:29  savage
+  Fixed inconsistencies of using LoadLibrary and LoadModule.
+  Now all units make use of LoadModule rather than LoadLibrary and other dynamic proc procedures.
+
+  Revision 1.3  2004/02/14 00:23:39  savage
+  As UNIX is defined in jedi-sdl.inc this will be used to check linux compatability as well. Units have been changed to reflect this change.
+
+  Revision 1.2  2004/02/14 00:09:19  savage
+  Changed uses to now make use of moduleloader.pas rather than dllfuncs.pas
+
+  Revision 1.1  2004/02/05 00:08:20  savage
+  Module 1.0 release
+
+  
+}
+
+{$I jedi-sdl.inc}
+
+interface
+
+{.$define MULTITHREADOPENGL}
+
+uses
+{$IFDEF __GPC__}
+  gpc;
+{$ENDIF}
+
+{$IFDEF WIN32}
+  {$IFNDEF __GPC__}
+  Windows;
+  {$ENDIF}
+{$ENDIF}
+
+{$IFDEF Unix}
+  {$IFDEF FPC}
+    {$IFDEF Ver1_0}
+    linux,
+    {$ELSE}
+    baseunix,
+    unix,
+    {$ENDIF}
+    x,
+    xlib,
+    xutil,
+    dl;
+  {$ELSE}
+  Types,
+  Libc,
+  Xlib;
+  {$ENDIF}
+{$ENDIF}
+
+type
+  TRCOptions = set of ( opDoubleBuffered, opGDI, opStereo );
+
+  {$EXTERNALSYM GLenum}
+  GLenum      = Cardinal;
+  TGLenum     = Cardinal; 
+  PGLenum     = ^TGLenum;
+
+  {$EXTERNALSYM GLboolean}
+  GLboolean   = BYTEBOOL;
+  TGLboolean  = BYTEBOOL;
+  PGLboolean  = ^TGLboolean;
+
+  {$EXTERNALSYM GLbitfield}
+  GLbitfield  = Cardinal;
+  TGLbitfield = Cardinal;
+  PGLbitfield = ^TGLbitfield;
+
+  {$EXTERNALSYM GLbyte}
+  GLbyte      = ShortInt;
+  TGLbyte     = ShortInt;
+  PGLbyte     = ^TGLbyte;
+
+  {$EXTERNALSYM GLshort}
+  GLshort     = SmallInt;
+  TGLshort    = SmallInt;
+  PGLshort    = ^TGLshort;
+
+  {$EXTERNALSYM GLint}
+  GLint       = Integer;
+  TGLint      = Integer;
+  PGLint      = ^TGLint;
+
+  {$EXTERNALSYM GLsizei}
+  GLsizei     = Integer;
+  TGLsizei    = Integer;
+  PGLsizei    = ^TGLsizei;
+
+  {$EXTERNALSYM GLubyte}
+  UCHAR       = Byte;
+  GLubyte     = UCHAR;
+  TGLubyte    = UCHAR;
+  PGLubyte    = ^TGLubyte;
+
+  {$EXTERNALSYM GLushort}
+  GLushort    = Word;
+  TGLushort   = Word;
+  PGLushort   = ^TGLushort;
+
+  {$EXTERNALSYM GLuint}
+  GLuint      = Cardinal;
+  TGLuint     = Cardinal;
+  PGLuint     = ^TGLuint;
+
+  {$EXTERNALSYM GLfloat}
+  GLfloat     = Single;
+  TGLfloat    = Single;
+  PGLfloat    = ^TGLfloat;
+
+  {$EXTERNALSYM GLclampf}
+  GLclampf    = Single;
+  TGLclampf   = Single;
+  PGLclampf   = ^TGLclampf;
+
+  {$EXTERNALSYM GLdouble}
+  GLdouble    = Double;
+  TGLdouble   = Double;
+  PGLdouble   = ^TGLdouble;
+
+  {$EXTERNALSYM GLclampd}
+  GLclampd    = Double;
+  TGLclampd   = Double;
+  PGLclampd   = ^TGLclampd; 
+
+  TVector3d = array[0..2] of GLdouble;
+  
+  TVector4i = array[0..3] of GLint;
+  TVector4f = array[0..3] of GLfloat;
+  TVector4p = array[0..3] of Pointer;
+
+  TMatrix4f = array[0..3, 0..3] of GLfloat;
+  TMatrix4d = array[0..3, 0..3] of GLdouble;
+  
+  PPointer = ^Pointer;
+
+{$ifndef FPC} 
+  {$ifdef MULTITHREADOPENGL}
+  threadvar
+  {$else}
+  var
+  {$endif} 
+{$else} 
+var 
+{$endif} 
+  GL_VERSION_1_0,
+  GL_VERSION_1_1,
+  GL_VERSION_1_2,
+  GLU_VERSION_1_1,
+  GLU_VERSION_1_2,
+  GLU_VERSION_1_3: Boolean; 
+
+  // Extensions (gl)
+  GL_3DFX_multisample,
+  GL_3DFX_tbuffer,
+  GL_3DFX_texture_compression_FXT1,
+
+  GL_APPLE_specular_vector,
+  GL_APPLE_transform_hint,
+
+  GL_ARB_imaging,
+  GL_ARB_multisample,
+  GL_ARB_multitexture,
+  GL_ARB_texture_compression,
+  GL_ARB_texture_cube_map,
+  GL_ARB_transpose_matrix,
+  GL_ARB_vertex_blend,
+
+  GL_EXT_422_pixels,
+  GL_EXT_abgr,
+  GL_EXT_bgra,
+  GL_EXT_blend_color,
+  GL_EXT_blend_func_separate,
+  GL_EXT_blend_logic_op,
+  GL_EXT_blend_minmax,
+  GL_EXT_blend_subtract,
+  GL_EXT_clip_volume_hint,
+  GL_EXT_cmyka,
+  GL_EXT_color_subtable,
+  GL_EXT_compiled_vertex_array,
+  GL_EXT_convolution,
+  GL_EXT_coordinate_frame,
+  GL_EXT_copy_texture,
+  GL_EXT_cull_vertex,
+  GL_EXT_draw_range_elements,
+  GL_EXT_fog_coord,
+  GL_EXT_histogram,
+  GL_EXT_index_array_formats,
+  GL_EXT_index_func,
+  GL_EXT_index_material,
+  GL_EXT_index_texture,
+  GL_EXT_light_max_exponent,
+  GL_EXT_light_texture,
+  GL_EXT_misc_attribute,
+  GL_EXT_multi_draw_arrays,
+  GL_EXT_multisample,
+  GL_EXT_packed_pixels,
+  GL_EXT_paletted_texture,
+  GL_EXT_pixel_transform,
+  GL_EXT_point_parameters,
+  GL_EXT_polygon_offset,
+  GL_EXT_rescale_normal,
+  GL_EXT_scene_marker,
+  GL_EXT_secondary_color,
+  GL_EXT_separate_specular_color,
+  GL_EXT_shared_texture_palette,
+  GL_EXT_stencil_wrap,
+  GL_EXT_subtexture,
+  GL_EXT_texture_color_table,
+  GL_EXT_texture_compression_s3tc,
+  GL_EXT_texture_cube_map,
+  GL_EXT_texture_edge_clamp,
+  GL_EXT_texture_env_add,
+  GL_EXT_texture_env_combine,
+  GL_EXT_texture_filter_anisotropic,
+  GL_EXT_texture_lod_bias,
+  GL_EXT_texture_object,
+  GL_EXT_texture_perturb_normal,
+  GL_EXT_texture3D,
+  GL_EXT_vertex_array,
+  GL_EXT_vertex_weighting,
+
+  GL_FfdMaskSGIX,
+  GL_HP_convolution_border_modes,
+  GL_HP_image_transform,
+  GL_HP_occlusion_test,
+  GL_HP_texture_lighting,
+
+  GL_IBM_cull_vertex,
+  GL_IBM_multimode_draw_arrays,
+  GL_IBM_rasterpos_clip,
+  GL_IBM_vertex_array_lists,
+
+  GL_INGR_color_clamp,
+  GL_INGR_interlace_read,
+
+  GL_INTEL_parallel_arrays,
+
+  GL_KTX_buffer_region,
+
+  GL_MESA_resize_buffers,
+  GL_MESA_window_pos,
+
+  GL_NV_blend_square,
+  GL_NV_fog_distance,
+  GL_NV_light_max_exponent,
+  GL_NV_register_combiners,
+  GL_NV_texgen_emboss,
+  GL_NV_texgen_reflection,
+  GL_NV_texture_env_combine4,
+  GL_NV_vertex_array_range,
+  GL_NV_vertex_program,
+
+  GL_PGI_misc_hints,
+  GL_PGI_vertex_hints,
+
+  GL_REND_screen_coordinates,
+
+  GL_SGI_color_matrix,
+  GL_SGI_color_table,
+  GL_SGI_depth_pass_instrument,
+
+  GL_SGIS_detail_texture,
+  GL_SGIS_fog_function,
+  GL_SGIS_generate_mipmap,
+  GL_SGIS_multisample,
+  GL_SGIS_multitexture,
+  GL_SGIS_pixel_texture,
+  GL_SGIS_point_line_texgen,
+  GL_SGIS_point_parameters,
+  GL_SGIS_sharpen_texture,
+  GL_SGIS_texture_border_clamp,
+  GL_SGIS_texture_color_mask,
+  GL_SGIS_texture_edge_clamp,
+  GL_SGIS_texture_filter4,
+  GL_SGIS_texture_lod,
+  GL_SGIS_texture_select,
+  GL_SGIS_texture4D,
+
+  GL_SGIX_async,
+  GL_SGIX_async_histogram,
+  GL_SGIX_async_pixel,
+  GL_SGIX_blend_alpha_minmax,
+  GL_SGIX_calligraphic_fragment,
+  GL_SGIX_clipmap,
+  GL_SGIX_convolution_accuracy,
+  GL_SGIX_depth_texture,
+  GL_SGIX_flush_raster,
+  GL_SGIX_fog_offset,
+  GL_SGIX_fog_scale,
+  GL_SGIX_fragment_lighting,
+  GL_SGIX_framezoom,
+  GL_SGIX_igloo_interface,
+  GL_SGIX_instruments,
+  GL_SGIX_interlace,
+  GL_SGIX_ir_instrument1,
+  GL_SGIX_list_priority,
+  GL_SGIX_pixel_texture,
+  GL_SGIX_pixel_tiles,
+  GL_SGIX_polynomial_ffd,
+  GL_SGIX_reference_plane,
+  GL_SGIX_resample,
+  GL_SGIX_shadow,
+  GL_SGIX_shadow_ambient,
+  GL_SGIX_sprite,
+  GL_SGIX_subsample,
+  GL_SGIX_tag_sample_buffer,
+  GL_SGIX_texture_add_env,
+  GL_SGIX_texture_lod_bias,
+  GL_SGIX_texture_multi_buffer,
+  GL_SGIX_texture_scale_bias,
+  GL_SGIX_vertex_preclip,
+  GL_SGIX_ycrcb,
+  GL_SGIX_ycrcba,
+
+  GL_SUN_convolution_border_modes,
+  GL_SUN_global_alpha,
+  GL_SUN_triangle_list,
+  GL_SUN_vertex,
+
+  GL_SUNX_constant_data,
+
+  GL_WIN_phong_shading,
+  GL_WIN_specular_fog,
+  GL_WIN_swap_hint,
+
+  WGL_EXT_swap_control,
+  WGL_ARB_extensions_string,
+  WGL_ARB_pixel_format,
+
+  // Extensions (glu)
+  GLU_EXT_Texture,
+  GLU_EXT_object_space_tess,
+  GLU_EXT_nurbs_tessellator: Boolean; 
+
+const
+  // ********** GL generic constants **********
+
+  // errors
+  GL_NO_ERROR                                       = 0;
+  {$EXTERNALSYM GL_NO_ERROR}
+  GL_INVALID_ENUM                                   = $0500;
+  {$EXTERNALSYM GL_INVALID_ENUM}
+  GL_INVALID_VALUE                                  = $0501;
+  {$EXTERNALSYM GL_INVALID_VALUE}
+  GL_INVALID_OPERATION                              = $0502;
+  {$EXTERNALSYM GL_INVALID_OPERATION}
+  GL_STACK_OVERFLOW                                 = $0503;
+  {$EXTERNALSYM GL_STACK_OVERFLOW}
+  GL_STACK_UNDERFLOW                                = $0504;
+  {$EXTERNALSYM GL_STACK_UNDERFLOW}
+  GL_OUT_OF_MEMORY                                  = $0505;
+  {$EXTERNALSYM GL_STACK_UNDERFLOW}
+
+  // attribute bits
+  GL_CURRENT_BIT                                    = $00000001;
+  {$EXTERNALSYM GL_CURRENT_BIT}
+  GL_POINT_BIT                                      = $00000002;
+  {$EXTERNALSYM GL_POINT_BIT}
+  GL_LINE_BIT                                       = $00000004;
+  {$EXTERNALSYM GL_LINE_BIT}
+  GL_POLYGON_BIT                                    = $00000008;
+  {$EXTERNALSYM GL_POLYGON_BIT}
+  GL_POLYGON_STIPPLE_BIT                            = $00000010;
+  {$EXTERNALSYM GL_POLYGON_STIPPLE_BIT}
+  GL_PIXEL_MODE_BIT                                 = $00000020;
+  {$EXTERNALSYM GL_PIXEL_MODE_BIT}
+  GL_LIGHTING_BIT                                   = $00000040;
+  {$EXTERNALSYM GL_LIGHTING_BIT}
+  GL_FOG_BIT                                        = $00000080;
+  {$EXTERNALSYM GL_FOG_BIT}
+  GL_DEPTH_BUFFER_BIT                               = $00000100;
+  {$EXTERNALSYM GL_DEPTH_BUFFER_BIT}
+  GL_ACCUM_BUFFER_BIT                               = $00000200;
+  {$EXTERNALSYM GL_ACCUM_BUFFER_BIT}
+  GL_STENCIL_BUFFER_BIT                             = $00000400;
+  {$EXTERNALSYM GL_STENCIL_BUFFER_BIT}
+  GL_VIEWPORT_BIT                                   = $00000800;
+  {$EXTERNALSYM GL_VIEWPORT_BIT}
+  GL_TRANSFORM_BIT                                  = $00001000;
+  {$EXTERNALSYM GL_TRANSFORM_BIT}
+  GL_ENABLE_BIT                                     = $00002000;
+  {$EXTERNALSYM GL_ENABLE_BIT}
+  GL_COLOR_BUFFER_BIT                               = $00004000;
+  {$EXTERNALSYM GL_COLOR_BUFFER_BIT}
+  GL_HINT_BIT                                       = $00008000;
+  {$EXTERNALSYM GL_HINT_BIT}
+  GL_EVAL_BIT                                       = $00010000;
+  {$EXTERNALSYM GL_EVAL_BIT}
+  GL_LIST_BIT                                       = $00020000;
+  {$EXTERNALSYM GL_LIST_BIT}
+  GL_TEXTURE_BIT                                    = $00040000;
+  {$EXTERNALSYM GL_TEXTURE_BIT}
+  GL_SCISSOR_BIT                                    = $00080000;
+  {$EXTERNALSYM GL_SCISSOR_BIT}
+  GL_ALL_ATTRIB_BITS                                = $000FFFFF;
+  {$EXTERNALSYM GL_ALL_ATTRIB_BITS}
+
+  // client attribute bits
+  GL_CLIENT_PIXEL_STORE_BIT                         = $00000001;
+  {$EXTERNALSYM GL_CLIENT_PIXEL_STORE_BIT}
+  GL_CLIENT_VERTEX_ARRAY_BIT                        = $00000002;
+  {$EXTERNALSYM GL_CLIENT_VERTEX_ARRAY_BIT}
+  GL_CLIENT_ALL_ATTRIB_BITS                         = $FFFFFFFF;
+  {$EXTERNALSYM GL_CLIENT_ALL_ATTRIB_BITS}
+
+  // boolean values
+  GL_FALSE                                          = Boolean( 0 );
+  {$EXTERNALSYM GL_FALSE}
+  GL_TRUE                                           = Boolean( 1 );
+  {$EXTERNALSYM GL_TRUE}
+
+  // primitives
+  GL_POINTS                                         = $0000;
+  {$EXTERNALSYM GL_POINTS}
+  GL_LINES                                          = $0001;
+  {$EXTERNALSYM GL_LINES}
+  GL_LINE_LOOP                                      = $0002;
+  {$EXTERNALSYM GL_LINE_LOOP}
+  GL_LINE_STRIP                                     = $0003;
+  {$EXTERNALSYM GL_LINE_STRIP}
+  GL_TRIANGLES                                      = $0004;
+  {$EXTERNALSYM GL_TRIANGLES}
+  GL_TRIANGLE_STRIP                                 = $0005;
+  {$EXTERNALSYM GL_TRIANGLE_STRIP}
+  GL_TRIANGLE_FAN                                   = $0006;
+  {$EXTERNALSYM GL_TRIANGLE_FAN}
+  GL_QUADS                                          = $0007;
+  {$EXTERNALSYM GL_QUADS}
+  GL_QUAD_STRIP                                     = $0008;
+  {$EXTERNALSYM GL_QUAD_STRIP}
+  GL_POLYGON                                        = $0009;
+  {$EXTERNALSYM GL_POLYGON}
+
+  // blending
+  GL_ZERO                                           = 0;
+  {$EXTERNALSYM GL_ZERO}
+  GL_ONE                                            = 1;
+  {$EXTERNALSYM GL_ONE}
+  GL_SRC_COLOR                                      = $0300;
+  {$EXTERNALSYM GL_SRC_COLOR}
+  GL_ONE_MINUS_SRC_COLOR                            = $0301;
+  {$EXTERNALSYM GL_ONE_MINUS_SRC_COLOR}
+  GL_SRC_ALPHA                                      = $0302;
+  {$EXTERNALSYM GL_SRC_ALPHA}
+  GL_ONE_MINUS_SRC_ALPHA                            = $0303;
+  {$EXTERNALSYM GL_ONE_MINUS_SRC_ALPHA}
+  GL_DST_ALPHA                                      = $0304;
+  {$EXTERNALSYM GL_DST_ALPHA}
+  GL_ONE_MINUS_DST_ALPHA                            = $0305;
+  {$EXTERNALSYM GL_ONE_MINUS_DST_ALPHA}
+  GL_DST_COLOR                                      = $0306;
+  {$EXTERNALSYM GL_DST_COLOR}
+  GL_ONE_MINUS_DST_COLOR                            = $0307;
+  {$EXTERNALSYM GL_ONE_MINUS_DST_COLOR}
+  GL_SRC_ALPHA_SATURATE                             = $0308;
+  {$EXTERNALSYM GL_SRC_ALPHA_SATURATE}
+  GL_BLEND_DST                                      = $0BE0;
+  {$EXTERNALSYM GL_BLEND_DST}
+  GL_BLEND_SRC                                      = $0BE1;
+  {$EXTERNALSYM GL_BLEND_SRC}
+  GL_BLEND                                          = $0BE2;
+  {$EXTERNALSYM GL_BLEND}
+
+  // blending (GL 1.2 ARB imaging)
+  GL_BLEND_COLOR                                    = $8005;
+  {$EXTERNALSYM GL_BLEND_COLOR}
+  GL_CONSTANT_COLOR                                 = $8001;
+  {$EXTERNALSYM GL_CONSTANT_COLOR}
+  GL_ONE_MINUS_CONSTANT_COLOR                       = $8002;
+  {$EXTERNALSYM GL_ONE_MINUS_CONSTANT_COLOR}
+  GL_CONSTANT_ALPHA                                 = $8003;
+  {$EXTERNALSYM GL_CONSTANT_ALPHA}
+  GL_ONE_MINUS_CONSTANT_ALPHA                       = $8004;
+  {$EXTERNALSYM GL_ONE_MINUS_CONSTANT_ALPHA}
+  GL_FUNC_ADD                                       = $8006;
+  {$EXTERNALSYM GL_FUNC_ADD}
+  GL_MIN                                            = $8007;
+  {$EXTERNALSYM GL_MIN}
+  GL_MAX                                            = $8008;
+  {$EXTERNALSYM GL_MAX}
+  GL_FUNC_SUBTRACT                                  = $800A;
+  {$EXTERNALSYM GL_FUNC_SUBTRACT}
+  GL_FUNC_REVERSE_SUBTRACT                          = $800B;
+  {$EXTERNALSYM GL_FUNC_REVERSE_SUBTRACT}
+
+  // color table GL 1.2 ARB imaging
+  GL_COLOR_TABLE                                    = $80D0;
+  {$EXTERNALSYM GL_COLOR_TABLE}
+  GL_POST_CONVOLUTION_COLOR_TABLE                   = $80D1;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_COLOR_TABLE}
+  GL_POST_COLOR_MATRIX_COLOR_TABLE                  = $80D2;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_COLOR_TABLE}
+  GL_PROXY_COLOR_TABLE                              = $80D3;
+  {$EXTERNALSYM GL_PROXY_COLOR_TABLE}
+  GL_PROXY_POST_CONVOLUTION_COLOR_TABLE             = $80D4;
+  {$EXTERNALSYM GL_PROXY_POST_CONVOLUTION_COLOR_TABLE}
+  GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE            = $80D5;
+  {$EXTERNALSYM GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE}
+  GL_COLOR_TABLE_SCALE                              = $80D6;
+  {$EXTERNALSYM GL_COLOR_TABLE_SCALE}
+  GL_COLOR_TABLE_BIAS                               = $80D7;
+  {$EXTERNALSYM GL_COLOR_TABLE_BIAS}
+  GL_COLOR_TABLE_FORMAT                             = $80D8;
+  {$EXTERNALSYM GL_COLOR_TABLE_FORMAT}
+  GL_COLOR_TABLE_WIDTH                              = $80D9;
+  {$EXTERNALSYM GL_COLOR_TABLE_WIDTH}
+  GL_COLOR_TABLE_RED_SIZE                           = $80DA;
+  {$EXTERNALSYM GL_COLOR_TABLE_RED_SIZE}
+  GL_COLOR_TABLE_GREEN_SIZE                         = $80DB;
+  {$EXTERNALSYM GL_COLOR_TABLE_GREEN_SIZE}
+  GL_COLOR_TABLE_BLUE_SIZE                          = $80DC;
+  {$EXTERNALSYM GL_COLOR_TABLE_BLUE_SIZE}
+  GL_COLOR_TABLE_ALPHA_SIZE                         = $80DD;
+  {$EXTERNALSYM GL_COLOR_TABLE_ALPHA_SIZE}
+  GL_COLOR_TABLE_LUMINANCE_SIZE                     = $80DE;
+  {$EXTERNALSYM GL_COLOR_TABLE_LUMINANCE_SIZE}
+  GL_COLOR_TABLE_INTENSITY_SIZE                     = $80DF;
+  {$EXTERNALSYM GL_COLOR_TABLE_INTENSITY_SIZE}
+
+  // convolutions GL 1.2 ARB imaging
+  GL_CONVOLUTION_1D                                 = $8010;
+  {$EXTERNALSYM GL_CONVOLUTION_1D}
+  GL_CONVOLUTION_2D                                 = $8011;
+  {$EXTERNALSYM GL_CONVOLUTION_2D}
+  GL_SEPARABLE_2D                                   = $8012;
+  {$EXTERNALSYM GL_SEPARABLE_2D}
+  GL_CONVOLUTION_BORDER_MODE                        = $8013;
+  {$EXTERNALSYM GL_CONVOLUTION_BORDER_MODE}
+  GL_CONVOLUTION_FILTER_SCALE                       = $8014;
+  {$EXTERNALSYM GL_CONVOLUTION_FILTER_SCALE}
+  GL_CONVOLUTION_FILTER_BIAS                        = $8015;
+  {$EXTERNALSYM GL_CONVOLUTION_FILTER_BIAS}
+  GL_REDUCE                                         = $8016;
+  {$EXTERNALSYM GL_REDUCE}
+  GL_CONVOLUTION_FORMAT                             = $8017;
+  {$EXTERNALSYM GL_CONVOLUTION_FORMAT}
+  GL_CONVOLUTION_WIDTH                              = $8018;
+  {$EXTERNALSYM GL_CONVOLUTION_WIDTH}
+  GL_CONVOLUTION_HEIGHT                             = $8019;
+  {$EXTERNALSYM GL_CONVOLUTION_HEIGHT}
+  GL_MAX_CONVOLUTION_WIDTH                          = $801A;
+  {$EXTERNALSYM GL_MAX_CONVOLUTION_WIDTH}
+  GL_MAX_CONVOLUTION_HEIGHT                         = $801B;
+  {$EXTERNALSYM GL_MAX_CONVOLUTION_HEIGHT}
+  GL_POST_CONVOLUTION_RED_SCALE                     = $801C;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_RED_SCALE}
+  GL_POST_CONVOLUTION_GREEN_SCALE                   = $801D;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_GREEN_SCALE}
+  GL_POST_CONVOLUTION_BLUE_SCALE                    = $801E;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_BLUE_SCALE}
+  GL_POST_CONVOLUTION_ALPHA_SCALE                   = $801F;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_ALPHA_SCALE}
+  GL_POST_CONVOLUTION_RED_BIAS                      = $8020;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_RED_BIAS}
+  GL_POST_CONVOLUTION_GREEN_BIAS                    = $8021;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_GREEN_BIAS}
+  GL_POST_CONVOLUTION_BLUE_BIAS                     = $8022;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_BLUE_BIAS}
+  GL_POST_CONVOLUTION_ALPHA_BIAS                    = $8023;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_ALPHA_BIAS}
+
+  // histogram GL 1.2 ARB imaging
+  GL_HISTOGRAM                                      = $8024;
+  {$EXTERNALSYM GL_HISTOGRAM}
+  GL_PROXY_HISTOGRAM                                = $8025;
+  {$EXTERNALSYM GL_PROXY_HISTOGRAM}
+  GL_HISTOGRAM_WIDTH                                = $8026;
+  {$EXTERNALSYM GL_HISTOGRAM_WIDTH}
+  GL_HISTOGRAM_FORMAT                               = $8027;
+  {$EXTERNALSYM GL_HISTOGRAM_FORMAT}
+  GL_HISTOGRAM_RED_SIZE                             = $8028;
+  {$EXTERNALSYM GL_HISTOGRAM_RED_SIZE}
+  GL_HISTOGRAM_GREEN_SIZE                           = $8029;
+  {$EXTERNALSYM GL_HISTOGRAM_GREEN_SIZE}
+  GL_HISTOGRAM_BLUE_SIZE                            = $802A;
+  {$EXTERNALSYM GL_HISTOGRAM_BLUE_SIZE}
+  GL_HISTOGRAM_ALPHA_SIZE                           = $802B;
+  {$EXTERNALSYM GL_HISTOGRAM_ALPHA_SIZE}
+  GL_HISTOGRAM_LUMINANCE_SIZE                       = $802C;
+  {$EXTERNALSYM GL_HISTOGRAM_LUMINANCE_SIZE}
+  GL_HISTOGRAM_SINK                                 = $802D;
+  {$EXTERNALSYM GL_HISTOGRAM_SINK}
+  GL_MINMAX                                         = $802E;
+  {$EXTERNALSYM GL_MINMAX}
+  GL_MINMAX_FORMAT                                  = $802F;
+  {$EXTERNALSYM GL_MINMAX_FORMAT}
+  GL_MINMAX_SINK                                    = $8030;
+  {$EXTERNALSYM GL_MINMAX_SINK}
+
+  // buffers
+  GL_NONE                                           = 0;
+  {$EXTERNALSYM GL_NONE}
+  GL_FRONT_LEFT                                     = $0400;
+  {$EXTERNALSYM GL_FRONT_LEFT}
+  GL_FRONT_RIGHT                                    = $0401;
+  {$EXTERNALSYM GL_FRONT_RIGHT}
+  GL_BACK_LEFT                                      = $0402;
+  {$EXTERNALSYM GL_BACK_LEFT}
+  GL_BACK_RIGHT                                     = $0403;
+  {$EXTERNALSYM GL_BACK_RIGHT}
+  GL_FRONT                                          = $0404;
+  {$EXTERNALSYM GL_FRONT}
+  GL_BACK                                           = $0405;
+  {$EXTERNALSYM GL_BACK}
+  GL_LEFT                                           = $0406;
+  {$EXTERNALSYM GL_LEFT}
+  GL_RIGHT                                          = $0407;
+  {$EXTERNALSYM GL_RIGHT}
+  GL_FRONT_AND_BACK                                 = $0408;
+  {$EXTERNALSYM GL_FRONT_AND_BACK}
+  GL_AUX0                                           = $0409;
+  {$EXTERNALSYM GL_AUX0}
+  GL_AUX1                                           = $040A;
+  {$EXTERNALSYM GL_AUX1}
+  GL_AUX2                                           = $040B;
+  {$EXTERNALSYM GL_AUX2}
+  GL_AUX3                                           = $040C;
+  {$EXTERNALSYM GL_AUX3}
+  GL_AUX_BUFFERS                                    = $0C00;
+  {$EXTERNALSYM GL_AUX_BUFFERS}
+  GL_DRAW_BUFFER                                    = $0C01;
+  {$EXTERNALSYM GL_DRAW_BUFFER}
+  GL_READ_BUFFER                                    = $0C02;
+  {$EXTERNALSYM GL_READ_BUFFER}
+  GL_DOUBLEBUFFER                                   = $0C32;
+  {$EXTERNALSYM GL_DOUBLEBUFFER}
+  GL_STEREO                                         = $0C33;
+  {$EXTERNALSYM GL_STEREO}
+
+  // depth buffer
+  GL_DEPTH_RANGE                                    = $0B70;
+  {$EXTERNALSYM GL_DEPTH_RANGE}
+  GL_DEPTH_TEST                                     = $0B71;
+  {$EXTERNALSYM GL_DEPTH_TEST}
+  GL_DEPTH_WRITEMASK                                = $0B72;
+  {$EXTERNALSYM GL_DEPTH_WRITEMASK}
+  GL_DEPTH_CLEAR_VALUE                              = $0B73;
+  {$EXTERNALSYM GL_DEPTH_CLEAR_VALUE}
+  GL_DEPTH_FUNC                                     = $0B74;
+  {$EXTERNALSYM GL_DEPTH_FUNC}
+  GL_NEVER                                          = $0200;
+  {$EXTERNALSYM GL_NEVER}
+  GL_LESS                                           = $0201;
+  {$EXTERNALSYM GL_LESS}
+  GL_EQUAL                                          = $0202;
+  {$EXTERNALSYM GL_EQUAL}
+  GL_LEQUAL                                         = $0203;
+  {$EXTERNALSYM GL_LEQUAL}
+  GL_GREATER                                        = $0204;
+  {$EXTERNALSYM GL_GREATER}
+  GL_NOTEQUAL                                       = $0205;
+  {$EXTERNALSYM GL_NOTEQUAL}
+  GL_GEQUAL                                         = $0206;
+  {$EXTERNALSYM GL_GEQUAL}
+  GL_ALWAYS                                         = $0207;
+  {$EXTERNALSYM GL_ALWAYS}
+
+  // accumulation buffer
+  GL_ACCUM                                          = $0100;
+  {$EXTERNALSYM GL_ACCUM}
+  GL_LOAD                                           = $0101;
+  {$EXTERNALSYM GL_LOAD}
+  GL_RETURN                                         = $0102;
+  {$EXTERNALSYM GL_RETURN}
+  GL_MULT                                           = $0103;
+  {$EXTERNALSYM GL_MULT}
+  GL_ADD                                            = $0104;
+  {$EXTERNALSYM GL_ADD}
+  GL_ACCUM_CLEAR_VALUE                              = $0B80;
+  {$EXTERNALSYM GL_ACCUM_CLEAR_VALUE}
+
+  // feedback buffer
+  GL_FEEDBACK_BUFFER_POINTER                        = $0DF0;
+  {$EXTERNALSYM GL_FEEDBACK_BUFFER_POINTER}
+  GL_FEEDBACK_BUFFER_SIZE                           = $0DF1;
+  {$EXTERNALSYM GL_FEEDBACK_BUFFER_SIZE}
+  GL_FEEDBACK_BUFFER_TYPE                           = $0DF2;
+  {$EXTERNALSYM GL_FEEDBACK_BUFFER_TYPE}
+
+  // feedback types
+  GL_2D                                             = $0600;
+  {$EXTERNALSYM GL_2D}
+  GL_3D                                             = $0601;
+  {$EXTERNALSYM GL_3D}
+  GL_3D_COLOR                                       = $0602;
+  {$EXTERNALSYM GL_3D_COLOR}
+  GL_3D_COLOR_TEXTURE                               = $0603;
+  {$EXTERNALSYM GL_3D_COLOR_TEXTURE}
+  GL_4D_COLOR_TEXTURE                               = $0604;
+  {$EXTERNALSYM GL_4D_COLOR_TEXTURE}
+
+  // feedback tokens
+  GL_PASS_THROUGH_TOKEN                             = $0700;
+  {$EXTERNALSYM GL_PASS_THROUGH_TOKEN}
+  GL_POINT_TOKEN                                    = $0701;
+  {$EXTERNALSYM GL_POINT_TOKEN}
+  GL_LINE_TOKEN                                     = $0702;
+  {$EXTERNALSYM GL_LINE_TOKEN}
+  GL_POLYGON_TOKEN                                  = $0703;
+  {$EXTERNALSYM GL_POLYGON_TOKEN}
+  GL_BITMAP_TOKEN                                   = $0704;
+  {$EXTERNALSYM GL_BITMAP_TOKEN}
+  GL_DRAW_PIXEL_TOKEN                               = $0705;
+  {$EXTERNALSYM GL_DRAW_PIXEL_TOKEN}
+  GL_COPY_PIXEL_TOKEN                               = $0706;
+  {$EXTERNALSYM GL_COPY_PIXEL_TOKEN}
+  GL_LINE_RESET_TOKEN                               = $0707;
+  {$EXTERNALSYM GL_LINE_RESET_TOKEN}
+
+  // fog
+  GL_EXP                                            = $0800;
+  {$EXTERNALSYM GL_EXP}
+  GL_EXP2                                           = $0801;
+  {$EXTERNALSYM GL_EXP2}
+  GL_FOG                                            = $0B60;
+  {$EXTERNALSYM GL_FOG}
+  GL_FOG_INDEX                                      = $0B61;
+  {$EXTERNALSYM GL_FOG_INDEX}
+  GL_FOG_DENSITY                                    = $0B62;
+  {$EXTERNALSYM GL_FOG_DENSITY}
+  GL_FOG_START                                      = $0B63;
+  {$EXTERNALSYM GL_FOG_START}
+  GL_FOG_END                                        = $0B64;
+  {$EXTERNALSYM GL_FOG_END}
+  GL_FOG_MODE                                       = $0B65;
+  {$EXTERNALSYM GL_FOG_MODE}
+  GL_FOG_COLOR                                      = $0B66;
+  {$EXTERNALSYM GL_FOG_COLOR}
+
+  // pixel mode, transfer
+  GL_PIXEL_MAP_I_TO_I                               = $0C70;
+  {$EXTERNALSYM GL_PIXEL_MAP_I_TO_I}
+  GL_PIXEL_MAP_S_TO_S                               = $0C71;
+  {$EXTERNALSYM GL_PIXEL_MAP_S_TO_S}
+  GL_PIXEL_MAP_I_TO_R                               = $0C72;
+  {$EXTERNALSYM GL_PIXEL_MAP_I_TO_R}
+  GL_PIXEL_MAP_I_TO_G                               = $0C73;
+  {$EXTERNALSYM GL_PIXEL_MAP_I_TO_G}
+  GL_PIXEL_MAP_I_TO_B                               = $0C74;
+  {$EXTERNALSYM GL_PIXEL_MAP_I_TO_B}
+  GL_PIXEL_MAP_I_TO_A                               = $0C75;
+  {$EXTERNALSYM GL_PIXEL_MAP_I_TO_A}
+  GL_PIXEL_MAP_R_TO_R                               = $0C76;
+  {$EXTERNALSYM GL_PIXEL_MAP_R_TO_R}
+  GL_PIXEL_MAP_G_TO_G                               = $0C77;
+  {$EXTERNALSYM GL_PIXEL_MAP_G_TO_G}
+  GL_PIXEL_MAP_B_TO_B                               = $0C78;
+  {$EXTERNALSYM GL_PIXEL_MAP_B_TO_B}
+  GL_PIXEL_MAP_A_TO_A                               = $0C79;
+  {$EXTERNALSYM GL_PIXEL_MAP_A_TO_A}
+
+  // vertex arrays
+  GL_VERTEX_ARRAY_POINTER                           = $808E;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_POINTER}
+  GL_NORMAL_ARRAY_POINTER                           = $808F;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_POINTER}
+  GL_COLOR_ARRAY_POINTER                            = $8090;
+  {$EXTERNALSYM GL_COLOR_ARRAY_POINTER}
+  GL_INDEX_ARRAY_POINTER                            = $8091;
+  {$EXTERNALSYM GL_INDEX_ARRAY_POINTER}
+  GL_TEXTURE_COORD_ARRAY_POINTER                    = $8092;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_POINTER}
+  GL_EDGE_FLAG_ARRAY_POINTER                        = $8093;
+  {$EXTERNALSYM GL_EDGE_FLAG_ARRAY_POINTER}
+
+  // stenciling
+  GL_STENCIL_TEST                                   = $0B90;
+  {$EXTERNALSYM GL_STENCIL_TEST}
+  GL_STENCIL_CLEAR_VALUE                            = $0B91;
+  {$EXTERNALSYM GL_STENCIL_CLEAR_VALUE}
+  GL_STENCIL_FUNC                                   = $0B92;
+  {$EXTERNALSYM GL_STENCIL_FUNC}
+  GL_STENCIL_VALUE_MASK                             = $0B93;
+  {$EXTERNALSYM GL_STENCIL_VALUE_MASK}
+  GL_STENCIL_FAIL                                   = $0B94;
+  {$EXTERNALSYM GL_STENCIL_FAIL}
+  GL_STENCIL_PASS_DEPTH_FAIL                        = $0B95;
+  {$EXTERNALSYM GL_STENCIL_PASS_DEPTH_FAIL}
+  GL_STENCIL_PASS_DEPTH_PASS                        = $0B96;
+  {$EXTERNALSYM GL_STENCIL_PASS_DEPTH_PASS}
+  GL_STENCIL_REF                                    = $0B97;
+  {$EXTERNALSYM GL_STENCIL_REF}
+  GL_STENCIL_WRITEMASK                              = $0B98;
+  {$EXTERNALSYM GL_STENCIL_WRITEMASK}
+  GL_KEEP                                           = $1E00;
+  {$EXTERNALSYM GL_KEEP}
+  GL_REPLACE                                        = $1E01;
+  {$EXTERNALSYM GL_REPLACE}
+  GL_INCR                                           = $1E02;
+  {$EXTERNALSYM GL_INCR}
+  GL_DECR                                           = $1E03;
+  {$EXTERNALSYM GL_DECR}
+
+  // color material
+  GL_COLOR_MATERIAL_FACE                            = $0B55;
+  {$EXTERNALSYM GL_COLOR_MATERIAL_FACE}
+  GL_COLOR_MATERIAL_PARAMETER                       = $0B56;
+  {$EXTERNALSYM GL_COLOR_MATERIAL_PARAMETER}
+  GL_COLOR_MATERIAL                                 = $0B57;
+  {$EXTERNALSYM GL_COLOR_MATERIAL}
+
+  // points
+  GL_POINT_SMOOTH                                   = $0B10;
+  {$EXTERNALSYM GL_POINT_SMOOTH}
+  GL_POINT_SIZE                                     = $0B11;
+  {$EXTERNALSYM GL_POINT_SIZE}
+  GL_POINT_SIZE_RANGE                               = $0B12;
+  {$EXTERNALSYM GL_POINT_SIZE_RANGE}
+  GL_POINT_SIZE_GRANULARITY                         = $0B13;
+  {$EXTERNALSYM GL_POINT_SIZE_GRANULARITY}
+
+  // lines
+  GL_LINE_SMOOTH                                    = $0B20;
+  {$EXTERNALSYM GL_LINE_SMOOTH}
+  GL_LINE_WIDTH                                     = $0B21;
+  {$EXTERNALSYM GL_LINE_WIDTH}
+  GL_LINE_WIDTH_RANGE                               = $0B22;
+  {$EXTERNALSYM GL_LINE_WIDTH_RANGE}
+  GL_LINE_WIDTH_GRANULARITY                         = $0B23;
+  {$EXTERNALSYM GL_LINE_WIDTH_GRANULARITY}
+  GL_LINE_STIPPLE                                   = $0B24;
+  {$EXTERNALSYM GL_LINE_STIPPLE}
+  GL_LINE_STIPPLE_PATTERN                           = $0B25;
+  {$EXTERNALSYM GL_LINE_STIPPLE_PATTERN}
+  GL_LINE_STIPPLE_REPEAT                            = $0B26;
+  {$EXTERNALSYM GL_LINE_STIPPLE_REPEAT}
+
+  // polygons
+  GL_POLYGON_MODE                                   = $0B40;
+  {$EXTERNALSYM GL_POLYGON_MODE}
+  GL_POLYGON_SMOOTH                                 = $0B41;
+  {$EXTERNALSYM GL_POLYGON_SMOOTH}
+  GL_POLYGON_STIPPLE                                = $0B42;
+  {$EXTERNALSYM GL_POLYGON_STIPPLE}
+  GL_EDGE_FLAG                                      = $0B43;
+  {$EXTERNALSYM GL_EDGE_FLAG}
+  GL_CULL_FACE                                      = $0B44;
+  {$EXTERNALSYM GL_CULL_FACE}
+  GL_CULL_FACE_MODE                                 = $0B45;
+  {$EXTERNALSYM GL_CULL_FACE_MODE}
+  GL_FRONT_FACE                                     = $0B46;
+  {$EXTERNALSYM GL_FRONT_FACE}
+  GL_CW                                             = $0900;
+  {$EXTERNALSYM GL_CW}
+  GL_CCW                                            = $0901;
+  {$EXTERNALSYM GL_CCW}
+  GL_POINT                                          = $1B00;
+  {$EXTERNALSYM GL_POINT}
+  GL_LINE                                           = $1B01;
+  {$EXTERNALSYM GL_LINE}
+  GL_FILL                                           = $1B02;
+  {$EXTERNALSYM GL_FILL}
+
+  // display lists
+  GL_LIST_MODE                                      = $0B30;
+  {$EXTERNALSYM GL_LIST_MODE}
+  GL_LIST_BASE                                      = $0B32;
+  {$EXTERNALSYM GL_LIST_BASE}
+  GL_LIST_INDEX                                     = $0B33;
+  {$EXTERNALSYM GL_LIST_INDEX}
+  GL_COMPILE                                        = $1300;
+  {$EXTERNALSYM GL_COMPILE}
+  GL_COMPILE_AND_EXECUTE                            = $1301;
+  {$EXTERNALSYM GL_COMPILE_AND_EXECUTE}
+
+  // lighting
+  GL_LIGHTING                                       = $0B50;
+  {$EXTERNALSYM GL_LIGHTING}
+  GL_LIGHT_MODEL_LOCAL_VIEWER                       = $0B51;
+  {$EXTERNALSYM GL_LIGHT_MODEL_LOCAL_VIEWER}
+  GL_LIGHT_MODEL_TWO_SIDE                           = $0B52;
+  {$EXTERNALSYM GL_LIGHT_MODEL_TWO_SIDE}
+  GL_LIGHT_MODEL_AMBIENT                            = $0B53;
+  {$EXTERNALSYM GL_LIGHT_MODEL_AMBIENT}
+  GL_LIGHT_MODEL_COLOR_CONTROL                      = $81F8; // GL 1.2
+  {$EXTERNALSYM GL_LIGHT_MODEL_COLOR_CONTROL}
+  GL_SHADE_MODEL                                    = $0B54;
+  {$EXTERNALSYM GL_SHADE_MODEL}
+  GL_NORMALIZE                                      = $0BA1;
+  {$EXTERNALSYM GL_NORMALIZE}
+  GL_AMBIENT                                        = $1200;
+  {$EXTERNALSYM GL_AMBIENT}
+  GL_DIFFUSE                                        = $1201;
+  {$EXTERNALSYM GL_DIFFUSE}
+  GL_SPECULAR                                       = $1202;
+  {$EXTERNALSYM GL_SPECULAR}
+  GL_POSITION                                       = $1203;
+  {$EXTERNALSYM GL_POSITION}
+  GL_SPOT_DIRECTION                                 = $1204;
+  {$EXTERNALSYM GL_SPOT_DIRECTION}
+  GL_SPOT_EXPONENT                                  = $1205;
+  {$EXTERNALSYM GL_SPOT_EXPONENT}
+  GL_SPOT_CUTOFF                                    = $1206;
+  {$EXTERNALSYM GL_SPOT_CUTOFF}
+  GL_CONSTANT_ATTENUATION                           = $1207;
+  {$EXTERNALSYM GL_CONSTANT_ATTENUATION}
+  GL_LINEAR_ATTENUATION                             = $1208;
+  {$EXTERNALSYM GL_LINEAR_ATTENUATION}
+  GL_QUADRATIC_ATTENUATION                          = $1209;
+  {$EXTERNALSYM GL_QUADRATIC_ATTENUATION}
+  GL_EMISSION                                       = $1600;
+  {$EXTERNALSYM GL_EMISSION}
+  GL_SHININESS                                      = $1601;
+  {$EXTERNALSYM GL_SHININESS}
+  GL_AMBIENT_AND_DIFFUSE                            = $1602;
+  {$EXTERNALSYM GL_AMBIENT_AND_DIFFUSE}
+  GL_COLOR_INDEXES                                  = $1603;
+  {$EXTERNALSYM GL_COLOR_INDEXES}
+  GL_FLAT                                           = $1D00;
+  {$EXTERNALSYM GL_FLAT}
+  GL_SMOOTH                                         = $1D01;
+  {$EXTERNALSYM GL_SMOOTH}
+  GL_LIGHT0                                         = $4000;
+  {$EXTERNALSYM GL_LIGHT0}
+  GL_LIGHT1                                         = $4001;
+  {$EXTERNALSYM GL_LIGHT1}
+  GL_LIGHT2                                         = $4002;
+  {$EXTERNALSYM GL_LIGHT2}
+  GL_LIGHT3                                         = $4003;
+  {$EXTERNALSYM GL_LIGHT3}
+  GL_LIGHT4                                         = $4004;
+  {$EXTERNALSYM GL_LIGHT4}
+  GL_LIGHT5                                         = $4005;
+  {$EXTERNALSYM GL_LIGHT5}
+  GL_LIGHT6                                         = $4006;
+  {$EXTERNALSYM GL_LIGHT6}
+  GL_LIGHT7                                         = $4007;
+  {$EXTERNALSYM GL_LIGHT7}
+
+  // matrix modes
+  GL_MATRIX_MODE                                    = $0BA0;
+  {$EXTERNALSYM GL_MATRIX_MODE}
+  GL_MODELVIEW                                      = $1700;
+  {$EXTERNALSYM GL_MODELVIEW}
+  GL_PROJECTION                                     = $1701;
+  {$EXTERNALSYM GL_PROJECTION}
+  GL_TEXTURE                                        = $1702;
+  {$EXTERNALSYM GL_TEXTURE}
+
+  // gets
+  GL_CURRENT_COLOR                                  = $0B00;
+  {$EXTERNALSYM GL_CURRENT_COLOR}
+  GL_CURRENT_INDEX                                  = $0B01;
+  {$EXTERNALSYM GL_CURRENT_INDEX}
+  GL_CURRENT_NORMAL                                 = $0B02;
+  {$EXTERNALSYM GL_CURRENT_NORMAL}
+  GL_CURRENT_TEXTURE_COORDS                         = $0B03;
+  {$EXTERNALSYM GL_CURRENT_TEXTURE_COORDS}
+  GL_CURRENT_RASTER_COLOR                           = $0B04;
+  {$EXTERNALSYM GL_CURRENT_RASTER_COLOR}
+  GL_CURRENT_RASTER_INDEX                           = $0B05;
+  {$EXTERNALSYM GL_CURRENT_RASTER_INDEX}
+  GL_CURRENT_RASTER_TEXTURE_COORDS                  = $0B06;
+  {$EXTERNALSYM GL_CURRENT_RASTER_TEXTURE_COORDS}
+  GL_CURRENT_RASTER_POSITION                        = $0B07;
+  {$EXTERNALSYM GL_CURRENT_RASTER_POSITION}
+  GL_CURRENT_RASTER_POSITION_VALID                  = $0B08;
+  {$EXTERNALSYM GL_CURRENT_RASTER_POSITION_VALID}
+  GL_CURRENT_RASTER_DISTANCE                        = $0B09;
+  {$EXTERNALSYM GL_CURRENT_RASTER_DISTANCE}
+  GL_MAX_LIST_NESTING                               = $0B31;
+  {$EXTERNALSYM GL_MAX_LIST_NESTING}
+  GL_VIEWPORT                                       = $0BA2;
+  {$EXTERNALSYM GL_VIEWPORT}
+  GL_MODELVIEW_STACK_DEPTH                          = $0BA3;
+  {$EXTERNALSYM GL_MODELVIEW_STACK_DEPTH}
+  GL_PROJECTION_STACK_DEPTH                         = $0BA4;
+  {$EXTERNALSYM GL_PROJECTION_STACK_DEPTH}
+  GL_TEXTURE_STACK_DEPTH                            = $0BA5;
+  {$EXTERNALSYM GL_TEXTURE_STACK_DEPTH}
+  GL_MODELVIEW_MATRIX                               = $0BA6;
+  {$EXTERNALSYM GL_MODELVIEW_MATRIX}
+  GL_PROJECTION_MATRIX                              = $0BA7;
+  {$EXTERNALSYM GL_PROJECTION_MATRIX}
+  GL_TEXTURE_MATRIX                                 = $0BA8;
+  {$EXTERNALSYM GL_TEXTURE_MATRIX}
+  GL_ATTRIB_STACK_DEPTH                             = $0BB0;
+  {$EXTERNALSYM GL_ATTRIB_STACK_DEPTH}
+  GL_CLIENT_ATTRIB_STACK_DEPTH                      = $0BB1;
+  {$EXTERNALSYM GL_CLIENT_ATTRIB_STACK_DEPTH}
+
+  GL_SINGLE_COLOR                                   = $81F9; // GL 1.2
+  {$EXTERNALSYM GL_SINGLE_COLOR}
+  GL_SEPARATE_SPECULAR_COLOR                        = $81FA; // GL 1.2
+  {$EXTERNALSYM GL_SEPARATE_SPECULAR_COLOR}
+
+  // alpha testing
+  GL_ALPHA_TEST                                     = $0BC0;
+  {$EXTERNALSYM GL_ALPHA_TEST}
+  GL_ALPHA_TEST_FUNC                                = $0BC1;
+  {$EXTERNALSYM GL_ALPHA_TEST_FUNC}
+  GL_ALPHA_TEST_REF                                 = $0BC2;
+  {$EXTERNALSYM GL_ALPHA_TEST_REF}
+
+  GL_LOGIC_OP_MODE                                  = $0BF0;
+  {$EXTERNALSYM GL_LOGIC_OP_MODE}
+  GL_INDEX_LOGIC_OP                                 = $0BF1;
+  {$EXTERNALSYM GL_INDEX_LOGIC_OP}
+  GL_LOGIC_OP                                       = $0BF1;
+  {$EXTERNALSYM GL_LOGIC_OP}
+  GL_COLOR_LOGIC_OP                                 = $0BF2;
+  {$EXTERNALSYM GL_COLOR_LOGIC_OP}
+  GL_SCISSOR_BOX                                    = $0C10;
+  {$EXTERNALSYM GL_SCISSOR_BOX}
+  GL_SCISSOR_TEST                                   = $0C11;
+  {$EXTERNALSYM GL_SCISSOR_TEST}
+  GL_INDEX_CLEAR_VALUE                              = $0C20;
+  {$EXTERNALSYM GL_INDEX_CLEAR_VALUE}
+  GL_INDEX_WRITEMASK                                = $0C21;
+  {$EXTERNALSYM GL_INDEX_WRITEMASK}
+  GL_COLOR_CLEAR_VALUE                              = $0C22;
+  {$EXTERNALSYM GL_COLOR_CLEAR_VALUE}
+  GL_COLOR_WRITEMASK                                = $0C23;
+  {$EXTERNALSYM GL_COLOR_WRITEMASK}
+  GL_INDEX_MODE                                     = $0C30;
+  {$EXTERNALSYM GL_INDEX_MODE}
+  GL_RGBA_MODE                                      = $0C31;
+  {$EXTERNALSYM GL_RGBA_MODE}
+  GL_RENDER_MODE                                    = $0C40;
+  {$EXTERNALSYM GL_RENDER_MODE}
+  GL_PERSPECTIVE_CORRECTION_HINT                    = $0C50;
+  {$EXTERNALSYM GL_PERSPECTIVE_CORRECTION_HINT}
+  GL_POINT_SMOOTH_HINT                              = $0C51;
+  {$EXTERNALSYM GL_POINT_SMOOTH_HINT}
+  GL_LINE_SMOOTH_HINT                               = $0C52;
+  {$EXTERNALSYM GL_LINE_SMOOTH_HINT}
+  GL_POLYGON_SMOOTH_HINT                            = $0C53;
+  {$EXTERNALSYM GL_POLYGON_SMOOTH_HINT}
+  GL_FOG_HINT                                       = $0C54;
+  {$EXTERNALSYM GL_FOG_HINT}
+  GL_TEXTURE_GEN_S                                  = $0C60;
+  {$EXTERNALSYM GL_TEXTURE_GEN_S}
+  GL_TEXTURE_GEN_T                                  = $0C61;
+  {$EXTERNALSYM GL_TEXTURE_GEN_T}
+  GL_TEXTURE_GEN_R                                  = $0C62;
+  {$EXTERNALSYM GL_TEXTURE_GEN_R}
+  GL_TEXTURE_GEN_Q                                  = $0C63;
+  {$EXTERNALSYM GL_TEXTURE_GEN_Q}
+  GL_PIXEL_MAP_I_TO_I_SIZE                          = $0CB0;
+  {$EXTERNALSYM GL_PIXEL_MAP_I_TO_I_SIZE}
+  GL_PIXEL_MAP_S_TO_S_SIZE                          = $0CB1;
+  {$EXTERNALSYM GL_PIXEL_MAP_S_TO_S_SIZE}
+  GL_PIXEL_MAP_I_TO_R_SIZE                          = $0CB2;
+  {$EXTERNALSYM GL_PIXEL_MAP_I_TO_R_SIZE}
+  GL_PIXEL_MAP_I_TO_G_SIZE                          = $0CB3;
+  {$EXTERNALSYM GL_PIXEL_MAP_I_TO_G_SIZE}
+  GL_PIXEL_MAP_I_TO_B_SIZE                          = $0CB4;
+  {$EXTERNALSYM GL_PIXEL_MAP_I_TO_B_SIZE}
+  GL_PIXEL_MAP_I_TO_A_SIZE                          = $0CB5;
+  {$EXTERNALSYM GL_PIXEL_MAP_I_TO_A_SIZE}
+  GL_PIXEL_MAP_R_TO_R_SIZE                          = $0CB6;
+  {$EXTERNALSYM GL_PIXEL_MAP_R_TO_R_SIZE}
+  GL_PIXEL_MAP_G_TO_G_SIZE                          = $0CB7;
+  {$EXTERNALSYM GL_PIXEL_MAP_G_TO_G_SIZE}
+  GL_PIXEL_MAP_B_TO_B_SIZE                          = $0CB8;
+  {$EXTERNALSYM GL_PIXEL_MAP_B_TO_B_SIZE}
+  GL_PIXEL_MAP_A_TO_A_SIZE                          = $0CB9;
+  {$EXTERNALSYM GL_PIXEL_MAP_A_TO_A_SIZE}
+  GL_UNPACK_SWAP_BYTES                              = $0CF0;
+  {$EXTERNALSYM GL_UNPACK_SWAP_BYTES}
+  GL_UNPACK_LSB_FIRST                               = $0CF1;
+  {$EXTERNALSYM GL_UNPACK_LSB_FIRST}
+  GL_UNPACK_ROW_LENGTH                              = $0CF2;
+  {$EXTERNALSYM GL_UNPACK_ROW_LENGTH}
+  GL_UNPACK_SKIP_ROWS                               = $0CF3;
+  {$EXTERNALSYM GL_UNPACK_SKIP_ROWS}
+  GL_UNPACK_SKIP_PIXELS                             = $0CF4;
+  {$EXTERNALSYM GL_UNPACK_SKIP_PIXELS}
+  GL_UNPACK_ALIGNMENT                               = $0CF5;
+  {$EXTERNALSYM GL_UNPACK_ALIGNMENT}
+  GL_PACK_SWAP_BYTES                                = $0D00;
+  {$EXTERNALSYM GL_PACK_SWAP_BYTES}
+  GL_PACK_LSB_FIRST                                 = $0D01;
+  {$EXTERNALSYM GL_PACK_LSB_FIRST}
+  GL_PACK_ROW_LENGTH                                = $0D02;
+  {$EXTERNALSYM GL_PACK_ROW_LENGTH}
+  GL_PACK_SKIP_ROWS                                 = $0D03;
+  {$EXTERNALSYM GL_PACK_SKIP_ROWS}
+  GL_PACK_SKIP_PIXELS                               = $0D04;
+  {$EXTERNALSYM GL_PACK_SKIP_PIXELS}
+  GL_PACK_ALIGNMENT                                 = $0D05;
+  {$EXTERNALSYM GL_PACK_ALIGNMENT}
+  GL_PACK_SKIP_IMAGES                               = $806B; // GL 1.2
+  {$EXTERNALSYM GL_PACK_SKIP_IMAGES}
+  GL_PACK_IMAGE_HEIGHT                              = $806C; // GL 1.2
+  {$EXTERNALSYM GL_PACK_IMAGE_HEIGHT}
+  GL_UNPACK_SKIP_IMAGES                             = $806D; // GL 1.2
+  {$EXTERNALSYM GL_UNPACK_SKIP_IMAGES}
+  GL_UNPACK_IMAGE_HEIGHT                            = $806E; // GL 1.2
+  {$EXTERNALSYM GL_UNPACK_IMAGE_HEIGHT}
+  GL_MAP_COLOR                                      = $0D10;
+  {$EXTERNALSYM GL_MAP_COLOR}
+  GL_MAP_STENCIL                                    = $0D11;
+  {$EXTERNALSYM GL_MAP_STENCIL}
+  GL_INDEX_SHIFT                                    = $0D12;
+  {$EXTERNALSYM GL_INDEX_SHIFT}
+  GL_INDEX_OFFSET                                   = $0D13;
+  {$EXTERNALSYM GL_INDEX_OFFSET}
+  GL_RED_SCALE                                      = $0D14;
+  {$EXTERNALSYM GL_RED_SCALE}
+  GL_RED_BIAS                                       = $0D15;
+  {$EXTERNALSYM GL_RED_BIAS}
+  GL_ZOOM_X                                         = $0D16;
+  {$EXTERNALSYM GL_ZOOM_X}
+  GL_ZOOM_Y                                         = $0D17;
+  {$EXTERNALSYM GL_ZOOM_Y}
+  GL_GREEN_SCALE                                    = $0D18;
+  {$EXTERNALSYM GL_GREEN_SCALE}
+  GL_GREEN_BIAS                                     = $0D19;
+  {$EXTERNALSYM GL_GREEN_BIAS}
+  GL_BLUE_SCALE                                     = $0D1A;
+  {$EXTERNALSYM GL_BLUE_SCALE}
+  GL_BLUE_BIAS                                      = $0D1B;
+  {$EXTERNALSYM GL_BLUE_BIAS}
+  GL_ALPHA_SCALE                                    = $0D1C;
+  {$EXTERNALSYM GL_ALPHA_SCALE}
+  GL_ALPHA_BIAS                                     = $0D1D;
+  {$EXTERNALSYM GL_ALPHA_BIAS}
+  GL_DEPTH_SCALE                                    = $0D1E;
+  {$EXTERNALSYM GL_DEPTH_SCALE}
+  GL_DEPTH_BIAS                                     = $0D1F;
+  {$EXTERNALSYM GL_DEPTH_BIAS}
+  GL_MAX_EVAL_ORDER                                 = $0D30;
+  {$EXTERNALSYM GL_MAX_EVAL_ORDER}
+  GL_MAX_LIGHTS                                     = $0D31;
+  {$EXTERNALSYM GL_MAX_LIGHTS}
+  GL_MAX_CLIP_PLANES                                = $0D32;
+  {$EXTERNALSYM GL_MAX_CLIP_PLANES}
+  GL_MAX_TEXTURE_SIZE                               = $0D33;
+  {$EXTERNALSYM GL_MAX_TEXTURE_SIZE}
+  GL_MAX_3D_TEXTURE_SIZE                            = $8073; // GL 1.2
+  {$EXTERNALSYM GL_MAX_3D_TEXTURE_SIZE}
+  GL_MAX_PIXEL_MAP_TABLE                            = $0D34;
+  {$EXTERNALSYM GL_MAX_PIXEL_MAP_TABLE}
+  GL_MAX_ATTRIB_STACK_DEPTH                         = $0D35;
+  {$EXTERNALSYM GL_MAX_ATTRIB_STACK_DEPTH}
+  GL_MAX_MODELVIEW_STACK_DEPTH                      = $0D36;
+  {$EXTERNALSYM GL_MAX_MODELVIEW_STACK_DEPTH}
+  GL_MAX_NAME_STACK_DEPTH                           = $0D37;
+  {$EXTERNALSYM GL_MAX_NAME_STACK_DEPTH}
+  GL_MAX_PROJECTION_STACK_DEPTH                     = $0D38;
+  {$EXTERNALSYM GL_MAX_PROJECTION_STACK_DEPTH}
+  GL_MAX_TEXTURE_STACK_DEPTH                        = $0D39;
+  {$EXTERNALSYM GL_MAX_TEXTURE_STACK_DEPTH}
+  GL_MAX_VIEWPORT_DIMS                              = $0D3A;
+  {$EXTERNALSYM GL_MAX_VIEWPORT_DIMS}
+  GL_MAX_CLIENT_ATTRIB_STACK_DEPTH                  = $0D3B;
+  {$EXTERNALSYM GL_MAX_CLIENT_ATTRIB_STACK_DEPTH}
+  GL_MAX_ELEMENTS_VERTICES                          = $80E8; // GL 1.2
+  {$EXTERNALSYM GL_MAX_ELEMENTS_VERTICES}
+  GL_MAX_ELEMENTS_INDICES                           = $80E9; // GL 1.2
+  {$EXTERNALSYM GL_MAX_ELEMENTS_INDICES}
+  GL_RESCALE_NORMAL                                 = $803A; // GL 1.2
+  {$EXTERNALSYM GL_RESCALE_NORMAL}
+  GL_SUBPIXEL_BITS                                  = $0D50;
+  {$EXTERNALSYM GL_SUBPIXEL_BITS}
+  GL_INDEX_BITS                                     = $0D51;
+  {$EXTERNALSYM GL_INDEX_BITS}
+  GL_RED_BITS                                       = $0D52;
+  {$EXTERNALSYM GL_RED_BITS}
+  GL_GREEN_BITS                                     = $0D53;
+  {$EXTERNALSYM GL_GREEN_BITS}
+  GL_BLUE_BITS                                      = $0D54;
+  {$EXTERNALSYM GL_BLUE_BITS}
+  GL_ALPHA_BITS                                     = $0D55;
+  {$EXTERNALSYM GL_ALPHA_BITS}
+  GL_DEPTH_BITS                                     = $0D56;
+  {$EXTERNALSYM GL_DEPTH_BITS}
+  GL_STENCIL_BITS                                   = $0D57;
+  {$EXTERNALSYM GL_STENCIL_BITS}
+  GL_ACCUM_RED_BITS                                 = $0D58;
+  {$EXTERNALSYM GL_ACCUM_RED_BITS}
+  GL_ACCUM_GREEN_BITS                               = $0D59;
+  {$EXTERNALSYM GL_ACCUM_GREEN_BITS}
+  GL_ACCUM_BLUE_BITS                                = $0D5A;
+  {$EXTERNALSYM GL_ACCUM_BLUE_BITS}
+  GL_ACCUM_ALPHA_BITS                               = $0D5B;
+  {$EXTERNALSYM GL_ACCUM_ALPHA_BITS}
+  GL_NAME_STACK_DEPTH                               = $0D70;
+  {$EXTERNALSYM GL_NAME_STACK_DEPTH}
+  GL_AUTO_NORMAL                                    = $0D80;
+  {$EXTERNALSYM GL_AUTO_NORMAL}
+  GL_MAP1_COLOR_4                                   = $0D90;
+  {$EXTERNALSYM GL_MAP1_COLOR_4}
+  GL_MAP1_INDEX                                     = $0D91;
+  {$EXTERNALSYM GL_MAP1_INDEX}
+  GL_MAP1_NORMAL                                    = $0D92;
+  {$EXTERNALSYM GL_MAP1_NORMAL}
+  GL_MAP1_TEXTURE_COORD_1                           = $0D93;
+  {$EXTERNALSYM GL_MAP1_TEXTURE_COORD_1}
+  GL_MAP1_TEXTURE_COORD_2                           = $0D94;
+  {$EXTERNALSYM GL_MAP1_TEXTURE_COORD_2}
+  GL_MAP1_TEXTURE_COORD_3                           = $0D95;
+  {$EXTERNALSYM GL_MAP1_TEXTURE_COORD_3}
+  GL_MAP1_TEXTURE_COORD_4                           = $0D96;
+  {$EXTERNALSYM GL_MAP1_TEXTURE_COORD_4}
+  GL_MAP1_VERTEX_3                                  = $0D97;
+  {$EXTERNALSYM GL_MAP1_VERTEX_3}
+  GL_MAP1_VERTEX_4                                  = $0D98;
+  {$EXTERNALSYM GL_MAP1_VERTEX_4}
+  GL_MAP2_COLOR_4                                   = $0DB0;
+  {$EXTERNALSYM GL_MAP2_COLOR_4}
+  GL_MAP2_INDEX                                     = $0DB1;
+  {$EXTERNALSYM GL_MAP2_INDEX}
+  GL_MAP2_NORMAL                                    = $0DB2;
+  {$EXTERNALSYM GL_MAP2_NORMAL}
+  GL_MAP2_TEXTURE_COORD_1                           = $0DB3;
+  {$EXTERNALSYM GL_MAP2_TEXTURE_COORD_1}
+  GL_MAP2_TEXTURE_COORD_2                           = $0DB4;
+  {$EXTERNALSYM GL_MAP2_TEXTURE_COORD_2}
+  GL_MAP2_TEXTURE_COORD_3                           = $0DB5;
+  {$EXTERNALSYM GL_MAP2_TEXTURE_COORD_3}
+  GL_MAP2_TEXTURE_COORD_4                           = $0DB6;
+  {$EXTERNALSYM GL_MAP2_TEXTURE_COORD_4}
+  GL_MAP2_VERTEX_3                                  = $0DB7;
+  {$EXTERNALSYM GL_MAP2_VERTEX_3}
+  GL_MAP2_VERTEX_4                                  = $0DB8;
+  {$EXTERNALSYM GL_MAP2_VERTEX_4}
+  GL_MAP1_GRID_DOMAIN                               = $0DD0;
+  {$EXTERNALSYM GL_MAP1_GRID_DOMAIN}
+  GL_MAP1_GRID_SEGMENTS                             = $0DD1;
+  {$EXTERNALSYM GL_MAP1_GRID_SEGMENTS}
+  GL_MAP2_GRID_DOMAIN                               = $0DD2;
+  {$EXTERNALSYM GL_MAP2_GRID_DOMAIN}
+  GL_MAP2_GRID_SEGMENTS                             = $0DD3;
+  {$EXTERNALSYM GL_MAP2_GRID_SEGMENTS}
+  GL_TEXTURE_1D                                     = $0DE0;
+  {$EXTERNALSYM GL_TEXTURE_1D}
+  GL_TEXTURE_2D                                     = $0DE1;
+  {$EXTERNALSYM GL_TEXTURE_2D}
+  GL_TEXTURE_3D                                     = $806F; // GL 1.2
+  {$EXTERNALSYM GL_TEXTURE_3D}
+  GL_SELECTION_BUFFER_POINTER                       = $0DF3;
+  {$EXTERNALSYM GL_SELECTION_BUFFER_POINTER}
+  GL_SELECTION_BUFFER_SIZE                          = $0DF4;
+  {$EXTERNALSYM GL_SELECTION_BUFFER_SIZE}
+  GL_POLYGON_OFFSET_UNITS                           = $2A00;
+  {$EXTERNALSYM GL_POLYGON_OFFSET_UNITS}
+  GL_POLYGON_OFFSET_POINT                           = $2A01;
+  {$EXTERNALSYM GL_POLYGON_OFFSET_POINT}
+  GL_POLYGON_OFFSET_LINE                            = $2A02;
+  {$EXTERNALSYM GL_POLYGON_OFFSET_LINE}
+  GL_POLYGON_OFFSET_FILL                            = $8037;
+  {$EXTERNALSYM GL_POLYGON_OFFSET_FILL}
+  GL_POLYGON_OFFSET_FACTOR                          = $8038;
+  {$EXTERNALSYM GL_POLYGON_OFFSET_FACTOR}
+  GL_TEXTURE_BINDING_1D                             = $8068;
+  {$EXTERNALSYM GL_TEXTURE_BINDING_1D}
+  GL_TEXTURE_BINDING_2D                             = $8069;
+  {$EXTERNALSYM GL_TEXTURE_BINDING_2D}
+  GL_VERTEX_ARRAY                                   = $8074;
+  {$EXTERNALSYM GL_VERTEX_ARRAY}
+  GL_NORMAL_ARRAY                                   = $8075;
+  {$EXTERNALSYM GL_NORMAL_ARRAY}
+  GL_COLOR_ARRAY                                    = $8076;
+  {$EXTERNALSYM GL_COLOR_ARRAY}
+  GL_INDEX_ARRAY                                    = $8077;
+  {$EXTERNALSYM GL_INDEX_ARRAY}
+  GL_TEXTURE_COORD_ARRAY                            = $8078;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY}
+  GL_EDGE_FLAG_ARRAY                                = $8079;
+  {$EXTERNALSYM GL_EDGE_FLAG_ARRAY}
+  GL_VERTEX_ARRAY_SIZE                              = $807A;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_SIZE}
+  GL_VERTEX_ARRAY_TYPE                              = $807B;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_TYPE}
+  GL_VERTEX_ARRAY_STRIDE                            = $807C;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_STRIDE}
+  GL_NORMAL_ARRAY_TYPE                              = $807E;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_TYPE}
+  GL_NORMAL_ARRAY_STRIDE                            = $807F;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_STRIDE}
+  GL_COLOR_ARRAY_SIZE                               = $8081;
+  {$EXTERNALSYM GL_COLOR_ARRAY_SIZE}
+  GL_COLOR_ARRAY_TYPE                               = $8082;
+  {$EXTERNALSYM GL_COLOR_ARRAY_TYPE}
+  GL_COLOR_ARRAY_STRIDE                             = $8083;
+  {$EXTERNALSYM GL_COLOR_ARRAY_STRIDE}
+  GL_INDEX_ARRAY_TYPE                               = $8085;
+  {$EXTERNALSYM GL_INDEX_ARRAY_TYPE}
+  GL_INDEX_ARRAY_STRIDE                             = $8086;
+  {$EXTERNALSYM GL_INDEX_ARRAY_STRIDE}
+  GL_TEXTURE_COORD_ARRAY_SIZE                       = $8088;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_SIZE}
+  GL_TEXTURE_COORD_ARRAY_TYPE                       = $8089;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_TYPE}
+  GL_TEXTURE_COORD_ARRAY_STRIDE                     = $808A;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_STRIDE}
+  GL_EDGE_FLAG_ARRAY_STRIDE                         = $808C;
+  {$EXTERNALSYM GL_EDGE_FLAG_ARRAY_STRIDE}
+  GL_COLOR_MATRIX                                   = $80B1; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_COLOR_MATRIX}
+  GL_COLOR_MATRIX_STACK_DEPTH                       = $80B2; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_COLOR_MATRIX_STACK_DEPTH}
+  GL_MAX_COLOR_MATRIX_STACK_DEPTH                   = $80B3; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_MAX_COLOR_MATRIX_STACK_DEPTH}
+  GL_POST_COLOR_MATRIX_RED_SCALE                    = $80B4; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_RED_SCALE}
+  GL_POST_COLOR_MATRIX_GREEN_SCALE                  = $80B5; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_GREEN_SCALE}
+  GL_POST_COLOR_MATRIX_BLUE_SCALE                   = $80B6; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_BLUE_SCALE}
+  GL_POST_COLOR_MATRIX_ALPHA_SCALE                  = $80B7; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_ALPHA_SCALE}
+  GL_POST_COLOR_MATRIX_RED_BIAS                     = $80B8; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_RED_BIAS}
+  GL_POST_COLOR_MATRIX_GREEN_BIAS                   = $80B9; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_GREEN_BIAS}
+  GL_POST_COLOR_MATRIX_BLUE_BIAS                    = $80BA; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_BLUE_BIAS}
+  GL_POST_COLOR_MATRIX_ALPHA_BIAS                   = $80BB; // GL 1.2 ARB imaging
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_ALPHA_BIAS}
+
+  // evaluators
+  GL_COEFF                                          = $0A00;
+  {$EXTERNALSYM GL_COEFF}
+  GL_ORDER                                          = $0A01;
+  {$EXTERNALSYM GL_ORDER}
+  GL_DOMAIN                                         = $0A02;
+  {$EXTERNALSYM GL_DOMAIN}
+
+  // texture mapping
+  GL_TEXTURE_WIDTH                                  = $1000;
+  {$EXTERNALSYM GL_TEXTURE_WIDTH}
+  GL_TEXTURE_HEIGHT                                 = $1001;
+  {$EXTERNALSYM GL_TEXTURE_HEIGHT}
+  GL_TEXTURE_INTERNAL_FORMAT                        = $1003;
+  {$EXTERNALSYM GL_TEXTURE_INTERNAL_FORMAT}
+  GL_TEXTURE_COMPONENTS                             = $1003;
+  {$EXTERNALSYM GL_TEXTURE_COMPONENTS}
+  GL_TEXTURE_BORDER_COLOR                           = $1004;
+  {$EXTERNALSYM GL_TEXTURE_BORDER_COLOR}
+  GL_TEXTURE_BORDER                                 = $1005;
+  {$EXTERNALSYM GL_TEXTURE_BORDER}
+  GL_TEXTURE_RED_SIZE                               = $805C;
+  {$EXTERNALSYM GL_TEXTURE_RED_SIZE}
+  GL_TEXTURE_GREEN_SIZE                             = $805D;
+  {$EXTERNALSYM GL_TEXTURE_GREEN_SIZE}
+  GL_TEXTURE_BLUE_SIZE                              = $805E;
+  {$EXTERNALSYM GL_TEXTURE_BLUE_SIZE}
+  GL_TEXTURE_ALPHA_SIZE                             = $805F;
+  {$EXTERNALSYM GL_TEXTURE_ALPHA_SIZE}
+  GL_TEXTURE_LUMINANCE_SIZE                         = $8060;
+  {$EXTERNALSYM GL_TEXTURE_LUMINANCE_SIZE}
+  GL_TEXTURE_INTENSITY_SIZE                         = $8061;
+  {$EXTERNALSYM GL_TEXTURE_INTENSITY_SIZE}
+  GL_TEXTURE_PRIORITY                               = $8066;
+  {$EXTERNALSYM GL_TEXTURE_PRIORITY}
+  GL_TEXTURE_RESIDENT                               = $8067;
+  {$EXTERNALSYM GL_TEXTURE_RESIDENT}
+  GL_BGR                                            = $80E0; // v 1.2
+  {$EXTERNALSYM GL_BGR}
+  GL_BGRA                                           = $80E1; // v 1.2
+  {$EXTERNALSYM GL_BGRA}
+  GL_S                                              = $2000;
+  {$EXTERNALSYM GL_S}
+  GL_T                                              = $2001;
+  {$EXTERNALSYM GL_T}
+  GL_R                                              = $2002;
+  {$EXTERNALSYM GL_R}
+  GL_Q                                              = $2003;
+  {$EXTERNALSYM GL_Q}
+  GL_MODULATE                                       = $2100;
+  {$EXTERNALSYM GL_MODULATE}
+  GL_DECAL                                          = $2101;
+  {$EXTERNALSYM GL_DECAL}
+  GL_TEXTURE_ENV_MODE                               = $2200;
+  {$EXTERNALSYM GL_TEXTURE_ENV_MODE}
+  GL_TEXTURE_ENV_COLOR                              = $2201;
+  {$EXTERNALSYM GL_TEXTURE_ENV_COLOR}
+  GL_TEXTURE_ENV                                    = $2300;
+  {$EXTERNALSYM GL_TEXTURE_ENV}
+  GL_EYE_LINEAR                                     = $2400;
+  {$EXTERNALSYM GL_EYE_LINEAR}
+  GL_OBJECT_LINEAR                                  = $2401;
+  {$EXTERNALSYM GL_OBJECT_LINEAR}
+  GL_SPHERE_MAP                                     = $2402;
+  {$EXTERNALSYM GL_SPHERE_MAP}
+  GL_TEXTURE_GEN_MODE                               = $2500;
+  {$EXTERNALSYM GL_TEXTURE_GEN_MODE}
+  GL_OBJECT_PLANE                                   = $2501;
+  {$EXTERNALSYM GL_OBJECT_PLANE}
+  GL_EYE_PLANE                                      = $2502;
+  {$EXTERNALSYM GL_EYE_PLANE}
+  GL_NEAREST                                        = $2600;
+  {$EXTERNALSYM GL_NEAREST}
+  GL_LINEAR                                         = $2601;
+  {$EXTERNALSYM GL_LINEAR}
+  GL_NEAREST_MIPMAP_NEAREST                         = $2700;
+  {$EXTERNALSYM GL_NEAREST_MIPMAP_NEAREST}
+  GL_LINEAR_MIPMAP_NEAREST                          = $2701;
+  {$EXTERNALSYM GL_LINEAR_MIPMAP_NEAREST}
+  GL_NEAREST_MIPMAP_LINEAR                          = $2702;
+  {$EXTERNALSYM GL_NEAREST_MIPMAP_LINEAR}
+  GL_LINEAR_MIPMAP_LINEAR                           = $2703;
+  {$EXTERNALSYM GL_LINEAR_MIPMAP_LINEAR}
+  GL_TEXTURE_MAG_FILTER                             = $2800;
+  {$EXTERNALSYM GL_TEXTURE_MAG_FILTER}
+  GL_TEXTURE_MIN_FILTER                             = $2801;
+  {$EXTERNALSYM GL_TEXTURE_MIN_FILTER}
+  GL_TEXTURE_WRAP_R                                 = $8072; // GL 1.2
+  {$EXTERNALSYM GL_TEXTURE_WRAP_R}
+  GL_TEXTURE_WRAP_S                                 = $2802;
+  {$EXTERNALSYM GL_TEXTURE_WRAP_S}
+  GL_TEXTURE_WRAP_T                                 = $2803;
+  {$EXTERNALSYM GL_TEXTURE_WRAP_T}
+  GL_CLAMP_TO_EDGE                                  = $812F; // GL 1.2
+  {$EXTERNALSYM GL_CLAMP_TO_EDGE}
+  GL_TEXTURE_MIN_LOD                                = $813A; // GL 1.2
+  {$EXTERNALSYM GL_TEXTURE_MIN_LOD}
+  GL_TEXTURE_MAX_LOD                                = $813B; // GL 1.2
+  {$EXTERNALSYM GL_TEXTURE_MAX_LOD}
+  GL_TEXTURE_BASE_LEVEL                             = $813C; // GL 1.2
+  {$EXTERNALSYM GL_TEXTURE_BASE_LEVEL}
+  GL_TEXTURE_MAX_LEVEL                              = $813D; // GL 1.2
+  {$EXTERNALSYM GL_TEXTURE_MAX_LEVEL}
+  GL_TEXTURE_DEPTH                                  = $8071; // GL 1.2
+  {$EXTERNALSYM GL_TEXTURE_DEPTH}
+  GL_PROXY_TEXTURE_1D                               = $8063;
+  {$EXTERNALSYM GL_PROXY_TEXTURE_1D}
+  GL_PROXY_TEXTURE_2D                               = $8064;
+  {$EXTERNALSYM GL_PROXY_TEXTURE_2D}
+  GL_PROXY_TEXTURE_3D                               = $8070; // GL 1.2
+  {$EXTERNALSYM GL_PROXY_TEXTURE_3D}
+  GL_CLAMP                                          = $2900;
+  {$EXTERNALSYM GL_CLAMP}
+  GL_REPEAT                                         = $2901;
+  {$EXTERNALSYM GL_REPEAT}
+
+  // hints
+  GL_DONT_CARE                                      = $1100;
+  {$EXTERNALSYM GL_DONT_CARE}
+  GL_FASTEST                                        = $1101;
+  {$EXTERNALSYM GL_FASTEST}
+  GL_NICEST                                         = $1102;
+  {$EXTERNALSYM GL_NICEST}
+
+  // data types
+  GL_BYTE                                           = $1400;
+  {$EXTERNALSYM GL_BYTE}
+  GL_UNSIGNED_BYTE                                  = $1401;
+  {$EXTERNALSYM GL_UNSIGNED_BYTE}
+  GL_SHORT                                          = $1402;
+  {$EXTERNALSYM GL_SHORT}
+  GL_UNSIGNED_SHORT                                 = $1403;
+  {$EXTERNALSYM GL_UNSIGNED_SHORT}
+  GL_INT                                            = $1404;
+  {$EXTERNALSYM GL_INT}
+  GL_UNSIGNED_INT                                   = $1405;
+  {$EXTERNALSYM GL_UNSIGNED_INT}
+  GL_FLOAT                                          = $1406;
+  {$EXTERNALSYM GL_FLOAT}
+  GL_2_BYTES                                        = $1407;
+  {$EXTERNALSYM GL_2_BYTES}
+  GL_3_BYTES                                        = $1408;
+  {$EXTERNALSYM GL_3_BYTES}
+  GL_4_BYTES                                        = $1409;
+  {$EXTERNALSYM GL_4_BYTES}
+  GL_DOUBLE                                         = $140A;
+  {$EXTERNALSYM GL_DOUBLE}
+  GL_DOUBLE_EXT                                     = $140A;
+  {$EXTERNALSYM GL_DOUBLE_EXT}
+
+  // logic operations
+  GL_CLEAR                                          = $1500;
+  {$EXTERNALSYM GL_CLEAR}
+  GL_AND                                            = $1501;
+  {$EXTERNALSYM GL_AND}
+  GL_AND_REVERSE                                    = $1502;
+  {$EXTERNALSYM GL_AND_REVERSE}
+  GL_COPY                                           = $1503;
+  {$EXTERNALSYM GL_COPY}
+  GL_AND_INVERTED                                   = $1504;
+  {$EXTERNALSYM GL_AND_INVERTED}
+  GL_NOOP                                           = $1505;
+  {$EXTERNALSYM GL_NOOP}
+  GL_XOR                                            = $1506;
+  {$EXTERNALSYM GL_XOR}
+  GL_OR                                             = $1507;
+  {$EXTERNALSYM GL_OR}
+  GL_NOR                                            = $1508;
+  {$EXTERNALSYM GL_NOR}
+  GL_EQUIV                                          = $1509;
+  {$EXTERNALSYM GL_EQUIV}
+  GL_INVERT                                         = $150A;
+  {$EXTERNALSYM GL_INVERT}
+  GL_OR_REVERSE                                     = $150B;
+  {$EXTERNALSYM GL_OR_REVERSE}
+  GL_COPY_INVERTED                                  = $150C;
+  {$EXTERNALSYM GL_COPY_INVERTED}
+  GL_OR_INVERTED                                    = $150D;
+  {$EXTERNALSYM GL_OR_INVERTED}
+  GL_NAND                                           = $150E;
+  {$EXTERNALSYM GL_NAND}
+  GL_SET                                            = $150F;
+  {$EXTERNALSYM GL_SET}
+
+  // PixelCopyType
+  GL_COLOR                                          = $1800;
+  {$EXTERNALSYM GL_COLOR}
+  GL_DEPTH                                          = $1801;
+  {$EXTERNALSYM GL_DEPTH}
+  GL_STENCIL                                        = $1802;
+  {$EXTERNALSYM GL_STENCIL}
+
+  // pixel formats
+  GL_COLOR_INDEX                                    = $1900;
+  {$EXTERNALSYM GL_COLOR_INDEX}
+  GL_STENCIL_INDEX                                  = $1901;
+  {$EXTERNALSYM GL_STENCIL_INDEX}
+  GL_DEPTH_COMPONENT                                = $1902;
+  {$EXTERNALSYM GL_DEPTH_COMPONENT}
+  GL_RED                                            = $1903;
+  {$EXTERNALSYM GL_RED}
+  GL_GREEN                                          = $1904;
+  {$EXTERNALSYM GL_GREEN}
+  GL_BLUE                                           = $1905;
+  {$EXTERNALSYM GL_BLUE}
+  GL_ALPHA                                          = $1906;
+  {$EXTERNALSYM GL_ALPHA}
+  GL_RGB                                            = $1907;
+  {$EXTERNALSYM GL_RGB}
+  GL_RGBA                                           = $1908;
+  {$EXTERNALSYM GL_RGBA}
+  GL_LUMINANCE                                      = $1909;
+  {$EXTERNALSYM GL_LUMINANCE}
+  GL_LUMINANCE_ALPHA                                = $190A;
+  {$EXTERNALSYM GL_LUMINANCE_ALPHA}
+
+  // pixel type
+  GL_BITMAP                                         = $1A00;
+  {$EXTERNALSYM GL_BITMAP}
+
+  // rendering modes
+  GL_RENDER                                         = $1C00;
+  {$EXTERNALSYM GL_RENDER}
+  GL_FEEDBACK                                       = $1C01;
+  {$EXTERNALSYM GL_FEEDBACK}
+  GL_SELECT                                         = $1C02;
+  {$EXTERNALSYM GL_SELECT}
+
+  // implementation strings
+  GL_VENDOR                                         = $1F00;
+  {$EXTERNALSYM GL_VENDOR}
+  GL_RENDERER                                       = $1F01;
+  {$EXTERNALSYM GL_RENDERER}
+  GL_VERSION                                        = $1F02;
+  {$EXTERNALSYM GL_VERSION}
+  GL_EXTENSIONS                                     = $1F03;
+  {$EXTERNALSYM GL_EXTENSIONS}
+
+  // pixel formats
+  GL_R3_G3_B2                                       = $2A10;
+  {$EXTERNALSYM GL_R3_G3_B2}
+  GL_ALPHA4                                         = $803B;
+  {$EXTERNALSYM GL_ALPHA4}
+  GL_ALPHA8                                         = $803C;
+  {$EXTERNALSYM GL_ALPHA8}
+  GL_ALPHA12                                        = $803D;
+  {$EXTERNALSYM GL_ALPHA12}
+  GL_ALPHA16                                        = $803E;
+  {$EXTERNALSYM GL_ALPHA16}
+  GL_LUMINANCE4                                     = $803F;
+  {$EXTERNALSYM GL_LUMINANCE4}
+  GL_LUMINANCE8                                     = $8040;
+  {$EXTERNALSYM GL_LUMINANCE8}
+  GL_LUMINANCE12                                    = $8041;
+  {$EXTERNALSYM GL_LUMINANCE12}
+  GL_LUMINANCE16                                    = $8042;
+  {$EXTERNALSYM GL_LUMINANCE16}
+  GL_LUMINANCE4_ALPHA4                              = $8043;
+  {$EXTERNALSYM GL_LUMINANCE4_ALPHA4}
+  GL_LUMINANCE6_ALPHA2                              = $8044;
+  {$EXTERNALSYM GL_LUMINANCE6_ALPHA2}
+  GL_LUMINANCE8_ALPHA8                              = $8045;
+  {$EXTERNALSYM GL_LUMINANCE8_ALPHA8}
+  GL_LUMINANCE12_ALPHA4                             = $8046;
+  {$EXTERNALSYM GL_LUMINANCE12_ALPHA4}
+  GL_LUMINANCE12_ALPHA12                            = $8047;
+  {$EXTERNALSYM GL_LUMINANCE12_ALPHA12}
+  GL_LUMINANCE16_ALPHA16                            = $8048;
+  {$EXTERNALSYM GL_LUMINANCE16_ALPHA16}
+  GL_INTENSITY                                      = $8049;
+  {$EXTERNALSYM GL_INTENSITY}
+  GL_INTENSITY4                                     = $804A;
+  {$EXTERNALSYM GL_INTENSITY4}
+  GL_INTENSITY8                                     = $804B;
+  {$EXTERNALSYM GL_INTENSITY8}
+  GL_INTENSITY12                                    = $804C;
+  {$EXTERNALSYM GL_INTENSITY12}
+  GL_INTENSITY16                                    = $804D;
+  {$EXTERNALSYM GL_INTENSITY16}
+  GL_RGB4                                           = $804F;
+  {$EXTERNALSYM GL_RGB4}
+  GL_RGB5                                           = $8050;
+  {$EXTERNALSYM GL_RGB5}
+  GL_RGB8                                           = $8051;
+  {$EXTERNALSYM GL_RGB8}
+  GL_RGB10                                          = $8052;
+  {$EXTERNALSYM GL_RGB10}
+  GL_RGB12                                          = $8053;
+  {$EXTERNALSYM GL_RGB12}
+  GL_RGB16                                          = $8054;
+  {$EXTERNALSYM GL_RGB16}
+  GL_RGBA2                                          = $8055;
+  {$EXTERNALSYM GL_RGBA2}
+  GL_RGBA4                                          = $8056;
+  {$EXTERNALSYM GL_RGBA4}
+  GL_RGB5_A1                                        = $8057;
+  {$EXTERNALSYM GL_RGB5_A1}
+  GL_RGBA8                                          = $8058;
+  {$EXTERNALSYM GL_RGBA8}
+  GL_RGB10_A2                                       = $8059;
+  {$EXTERNALSYM GL_RGB10_A2}
+  GL_RGBA12                                         = $805A;
+  {$EXTERNALSYM GL_RGBA12}
+  GL_RGBA16                                         = $805B;
+  {$EXTERNALSYM GL_RGBA16}
+  UNSIGNED_BYTE_3_3_2                               = $8032; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_BYTE_3_3_2}
+  UNSIGNED_BYTE_2_3_3_REV                           = $8362; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_BYTE_2_3_3_REV}
+  UNSIGNED_SHORT_5_6_5                              = $8363; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_SHORT_5_6_5}
+  UNSIGNED_SHORT_5_6_5_REV                          = $8364; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_SHORT_5_6_5_REV}
+  UNSIGNED_SHORT_4_4_4_4                            = $8033; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_SHORT_4_4_4_4}
+  UNSIGNED_SHORT_4_4_4_4_REV                        = $8365; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_SHORT_4_4_4_4_REV}
+  UNSIGNED_SHORT_5_5_5_1                            = $8034; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_SHORT_5_5_5_1}
+  UNSIGNED_SHORT_1_5_5_5_REV                        = $8366; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_SHORT_1_5_5_5_REV}
+  UNSIGNED_INT_8_8_8_8                              = $8035; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_INT_8_8_8_8}
+  UNSIGNED_INT_8_8_8_8_REV                          = $8367; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_INT_8_8_8_8_REV}
+  UNSIGNED_INT_10_10_10_2                           = $8036; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_INT_10_10_10_2}
+  UNSIGNED_INT_2_10_10_10_REV                       = $8368; // GL 1.2
+  {$EXTERNALSYM UNSIGNED_INT_2_10_10_10_REV}
+
+  // interleaved arrays formats
+  GL_V2F                                            = $2A20;
+  {$EXTERNALSYM GL_V2F}
+  GL_V3F                                            = $2A21;
+  {$EXTERNALSYM GL_V3F}
+  GL_C4UB_V2F                                       = $2A22;
+  {$EXTERNALSYM GL_C4UB_V2F}
+  GL_C4UB_V3F                                       = $2A23;
+  {$EXTERNALSYM GL_C4UB_V3F}
+  GL_C3F_V3F                                        = $2A24;
+  {$EXTERNALSYM GL_C3F_V3F}
+  GL_N3F_V3F                                        = $2A25;
+  {$EXTERNALSYM GL_N3F_V3F}
+  GL_C4F_N3F_V3F                                    = $2A26;
+  {$EXTERNALSYM GL_C4F_N3F_V3F}
+  GL_T2F_V3F                                        = $2A27;
+  {$EXTERNALSYM GL_T2F_V3F}
+  GL_T4F_V4F                                        = $2A28;
+  {$EXTERNALSYM GL_T4F_V4F}
+  GL_T2F_C4UB_V3F                                   = $2A29;
+  {$EXTERNALSYM GL_T2F_C4UB_V3F}
+  GL_T2F_C3F_V3F                                    = $2A2A;
+  {$EXTERNALSYM GL_T2F_C3F_V3F}
+  GL_T2F_N3F_V3F                                    = $2A2B;
+  {$EXTERNALSYM GL_T2F_N3F_V3F}
+  GL_T2F_C4F_N3F_V3F                                = $2A2C;
+  {$EXTERNALSYM GL_T2F_C4F_N3F_V3F}
+  GL_T4F_C4F_N3F_V4F                                = $2A2D;
+  {$EXTERNALSYM GL_T4F_C4F_N3F_V4F}
+
+  // clip planes
+  GL_CLIP_PLANE0                                    = $3000;
+  {$EXTERNALSYM GL_CLIP_PLANE0}
+  GL_CLIP_PLANE1                                    = $3001;
+  {$EXTERNALSYM GL_CLIP_PLANE1}
+  GL_CLIP_PLANE2                                    = $3002;
+  {$EXTERNALSYM GL_CLIP_PLANE2}
+  GL_CLIP_PLANE3                                    = $3003;
+  {$EXTERNALSYM GL_CLIP_PLANE3}
+  GL_CLIP_PLANE4                                    = $3004;
+  {$EXTERNALSYM GL_CLIP_PLANE4}
+  GL_CLIP_PLANE5                                    = $3005;
+  {$EXTERNALSYM GL_CLIP_PLANE5}
+
+  // miscellaneous
+  GL_DITHER                                         = $0BD0;
+  {$EXTERNALSYM GL_DITHER}
+
+  // ----- extensions enumerants -----
+  // EXT_abgr
+  GL_ABGR_EXT                                       = $8000;
+  {$EXTERNALSYM GL_ABGR_EXT}
+
+  // EXT_packed_pixels
+  GL_UNSIGNED_BYTE_3_3_2_EXT                        = $8032;
+  {$EXTERNALSYM GL_UNSIGNED_BYTE_3_3_2_EXT}
+  GL_UNSIGNED_SHORT_4_4_4_4_EXT                     = $8033;
+  {$EXTERNALSYM GL_UNSIGNED_SHORT_4_4_4_4_EXT}
+  GL_UNSIGNED_SHORT_5_5_5_1_EXT                     = $8034;
+  {$EXTERNALSYM GL_UNSIGNED_SHORT_5_5_5_1_EXT}
+  GL_UNSIGNED_INT_8_8_8_8_EXT                       = $8035;
+  {$EXTERNALSYM GL_UNSIGNED_INT_8_8_8_8_EXT}
+  GL_UNSIGNED_INT_10_10_10_2_EXT                    = $8036;
+  {$EXTERNALSYM GL_UNSIGNED_INT_10_10_10_2_EXT}
+
+  // EXT_vertex_array
+  GL_VERTEX_ARRAY_EXT                               = $8074;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_EXT}
+  GL_NORMAL_ARRAY_EXT                               = $8075;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_EXT}
+  GL_COLOR_ARRAY_EXT                                = $8076;
+  {$EXTERNALSYM GL_COLOR_ARRAY_EXT}
+  GL_INDEX_ARRAY_EXT                                = $8077;
+  {$EXTERNALSYM GL_INDEX_ARRAY_EXT}
+  GL_TEXTURE_COORD_ARRAY_EXT                        = $8078;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_EXT}
+  GL_EDGE_FLAG_ARRAY_EXT                            = $8079;
+  {$EXTERNALSYM GL_EDGE_FLAG_ARRAY_EXT}
+  GL_VERTEX_ARRAY_SIZE_EXT                          = $807A;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_SIZE_EXT}
+  GL_VERTEX_ARRAY_TYPE_EXT                          = $807B;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_TYPE_EXT}
+  GL_VERTEX_ARRAY_STRIDE_EXT                        = $807C;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_STRIDE_EXT}
+  GL_VERTEX_ARRAY_COUNT_EXT                         = $807D;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_COUNT_EXT}
+  GL_NORMAL_ARRAY_TYPE_EXT                          = $807E;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_TYPE_EXT}
+  GL_NORMAL_ARRAY_STRIDE_EXT                        = $807F;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_STRIDE_EXT}
+  GL_NORMAL_ARRAY_COUNT_EXT                         = $8080;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_COUNT_EXT}
+  GL_COLOR_ARRAY_SIZE_EXT                           = $8081;
+  {$EXTERNALSYM GL_COLOR_ARRAY_SIZE_EXT}
+  GL_COLOR_ARRAY_TYPE_EXT                           = $8082;
+  {$EXTERNALSYM GL_COLOR_ARRAY_TYPE_EXT}
+  GL_COLOR_ARRAY_STRIDE_EXT                         = $8083;
+  {$EXTERNALSYM GL_COLOR_ARRAY_STRIDE_EXT}
+  GL_COLOR_ARRAY_COUNT_EXT                          = $8084;
+  {$EXTERNALSYM GL_COLOR_ARRAY_COUNT_EXT}
+  GL_INDEX_ARRAY_TYPE_EXT                           = $8085;
+  {$EXTERNALSYM GL_INDEX_ARRAY_TYPE_EXT}
+  GL_INDEX_ARRAY_STRIDE_EXT                         = $8086;
+  {$EXTERNALSYM GL_INDEX_ARRAY_STRIDE_EXT}
+  GL_INDEX_ARRAY_COUNT_EXT                          = $8087;
+  {$EXTERNALSYM GL_INDEX_ARRAY_COUNT_EXT}
+  GL_TEXTURE_COORD_ARRAY_SIZE_EXT                   = $8088;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_SIZE_EXT}
+  GL_TEXTURE_COORD_ARRAY_TYPE_EXT                   = $8089;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_TYPE_EXT}
+  GL_TEXTURE_COORD_ARRAY_STRIDE_EXT                 = $808A;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_STRIDE_EXT}
+  GL_TEXTURE_COORD_ARRAY_COUNT_EXT                  = $808B;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_COUNT_EXT}
+  GL_EDGE_FLAG_ARRAY_STRIDE_EXT                     = $808C;
+  {$EXTERNALSYM GL_EDGE_FLAG_ARRAY_STRIDE_EXT}
+  GL_EDGE_FLAG_ARRAY_COUNT_EXT                      = $808D;
+  {$EXTERNALSYM GL_EDGE_FLAG_ARRAY_COUNT_EXT}
+  GL_VERTEX_ARRAY_POINTER_EXT                       = $808E;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_POINTER_EXT}
+  GL_NORMAL_ARRAY_POINTER_EXT                       = $808F;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_POINTER_EXT}
+  GL_COLOR_ARRAY_POINTER_EXT                        = $8090;
+  {$EXTERNALSYM GL_COLOR_ARRAY_POINTER_EXT}
+  GL_INDEX_ARRAY_POINTER_EXT                        = $8091;
+  {$EXTERNALSYM GL_INDEX_ARRAY_POINTER_EXT}
+  GL_TEXTURE_COORD_ARRAY_POINTER_EXT                = $8092;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_POINTER_EXT}
+  GL_EDGE_FLAG_ARRAY_POINTER_EXT                    = $8093;
+  {$EXTERNALSYM GL_EDGE_FLAG_ARRAY_POINTER_EXT}
+
+  // EXT_color_table
+  GL_TABLE_TOO_LARGE_EXT                            = $8031;
+  {$EXTERNALSYM GL_TABLE_TOO_LARGE_EXT}
+  GL_COLOR_TABLE_EXT                                = $80D0;
+  {$EXTERNALSYM GL_COLOR_TABLE_EXT}
+  GL_POST_CONVOLUTION_COLOR_TABLE_EXT               = $80D1;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_COLOR_TABLE_EXT}
+  GL_POST_COLOR_MATRIX_COLOR_TABLE_EXT              = $80D2;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_COLOR_TABLE_EXT}
+  GL_PROXY_COLOR_TABLE_EXT                          = $80D3;
+  {$EXTERNALSYM GL_PROXY_COLOR_TABLE_EXT}
+  GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_EXT         = $80D4;
+  {$EXTERNALSYM GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_EXT}
+  GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_EXT        = $80D5;
+  {$EXTERNALSYM GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_EXT}
+  GL_COLOR_TABLE_SCALE_EXT                          = $80D6;
+  {$EXTERNALSYM GL_COLOR_TABLE_SCALE_EXT}
+  GL_COLOR_TABLE_BIAS_EXT                           = $80D7;
+  {$EXTERNALSYM GL_COLOR_TABLE_BIAS_EXT}
+  GL_COLOR_TABLE_FORMAT_EXT                         = $80D8;
+  {$EXTERNALSYM GL_COLOR_TABLE_FORMAT_EXT}
+  GL_COLOR_TABLE_WIDTH_EXT                          = $80D9;
+  {$EXTERNALSYM GL_COLOR_TABLE_WIDTH_EXT}
+  GL_COLOR_TABLE_RED_SIZE_EXT                       = $80DA;
+  {$EXTERNALSYM GL_COLOR_TABLE_RED_SIZE_EXT}
+  GL_COLOR_TABLE_GREEN_SIZE_EXT                     = $80DB;
+  {$EXTERNALSYM GL_COLOR_TABLE_GREEN_SIZE_EXT}
+  GL_COLOR_TABLE_BLUE_SIZE_EXT                      = $80DC;
+  {$EXTERNALSYM GL_COLOR_TABLE_BLUE_SIZE_EXT}
+  GL_COLOR_TABLE_ALPHA_SIZE_EXT                     = $80DD;
+  {$EXTERNALSYM GL_COLOR_TABLE_ALPHA_SIZE_EXT}
+  GL_COLOR_TABLE_LUMINANCE_SIZE_EXT                 = $80DE;
+  {$EXTERNALSYM GL_COLOR_TABLE_LUMINANCE_SIZE_EXT}
+  GL_COLOR_TABLE_INTENSITY_SIZE_EXT                 = $80DF;
+  {$EXTERNALSYM GL_COLOR_TABLE_INTENSITY_SIZE_EXT}
+
+  // EXT_bgra
+  GL_BGR_EXT                                        = $80E0;
+  {$EXTERNALSYM GL_BGR_EXT}
+  GL_BGRA_EXT                                       = $80E1;
+  {$EXTERNALSYM GL_BGRA_EXT}
+
+  // EXT_paletted_texture
+  GL_COLOR_INDEX1_EXT                               = $80E2;
+  {$EXTERNALSYM GL_COLOR_INDEX1_EXT}
+  GL_COLOR_INDEX2_EXT                               = $80E3;
+  {$EXTERNALSYM GL_COLOR_INDEX2_EXT}
+  GL_COLOR_INDEX4_EXT                               = $80E4;
+  {$EXTERNALSYM GL_COLOR_INDEX4_EXT}
+  GL_COLOR_INDEX8_EXT                               = $80E5;
+  {$EXTERNALSYM GL_COLOR_INDEX8_EXT}
+  GL_COLOR_INDEX12_EXT                              = $80E6;
+  {$EXTERNALSYM GL_COLOR_INDEX12_EXT}
+  GL_COLOR_INDEX16_EXT                              = $80E7;
+  {$EXTERNALSYM GL_COLOR_INDEX16_EXT}
+
+  // EXT_blend_color
+  GL_CONSTANT_COLOR_EXT                             = $8001;
+  {$EXTERNALSYM GL_CONSTANT_COLOR_EXT}
+  GL_ONE_MINUS_CONSTANT_COLOR_EXT                   = $8002;
+  {$EXTERNALSYM GL_ONE_MINUS_CONSTANT_COLOR_EXT}
+  GL_CONSTANT_ALPHA_EXT                             = $8003;
+  {$EXTERNALSYM GL_CONSTANT_ALPHA_EXT}
+  GL_ONE_MINUS_CONSTANT_ALPHA_EXT                   = $8004;
+  {$EXTERNALSYM GL_ONE_MINUS_CONSTANT_ALPHA_EXT}
+  GL_BLEND_COLOR_EXT                                = $8005;
+  {$EXTERNALSYM GL_BLEND_COLOR_EXT}
+
+  // EXT_blend_minmax
+  GL_FUNC_ADD_EXT                                   = $8006;
+  {$EXTERNALSYM GL_FUNC_ADD_EXT}
+  GL_MIN_EXT                                        = $8007;
+  {$EXTERNALSYM GL_MIN_EXT}
+  GL_MAX_EXT                                        = $8008;
+  {$EXTERNALSYM GL_MAX_EXT}
+  GL_BLEND_EQUATION_EXT                             = $8009;
+  {$EXTERNALSYM GL_BLEND_EQUATION_EXT}
+
+  // EXT_blend_subtract
+  GL_FUNC_SUBTRACT_EXT                              = $800A;
+  {$EXTERNALSYM GL_FUNC_SUBTRACT_EXT}
+  GL_FUNC_REVERSE_SUBTRACT_EXT                      = $800B;
+  {$EXTERNALSYM GL_FUNC_REVERSE_SUBTRACT_EXT}
+
+  // EXT_convolution
+  GL_CONVOLUTION_1D_EXT                             = $8010;
+  {$EXTERNALSYM GL_CONVOLUTION_1D_EXT}
+  GL_CONVOLUTION_2D_EXT                             = $8011;
+  {$EXTERNALSYM GL_CONVOLUTION_2D_EXT}
+  GL_SEPARABLE_2D_EXT                               = $8012;
+  {$EXTERNALSYM GL_SEPARABLE_2D_EXT}
+  GL_CONVOLUTION_BORDER_MODE_EXT                    = $8013;
+  {$EXTERNALSYM GL_CONVOLUTION_BORDER_MODE_EXT}
+  GL_CONVOLUTION_FILTER_SCALE_EXT                   = $8014;
+  {$EXTERNALSYM GL_CONVOLUTION_FILTER_SCALE_EXT}
+  GL_CONVOLUTION_FILTER_BIAS_EXT                    = $8015;
+  {$EXTERNALSYM GL_CONVOLUTION_FILTER_BIAS_EXT}
+  GL_REDUCE_EXT                                     = $8016;
+  {$EXTERNALSYM GL_REDUCE_EXT}
+  GL_CONVOLUTION_FORMAT_EXT                         = $8017;
+  {$EXTERNALSYM GL_CONVOLUTION_FORMAT_EXT}
+  GL_CONVOLUTION_WIDTH_EXT                          = $8018;
+  {$EXTERNALSYM GL_CONVOLUTION_WIDTH_EXT}
+  GL_CONVOLUTION_HEIGHT_EXT                         = $8019;
+  {$EXTERNALSYM GL_CONVOLUTION_HEIGHT_EXT}
+  GL_MAX_CONVOLUTION_WIDTH_EXT                      = $801A;
+  {$EXTERNALSYM GL_MAX_CONVOLUTION_WIDTH_EXT}
+  GL_MAX_CONVOLUTION_HEIGHT_EXT                     = $801B;
+  {$EXTERNALSYM GL_MAX_CONVOLUTION_HEIGHT_EXT}
+  GL_POST_CONVOLUTION_RED_SCALE_EXT                 = $801C;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_RED_SCALE_EXT}
+  GL_POST_CONVOLUTION_GREEN_SCALE_EXT               = $801D;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_GREEN_SCALE_EXT}
+  GL_POST_CONVOLUTION_BLUE_SCALE_EXT                = $801E;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_BLUE_SCALE_EXT}
+  GL_POST_CONVOLUTION_ALPHA_SCALE_EXT               = $801F;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_ALPHA_SCALE_EXT}
+  GL_POST_CONVOLUTION_RED_BIAS_EXT                  = $8020;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_RED_BIAS_EXT}
+  GL_POST_CONVOLUTION_GREEN_BIAS_EXT                = $8021;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_GREEN_BIAS_EXT}
+  GL_POST_CONVOLUTION_BLUE_BIAS_EXT                 = $8022;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_BLUE_BIAS_EXT}
+  GL_POST_CONVOLUTION_ALPHA_BIAS_EXT                = $8023;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_ALPHA_BIAS_EXT}
+
+  // EXT_histogram
+  GL_HISTOGRAM_EXT                                  = $8024;
+  {$EXTERNALSYM GL_HISTOGRAM_EXT}
+  GL_PROXY_HISTOGRAM_EXT                            = $8025;
+  {$EXTERNALSYM GL_PROXY_HISTOGRAM_EXT}
+  GL_HISTOGRAM_WIDTH_EXT                            = $8026;
+  {$EXTERNALSYM GL_HISTOGRAM_WIDTH_EXT}
+  GL_HISTOGRAM_FORMAT_EXT                           = $8027;
+  {$EXTERNALSYM GL_HISTOGRAM_FORMAT_EXT}
+  GL_HISTOGRAM_RED_SIZE_EXT                         = $8028;
+  {$EXTERNALSYM GL_HISTOGRAM_RED_SIZE_EXT}
+  GL_HISTOGRAM_GREEN_SIZE_EXT                       = $8029;
+  {$EXTERNALSYM GL_HISTOGRAM_GREEN_SIZE_EXT}
+  GL_HISTOGRAM_BLUE_SIZE_EXT                        = $802A;
+  {$EXTERNALSYM GL_HISTOGRAM_BLUE_SIZE_EXT}
+  GL_HISTOGRAM_ALPHA_SIZE_EXT                       = $802B;
+  {$EXTERNALSYM GL_HISTOGRAM_ALPHA_SIZE_EXT}
+  GL_HISTOGRAM_LUMINANCE_SIZE_EXT                   = $802C;
+  {$EXTERNALSYM GL_HISTOGRAM_LUMINANCE_SIZE_EXT}
+  GL_HISTOGRAM_SINK_EXT                             = $802D;
+  {$EXTERNALSYM GL_HISTOGRAM_SINK_EXT}
+  GL_MINMAX_EXT                                     = $802E;
+  {$EXTERNALSYM GL_MINMAX_EXT}
+  GL_MINMAX_FORMAT_EXT                              = $802F;
+  {$EXTERNALSYM GL_MINMAX_FORMAT_EXT}
+  GL_MINMAX_SINK_EXT                                = $8030;
+  {$EXTERNALSYM GL_MINMAX_SINK_EXT}
+
+  // EXT_polygon_offset
+  GL_POLYGON_OFFSET_EXT                             = $8037;
+  {$EXTERNALSYM GL_POLYGON_OFFSET_EXT}
+  GL_POLYGON_OFFSET_FACTOR_EXT                      = $8038;
+  {$EXTERNALSYM GL_POLYGON_OFFSET_FACTOR_EXT}
+  GL_POLYGON_OFFSET_BIAS_EXT                        = $8039;
+  {$EXTERNALSYM GL_POLYGON_OFFSET_BIAS_EXT}
+
+  // EXT_texture
+  GL_ALPHA4_EXT                                     = $803B;
+  {$EXTERNALSYM GL_ALPHA4_EXT}
+  GL_ALPHA8_EXT                                     = $803C;
+  {$EXTERNALSYM GL_ALPHA8_EXT}
+  GL_ALPHA12_EXT                                    = $803D;
+  {$EXTERNALSYM GL_ALPHA12_EXT}
+  GL_ALPHA16_EXT                                    = $803E;
+  {$EXTERNALSYM GL_ALPHA16_EXT}
+  GL_LUMINANCE4_EXT                                 = $803F;
+  {$EXTERNALSYM GL_LUMINANCE4_EXT}
+  GL_LUMINANCE8_EXT                                 = $8040;
+  {$EXTERNALSYM GL_LUMINANCE8_EXT}
+  GL_LUMINANCE12_EXT                                = $8041;
+  {$EXTERNALSYM GL_LUMINANCE12_EXT}
+  GL_LUMINANCE16_EXT                                = $8042;
+  {$EXTERNALSYM GL_LUMINANCE16_EXT}
+  GL_LUMINANCE4_ALPHA4_EXT                          = $8043;
+  {$EXTERNALSYM GL_LUMINANCE4_ALPHA4_EXT}
+  GL_LUMINANCE6_ALPHA2_EXT                          = $8044;
+  {$EXTERNALSYM GL_LUMINANCE6_ALPHA2_EXT}
+  GL_LUMINANCE8_ALPHA8_EXT                          = $8045;
+  {$EXTERNALSYM GL_LUMINANCE8_ALPHA8_EXT}
+  GL_LUMINANCE12_ALPHA4_EXT                         = $8046;
+  {$EXTERNALSYM GL_LUMINANCE12_ALPHA4_EXT}
+  GL_LUMINANCE12_ALPHA12_EXT                        = $8047;
+  {$EXTERNALSYM GL_LUMINANCE12_ALPHA12_EXT}
+  GL_LUMINANCE16_ALPHA16_EXT                        = $8048;
+  {$EXTERNALSYM GL_LUMINANCE16_ALPHA16_EXT}
+  GL_INTENSITY_EXT                                  = $8049;
+  {$EXTERNALSYM GL_INTENSITY_EXT}
+  GL_INTENSITY4_EXT                                 = $804A;
+  {$EXTERNALSYM GL_INTENSITY4_EXT}
+  GL_INTENSITY8_EXT                                 = $804B;
+  {$EXTERNALSYM GL_INTENSITY8_EXT}
+  GL_INTENSITY12_EXT                                = $804C;
+  {$EXTERNALSYM GL_INTENSITY12_EXT}
+  GL_INTENSITY16_EXT                                = $804D;
+  {$EXTERNALSYM GL_INTENSITY16_EXT}
+  GL_RGB2_EXT                                       = $804E;
+  {$EXTERNALSYM GL_RGB2_EXT}
+  GL_RGB4_EXT                                       = $804F;
+  {$EXTERNALSYM GL_RGB4_EXT}
+  GL_RGB5_EXT                                       = $8050;
+  {$EXTERNALSYM GL_RGB5_EXT}
+  GL_RGB8_EXT                                       = $8051;
+  {$EXTERNALSYM GL_RGB8_EXT}
+  GL_RGB10_EXT                                      = $8052;
+  {$EXTERNALSYM GL_RGB10_EXT}
+  GL_RGB12_EXT                                      = $8053;
+  {$EXTERNALSYM GL_RGB12_EXT}
+  GL_RGB16_EXT                                      = $8054;
+  {$EXTERNALSYM GL_RGB16_EXT}
+  GL_RGBA2_EXT                                      = $8055;
+  {$EXTERNALSYM GL_RGBA2_EXT}
+  GL_RGBA4_EXT                                      = $8056;
+  {$EXTERNALSYM GL_RGBA4_EXT}
+  GL_RGB5_A1_EXT                                    = $8057;
+  {$EXTERNALSYM GL_RGB5_A1_EXT}
+  GL_RGBA8_EXT                                      = $8058;
+  {$EXTERNALSYM GL_RGBA8_EXT}
+  GL_RGB10_A2_EXT                                   = $8059;
+  {$EXTERNALSYM GL_RGB10_A2_EXT}
+  GL_RGBA12_EXT                                     = $805A;
+  {$EXTERNALSYM GL_RGBA12_EXT}
+  GL_RGBA16_EXT                                     = $805B;
+  {$EXTERNALSYM GL_RGBA16_EXT}
+  GL_TEXTURE_RED_SIZE_EXT                           = $805C;
+  {$EXTERNALSYM GL_TEXTURE_RED_SIZE_EXT}
+  GL_TEXTURE_GREEN_SIZE_EXT                         = $805D;
+  {$EXTERNALSYM GL_TEXTURE_GREEN_SIZE_EXT}
+  GL_TEXTURE_BLUE_SIZE_EXT                          = $805E;
+  {$EXTERNALSYM GL_TEXTURE_BLUE_SIZE_EXT}
+  GL_TEXTURE_ALPHA_SIZE_EXT                         = $805F;
+  {$EXTERNALSYM GL_TEXTURE_ALPHA_SIZE_EXT}
+  GL_TEXTURE_LUMINANCE_SIZE_EXT                     = $8060;
+  {$EXTERNALSYM GL_TEXTURE_LUMINANCE_SIZE_EXT}
+  GL_TEXTURE_INTENSITY_SIZE_EXT                     = $8061;
+  {$EXTERNALSYM GL_TEXTURE_INTENSITY_SIZE_EXT}
+  GL_REPLACE_EXT                                    = $8062;
+  {$EXTERNALSYM GL_REPLACE_EXT}
+  GL_PROXY_TEXTURE_1D_EXT                           = $8063;
+  {$EXTERNALSYM GL_PROXY_TEXTURE_1D_EXT}
+  GL_PROXY_TEXTURE_2D_EXT                           = $8064;
+  {$EXTERNALSYM GL_PROXY_TEXTURE_2D_EXT}
+  GL_TEXTURE_TOO_LARGE_EXT                          = $8065;
+  {$EXTERNALSYM GL_TEXTURE_TOO_LARGE_EXT}
+
+  // EXT_texture_object
+  GL_TEXTURE_PRIORITY_EXT                           = $8066;
+  {$EXTERNALSYM GL_TEXTURE_PRIORITY_EXT}
+  GL_TEXTURE_RESIDENT_EXT                           = $8067;
+  {$EXTERNALSYM GL_TEXTURE_RESIDENT_EXT}
+  GL_TEXTURE_1D_BINDING_EXT                         = $8068;
+  {$EXTERNALSYM GL_TEXTURE_1D_BINDING_EXT}
+  GL_TEXTURE_2D_BINDING_EXT                         = $8069;
+  {$EXTERNALSYM GL_TEXTURE_2D_BINDING_EXT}
+  GL_TEXTURE_3D_BINDING_EXT                         = $806A;
+  {$EXTERNALSYM GL_TEXTURE_3D_BINDING_EXT}
+
+  // EXT_texture3D
+  GL_PACK_SKIP_IMAGES_EXT                           = $806B;
+  {$EXTERNALSYM GL_PACK_SKIP_IMAGES_EXT}
+  GL_PACK_IMAGE_HEIGHT_EXT                          = $806C;
+  {$EXTERNALSYM GL_PACK_IMAGE_HEIGHT_EXT}
+  GL_UNPACK_SKIP_IMAGES_EXT                         = $806D;
+  {$EXTERNALSYM GL_UNPACK_SKIP_IMAGES_EXT}
+  GL_UNPACK_IMAGE_HEIGHT_EXT                        = $806E;
+  {$EXTERNALSYM GL_UNPACK_IMAGE_HEIGHT_EXT}
+  GL_TEXTURE_3D_EXT                                 = $806F;
+  {$EXTERNALSYM GL_TEXTURE_3D_EXT}
+  GL_PROXY_TEXTURE_3D_EXT                           = $8070;
+  {$EXTERNALSYM GL_PROXY_TEXTURE_3D_EXT}
+  GL_TEXTURE_DEPTH_EXT                              = $8071;
+  {$EXTERNALSYM GL_TEXTURE_DEPTH_EXT}
+  GL_TEXTURE_WRAP_R_EXT                             = $8072;
+  {$EXTERNALSYM GL_TEXTURE_WRAP_R_EXT}
+  GL_MAX_3D_TEXTURE_SIZE_EXT                        = $8073;
+  {$EXTERNALSYM GL_MAX_3D_TEXTURE_SIZE_EXT}
+
+  // SGI_color_matrix
+  GL_COLOR_MATRIX_SGI                               = $80B1;
+  {$EXTERNALSYM GL_COLOR_MATRIX_SGI}
+  GL_COLOR_MATRIX_STACK_DEPTH_SGI                   = $80B2;
+  {$EXTERNALSYM GL_COLOR_MATRIX_STACK_DEPTH_SGI}
+  GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI               = $80B3;
+  {$EXTERNALSYM GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI}
+  GL_POST_COLOR_MATRIX_RED_SCALE_SGI                = $80B4;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_RED_SCALE_SGI}
+  GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI              = $80B5;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI}
+  GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI               = $80B6;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI}
+  GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI              = $80B7;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI}
+  GL_POST_COLOR_MATRIX_RED_BIAS_SGI                 = $80B8;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_RED_BIAS_SGI}
+  GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI               = $80B9;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI}
+  GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI                = $80BA;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI}
+  GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI               = $80BB;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI}
+
+  // SGI_texture_color_table
+  GL_TEXTURE_COLOR_TABLE_SGI                        = $80BC;
+  {$EXTERNALSYM GL_TEXTURE_COLOR_TABLE_SGI}
+  GL_PROXY_TEXTURE_COLOR_TABLE_SGI                  = $80BD;
+  {$EXTERNALSYM GL_PROXY_TEXTURE_COLOR_TABLE_SGI}
+  GL_TEXTURE_COLOR_TABLE_BIAS_SGI                   = $80BE;
+  {$EXTERNALSYM GL_TEXTURE_COLOR_TABLE_BIAS_SGI}
+  GL_TEXTURE_COLOR_TABLE_SCALE_SGI                  = $80BF;
+  {$EXTERNALSYM GL_TEXTURE_COLOR_TABLE_SCALE_SGI}
+
+  // SGI_color_table
+  GL_COLOR_TABLE_SGI                                = $80D0;
+  {$EXTERNALSYM GL_COLOR_TABLE_SGI}
+  GL_POST_CONVOLUTION_COLOR_TABLE_SGI               = $80D1;
+  {$EXTERNALSYM GL_POST_CONVOLUTION_COLOR_TABLE_SGI}
+  GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI              = $80D2;
+  {$EXTERNALSYM GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI}
+  GL_PROXY_COLOR_TABLE_SGI                          = $80D3;
+  {$EXTERNALSYM GL_PROXY_COLOR_TABLE_SGI}
+  GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI         = $80D4;
+  {$EXTERNALSYM GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI}
+  GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI        = $80D5;
+  {$EXTERNALSYM GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI}
+  GL_COLOR_TABLE_SCALE_SGI                          = $80D6;
+  {$EXTERNALSYM GL_COLOR_TABLE_SCALE_SGI}
+  GL_COLOR_TABLE_BIAS_SGI                           = $80D7;
+  {$EXTERNALSYM GL_COLOR_TABLE_BIAS_SGI}
+  GL_COLOR_TABLE_FORMAT_SGI                         = $80D8;
+  {$EXTERNALSYM GL_COLOR_TABLE_FORMAT_SGI}
+  GL_COLOR_TABLE_WIDTH_SGI                          = $80D9;
+  {$EXTERNALSYM GL_COLOR_TABLE_WIDTH_SGI}
+  GL_COLOR_TABLE_RED_SIZE_SGI                       = $80DA;
+  {$EXTERNALSYM GL_COLOR_TABLE_RED_SIZE_SGI}
+  GL_COLOR_TABLE_GREEN_SIZE_SGI                     = $80DB;
+  {$EXTERNALSYM GL_COLOR_TABLE_GREEN_SIZE_SGI}
+  GL_COLOR_TABLE_BLUE_SIZE_SGI                      = $80DC;
+  {$EXTERNALSYM GL_COLOR_TABLE_BLUE_SIZE_SGI}
+  GL_COLOR_TABLE_ALPHA_SIZE_SGI                     = $80DD;
+  {$EXTERNALSYM GL_COLOR_TABLE_ALPHA_SIZE_SGI}
+  GL_COLOR_TABLE_LUMINANCE_SIZE_SGI                 = $80DE;
+  {$EXTERNALSYM GL_COLOR_TABLE_LUMINANCE_SIZE_SGI}
+  GL_COLOR_TABLE_INTENSITY_SIZE_SGI                 = $80DF;
+  {$EXTERNALSYM GL_COLOR_TABLE_INTENSITY_SIZE_SGI}
+
+  // EXT_cmyka
+  GL_CMYK_EXT                                       = $800C;
+  {$EXTERNALSYM GL_CMYK_EXT}
+  GL_CMYKA_EXT                                      = $800D;
+  {$EXTERNALSYM GL_CMYKA_EXT}
+  GL_PACK_CMYK_HINT_EXT                             = $800E;
+  {$EXTERNALSYM GL_PACK_CMYK_HINT_EXT}
+  GL_UNPACK_CMYK_HINT_EXT                           = $800F;
+  {$EXTERNALSYM GL_UNPACK_CMYK_HINT_EXT}
+
+  // EXT_rescale_normal
+  GL_RESCALE_NORMAL_EXT                             = $803A;
+  {$EXTERNALSYM GL_RESCALE_NORMAL_EXT}
+
+  // EXT_clip_volume_hint
+  GL_CLIP_VOLUME_CLIPPING_HINT_EXT	                = $80F0;
+  {$EXTERNALSYM GL_CLIP_VOLUME_CLIPPING_HINT_EXT}
+
+  // EXT_cull_vertex
+  GL_CULL_VERTEX_EXT                                = $81AA;
+  {$EXTERNALSYM GL_CULL_VERTEX_EXT}
+  GL_CULL_VERTEX_EYE_POSITION_EXT                   = $81AB;
+  {$EXTERNALSYM GL_CULL_VERTEX_EYE_POSITION_EXT}
+  GL_CULL_VERTEX_OBJECT_POSITION_EXT                = $81AC;
+  {$EXTERNALSYM GL_CULL_VERTEX_OBJECT_POSITION_EXT}
+
+  // EXT_index_array_formats
+  GL_IUI_V2F_EXT                                    = $81AD;
+  {$EXTERNALSYM GL_IUI_V2F_EXT}
+  GL_IUI_V3F_EXT                                    = $81AE;
+  {$EXTERNALSYM GL_IUI_V3F_EXT}
+  GL_IUI_N3F_V2F_EXT                                = $81AF;
+  {$EXTERNALSYM GL_IUI_N3F_V2F_EXT}
+  GL_IUI_N3F_V3F_EXT                                = $81B0;
+  {$EXTERNALSYM GL_IUI_N3F_V3F_EXT}
+  GL_T2F_IUI_V2F_EXT                                = $81B1;
+  {$EXTERNALSYM GL_T2F_IUI_V2F_EXT}
+  GL_T2F_IUI_V3F_EXT                                = $81B2;
+  {$EXTERNALSYM GL_T2F_IUI_V3F_EXT}
+  GL_T2F_IUI_N3F_V2F_EXT                            = $81B3;
+  {$EXTERNALSYM GL_T2F_IUI_N3F_V2F_EXT}
+  GL_T2F_IUI_N3F_V3F_EXT                            = $81B4;
+  {$EXTERNALSYM GL_T2F_IUI_N3F_V3F_EXT}
+
+  // EXT_index_func
+  GL_INDEX_TEST_EXT                                 = $81B5;
+  {$EXTERNALSYM GL_INDEX_TEST_EXT}
+  GL_INDEX_TEST_FUNC_EXT                            = $81B6;
+  {$EXTERNALSYM GL_INDEX_TEST_FUNC_EXT}
+  GL_INDEX_TEST_REF_EXT                             = $81B7;
+  {$EXTERNALSYM GL_INDEX_TEST_REF_EXT}
+
+  // EXT_index_material
+  GL_INDEX_MATERIAL_EXT                             = $81B8;
+  {$EXTERNALSYM GL_INDEX_MATERIAL_EXT}
+  GL_INDEX_MATERIAL_PARAMETER_EXT                   = $81B9;
+  {$EXTERNALSYM GL_INDEX_MATERIAL_PARAMETER_EXT}
+  GL_INDEX_MATERIAL_FACE_EXT                        = $81BA;
+  {$EXTERNALSYM GL_INDEX_MATERIAL_FACE_EXT}
+
+  // EXT_misc_attribute
+  GL_MISC_BIT_EXT                                   = 0; // not yet defined
+  {$EXTERNALSYM GL_MISC_BIT_EXT}
+
+  // EXT_scene_marker
+  GL_SCENE_REQUIRED_EXT                             = 0; // not yet defined
+  {$EXTERNALSYM GL_SCENE_REQUIRED_EXT}
+
+  // EXT_shared_texture_palette
+  GL_SHARED_TEXTURE_PALETTE_EXT                     = $81FB;
+  {$EXTERNALSYM GL_SHARED_TEXTURE_PALETTE_EXT}
+
+  // EXT_nurbs_tessellator
+  GLU_NURBS_MODE_EXT                                = 100160;
+  {$EXTERNALSYM GLU_NURBS_MODE_EXT}
+  GLU_NURBS_TESSELLATOR_EXT                         = 100161;
+  {$EXTERNALSYM GLU_NURBS_TESSELLATOR_EXT}
+  GLU_NURBS_RENDERER_EXT                            = 100162;
+  {$EXTERNALSYM GLU_NURBS_RENDERER_EXT}
+  GLU_NURBS_BEGIN_EXT                               = 100164;
+  {$EXTERNALSYM GLU_NURBS_BEGIN_EXT}
+  GLU_NURBS_VERTEX_EXT                              = 100165;
+  {$EXTERNALSYM GLU_NURBS_VERTEX_EXT}
+  GLU_NURBS_NORMAL_EXT                              = 100166;
+  {$EXTERNALSYM GLU_NURBS_NORMAL_EXT}
+  GLU_NURBS_COLOR_EXT                               = 100167;
+  {$EXTERNALSYM GLU_NURBS_COLOR_EXT}
+  GLU_NURBS_TEX_COORD_EXT                           = 100168;
+  {$EXTERNALSYM GLU_NURBS_TEX_COORD_EXT}
+  GLU_NURBS_END_EXT                                 = 100169;
+  {$EXTERNALSYM GLU_NURBS_END_EXT}
+  GLU_NURBS_BEGIN_DATA_EXT                          = 100170;
+  {$EXTERNALSYM GLU_NURBS_BEGIN_DATA_EXT}
+  GLU_NURBS_VERTEX_DATA_EXT                         = 100171;
+  {$EXTERNALSYM GLU_NURBS_VERTEX_DATA_EXT}
+  GLU_NURBS_NORMAL_DATA_EXT                         = 100172;
+  {$EXTERNALSYM GLU_NURBS_NORMAL_DATA_EXT}
+  GLU_NURBS_COLOR_DATA_EXT                          = 100173;
+  {$EXTERNALSYM GLU_NURBS_COLOR_DATA_EXT}
+  GLU_NURBS_TEX_COORD_DATA_EXT                      = 100174;
+  {$EXTERNALSYM GLU_NURBS_TEX_COORD_DATA_EXT}
+  GLU_NURBS_END_DATA_EXT                            = 100175;
+  {$EXTERNALSYM GLU_NURBS_END_DATA_EXT}
+
+  // EXT_object_space_tess
+  GLU_OBJECT_PARAMETRIC_ERROR_EXT                   = 100208;
+  {$EXTERNALSYM GLU_OBJECT_PARAMETRIC_ERROR_EXT}
+  GLU_OBJECT_PATH_LENGTH_EXT                        = 100209;
+  {$EXTERNALSYM GLU_OBJECT_PATH_LENGTH_EXT}
+
+  // EXT_point_parameters
+  GL_POINT_SIZE_MIN_EXT                             = $8126;
+  {$EXTERNALSYM GL_POINT_SIZE_MIN_EXT}
+  GL_POINT_SIZE_MAX_EXT                             = $8127;
+  {$EXTERNALSYM GL_POINT_SIZE_MAX_EXT}
+  GL_POINT_FADE_THRESHOLD_SIZE_EXT                  = $8128;
+  {$EXTERNALSYM GL_POINT_FADE_THRESHOLD_SIZE_EXT}
+  GL_DISTANCE_ATTENUATION_EXT                       = $8129;
+  {$EXTERNALSYM GL_DISTANCE_ATTENUATION_EXT}
+
+  // EXT_compiled_vertex_array
+  GL_ARRAY_ELEMENT_LOCK_FIRST_EXT                   = $81A8;
+  {$EXTERNALSYM GL_ARRAY_ELEMENT_LOCK_FIRST_EXT}
+  GL_ARRAY_ELEMENT_LOCK_COUNT_EXT                   = $81A9;
+  {$EXTERNALSYM GL_ARRAY_ELEMENT_LOCK_COUNT_EXT}
+
+  // ARB_multitexture
+  GL_ACTIVE_TEXTURE_ARB                             = $84E0;
+  {$EXTERNALSYM GL_ACTIVE_TEXTURE_ARB}
+  GL_CLIENT_ACTIVE_TEXTURE_ARB                      = $84E1;
+  {$EXTERNALSYM GL_CLIENT_ACTIVE_TEXTURE_ARB}
+  GL_MAX_TEXTURE_UNITS_ARB                          = $84E2;
+  {$EXTERNALSYM GL_MAX_TEXTURE_UNITS_ARB}
+  GL_TEXTURE0_ARB                                   = $84C0;
+  {$EXTERNALSYM GL_TEXTURE0_ARB}
+  GL_TEXTURE1_ARB                                   = $84C1;
+  {$EXTERNALSYM GL_TEXTURE1_ARB}
+  GL_TEXTURE2_ARB                                   = $84C2;
+  {$EXTERNALSYM GL_TEXTURE2_ARB}
+  GL_TEXTURE3_ARB                                   = $84C3;
+  {$EXTERNALSYM GL_TEXTURE3_ARB}
+  GL_TEXTURE4_ARB                                   = $84C4;
+  {$EXTERNALSYM GL_TEXTURE4_ARB}
+  GL_TEXTURE5_ARB                                   = $84C5;
+  {$EXTERNALSYM GL_TEXTURE5_ARB}
+  GL_TEXTURE6_ARB                                   = $84C6;
+  {$EXTERNALSYM GL_TEXTURE6_ARB}
+  GL_TEXTURE7_ARB                                   = $84C7;
+  {$EXTERNALSYM GL_TEXTURE7_ARB}
+  GL_TEXTURE8_ARB                                   = $84C8;
+  {$EXTERNALSYM GL_TEXTURE8_ARB}
+  GL_TEXTURE9_ARB                                   = $84C9;
+  {$EXTERNALSYM GL_TEXTURE9_ARB}
+  GL_TEXTURE10_ARB                                  = $84CA;
+  {$EXTERNALSYM GL_TEXTURE10_ARB}
+  GL_TEXTURE11_ARB                                  = $84CB;
+  {$EXTERNALSYM GL_TEXTURE11_ARB}
+  GL_TEXTURE12_ARB                                  = $84CC;
+  {$EXTERNALSYM GL_TEXTURE12_ARB}
+  GL_TEXTURE13_ARB                                  = $84CD;
+  {$EXTERNALSYM GL_TEXTURE13_ARB}
+  GL_TEXTURE14_ARB                                  = $84CE;
+  {$EXTERNALSYM GL_TEXTURE14_ARB}
+  GL_TEXTURE15_ARB                                  = $84CF;
+  {$EXTERNALSYM GL_TEXTURE15_ARB}
+  GL_TEXTURE16_ARB                                  = $84D0;
+  {$EXTERNALSYM GL_TEXTURE16_ARB}
+  GL_TEXTURE17_ARB                                  = $84D1;
+  {$EXTERNALSYM GL_TEXTURE17_ARB}
+  GL_TEXTURE18_ARB                                  = $84D2;
+  {$EXTERNALSYM GL_TEXTURE18_ARB}
+  GL_TEXTURE19_ARB                                  = $84D3;
+  {$EXTERNALSYM GL_TEXTURE19_ARB}
+  GL_TEXTURE20_ARB                                  = $84D4;
+  {$EXTERNALSYM GL_TEXTURE20_ARB}
+  GL_TEXTURE21_ARB                                  = $84D5;
+  {$EXTERNALSYM GL_TEXTURE21_ARB}
+  GL_TEXTURE22_ARB                                  = $84D6;
+  {$EXTERNALSYM GL_TEXTURE22_ARB}
+  GL_TEXTURE23_ARB                                  = $84D7;
+  {$EXTERNALSYM GL_TEXTURE23_ARB}
+  GL_TEXTURE24_ARB                                  = $84D8;
+  {$EXTERNALSYM GL_TEXTURE24_ARB}
+  GL_TEXTURE25_ARB                                  = $84D9;
+  {$EXTERNALSYM GL_TEXTURE25_ARB}
+  GL_TEXTURE26_ARB                                  = $84DA;
+  {$EXTERNALSYM GL_TEXTURE26_ARB}
+  GL_TEXTURE27_ARB                                  = $84DB;
+  {$EXTERNALSYM GL_TEXTURE27_ARB}
+  GL_TEXTURE28_ARB                                  = $84DC;
+  {$EXTERNALSYM GL_TEXTURE28_ARB}
+  GL_TEXTURE29_ARB                                  = $84DD;
+  {$EXTERNALSYM GL_TEXTURE29_ARB}
+  GL_TEXTURE30_ARB                                  = $84DE;
+  {$EXTERNALSYM GL_TEXTURE30_ARB}
+  GL_TEXTURE31_ARB                                  = $84DF;
+  {$EXTERNALSYM GL_TEXTURE31_ARB}
+
+  // EXT_stencil_wrap
+  GL_INCR_WRAP_EXT                                  = $8507;
+  {$EXTERNALSYM GL_INCR_WRAP_EXT}
+  GL_DECR_WRAP_EXT                                  = $8508;
+  {$EXTERNALSYM GL_DECR_WRAP_EXT}
+
+  // NV_texgen_reflection
+  GL_NORMAL_MAP_NV                                  = $8511;
+  {$EXTERNALSYM GL_NORMAL_MAP_NV}
+  GL_REFLECTION_MAP_NV                              = $8512;
+  {$EXTERNALSYM GL_REFLECTION_MAP_NV}
+
+  // EXT_texture_env_combine
+  GL_COMBINE_EXT                                    = $8570;
+  {$EXTERNALSYM GL_COMBINE_EXT}
+  GL_COMBINE_RGB_EXT                                = $8571;
+  {$EXTERNALSYM GL_COMBINE_RGB_EXT}
+  GL_COMBINE_ALPHA_EXT                              = $8572;
+  {$EXTERNALSYM GL_COMBINE_ALPHA_EXT}
+  GL_RGB_SCALE_EXT                                  = $8573;
+  {$EXTERNALSYM GL_RGB_SCALE_EXT}
+  GL_ADD_SIGNED_EXT                                 = $8574;
+  {$EXTERNALSYM GL_ADD_SIGNED_EXT}
+  GL_INTERPOLATE_EXT                                = $8575;
+  {$EXTERNALSYM GL_INTERPOLATE_EXT}
+  GL_CONSTANT_EXT                                   = $8576;
+  {$EXTERNALSYM GL_CONSTANT_EXT}
+  GL_PRIMARY_COLOR_EXT                              = $8577;
+  {$EXTERNALSYM GL_PRIMARY_COLOR_EXT}
+  GL_PREVIOUS_EXT                                   = $8578;
+  {$EXTERNALSYM GL_PREVIOUS_EXT}
+  GL_SOURCE0_RGB_EXT                                = $8580;
+  {$EXTERNALSYM GL_SOURCE0_RGB_EXT}
+  GL_SOURCE1_RGB_EXT                                = $8581;
+  {$EXTERNALSYM GL_SOURCE1_RGB_EXT}
+  GL_SOURCE2_RGB_EXT                                = $8582;
+  {$EXTERNALSYM GL_SOURCE2_RGB_EXT}
+  GL_SOURCE0_ALPHA_EXT                              = $8588;
+  {$EXTERNALSYM GL_SOURCE0_ALPHA_EXT}
+  GL_SOURCE1_ALPHA_EXT                              = $8589;
+  {$EXTERNALSYM GL_SOURCE1_ALPHA_EXT}
+  GL_SOURCE2_ALPHA_EXT                              = $858A;
+  {$EXTERNALSYM GL_SOURCE2_ALPHA_EXT}
+  GL_OPERAND0_RGB_EXT                               = $8590;
+  {$EXTERNALSYM GL_OPERAND0_RGB_EXT}
+  GL_OPERAND1_RGB_EXT                               = $8591;
+  {$EXTERNALSYM GL_OPERAND1_RGB_EXT}
+  GL_OPERAND2_RGB_EXT                               = $8592;
+  {$EXTERNALSYM GL_OPERAND2_RGB_EXT}
+  GL_OPERAND0_ALPHA_EXT                             = $8598;
+  {$EXTERNALSYM GL_OPERAND0_ALPHA_EXT}
+  GL_OPERAND1_ALPHA_EXT                             = $8599;
+  {$EXTERNALSYM GL_OPERAND1_ALPHA_EXT}
+  GL_OPERAND2_ALPHA_EXT                             = $859A;
+  {$EXTERNALSYM GL_OPERAND2_ALPHA_EXT}
+
+  // NV_texture_env_combine4
+  GL_COMBINE4_NV                                    = $8503;
+  {$EXTERNALSYM GL_COMBINE4_NV}
+  GL_SOURCE3_RGB_NV                                 = $8583;
+  {$EXTERNALSYM GL_SOURCE3_RGB_NV}
+  GL_SOURCE3_ALPHA_NV                               = $858B;
+  {$EXTERNALSYM GL_SOURCE3_ALPHA_NV}
+  GL_OPERAND3_RGB_NV                                = $8593;
+  {$EXTERNALSYM GL_OPERAND3_RGB_NV}
+  GL_OPERAND3_ALPHA_NV                              = $859B;
+  {$EXTERNALSYM GL_OPERAND3_ALPHA_NV}
+
+  GL_BLEND_EQUATION                                 = $8009;
+  {$EXTERNALSYM GL_BLEND_EQUATION}
+  GL_TABLE_TOO_LARGE                                = $8031;
+  {$EXTERNALSYM GL_TABLE_TOO_LARGE}
+  GL_UNSIGNED_BYTE_3_3_2                            = $8032;
+  {$EXTERNALSYM GL_UNSIGNED_BYTE_3_3_2}
+  GL_UNSIGNED_SHORT_4_4_4_4                         = $8033;
+  {$EXTERNALSYM GL_UNSIGNED_SHORT_4_4_4_4}
+  GL_UNSIGNED_SHORT_5_5_5_1                         = $8034;
+  {$EXTERNALSYM GL_UNSIGNED_SHORT_5_5_5_1}
+  GL_UNSIGNED_INT_8_8_8_8                           = $8035;
+  {$EXTERNALSYM GL_UNSIGNED_INT_8_8_8_8}
+  GL_UNSIGNED_INT_10_10_10_2                        = $8036;
+  {$EXTERNALSYM GL_UNSIGNED_INT_10_10_10_2}
+  GL_UNSIGNED_BYTE_2_3_3_REV                        = $8362;
+  {$EXTERNALSYM GL_UNSIGNED_BYTE_2_3_3_REV}
+  GL_UNSIGNED_SHORT_5_6_5                           = $8363;
+  {$EXTERNALSYM GL_UNSIGNED_SHORT_5_6_5}
+  GL_UNSIGNED_SHORT_5_6_5_REV                       = $8364;
+  {$EXTERNALSYM GL_UNSIGNED_SHORT_5_6_5_REV}
+  GL_UNSIGNED_SHORT_4_4_4_4_REV                     = $8365;
+  {$EXTERNALSYM GL_UNSIGNED_SHORT_4_4_4_4_REV}
+  GL_UNSIGNED_SHORT_1_5_5_5_REV                     = $8366;
+  {$EXTERNALSYM GL_UNSIGNED_SHORT_1_5_5_5_REV}
+  GL_UNSIGNED_INT_8_8_8_8_REV                       = $8367;
+  {$EXTERNALSYM GL_UNSIGNED_INT_8_8_8_8_REV}
+  GL_UNSIGNED_INT_2_10_10_10_REV                    = $8368;
+  {$EXTERNALSYM GL_UNSIGNED_INT_2_10_10_10_REV}
+
+  // GL_ARB_transpose_matrix
+  GL_TRANSPOSE_MODELVIEW_MATRIX_ARB                 = $84E3;
+  {$EXTERNALSYM GL_TRANSPOSE_MODELVIEW_MATRIX_ARB}
+  GL_TRANSPOSE_PROJECTION_MATRIX_ARB                = $84E4;
+  {$EXTERNALSYM GL_TRANSPOSE_PROJECTION_MATRIX_ARB}
+  GL_TRANSPOSE_TEXTURE_MATRIX_ARB                   = $84E5;
+  {$EXTERNALSYM GL_TRANSPOSE_TEXTURE_MATRIX_ARB}
+  GL_TRANSPOSE_COLOR_MATRIX_ARB                     = $84E6;
+  {$EXTERNALSYM GL_TRANSPOSE_COLOR_MATRIX_ARB}
+
+  // GL_ARB_multisample
+  GL_MULTISAMPLE_ARB                                = $809D;
+  {$EXTERNALSYM GL_MULTISAMPLE_ARB}
+  GL_SAMPLE_ALPHA_TO_COVERAGE_ARB                   = $809E;
+  {$EXTERNALSYM GL_SAMPLE_ALPHA_TO_COVERAGE_ARB}
+  GL_SAMPLE_ALPHA_TO_ONE_ARB                        = $809F;
+  {$EXTERNALSYM GL_SAMPLE_ALPHA_TO_ONE_ARB}
+  GL_SAMPLE_COVERAGE_ARB                            = $80A0;
+  {$EXTERNALSYM GL_SAMPLE_COVERAGE_ARB}
+  GL_SAMPLE_BUFFERS_ARB                             = $80A8;
+  {$EXTERNALSYM GL_SAMPLE_BUFFERS_ARB}
+  GL_SAMPLES_ARB                                    = $80A9;
+  {$EXTERNALSYM GL_SAMPLES_ARB}
+  GL_SAMPLE_COVERAGE_VALUE_ARB                      = $80AA;
+  {$EXTERNALSYM GL_SAMPLE_COVERAGE_VALUE_ARB}
+  GL_SAMPLE_COVERAGE_INVERT_ARB                     = $80AB;
+  {$EXTERNALSYM GL_SAMPLE_COVERAGE_INVERT_ARB}
+  GL_MULTISAMPLE_BIT_ARB                            = $20000000;
+  {$EXTERNALSYM GL_MULTISAMPLE_BIT_ARB}
+  GLX_SAMPLE_BUFFERS_ARB                            = 100000;
+  {$EXTERNALSYM GLX_SAMPLE_BUFFERS_ARB}
+  GLX_SAMPLES_ARB                                   = 100001;
+  {$EXTERNALSYM GLX_SAMPLES_ARB}
+  WGL_SAMPLE_BUFFERS_ARB                            = $2041;
+  {$EXTERNALSYM WGL_SAMPLE_BUFFERS_ARB}
+  WGL_SAMPLES_ARB                                   = $2042;
+  {$EXTERNALSYM WGL_SAMPLES_ARB}
+
+  // GL_ARB_texture_cube_map
+  GL_NORMAL_MAP_ARB                                 = $8511;
+  {$EXTERNALSYM GL_NORMAL_MAP_ARB}
+  GL_REFLECTION_MAP_ARB                             = $8512;
+  {$EXTERNALSYM GL_REFLECTION_MAP_ARB}
+  GL_TEXTURE_CUBE_MAP_ARB                           = $8513;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_ARB}
+  GL_TEXTURE_BINDING_CUBE_MAP_ARB                   = $8514;
+  {$EXTERNALSYM GL_TEXTURE_BINDING_CUBE_MAP_ARB}
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB                = $8515;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB}
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB                = $8516;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB}
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB                = $8517;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB}
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB                = $8518;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB}
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB                = $8519;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB}
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB                = $851A;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB}
+  GL_PROXY_TEXTURE_CUBE_MAP_ARB                     = $851B;
+  {$EXTERNALSYM GL_PROXY_TEXTURE_CUBE_MAP_ARB}
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB                  = $851C;
+  {$EXTERNALSYM GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB}
+
+  // GL_ARB_texture_compression
+  GL_COMPRESSED_ALPHA_ARB                           = $84E9;
+  {$EXTERNALSYM GL_COMPRESSED_ALPHA_ARB}
+  GL_COMPRESSED_LUMINANCE_ARB                       = $84EA;
+  {$EXTERNALSYM GL_COMPRESSED_LUMINANCE_ARB}
+  GL_COMPRESSED_LUMINANCE_ALPHA_ARB                 = $84EB;
+  {$EXTERNALSYM GL_COMPRESSED_LUMINANCE_ALPHA_ARB}
+  GL_COMPRESSED_INTENSITY_ARB                       = $84EC;
+  {$EXTERNALSYM GL_COMPRESSED_INTENSITY_ARB}
+  GL_COMPRESSED_RGB_ARB                             = $84ED;
+  {$EXTERNALSYM GL_COMPRESSED_RGB_ARB}
+  GL_COMPRESSED_RGBA_ARB                            = $84EE;
+  {$EXTERNALSYM GL_COMPRESSED_RGBA_ARB}
+  GL_TEXTURE_COMPRESSION_HINT_ARB                   = $84EF;
+  {$EXTERNALSYM GL_TEXTURE_COMPRESSION_HINT_ARB}
+  GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB              = $86A0;
+  {$EXTERNALSYM GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB}
+  GL_TEXTURE_COMPRESSED_ARB                         = $86A1;
+  {$EXTERNALSYM GL_TEXTURE_COMPRESSED_ARB}
+  GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB             = $86A2;
+  {$EXTERNALSYM GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB}
+  GL_COMPRESSED_TEXTURE_FORMATS_ARB                 = $86A3;
+  {$EXTERNALSYM GL_COMPRESSED_TEXTURE_FORMATS_ARB}
+
+  // GL_ARB_vertex_blend
+  GL_MAX_VERTEX_UNITS_ARB                           = $86A4;
+  {$EXTERNALSYM GL_MAX_VERTEX_UNITS_ARB}
+  GL_ACTIVE_VERTEX_UNITS_ARB                        = $86A5;
+  {$EXTERNALSYM GL_ACTIVE_VERTEX_UNITS_ARB}
+  GL_WEIGHT_SUM_UNITY_ARB                           = $86A6;
+  {$EXTERNALSYM GL_WEIGHT_SUM_UNITY_ARB}
+  GL_VERTEX_BLEND_ARB                               = $86A7;
+  {$EXTERNALSYM GL_VERTEX_BLEND_ARB}
+  GL_CURRENT_WEIGHT_ARB                             = $86A8;
+  {$EXTERNALSYM GL_CURRENT_WEIGHT_ARB}
+  GL_WEIGHT_ARRAY_TYPE_ARB                          = $86A9;
+  {$EXTERNALSYM GL_WEIGHT_ARRAY_TYPE_ARB}
+  GL_WEIGHT_ARRAY_STRIDE_ARB                        = $86AA;
+  {$EXTERNALSYM GL_WEIGHT_ARRAY_STRIDE_ARB}
+  GL_WEIGHT_ARRAY_SIZE_ARB                          = $86AB;
+  {$EXTERNALSYM GL_WEIGHT_ARRAY_SIZE_ARB}
+  GL_WEIGHT_ARRAY_POINTER_ARB                       = $86AC;
+  {$EXTERNALSYM GL_WEIGHT_ARRAY_POINTER_ARB}
+  GL_WEIGHT_ARRAY_ARB                               = $86AD;
+  {$EXTERNALSYM GL_WEIGHT_ARRAY_ARB}
+  GL_MODELVIEW0_ARB                                 = $1700;
+  {$EXTERNALSYM GL_MODELVIEW0_ARB}
+  GL_MODELVIEW1_ARB                                 = $850A;
+  {$EXTERNALSYM GL_MODELVIEW1_ARB}
+  GL_MODELVIEW2_ARB                                 = $8722;
+  {$EXTERNALSYM GL_MODELVIEW2_ARB}
+  GL_MODELVIEW3_ARB                                 = $8723;
+  {$EXTERNALSYM GL_MODELVIEW3_ARB}
+  GL_MODELVIEW4_ARB                                 = $8724;
+  {$EXTERNALSYM GL_MODELVIEW4_ARB}
+  GL_MODELVIEW5_ARB                                 = $8725;
+  {$EXTERNALSYM GL_MODELVIEW5_ARB}
+  GL_MODELVIEW6_ARB                                 = $8726;
+  {$EXTERNALSYM GL_MODELVIEW6_ARB}
+  GL_MODELVIEW7_ARB                                 = $8727;
+  {$EXTERNALSYM GL_MODELVIEW7_ARB}
+  GL_MODELVIEW8_ARB                                 = $8728;
+  {$EXTERNALSYM GL_MODELVIEW8_ARB}
+  GL_MODELVIEW9_ARB                                 = $8729;
+  {$EXTERNALSYM GL_MODELVIEW9_ARB}
+  GL_MODELVIEW10_ARB                                = $872A;
+  {$EXTERNALSYM GL_MODELVIEW10_ARB}
+  GL_MODELVIEW11_ARB                                = $872B;
+  {$EXTERNALSYM GL_MODELVIEW11_ARB}
+  GL_MODELVIEW12_ARB                                = $872C;
+  {$EXTERNALSYM GL_MODELVIEW12_ARB}
+  GL_MODELVIEW13_ARB                                = $872D;
+  {$EXTERNALSYM GL_MODELVIEW13_ARB}
+  GL_MODELVIEW14_ARB                                = $872E;
+  {$EXTERNALSYM GL_MODELVIEW14_ARB}
+  GL_MODELVIEW15_ARB                                = $872F;
+  {$EXTERNALSYM GL_MODELVIEW15_ARB}
+  GL_MODELVIEW16_ARB                                = $8730;
+  {$EXTERNALSYM GL_MODELVIEW16_ARB}
+  GL_MODELVIEW17_ARB                                = $8731;
+  {$EXTERNALSYM GL_MODELVIEW17_ARB}
+  GL_MODELVIEW18_ARB                                = $8732;
+  {$EXTERNALSYM GL_MODELVIEW18_ARB}
+  GL_MODELVIEW19_ARB                                = $8733;
+  {$EXTERNALSYM GL_MODELVIEW19_ARB}
+  GL_MODELVIEW20_ARB                                = $8734;
+  {$EXTERNALSYM GL_MODELVIEW20_ARB}
+  GL_MODELVIEW21_ARB                                = $8735;
+  {$EXTERNALSYM GL_MODELVIEW21_ARB}
+  GL_MODELVIEW22_ARB                                = $8736;
+  {$EXTERNALSYM GL_MODELVIEW22_ARB}
+  GL_MODELVIEW23_ARB                                = $8737;
+  {$EXTERNALSYM GL_MODELVIEW23_ARB}
+  GL_MODELVIEW24_ARB                                = $8738;
+  {$EXTERNALSYM GL_MODELVIEW24_ARB}
+  GL_MODELVIEW25_ARB                                = $8739;
+  {$EXTERNALSYM GL_MODELVIEW25_ARB}
+  GL_MODELVIEW26_ARB                                = $873A;
+  {$EXTERNALSYM GL_MODELVIEW26_ARB}
+  GL_MODELVIEW27_ARB                                = $873B;
+  {$EXTERNALSYM GL_MODELVIEW27_ARB}
+  GL_MODELVIEW28_ARB                                = $873C;
+  {$EXTERNALSYM GL_MODELVIEW28_ARB}
+  GL_MODELVIEW29_ARB                                = $873D;
+  {$EXTERNALSYM GL_MODELVIEW29_ARB}
+  GL_MODELVIEW30_ARB                                = $873E;
+  {$EXTERNALSYM GL_MODELVIEW30_ARB}
+  GL_MODELVIEW31_ARB                                = $873F;
+  {$EXTERNALSYM GL_MODELVIEW31_ARB}
+
+  // GL_SGIS_texture_filter4
+  GL_FILTER4_SGIS                                   = $8146;
+  {$EXTERNALSYM GL_FILTER4_SGIS}
+  GL_TEXTURE_FILTER4_SIZE_SGIS                      = $8147;
+  {$EXTERNALSYM GL_TEXTURE_FILTER4_SIZE_SGIS}
+
+  // GL_SGIS_pixel_texture
+  GL_PIXEL_TEXTURE_SGIS                             = $8353;
+  {$EXTERNALSYM GL_PIXEL_TEXTURE_SGIS}
+  GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS                 = $8354;
+  {$EXTERNALSYM GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS}
+  GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS               = $8355;
+  {$EXTERNALSYM GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS}
+  GL_PIXEL_GROUP_COLOR_SGIS                         = $8356;
+  {$EXTERNALSYM GL_PIXEL_GROUP_COLOR_SGIS}
+
+  // GL_SGIX_pixel_texture
+  GL_PIXEL_TEX_GEN_SGIX                             = $8139;
+  {$EXTERNALSYM GL_PIXEL_TEX_GEN_SGIX}
+  GL_PIXEL_TEX_GEN_MODE_SGIX                        = $832B;
+  {$EXTERNALSYM GL_PIXEL_TEX_GEN_MODE_SGIX}
+
+  // GL_SGIS_texture4D
+  GL_PACK_SKIP_VOLUMES_SGIS                         = $8130;
+  {$EXTERNALSYM GL_PACK_SKIP_VOLUMES_SGIS}
+  GL_PACK_IMAGE_DEPTH_SGIS                          = $8131;
+  {$EXTERNALSYM GL_PACK_IMAGE_DEPTH_SGIS}
+  GL_UNPACK_SKIP_VOLUMES_SGIS                       = $8132;
+  {$EXTERNALSYM GL_UNPACK_SKIP_VOLUMES_SGIS}
+  GL_UNPACK_IMAGE_DEPTH_SGIS                        = $8133;
+  {$EXTERNALSYM GL_UNPACK_IMAGE_DEPTH_SGIS}
+  GL_TEXTURE_4D_SGIS                                = $8134;
+  {$EXTERNALSYM GL_TEXTURE_4D_SGIS}
+  GL_PROXY_TEXTURE_4D_SGIS                          = $8135;
+  {$EXTERNALSYM GL_PROXY_TEXTURE_4D_SGIS}
+  GL_TEXTURE_4DSIZE_SGIS                            = $8136;
+  {$EXTERNALSYM GL_TEXTURE_4DSIZE_SGIS}
+  GL_TEXTURE_WRAP_Q_SGIS                            = $8137;
+  {$EXTERNALSYM GL_TEXTURE_WRAP_Q_SGIS}
+  GL_MAX_4D_TEXTURE_SIZE_SGIS                       = $8138;
+  {$EXTERNALSYM GL_MAX_4D_TEXTURE_SIZE_SGIS}
+  GL_TEXTURE_4D_BINDING_SGIS                        = $814F;
+  {$EXTERNALSYM GL_TEXTURE_4D_BINDING_SGIS}
+
+  // GL_SGIS_detail_texture
+  GL_DETAIL_TEXTURE_2D_SGIS                         = $8095;
+  {$EXTERNALSYM GL_DETAIL_TEXTURE_2D_SGIS}
+  GL_DETAIL_TEXTURE_2D_BINDING_SGIS                 = $8096;
+  {$EXTERNALSYM GL_DETAIL_TEXTURE_2D_BINDING_SGIS}
+  GL_LINEAR_DETAIL_SGIS                             = $8097;
+  {$EXTERNALSYM GL_LINEAR_DETAIL_SGIS}
+  GL_LINEAR_DETAIL_ALPHA_SGIS                       = $8098;
+  {$EXTERNALSYM GL_LINEAR_DETAIL_ALPHA_SGIS}
+  GL_LINEAR_DETAIL_COLOR_SGIS                       = $8099;
+  {$EXTERNALSYM GL_LINEAR_DETAIL_COLOR_SGIS}
+  GL_DETAIL_TEXTURE_LEVEL_SGIS                      = $809A;
+  {$EXTERNALSYM GL_DETAIL_TEXTURE_LEVEL_SGIS}
+  GL_DETAIL_TEXTURE_MODE_SGIS                       = $809B;
+  {$EXTERNALSYM GL_DETAIL_TEXTURE_MODE_SGIS}
+  GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS                = $809C;
+  {$EXTERNALSYM GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS}
+
+  // GL_SGIS_sharpen_texture
+  GL_LINEAR_SHARPEN_SGIS                            = $80AD;
+  {$EXTERNALSYM GL_LINEAR_SHARPEN_SGIS}
+  GL_LINEAR_SHARPEN_ALPHA_SGIS                      = $80AE;
+  {$EXTERNALSYM GL_LINEAR_SHARPEN_ALPHA_SGIS}
+  GL_LINEAR_SHARPEN_COLOR_SGIS                      = $80AF;
+  {$EXTERNALSYM GL_LINEAR_SHARPEN_COLOR_SGIS}
+  GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS               = $80B0;
+  {$EXTERNALSYM GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS}
+
+  // GL_SGIS_texture_lod
+  GL_TEXTURE_MIN_LOD_SGIS                           = $813A;
+  {$EXTERNALSYM GL_TEXTURE_MIN_LOD_SGIS}
+  GL_TEXTURE_MAX_LOD_SGIS                           = $813B;
+  {$EXTERNALSYM GL_TEXTURE_MAX_LOD_SGIS}
+  GL_TEXTURE_BASE_LEVEL_SGIS                        = $813C;
+  {$EXTERNALSYM GL_TEXTURE_BASE_LEVEL_SGIS}
+  GL_TEXTURE_MAX_LEVEL_SGIS                         = $813D;
+  {$EXTERNALSYM GL_TEXTURE_MAX_LEVEL_SGIS}
+
+  // GL_SGIS_multisample
+  GL_MULTISAMPLE_SGIS                               = $809D;
+  {$EXTERNALSYM GL_MULTISAMPLE_SGIS}
+  GL_SAMPLE_ALPHA_TO_MASK_SGIS                      = $809E;
+  {$EXTERNALSYM GL_SAMPLE_ALPHA_TO_MASK_SGIS}
+  GL_SAMPLE_ALPHA_TO_ONE_SGIS                       = $809F;
+  {$EXTERNALSYM GL_SAMPLE_ALPHA_TO_ONE_SGIS}
+  GL_SAMPLE_MASK_SGIS                               = $80A0;
+  {$EXTERNALSYM GL_SAMPLE_MASK_SGIS}
+  GL_1PASS_SGIS                                     = $80A1;
+  {$EXTERNALSYM GL_1PASS_SGIS}
+  GL_2PASS_0_SGIS                                   = $80A2;
+  {$EXTERNALSYM GL_2PASS_0_SGIS}
+  GL_2PASS_1_SGIS                                   = $80A3;
+  {$EXTERNALSYM GL_2PASS_1_SGIS}
+  GL_4PASS_0_SGIS                                   = $80A4;
+  {$EXTERNALSYM GL_4PASS_0_SGIS}
+  GL_4PASS_1_SGIS                                   = $80A5;
+  {$EXTERNALSYM GL_4PASS_1_SGIS}
+  GL_4PASS_2_SGIS                                   = $80A6;
+  {$EXTERNALSYM GL_4PASS_2_SGIS}
+  GL_4PASS_3_SGIS                                   = $80A7;
+  {$EXTERNALSYM GL_4PASS_3_SGIS}
+  GL_SAMPLE_BUFFERS_SGIS                            = $80A8;
+  {$EXTERNALSYM GL_SAMPLE_BUFFERS_SGIS}
+  GL_SAMPLES_SGIS                                   = $80A9;
+  {$EXTERNALSYM GL_SAMPLES_SGIS}
+  GL_SAMPLE_MASK_VALUE_SGIS                         = $80AA;
+  {$EXTERNALSYM GL_SAMPLE_MASK_VALUE_SGIS}
+  GL_SAMPLE_MASK_INVERT_SGIS                        = $80AB;
+  {$EXTERNALSYM GL_SAMPLE_MASK_INVERT_SGIS}
+  GL_SAMPLE_PATTERN_SGIS                            = $80AC;
+  {$EXTERNALSYM GL_SAMPLE_PATTERN_SGIS}
+
+  // GL_SGIS_generate_mipmap
+  GL_GENERATE_MIPMAP_SGIS                           = $8191;
+  {$EXTERNALSYM GL_GENERATE_MIPMAP_SGIS}
+  GL_GENERATE_MIPMAP_HINT_SGIS                      = $8192;
+  {$EXTERNALSYM GL_GENERATE_MIPMAP_HINT_SGIS}
+
+  // GL_SGIX_clipmap
+  GL_LINEAR_CLIPMAP_LINEAR_SGIX                     = $8170;
+  {$EXTERNALSYM GL_LINEAR_CLIPMAP_LINEAR_SGIX}
+  GL_TEXTURE_CLIPMAP_CENTER_SGIX                    = $8171;
+  {$EXTERNALSYM GL_TEXTURE_CLIPMAP_CENTER_SGIX}
+  GL_TEXTURE_CLIPMAP_FRAME_SGIX                     = $8172;
+  {$EXTERNALSYM GL_TEXTURE_CLIPMAP_FRAME_SGIX}
+  GL_TEXTURE_CLIPMAP_OFFSET_SGIX                    = $8173;
+  {$EXTERNALSYM GL_TEXTURE_CLIPMAP_OFFSET_SGIX}
+  GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX             = $8174;
+  {$EXTERNALSYM GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX}
+  GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX                = $8175;
+  {$EXTERNALSYM GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX}
+  GL_TEXTURE_CLIPMAP_DEPTH_SGIX                     = $8176;
+  {$EXTERNALSYM GL_TEXTURE_CLIPMAP_DEPTH_SGIX}
+  GL_MAX_CLIPMAP_DEPTH_SGIX                         = $8177;
+  {$EXTERNALSYM GL_MAX_CLIPMAP_DEPTH_SGIX}
+  GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX                 = $8178;
+  {$EXTERNALSYM GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX}
+  GL_NEAREST_CLIPMAP_NEAREST_SGIX                   = $844D;
+  {$EXTERNALSYM GL_NEAREST_CLIPMAP_NEAREST_SGIX}
+  GL_NEAREST_CLIPMAP_LINEAR_SGIX                    = $844E;
+  {$EXTERNALSYM GL_NEAREST_CLIPMAP_LINEAR_SGIX}
+  GL_LINEAR_CLIPMAP_NEAREST_SGIX                    = $844F;
+  {$EXTERNALSYM GL_LINEAR_CLIPMAP_NEAREST_SGIX}
+
+  // GL_SGIX_shadow
+  GL_TEXTURE_COMPARE_SGIX                           = $819A;
+  {$EXTERNALSYM GL_TEXTURE_COMPARE_SGIX}
+  GL_TEXTURE_COMPARE_OPERATOR_SGIX                  = $819B;
+  {$EXTERNALSYM GL_TEXTURE_COMPARE_OPERATOR_SGIX}
+  GL_TEXTURE_LEQUAL_R_SGIX                          = $819C;
+  {$EXTERNALSYM GL_TEXTURE_LEQUAL_R_SGIX}
+  GL_TEXTURE_GEQUAL_R_SGIX                          = $819D;
+  {$EXTERNALSYM GL_TEXTURE_GEQUAL_R_SGIX}
+
+  // GL_SGIS_texture_edge_clamp
+  GL_CLAMP_TO_EDGE_SGIS                             = $812F;
+  {$EXTERNALSYM GL_CLAMP_TO_EDGE_SGIS}
+
+  // GL_SGIS_texture_border_clamp
+  GL_CLAMP_TO_BORDER_SGIS                           = $812D;
+  {$EXTERNALSYM GL_CLAMP_TO_BORDER_SGIS}
+
+  // GL_SGIX_interlace
+  GL_INTERLACE_SGIX                                 = $8094;
+  {$EXTERNALSYM GL_INTERLACE_SGIX}
+
+  // GL_SGIX_pixel_tiles
+  GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX                 = $813E;
+  {$EXTERNALSYM GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX}
+  GL_PIXEL_TILE_CACHE_INCREMENT_SGIX                = $813F;
+  {$EXTERNALSYM GL_PIXEL_TILE_CACHE_INCREMENT_SGIX}
+  GL_PIXEL_TILE_WIDTH_SGIX                          = $8140;
+  {$EXTERNALSYM GL_PIXEL_TILE_WIDTH_SGIX}
+  GL_PIXEL_TILE_HEIGHT_SGIX                         = $8141;
+  {$EXTERNALSYM GL_PIXEL_TILE_HEIGHT_SGIX}
+  GL_PIXEL_TILE_GRID_WIDTH_SGIX                     = $8142;
+  {$EXTERNALSYM GL_PIXEL_TILE_GRID_WIDTH_SGIX}
+  GL_PIXEL_TILE_GRID_HEIGHT_SGIX                    = $8143;
+  {$EXTERNALSYM GL_PIXEL_TILE_GRID_HEIGHT_SGIX}
+  GL_PIXEL_TILE_GRID_DEPTH_SGIX                     = $8144;
+  {$EXTERNALSYM GL_PIXEL_TILE_GRID_DEPTH_SGIX}
+  GL_PIXEL_TILE_CACHE_SIZE_SGIX                     = $8145;
+  {$EXTERNALSYM GL_PIXEL_TILE_CACHE_SIZE_SGIX}
+
+  // GL_SGIS_texture_select
+  GL_DUAL_ALPHA4_SGIS                               = $8110;
+  {$EXTERNALSYM GL_DUAL_ALPHA4_SGIS}
+  GL_DUAL_ALPHA8_SGIS                               = $8111;
+  {$EXTERNALSYM GL_DUAL_ALPHA8_SGIS}
+  GL_DUAL_ALPHA12_SGIS                              = $8112;
+  {$EXTERNALSYM GL_DUAL_ALPHA12_SGIS}
+  GL_DUAL_ALPHA16_SGIS                              = $8113;
+  {$EXTERNALSYM GL_DUAL_ALPHA16_SGIS}
+  GL_DUAL_LUMINANCE4_SGIS                           = $8114;
+  {$EXTERNALSYM GL_DUAL_LUMINANCE4_SGIS}
+  GL_DUAL_LUMINANCE8_SGIS                           = $8115;
+  {$EXTERNALSYM GL_DUAL_LUMINANCE8_SGIS}
+  GL_DUAL_LUMINANCE12_SGIS                          = $8116;
+  {$EXTERNALSYM GL_DUAL_LUMINANCE12_SGIS}
+  GL_DUAL_LUMINANCE16_SGIS                          = $8117;
+  {$EXTERNALSYM GL_DUAL_LUMINANCE16_SGIS}
+  GL_DUAL_INTENSITY4_SGIS                           = $8118;
+  {$EXTERNALSYM GL_DUAL_INTENSITY4_SGIS}
+  GL_DUAL_INTENSITY8_SGIS                           = $8119;
+  {$EXTERNALSYM GL_DUAL_INTENSITY8_SGIS}
+  GL_DUAL_INTENSITY12_SGIS                          = $811A;
+  {$EXTERNALSYM GL_DUAL_INTENSITY12_SGIS}
+  GL_DUAL_INTENSITY16_SGIS                          = $811B;
+  {$EXTERNALSYM GL_DUAL_INTENSITY16_SGIS}
+  GL_DUAL_LUMINANCE_ALPHA4_SGIS                     = $811C;
+  {$EXTERNALSYM GL_DUAL_LUMINANCE_ALPHA4_SGIS}
+  GL_DUAL_LUMINANCE_ALPHA8_SGIS                     = $811D;
+  {$EXTERNALSYM GL_DUAL_LUMINANCE_ALPHA8_SGIS}
+  GL_QUAD_ALPHA4_SGIS                               = $811E;
+  {$EXTERNALSYM GL_QUAD_ALPHA4_SGIS}
+  GL_QUAD_ALPHA8_SGIS                               = $811F;
+  {$EXTERNALSYM GL_QUAD_ALPHA8_SGIS}
+  GL_QUAD_LUMINANCE4_SGIS                           = $8120;
+  {$EXTERNALSYM GL_QUAD_LUMINANCE4_SGIS}
+  GL_QUAD_LUMINANCE8_SGIS                           = $8121;
+  {$EXTERNALSYM GL_QUAD_LUMINANCE8_SGIS}
+  GL_QUAD_INTENSITY4_SGIS                           = $8122;
+  {$EXTERNALSYM GL_QUAD_INTENSITY4_SGIS}
+  GL_QUAD_INTENSITY8_SGIS                           = $8123;
+  {$EXTERNALSYM GL_QUAD_INTENSITY8_SGIS}
+  GL_DUAL_TEXTURE_SELECT_SGIS                       = $8124;
+  {$EXTERNALSYM GL_DUAL_TEXTURE_SELECT_SGIS}
+  GL_QUAD_TEXTURE_SELECT_SGIS                       = $8125;
+  {$EXTERNALSYM GL_QUAD_TEXTURE_SELECT_SGIS}
+
+  // GL_SGIX_sprite
+  GL_SPRITE_SGIX                                    = $8148;
+  {$EXTERNALSYM GL_SPRITE_SGIX}
+  GL_SPRITE_MODE_SGIX                               = $8149;
+  {$EXTERNALSYM GL_SPRITE_MODE_SGIX}
+  GL_SPRITE_AXIS_SGIX                               = $814A;
+  {$EXTERNALSYM GL_SPRITE_AXIS_SGIX}
+  GL_SPRITE_TRANSLATION_SGIX                        = $814B;
+  {$EXTERNALSYM GL_SPRITE_TRANSLATION_SGIX}
+  GL_SPRITE_AXIAL_SGIX                              = $814C;
+  {$EXTERNALSYM GL_SPRITE_AXIAL_SGIX}
+  GL_SPRITE_OBJECT_ALIGNED_SGIX                     = $814D;
+  {$EXTERNALSYM GL_SPRITE_OBJECT_ALIGNED_SGIX}
+  GL_SPRITE_EYE_ALIGNED_SGIX                        = $814E;
+  {$EXTERNALSYM GL_SPRITE_EYE_ALIGNED_SGIX}
+
+  // GL_SGIX_texture_multi_buffer
+  GL_TEXTURE_MULTI_BUFFER_HINT_SGIX                 = $812E;
+  {$EXTERNALSYM GL_TEXTURE_MULTI_BUFFER_HINT_SGIX}
+
+  // GL_SGIS_point_parameters
+  GL_POINT_SIZE_MIN_SGIS                            = $8126;
+  {$EXTERNALSYM GL_POINT_SIZE_MIN_SGIS}
+  GL_POINT_SIZE_MAX_SGIS                            = $8127;
+  {$EXTERNALSYM GL_POINT_SIZE_MAX_SGIS}
+  GL_POINT_FADE_THRESHOLD_SIZE_SGIS                 = $8128;
+  {$EXTERNALSYM GL_POINT_FADE_THRESHOLD_SIZE_SGIS}
+  GL_DISTANCE_ATTENUATION_SGIS                      = $8129;
+  {$EXTERNALSYM GL_DISTANCE_ATTENUATION_SGIS}
+
+  // GL_SGIX_instruments
+  GL_INSTRUMENT_BUFFER_POINTER_SGIX                 = $8180;
+  {$EXTERNALSYM GL_INSTRUMENT_BUFFER_POINTER_SGIX}
+  GL_INSTRUMENT_MEASUREMENTS_SGIX                   = $8181;
+  {$EXTERNALSYM GL_INSTRUMENT_MEASUREMENTS_SGIX}
+
+  // GL_SGIX_texture_scale_bias
+  GL_POST_TEXTURE_FILTER_BIAS_SGIX                  = $8179;
+  {$EXTERNALSYM GL_POST_TEXTURE_FILTER_BIAS_SGIX}
+  GL_POST_TEXTURE_FILTER_SCALE_SGIX                 = $817A;
+  {$EXTERNALSYM GL_POST_TEXTURE_FILTER_SCALE_SGIX}
+  GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX            = $817B;
+  {$EXTERNALSYM GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX}
+  GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX           = $817C;
+  {$EXTERNALSYM GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX}
+
+  // GL_SGIX_framezoom
+  GL_FRAMEZOOM_SGIX                                 = $818B;
+  {$EXTERNALSYM GL_FRAMEZOOM_SGIX}
+  GL_FRAMEZOOM_FACTOR_SGIX                          = $818C;
+  {$EXTERNALSYM GL_FRAMEZOOM_FACTOR_SGIX}
+  GL_MAX_FRAMEZOOM_FACTOR_SGIX                      = $818D;
+  {$EXTERNALSYM GL_MAX_FRAMEZOOM_FACTOR_SGIX}
+
+  // GL_FfdMaskSGIX
+  GL_TEXTURE_DEFORMATION_BIT_SGIX                   = $00000001;
+  {$EXTERNALSYM GL_TEXTURE_DEFORMATION_BIT_SGIX}
+  GL_GEOMETRY_DEFORMATION_BIT_SGIX                  = $00000002;
+  {$EXTERNALSYM GL_GEOMETRY_DEFORMATION_BIT_SGIX}
+
+  // GL_SGIX_polynomial_ffd
+  GL_GEOMETRY_DEFORMATION_SGIX                      = $8194;
+  {$EXTERNALSYM GL_GEOMETRY_DEFORMATION_SGIX}
+  GL_TEXTURE_DEFORMATION_SGIX                       = $8195;
+  {$EXTERNALSYM GL_TEXTURE_DEFORMATION_SGIX}
+  GL_DEFORMATIONS_MASK_SGIX                         = $8196;
+  {$EXTERNALSYM GL_DEFORMATIONS_MASK_SGIX}
+  GL_MAX_DEFORMATION_ORDER_SGIX                     = $8197;
+  {$EXTERNALSYM GL_MAX_DEFORMATION_ORDER_SGIX}
+
+  // GL_SGIX_reference_plane
+  GL_REFERENCE_PLANE_SGIX                           = $817D;
+  {$EXTERNALSYM GL_REFERENCE_PLANE_SGIX}
+  GL_REFERENCE_PLANE_EQUATION_SGIX                  = $817E;
+  {$EXTERNALSYM GL_REFERENCE_PLANE_EQUATION_SGIX}
+
+  // GL_SGIX_depth_texture
+  GL_DEPTH_COMPONENT16_SGIX                         = $81A5;
+  {$EXTERNALSYM GL_DEPTH_COMPONENT16_SGIX}
+  GL_DEPTH_COMPONENT24_SGIX                         = $81A6;
+  {$EXTERNALSYM GL_DEPTH_COMPONENT24_SGIX}
+  GL_DEPTH_COMPONENT32_SGIX                         = $81A7;
+  {$EXTERNALSYM GL_DEPTH_COMPONENT32_SGIX}
+
+  // GL_SGIS_fog_function
+  GL_FOG_FUNC_SGIS                                  = $812A;
+  {$EXTERNALSYM GL_FOG_FUNC_SGIS}
+  GL_FOG_FUNC_POINTS_SGIS                           = $812B;
+  {$EXTERNALSYM GL_FOG_FUNC_POINTS_SGIS}
+  GL_MAX_FOG_FUNC_POINTS_SGIS                       = $812C;
+  {$EXTERNALSYM GL_MAX_FOG_FUNC_POINTS_SGIS}
+
+  // GL_SGIX_fog_offset
+  GL_FOG_OFFSET_SGIX                                = $8198;
+  {$EXTERNALSYM GL_FOG_OFFSET_SGIX}
+  GL_FOG_OFFSET_VALUE_SGIX                          = $8199;
+  {$EXTERNALSYM GL_FOG_OFFSET_VALUE_SGIX}
+
+  // GL_HP_image_transform
+  GL_IMAGE_SCALE_X_HP                               = $8155;
+  {$EXTERNALSYM GL_IMAGE_SCALE_X_HP}
+  GL_IMAGE_SCALE_Y_HP                               = $8156;
+  {$EXTERNALSYM GL_IMAGE_SCALE_Y_HP}
+  GL_IMAGE_TRANSLATE_X_HP                           = $8157;
+  {$EXTERNALSYM GL_IMAGE_TRANSLATE_X_HP}
+  GL_IMAGE_TRANSLATE_Y_HP                           = $8158;
+  {$EXTERNALSYM GL_IMAGE_TRANSLATE_Y_HP}
+  GL_IMAGE_ROTATE_ANGLE_HP                          = $8159;
+  {$EXTERNALSYM GL_IMAGE_ROTATE_ANGLE_HP}
+  GL_IMAGE_ROTATE_ORIGIN_X_HP                       = $815A;
+  {$EXTERNALSYM GL_IMAGE_ROTATE_ORIGIN_X_HP}
+  GL_IMAGE_ROTATE_ORIGIN_Y_HP                       = $815B;
+  {$EXTERNALSYM GL_IMAGE_ROTATE_ORIGIN_Y_HP}
+  GL_IMAGE_MAG_FILTER_HP                            = $815C;
+  {$EXTERNALSYM GL_IMAGE_MAG_FILTER_HP}
+  GL_IMAGE_MIN_FILTER_HP                            = $815D;
+  {$EXTERNALSYM GL_IMAGE_MIN_FILTER_HP}
+  GL_IMAGE_CUBIC_WEIGHT_HP                          = $815E;
+  {$EXTERNALSYM GL_IMAGE_CUBIC_WEIGHT_HP}
+  GL_CUBIC_HP                                       = $815F;
+  {$EXTERNALSYM GL_CUBIC_HP}
+  GL_AVERAGE_HP                                     = $8160;
+  {$EXTERNALSYM GL_AVERAGE_HP}
+  GL_IMAGE_TRANSFORM_2D_HP                          = $8161;
+  {$EXTERNALSYM GL_IMAGE_TRANSFORM_2D_HP}
+  GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP            = $8162;
+  {$EXTERNALSYM GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP}
+  GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP      = $8163;
+  {$EXTERNALSYM GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP}
+
+  // GL_HP_convolution_border_modes
+  GL_IGNORE_BORDER_HP                               = $8150;
+  {$EXTERNALSYM GL_IGNORE_BORDER_HP}
+  GL_CONSTANT_BORDER_HP                             = $8151;
+  {$EXTERNALSYM GL_CONSTANT_BORDER_HP}
+  GL_REPLICATE_BORDER_HP                            = $8153;
+  {$EXTERNALSYM GL_REPLICATE_BORDER_HP}
+  GL_CONVOLUTION_BORDER_COLOR_HP                    = $8154;
+  {$EXTERNALSYM GL_CONVOLUTION_BORDER_COLOR_HP}
+
+  // GL_SGIX_texture_add_env
+  GL_TEXTURE_ENV_BIAS_SGIX                          = $80BE;
+  {$EXTERNALSYM GL_TEXTURE_ENV_BIAS_SGIX}
+
+  // GL_PGI_vertex_hints
+  GL_VERTEX_DATA_HINT_PGI                           = $1A22A;
+  {$EXTERNALSYM GL_VERTEX_DATA_HINT_PGI}
+  GL_VERTEX_CONSISTENT_HINT_PGI                     = $1A22B;
+  {$EXTERNALSYM GL_VERTEX_CONSISTENT_HINT_PGI}
+  GL_MATERIAL_SIDE_HINT_PGI                         = $1A22C;
+  {$EXTERNALSYM GL_MATERIAL_SIDE_HINT_PGI}
+  GL_MAX_VERTEX_HINT_PGI                            = $1A22D;
+  {$EXTERNALSYM GL_MAX_VERTEX_HINT_PGI}
+  GL_COLOR3_BIT_PGI                                 = $00010000;
+  {$EXTERNALSYM GL_COLOR3_BIT_PGI}
+  GL_COLOR4_BIT_PGI                                 = $00020000;
+  {$EXTERNALSYM GL_COLOR4_BIT_PGI}
+  GL_EDGEFLAG_BIT_PGI                               = $00040000;
+  {$EXTERNALSYM GL_EDGEFLAG_BIT_PGI}
+  GL_INDEX_BIT_PGI                                  = $00080000;
+  {$EXTERNALSYM GL_INDEX_BIT_PGI}
+  GL_MAT_AMBIENT_BIT_PGI                            = $00100000;
+  {$EXTERNALSYM GL_MAT_AMBIENT_BIT_PGI}
+  GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI                = $00200000;
+  {$EXTERNALSYM GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI}
+  GL_MAT_DIFFUSE_BIT_PGI                            = $00400000;
+  {$EXTERNALSYM GL_MAT_DIFFUSE_BIT_PGI}
+  GL_MAT_EMISSION_BIT_PGI                           = $00800000;
+  {$EXTERNALSYM GL_MAT_EMISSION_BIT_PGI}
+  GL_MAT_COLOR_INDEXES_BIT_PGI                      = $01000000;
+  {$EXTERNALSYM GL_MAT_COLOR_INDEXES_BIT_PGI}
+  GL_MAT_SHININESS_BIT_PGI                          = $02000000;
+  {$EXTERNALSYM GL_MAT_SHININESS_BIT_PGI}
+  GL_MAT_SPECULAR_BIT_PGI                           = $04000000;
+  {$EXTERNALSYM GL_MAT_SPECULAR_BIT_PGI}
+  GL_NORMAL_BIT_PGI                                 = $08000000;
+  {$EXTERNALSYM GL_NORMAL_BIT_PGI}
+  GL_TEXCOORD1_BIT_PGI                              = $10000000;
+  {$EXTERNALSYM GL_TEXCOORD1_BIT_PGI}
+  GL_TEXCOORD2_BIT_PGI                              = $20000000;
+  {$EXTERNALSYM GL_TEXCOORD2_BIT_PGI}
+  GL_TEXCOORD3_BIT_PGI                              = $40000000;
+  {$EXTERNALSYM GL_TEXCOORD3_BIT_PGI}
+  GL_TEXCOORD4_BIT_PGI                              = $80000000;
+  {$EXTERNALSYM GL_TEXCOORD4_BIT_PGI}
+  GL_VERTEX23_BIT_PGI                               = $00000004;
+  {$EXTERNALSYM GL_VERTEX23_BIT_PGI}
+  GL_VERTEX4_BIT_PGI                                = $00000008;
+  {$EXTERNALSYM GL_VERTEX4_BIT_PGI}
+
+  // GL_PGI_misc_hints
+  GL_PREFER_DOUBLEBUFFER_HINT_PGI                   = $1A1F8;
+  {$EXTERNALSYM GL_PREFER_DOUBLEBUFFER_HINT_PGI}
+  GL_CONSERVE_MEMORY_HINT_PGI                       = $1A1FD;
+  {$EXTERNALSYM GL_CONSERVE_MEMORY_HINT_PGI}
+  GL_RECLAIM_MEMORY_HINT_PGI                        = $1A1FE;
+  {$EXTERNALSYM GL_RECLAIM_MEMORY_HINT_PGI}
+  GL_NATIVE_GRAPHICS_HANDLE_PGI                     = $1A202;
+  {$EXTERNALSYM GL_NATIVE_GRAPHICS_HANDLE_PGI}
+  GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI                 = $1A203;
+  {$EXTERNALSYM GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI}
+  GL_NATIVE_GRAPHICS_END_HINT_PGI                   = $1A204;
+  {$EXTERNALSYM GL_NATIVE_GRAPHICS_END_HINT_PGI}
+  GL_ALWAYS_FAST_HINT_PGI                           = $1A20C;
+  {$EXTERNALSYM GL_ALWAYS_FAST_HINT_PGI}
+  GL_ALWAYS_SOFT_HINT_PGI                           = $1A20D;
+  {$EXTERNALSYM GL_ALWAYS_SOFT_HINT_PGI}
+  GL_ALLOW_DRAW_OBJ_HINT_PGI                        = $1A20E;
+  {$EXTERNALSYM GL_ALLOW_DRAW_OBJ_HINT_PGI}
+  GL_ALLOW_DRAW_WIN_HINT_PGI                        = $1A20F;
+  {$EXTERNALSYM GL_ALLOW_DRAW_WIN_HINT_PGI}
+  GL_ALLOW_DRAW_FRG_HINT_PGI                        = $1A210;
+  {$EXTERNALSYM GL_ALLOW_DRAW_FRG_HINT_PGI}
+  GL_ALLOW_DRAW_MEM_HINT_PGI                        = $1A211;
+  {$EXTERNALSYM GL_ALLOW_DRAW_MEM_HINT_PGI}
+  GL_STRICT_DEPTHFUNC_HINT_PGI                      = $1A216;
+  {$EXTERNALSYM GL_STRICT_DEPTHFUNC_HINT_PGI}
+  GL_STRICT_LIGHTING_HINT_PGI                       = $1A217;
+  {$EXTERNALSYM GL_STRICT_LIGHTING_HINT_PGI}
+  GL_STRICT_SCISSOR_HINT_PGI                        = $1A218;
+  {$EXTERNALSYM GL_STRICT_SCISSOR_HINT_PGI}
+  GL_FULL_STIPPLE_HINT_PGI                          = $1A219;
+  {$EXTERNALSYM GL_FULL_STIPPLE_HINT_PGI}
+  GL_CLIP_NEAR_HINT_PGI                             = $1A220;
+  {$EXTERNALSYM GL_CLIP_NEAR_HINT_PGI}
+  GL_CLIP_FAR_HINT_PGI                              = $1A221;
+  {$EXTERNALSYM GL_CLIP_FAR_HINT_PGI}
+  GL_WIDE_LINE_HINT_PGI                             = $1A222;
+  {$EXTERNALSYM GL_WIDE_LINE_HINT_PGI}
+  GL_BACK_NORMALS_HINT_PGI                          = $1A223;
+  {$EXTERNALSYM GL_BACK_NORMALS_HINT_PGI}
+
+  // GL_EXT_paletted_texture
+  GL_TEXTURE_INDEX_SIZE_EXT                         = $80ED;
+  {$EXTERNALSYM GL_TEXTURE_INDEX_SIZE_EXT}
+
+  // GL_SGIX_list_priority
+  GL_LIST_PRIORITY_SGIX                             = $8182;
+  {$EXTERNALSYM GL_LIST_PRIORITY_SGIX}
+
+  // GL_SGIX_ir_instrument1
+  GL_IR_INSTRUMENT1_SGIX                            = $817F;
+  {$EXTERNALSYM GL_IR_INSTRUMENT1_SGIX}
+
+  // GL_SGIX_calligraphic_fragment
+  GL_CALLIGRAPHIC_FRAGMENT_SGIX                     = $8183;
+  {$EXTERNALSYM GL_CALLIGRAPHIC_FRAGMENT_SGIX}
+
+  // GL_SGIX_texture_lod_bias
+  GL_TEXTURE_LOD_BIAS_S_SGIX                        = $818E;
+  {$EXTERNALSYM GL_TEXTURE_LOD_BIAS_S_SGIX}
+  GL_TEXTURE_LOD_BIAS_T_SGIX                        = $818F;
+  {$EXTERNALSYM GL_TEXTURE_LOD_BIAS_T_SGIX}
+  GL_TEXTURE_LOD_BIAS_R_SGIX                        = $8190;
+  {$EXTERNALSYM GL_TEXTURE_LOD_BIAS_R_SGIX}
+
+  // GL_SGIX_shadow_ambient
+  GL_SHADOW_AMBIENT_SGIX                            = $80BF;
+  {$EXTERNALSYM GL_SHADOW_AMBIENT_SGIX}
+
+  // GL_SGIX_ycrcb
+  GL_YCRCB_422_SGIX                                 = $81BB;
+  {$EXTERNALSYM GL_YCRCB_422_SGIX}
+  GL_YCRCB_444_SGIX                                 = $81BC;
+  {$EXTERNALSYM GL_YCRCB_444_SGIX}
+
+  // GL_SGIX_fragment_lighting
+  GL_FRAGMENT_LIGHTING_SGIX                         = $8400;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHTING_SGIX}
+  GL_FRAGMENT_COLOR_MATERIAL_SGIX                   = $8401;
+  {$EXTERNALSYM GL_FRAGMENT_COLOR_MATERIAL_SGIX}
+  GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX              = $8402;
+  {$EXTERNALSYM GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX}
+  GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX         = $8403;
+  {$EXTERNALSYM GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX}
+  GL_MAX_FRAGMENT_LIGHTS_SGIX                       = $8404;
+  {$EXTERNALSYM GL_MAX_FRAGMENT_LIGHTS_SGIX}
+  GL_MAX_ACTIVE_LIGHTS_SGIX                         = $8405;
+  {$EXTERNALSYM GL_MAX_ACTIVE_LIGHTS_SGIX}
+  GL_CURRENT_RASTER_NORMAL_SGIX                     = $8406;
+  {$EXTERNALSYM GL_CURRENT_RASTER_NORMAL_SGIX}
+  GL_LIGHT_ENV_MODE_SGIX                            = $8407;
+  {$EXTERNALSYM GL_LIGHT_ENV_MODE_SGIX}
+  GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX         = $8408;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX}
+  GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX             = $8409;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX}
+  GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX              = $840A;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX}
+  GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = $840B;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX}
+  GL_FRAGMENT_LIGHT0_SGIX                           = $840C;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT0_SGIX}
+  GL_FRAGMENT_LIGHT1_SGIX                           = $840D;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT1_SGIX}
+  GL_FRAGMENT_LIGHT2_SGIX                           = $840E;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT2_SGIX}
+  GL_FRAGMENT_LIGHT3_SGIX                           = $840F;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT3_SGIX}
+  GL_FRAGMENT_LIGHT4_SGIX                           = $8410;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT4_SGIX}
+  GL_FRAGMENT_LIGHT5_SGIX                           = $8411;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT5_SGIX}
+  GL_FRAGMENT_LIGHT6_SGIX                           = $8412;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT6_SGIX}
+  GL_FRAGMENT_LIGHT7_SGIX                           = $8413;
+  {$EXTERNALSYM GL_FRAGMENT_LIGHT7_SGIX}
+
+  // GL_IBM_rasterpos_clip
+  GL_RASTER_POSITION_UNCLIPPED_IBM                  = $19262;
+  {$EXTERNALSYM GL_RASTER_POSITION_UNCLIPPED_IBM}
+
+  // GL_HP_texture_lighting
+  GL_TEXTURE_LIGHTING_MODE_HP                       = $8167;
+  {$EXTERNALSYM GL_TEXTURE_LIGHTING_MODE_HP}
+  GL_TEXTURE_POST_SPECULAR_HP                       = $8168;
+  {$EXTERNALSYM GL_TEXTURE_POST_SPECULAR_HP}
+  GL_TEXTURE_PRE_SPECULAR_HP                        = $8169;
+  {$EXTERNALSYM GL_TEXTURE_PRE_SPECULAR_HP}
+
+  // GL_EXT_draw_range_elements
+  GL_MAX_ELEMENTS_VERTICES_EXT                      = $80E8;
+  {$EXTERNALSYM GL_MAX_ELEMENTS_VERTICES_EXT}
+  GL_MAX_ELEMENTS_INDICES_EXT                       = $80E9;
+  {$EXTERNALSYM GL_MAX_ELEMENTS_INDICES_EXT}
+
+  // GL_WIN_phong_shading
+  GL_PHONG_WIN                                      = $80EA;
+  {$EXTERNALSYM GL_PHONG_WIN}
+  GL_PHONG_HINT_WIN                                 = $80EB;
+  {$EXTERNALSYM GL_PHONG_HINT_WIN}
+
+  // GL_WIN_specular_fog
+  GL_FOG_SPECULAR_TEXTURE_WIN                       = $80EC;
+  {$EXTERNALSYM GL_FOG_SPECULAR_TEXTURE_WIN}
+
+  // GL_EXT_light_texture
+  GL_FRAGMENT_MATERIAL_EXT                          = $8349;
+  {$EXTERNALSYM GL_FRAGMENT_MATERIAL_EXT}
+  GL_FRAGMENT_NORMAL_EXT                            = $834A;
+  {$EXTERNALSYM GL_FRAGMENT_NORMAL_EXT}
+  GL_FRAGMENT_COLOR_EXT                             = $834C;
+  {$EXTERNALSYM GL_FRAGMENT_COLOR_EXT}
+  GL_ATTENUATION_EXT                                = $834D;
+  {$EXTERNALSYM GL_ATTENUATION_EXT}
+  GL_SHADOW_ATTENUATION_EXT                         = $834E;
+  {$EXTERNALSYM GL_SHADOW_ATTENUATION_EXT}
+  GL_TEXTURE_APPLICATION_MODE_EXT                   = $834F;
+  {$EXTERNALSYM GL_TEXTURE_APPLICATION_MODE_EXT}
+  GL_TEXTURE_LIGHT_EXT                              = $8350;
+  {$EXTERNALSYM GL_TEXTURE_LIGHT_EXT}
+  GL_TEXTURE_MATERIAL_FACE_EXT                      = $8351;
+  {$EXTERNALSYM GL_TEXTURE_MATERIAL_FACE_EXT}
+  GL_TEXTURE_MATERIAL_PARAMETER_EXT                 = $8352;
+  {$EXTERNALSYM GL_TEXTURE_MATERIAL_PARAMETER_EXT}
+
+  // GL_SGIX_blend_alpha_minmax
+  GL_ALPHA_MIN_SGIX                                 = $8320;
+  {$EXTERNALSYM GL_ALPHA_MIN_SGIX}
+  GL_ALPHA_MAX_SGIX                                 = $8321;
+  {$EXTERNALSYM GL_ALPHA_MAX_SGIX}
+
+  // GL_SGIX_async
+  GL_ASYNC_MARKER_SGIX                              = $8329;
+  {$EXTERNALSYM GL_ASYNC_MARKER_SGIX}
+
+  // GL_SGIX_async_pixel
+  GL_ASYNC_TEX_IMAGE_SGIX                           = $835C;
+  {$EXTERNALSYM GL_ASYNC_TEX_IMAGE_SGIX}
+  GL_ASYNC_DRAW_PIXELS_SGIX                         = $835D;
+  {$EXTERNALSYM GL_ASYNC_DRAW_PIXELS_SGIX}
+  GL_ASYNC_READ_PIXELS_SGIX                         = $835E;
+  {$EXTERNALSYM GL_ASYNC_READ_PIXELS_SGIX}
+  GL_MAX_ASYNC_TEX_IMAGE_SGIX                       = $835F;
+  {$EXTERNALSYM GL_MAX_ASYNC_TEX_IMAGE_SGIX}
+  GL_MAX_ASYNC_DRAW_PIXELS_SGIX                     = $8360;
+  {$EXTERNALSYM GL_MAX_ASYNC_DRAW_PIXELS_SGIX}
+  GL_MAX_ASYNC_READ_PIXELS_SGIX                     = $8361;
+  {$EXTERNALSYM GL_MAX_ASYNC_READ_PIXELS_SGIX}
+
+  // GL_SGIX_async_histogram
+  GL_ASYNC_HISTOGRAM_SGIX                           = $832C;
+  {$EXTERNALSYM GL_ASYNC_HISTOGRAM_SGIX}
+  GL_MAX_ASYNC_HISTOGRAM_SGIX                       = $832D;
+  {$EXTERNALSYM GL_MAX_ASYNC_HISTOGRAM_SGIX}
+
+  // GL_INTEL_parallel_arrays
+  GL_PARALLEL_ARRAYS_INTEL                          = $83F4;
+  {$EXTERNALSYM GL_PARALLEL_ARRAYS_INTEL}
+  GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL           = $83F5;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL}
+  GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL           = $83F6;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL}
+  GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL            = $83F7;
+  {$EXTERNALSYM GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL}
+  GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL    = $83F8;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL}
+
+  // GL_HP_occlusion_test
+  GL_OCCLUSION_TEST_HP                              = $8165;
+  {$EXTERNALSYM GL_OCCLUSION_TEST_HP}
+  GL_OCCLUSION_TEST_RESULT_HP                       = $8166;
+  {$EXTERNALSYM GL_OCCLUSION_TEST_RESULT_HP}
+
+  // GL_EXT_pixel_transform
+  GL_PIXEL_TRANSFORM_2D_EXT                         = $8330;
+  {$EXTERNALSYM GL_PIXEL_TRANSFORM_2D_EXT}
+  GL_PIXEL_MAG_FILTER_EXT                           = $8331;
+  {$EXTERNALSYM GL_PIXEL_MAG_FILTER_EXT}
+  GL_PIXEL_MIN_FILTER_EXT                           = $8332;
+  {$EXTERNALSYM GL_PIXEL_MIN_FILTER_EXT}
+  GL_PIXEL_CUBIC_WEIGHT_EXT                         = $8333;
+  {$EXTERNALSYM GL_PIXEL_CUBIC_WEIGHT_EXT}
+  GL_CUBIC_EXT                                      = $8334;
+  {$EXTERNALSYM GL_CUBIC_EXT}
+  GL_AVERAGE_EXT                                    = $8335;
+  {$EXTERNALSYM GL_AVERAGE_EXT}
+  GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT             = $8336;
+  {$EXTERNALSYM GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT}
+  GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT         = $8337;
+  {$EXTERNALSYM GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT}
+  GL_PIXEL_TRANSFORM_2D_MATRIX_EXT                  = $8338;
+  {$EXTERNALSYM GL_PIXEL_TRANSFORM_2D_MATRIX_EXT}
+
+  // GL_EXT_separate_specular_color
+  GL_LIGHT_MODEL_COLOR_CONTROL_EXT                  = $81F8;
+  {$EXTERNALSYM GL_LIGHT_MODEL_COLOR_CONTROL_EXT}
+  GL_SINGLE_COLOR_EXT                               = $81F9;
+  {$EXTERNALSYM GL_SINGLE_COLOR_EXT}
+  GL_SEPARATE_SPECULAR_COLOR_EXT                    = $81FA;
+  {$EXTERNALSYM GL_SEPARATE_SPECULAR_COLOR_EXT}
+
+  // GL_EXT_secondary_color
+  GL_COLOR_SUM_EXT                                  = $8458;
+  {$EXTERNALSYM GL_COLOR_SUM_EXT}
+  GL_CURRENT_SECONDARY_COLOR_EXT                    = $8459;
+  {$EXTERNALSYM GL_CURRENT_SECONDARY_COLOR_EXT}
+  GL_SECONDARY_COLOR_ARRAY_SIZE_EXT                 = $845A;
+  {$EXTERNALSYM GL_SECONDARY_COLOR_ARRAY_SIZE_EXT}
+  GL_SECONDARY_COLOR_ARRAY_TYPE_EXT                 = $845B;
+  {$EXTERNALSYM GL_SECONDARY_COLOR_ARRAY_TYPE_EXT}
+  GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT               = $845C;
+  {$EXTERNALSYM GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT}
+  GL_SECONDARY_COLOR_ARRAY_POINTER_EXT              = $845D;
+  {$EXTERNALSYM GL_SECONDARY_COLOR_ARRAY_POINTER_EXT}
+  GL_SECONDARY_COLOR_ARRAY_EXT                      = $845E;
+  {$EXTERNALSYM GL_SECONDARY_COLOR_ARRAY_EXT}
+
+  // GL_EXT_texture_perturb_normal
+  GL_PERTURB_EXT                                    = $85AE;
+  {$EXTERNALSYM GL_PERTURB_EXT}
+  GL_TEXTURE_NORMAL_EXT                             = $85AF;
+  {$EXTERNALSYM GL_TEXTURE_NORMAL_EXT}
+
+  // GL_EXT_fog_coord
+  GL_FOG_COORDINATE_SOURCE_EXT                      = $8450;
+  {$EXTERNALSYM GL_FOG_COORDINATE_SOURCE_EXT}
+  GL_FOG_COORDINATE_EXT                             = $8451;
+  {$EXTERNALSYM GL_FOG_COORDINATE_EXT}
+  GL_FRAGMENT_DEPTH_EXT                             = $8452;
+  {$EXTERNALSYM GL_FRAGMENT_DEPTH_EXT}
+  GL_CURRENT_FOG_COORDINATE_EXT                     = $8453;
+  {$EXTERNALSYM GL_CURRENT_FOG_COORDINATE_EXT}
+  GL_FOG_COORDINATE_ARRAY_TYPE_EXT                  = $8454;
+  {$EXTERNALSYM GL_FOG_COORDINATE_ARRAY_TYPE_EXT}
+  GL_FOG_COORDINATE_ARRAY_STRIDE_EXT                = $8455;
+  {$EXTERNALSYM GL_FOG_COORDINATE_ARRAY_STRIDE_EXT}
+  GL_FOG_COORDINATE_ARRAY_POINTER_EXT               = $8456;
+  {$EXTERNALSYM GL_FOG_COORDINATE_ARRAY_POINTER_EXT}
+  GL_FOG_COORDINATE_ARRAY_EXT                       = $8457;
+  {$EXTERNALSYM GL_FOG_COORDINATE_ARRAY_EXT}
+
+  // GL_REND_screen_coordinates
+  GL_SCREEN_COORDINATES_REND                        = $8490;
+  {$EXTERNALSYM GL_SCREEN_COORDINATES_REND}
+  GL_INVERTED_SCREEN_W_REND                         = $8491;
+  {$EXTERNALSYM GL_INVERTED_SCREEN_W_REND}
+
+  // GL_EXT_coordinate_frame
+  GL_TANGENT_ARRAY_EXT                              = $8439;
+  {$EXTERNALSYM GL_TANGENT_ARRAY_EXT}
+  GL_BINORMAL_ARRAY_EXT                             = $843A;
+  {$EXTERNALSYM GL_BINORMAL_ARRAY_EXT}
+  GL_CURRENT_TANGENT_EXT                            = $843B;
+  {$EXTERNALSYM GL_CURRENT_TANGENT_EXT}
+  GL_CURRENT_BINORMAL_EXT                           = $843C;
+  {$EXTERNALSYM GL_CURRENT_BINORMAL_EXT}
+  GL_TANGENT_ARRAY_TYPE_EXT                         = $843E;
+  {$EXTERNALSYM GL_TANGENT_ARRAY_TYPE_EXT}
+  GL_TANGENT_ARRAY_STRIDE_EXT                       = $843F;
+  {$EXTERNALSYM GL_TANGENT_ARRAY_STRIDE_EXT}
+  GL_BINORMAL_ARRAY_TYPE_EXT                        = $8440;
+  {$EXTERNALSYM GL_BINORMAL_ARRAY_TYPE_EXT}
+  GL_BINORMAL_ARRAY_STRIDE_EXT                      = $8441;
+  {$EXTERNALSYM GL_BINORMAL_ARRAY_STRIDE_EXT}
+  GL_TANGENT_ARRAY_POINTER_EXT                      = $8442;
+  {$EXTERNALSYM GL_TANGENT_ARRAY_POINTER_EXT}
+  GL_BINORMAL_ARRAY_POINTER_EXT                     = $8443;
+  {$EXTERNALSYM GL_BINORMAL_ARRAY_POINTER_EXT}
+  GL_MAP1_TANGENT_EXT                               = $8444;
+  {$EXTERNALSYM GL_MAP1_TANGENT_EXT}
+  GL_MAP2_TANGENT_EXT                               = $8445;
+  {$EXTERNALSYM GL_MAP2_TANGENT_EXT}
+  GL_MAP1_BINORMAL_EXT                              = $8446;
+  {$EXTERNALSYM GL_MAP1_BINORMAL_EXT}
+  GL_MAP2_BINORMAL_EXT                              = $8447;
+  {$EXTERNALSYM GL_MAP2_BINORMAL_EXT}
+
+  // GL_EXT_texture_env_combine
+  GL_SOURCE3_RGB_EXT                                = $8583;
+  {$EXTERNALSYM GL_SOURCE3_RGB_EXT}
+  GL_SOURCE4_RGB_EXT                                = $8584;
+  {$EXTERNALSYM GL_SOURCE4_RGB_EXT}
+  GL_SOURCE5_RGB_EXT                                = $8585;
+  {$EXTERNALSYM GL_SOURCE5_RGB_EXT}
+  GL_SOURCE6_RGB_EXT                                = $8586;
+  {$EXTERNALSYM GL_SOURCE6_RGB_EXT}
+  GL_SOURCE7_RGB_EXT                                = $8587;
+  {$EXTERNALSYM GL_SOURCE7_RGB_EXT}
+  GL_SOURCE3_ALPHA_EXT                              = $858B;
+  {$EXTERNALSYM GL_SOURCE3_ALPHA_EXT}
+  GL_SOURCE4_ALPHA_EXT                              = $858C;
+  {$EXTERNALSYM GL_SOURCE4_ALPHA_EXT}
+  GL_SOURCE5_ALPHA_EXT                              = $858D;
+  {$EXTERNALSYM GL_SOURCE5_ALPHA_EXT}
+  GL_SOURCE6_ALPHA_EXT                              = $858E;
+  {$EXTERNALSYM GL_SOURCE6_ALPHA_EXT}
+  GL_SOURCE7_ALPHA_EXT                              = $858F;
+  {$EXTERNALSYM GL_SOURCE7_ALPHA_EXT}
+  GL_OPERAND3_RGB_EXT                               = $8593;
+  {$EXTERNALSYM GL_OPERAND3_RGB_EXT}
+  GL_OPERAND4_RGB_EXT                               = $8594;
+  {$EXTERNALSYM GL_OPERAND4_RGB_EXT}
+  GL_OPERAND5_RGB_EXT                               = $8595;
+  {$EXTERNALSYM GL_OPERAND5_RGB_EXT}
+  GL_OPERAND6_RGB_EXT                               = $8596;
+  {$EXTERNALSYM GL_OPERAND6_RGB_EXT}
+  GL_OPERAND7_RGB_EXT                               = $8597;
+  {$EXTERNALSYM GL_OPERAND7_RGB_EXT}
+  GL_OPERAND3_ALPHA_EXT                             = $859B;
+  {$EXTERNALSYM GL_OPERAND3_ALPHA_EXT}
+  GL_OPERAND4_ALPHA_EXT                             = $859C;
+  {$EXTERNALSYM GL_OPERAND4_ALPHA_EXT}
+  GL_OPERAND5_ALPHA_EXT                             = $859D;
+  {$EXTERNALSYM GL_OPERAND5_ALPHA_EXT}
+  GL_OPERAND6_ALPHA_EXT                             = $859E;
+  {$EXTERNALSYM GL_OPERAND6_ALPHA_EXT}
+  GL_OPERAND7_ALPHA_EXT                             = $859F;
+  {$EXTERNALSYM GL_OPERAND7_ALPHA_EXT}
+
+  // GL_APPLE_specular_vector
+  GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE              = $85B0;
+  {$EXTERNALSYM GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE}
+
+  // GL_APPLE_transform_hint
+  GL_TRANSFORM_HINT_APPLE                           = $85B1;
+  {$EXTERNALSYM GL_TRANSFORM_HINT_APPLE}
+
+  // GL_SGIX_fog_scale
+  GL_FOG_SCALE_SGIX                                 = $81FC;
+  {$EXTERNALSYM GL_FOG_SCALE_SGIX}
+  GL_FOG_SCALE_VALUE_SGIX                           = $81FD;
+  {$EXTERNALSYM GL_FOG_SCALE_VALUE_SGIX}
+
+  // GL_SUNX_constant_data
+  GL_UNPACK_CONSTANT_DATA_SUNX                      = $81D5;
+  {$EXTERNALSYM GL_UNPACK_CONSTANT_DATA_SUNX}
+  GL_TEXTURE_CONSTANT_DATA_SUNX                     = $81D6;
+  {$EXTERNALSYM GL_TEXTURE_CONSTANT_DATA_SUNX}
+
+  // GL_SUN_global_alpha
+  GL_GLOBAL_ALPHA_SUN                               = $81D9;
+  {$EXTERNALSYM GL_GLOBAL_ALPHA_SUN}
+  GL_GLOBAL_ALPHA_FACTOR_SUN                        = $81DA;
+  {$EXTERNALSYM GL_GLOBAL_ALPHA_FACTOR_SUN}
+
+  // GL_SUN_triangle_list
+  GL_RESTART_SUN                                    = $01;
+  {$EXTERNALSYM GL_RESTART_SUN}
+  GL_REPLACE_MIDDLE_SUN                             = $02;
+  {$EXTERNALSYM GL_REPLACE_MIDDLE_SUN}
+  GL_REPLACE_OLDEST_SUN                             = $03;
+  {$EXTERNALSYM GL_REPLACE_OLDEST_SUN}
+  GL_TRIANGLE_LIST_SUN                              = $81D7;
+  {$EXTERNALSYM GL_TRIANGLE_LIST_SUN}
+  GL_REPLACEMENT_CODE_SUN                           = $81D8;
+  {$EXTERNALSYM GL_REPLACEMENT_CODE_SUN}
+  GL_REPLACEMENT_CODE_ARRAY_SUN                     = $85C0;
+  {$EXTERNALSYM GL_REPLACEMENT_CODE_ARRAY_SUN}
+  GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN                = $85C1;
+  {$EXTERNALSYM GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN}
+  GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN              = $85C2;
+  {$EXTERNALSYM GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN}
+  GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN             = $85C3;
+  {$EXTERNALSYM GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN}
+  GL_R1UI_V3F_SUN                                   = $85C4;
+  {$EXTERNALSYM GL_R1UI_V3F_SUN}
+  GL_R1UI_C4UB_V3F_SUN                              = $85C5;
+  {$EXTERNALSYM GL_R1UI_C4UB_V3F_SUN}
+  GL_R1UI_C3F_V3F_SUN                               = $85C6;
+  {$EXTERNALSYM GL_R1UI_C3F_V3F_SUN}
+  GL_R1UI_N3F_V3F_SUN                               = $85C7;
+  {$EXTERNALSYM GL_R1UI_N3F_V3F_SUN}
+  GL_R1UI_C4F_N3F_V3F_SUN                           = $85C8;
+  {$EXTERNALSYM GL_R1UI_C4F_N3F_V3F_SUN}
+  GL_R1UI_T2F_V3F_SUN                               = $85C9;
+  {$EXTERNALSYM GL_R1UI_T2F_V3F_SUN}
+  GL_R1UI_T2F_N3F_V3F_SUN                           = $85CA;
+  {$EXTERNALSYM GL_R1UI_T2F_N3F_V3F_SUN}
+  GL_R1UI_T2F_C4F_N3F_V3F_SUN                       = $85CB;
+  {$EXTERNALSYM GL_R1UI_T2F_C4F_N3F_V3F_SUN}
+
+  // GL_EXT_blend_func_separate
+  GL_BLEND_DST_RGB_EXT                              = $80C8;
+  {$EXTERNALSYM GL_BLEND_DST_RGB_EXT}
+  GL_BLEND_SRC_RGB_EXT                              = $80C9;
+  {$EXTERNALSYM GL_BLEND_SRC_RGB_EXT}
+  GL_BLEND_DST_ALPHA_EXT                            = $80CA;
+  {$EXTERNALSYM GL_BLEND_DST_ALPHA_EXT}
+  GL_BLEND_SRC_ALPHA_EXT                            = $80CB;
+  {$EXTERNALSYM GL_BLEND_SRC_ALPHA_EXT}
+
+  // GL_INGR_color_clamp
+  GL_RED_MIN_CLAMP_INGR                             = $8560;
+  {$EXTERNALSYM GL_RED_MIN_CLAMP_INGR}
+  GL_GREEN_MIN_CLAMP_INGR                           = $8561;
+  {$EXTERNALSYM GL_GREEN_MIN_CLAMP_INGR}
+  GL_BLUE_MIN_CLAMP_INGR                            = $8562;
+  {$EXTERNALSYM GL_BLUE_MIN_CLAMP_INGR}
+  GL_ALPHA_MIN_CLAMP_INGR                           = $8563;
+  {$EXTERNALSYM GL_ALPHA_MIN_CLAMP_INGR}
+  GL_RED_MAX_CLAMP_INGR                             = $8564;
+  {$EXTERNALSYM GL_RED_MAX_CLAMP_INGR}
+  GL_GREEN_MAX_CLAMP_INGR                           = $8565;
+  {$EXTERNALSYM GL_GREEN_MAX_CLAMP_INGR}
+  GL_BLUE_MAX_CLAMP_INGR                            = $8566;
+  {$EXTERNALSYM GL_BLUE_MAX_CLAMP_INGR}
+  GL_ALPHA_MAX_CLAMP_INGR                           = $8567;
+  {$EXTERNALSYM GL_ALPHA_MAX_CLAMP_INGR}
+
+  // GL_INGR_interlace_read
+  GL_INTERLACE_READ_INGR                            = $8568;
+  {$EXTERNALSYM GL_INTERLACE_READ_INGR}
+
+  // GL_EXT_422_pixels
+  GL_422_EXT                                        = $80CC;
+  {$EXTERNALSYM GL_422_EXT}
+  GL_422_REV_EXT                                    = $80CD;
+  {$EXTERNALSYM GL_422_REV_EXT}
+  GL_422_AVERAGE_EXT                                = $80CE;
+  {$EXTERNALSYM GL_422_AVERAGE_EXT}
+  GL_422_REV_AVERAGE_EXT                            = $80CF;
+  {$EXTERNALSYM GL_422_REV_AVERAGE_EXT}
+
+  // GL_EXT_texture_cube_map
+  GL_NORMAL_MAP_EXT                                 = $8511;
+  {$EXTERNALSYM GL_NORMAL_MAP_EXT}
+  GL_REFLECTION_MAP_EXT                             = $8512;
+  {$EXTERNALSYM GL_REFLECTION_MAP_EXT}
+  GL_TEXTURE_CUBE_MAP_EXT                           = $8513;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_EXT}
+  GL_TEXTURE_BINDING_CUBE_MAP_EXT                   = $8514;
+  {$EXTERNALSYM GL_TEXTURE_BINDING_CUBE_MAP_EXT}
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT                = $8515;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT}
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT                = $8516;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT}
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT                = $8517;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT}
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT                = $8518;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT}
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT                = $8519;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT}
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT                = $851A;
+  {$EXTERNALSYM GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT}
+  GL_PROXY_TEXTURE_CUBE_MAP_EXT                     = $851B;
+  {$EXTERNALSYM GL_PROXY_TEXTURE_CUBE_MAP_EXT}
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT                  = $851C;
+  {$EXTERNALSYM GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT}
+
+  // GL_SUN_convolution_border_modes
+  GL_WRAP_BORDER_SUN                                = $81D4;
+  {$EXTERNALSYM GL_WRAP_BORDER_SUN}
+
+  // GL_EXT_texture_lod_bias
+  GL_MAX_TEXTURE_LOD_BIAS_EXT                       = $84FD;
+  {$EXTERNALSYM GL_MAX_TEXTURE_LOD_BIAS_EXT}
+  GL_TEXTURE_FILTER_CONTROL_EXT                     = $8500;
+  {$EXTERNALSYM GL_TEXTURE_FILTER_CONTROL_EXT}
+  GL_TEXTURE_LOD_BIAS_EXT                           = $8501;
+  {$EXTERNALSYM GL_TEXTURE_LOD_BIAS_EXT}
+
+  // GL_EXT_texture_filter_anisotropic
+  GL_TEXTURE_MAX_ANISOTROPY_EXT                     = $84FE;
+  {$EXTERNALSYM GL_TEXTURE_MAX_ANISOTROPY_EXT}
+  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT                 = $84FF;
+  {$EXTERNALSYM GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT}
+
+  // GL_EXT_vertex_weighting
+  GL_MODELVIEW0_STACK_DEPTH_EXT                     = GL_MODELVIEW_STACK_DEPTH;
+  {$EXTERNALSYM GL_MODELVIEW0_STACK_DEPTH_EXT}
+  GL_MODELVIEW1_STACK_DEPTH_EXT                     = $8502;
+  {$EXTERNALSYM GL_MODELVIEW1_STACK_DEPTH_EXT}
+  GL_MODELVIEW0_MATRIX_EXT                          = GL_MODELVIEW_MATRIX;
+  {$EXTERNALSYM GL_MODELVIEW0_MATRIX_EXT}
+  GL_MODELVIEW_MATRIX1_EXT                          = $8506;
+  {$EXTERNALSYM GL_MODELVIEW_MATRIX1_EXT}
+  GL_VERTEX_WEIGHTING_EXT                           = $8509;
+  {$EXTERNALSYM GL_VERTEX_WEIGHTING_EXT}
+  GL_MODELVIEW0_EXT                                 = GL_MODELVIEW;
+  {$EXTERNALSYM GL_MODELVIEW0_EXT}
+  GL_MODELVIEW1_EXT                                 = $850A;
+  {$EXTERNALSYM GL_MODELVIEW1_EXT}
+  GL_CURRENT_VERTEX_WEIGHT_EXT                      = $850B;
+  {$EXTERNALSYM GL_CURRENT_VERTEX_WEIGHT_EXT}
+  GL_VERTEX_WEIGHT_ARRAY_EXT                        = $850C;
+  {$EXTERNALSYM GL_VERTEX_WEIGHT_ARRAY_EXT}
+  GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT                   = $850D;
+  {$EXTERNALSYM GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT}
+  GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT                   = $850E;
+  {$EXTERNALSYM GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT}
+  GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT                 = $850F;
+  {$EXTERNALSYM GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT}
+  GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT                = $8510;
+  {$EXTERNALSYM GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT}
+
+  // GL_NV_light_max_exponent
+  GL_MAX_SHININESS_NV                               = $8504;
+  {$EXTERNALSYM GL_MAX_SHININESS_NV}
+  GL_MAX_SPOT_EXPONENT_NV                           = $8505;
+  {$EXTERNALSYM GL_MAX_SPOT_EXPONENT_NV}
+
+  // GL_NV_vertex_array_range
+  GL_VERTEX_ARRAY_RANGE_NV                          = $851D;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_RANGE_NV}
+  GL_VERTEX_ARRAY_RANGE_LENGTH_NV                   = $851E;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_RANGE_LENGTH_NV}
+  GL_VERTEX_ARRAY_RANGE_VALID_NV                    = $851F;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_RANGE_VALID_NV}
+  GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV              = $8520;
+  {$EXTERNALSYM GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV}
+  GL_VERTEX_ARRAY_RANGE_POINTER_NV                  = $8521;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_RANGE_POINTER_NV}
+
+  // GL_NV_register_combiners
+  GL_REGISTER_COMBINERS_NV                          = $8522;
+  {$EXTERNALSYM GL_REGISTER_COMBINERS_NV}
+  GL_VARIABLE_A_NV                                  = $8523;
+  {$EXTERNALSYM GL_VARIABLE_A_NV}
+  GL_VARIABLE_B_NV                                  = $8524;
+  {$EXTERNALSYM GL_VARIABLE_B_NV}
+  GL_VARIABLE_C_NV                                  = $8525;
+  {$EXTERNALSYM GL_VARIABLE_C_NV}
+  GL_VARIABLE_D_NV                                  = $8526;
+  {$EXTERNALSYM GL_VARIABLE_D_NV}
+  GL_VARIABLE_E_NV                                  = $8527;
+  {$EXTERNALSYM GL_VARIABLE_E_NV}
+  GL_VARIABLE_F_NV                                  = $8528;
+  {$EXTERNALSYM GL_VARIABLE_F_NV}
+  GL_VARIABLE_G_NV                                  = $8529;
+  {$EXTERNALSYM GL_VARIABLE_G_NV}
+  GL_CONSTANT_COLOR0_NV                             = $852A;
+  {$EXTERNALSYM GL_CONSTANT_COLOR0_NV}
+  GL_CONSTANT_COLOR1_NV                             = $852B;
+  {$EXTERNALSYM GL_CONSTANT_COLOR1_NV}
+  GL_PRIMARY_COLOR_NV                               = $852C;
+  {$EXTERNALSYM GL_PRIMARY_COLOR_NV}
+  GL_SECONDARY_COLOR_NV                             = $852D;
+  {$EXTERNALSYM GL_SECONDARY_COLOR_NV}
+  GL_SPARE0_NV                                      = $852E;
+  {$EXTERNALSYM GL_SPARE0_NV}
+  GL_SPARE1_NV                                      = $852F;
+  {$EXTERNALSYM GL_SPARE1_NV}
+  GL_DISCARD_NV                                     = $8530;
+  {$EXTERNALSYM GL_DISCARD_NV}
+  GL_E_TIMES_F_NV                                   = $8531;
+  {$EXTERNALSYM GL_E_TIMES_F_NV}
+  GL_SPARE0_PLUS_SECONDARY_COLOR_NV                 = $8532;
+  {$EXTERNALSYM GL_SPARE0_PLUS_SECONDARY_COLOR_NV}
+  GL_UNSIGNED_IDENTITY_NV                           = $8536;
+  {$EXTERNALSYM GL_UNSIGNED_IDENTITY_NV}
+  GL_UNSIGNED_INVERT_NV                             = $8537;
+  {$EXTERNALSYM GL_UNSIGNED_INVERT_NV}
+  GL_EXPAND_NORMAL_NV                               = $8538;
+  {$EXTERNALSYM GL_EXPAND_NORMAL_NV}
+  GL_EXPAND_NEGATE_NV                               = $8539;
+  {$EXTERNALSYM GL_EXPAND_NEGATE_NV}
+  GL_HALF_BIAS_NORMAL_NV                            = $853A;
+  {$EXTERNALSYM GL_HALF_BIAS_NORMAL_NV}
+  GL_HALF_BIAS_NEGATE_NV                            = $853B;
+  {$EXTERNALSYM GL_HALF_BIAS_NEGATE_NV}
+  GL_SIGNED_IDENTITY_NV                             = $853C;
+  {$EXTERNALSYM GL_SIGNED_IDENTITY_NV}
+  GL_SIGNED_NEGATE_NV                               = $853D;
+  {$EXTERNALSYM GL_SIGNED_NEGATE_NV}
+  GL_SCALE_BY_TWO_NV                                = $853E;
+  {$EXTERNALSYM GL_SCALE_BY_TWO_NV}
+  GL_SCALE_BY_FOUR_NV                               = $853F;
+  {$EXTERNALSYM GL_SCALE_BY_FOUR_NV}
+  GL_SCALE_BY_ONE_HALF_NV                           = $8540;
+  {$EXTERNALSYM GL_SCALE_BY_ONE_HALF_NV}
+  GL_BIAS_BY_NEGATIVE_ONE_HALF_NV                   = $8541;
+  {$EXTERNALSYM GL_BIAS_BY_NEGATIVE_ONE_HALF_NV}
+  GL_COMBINER_INPUT_NV                              = $8542;
+  {$EXTERNALSYM GL_COMBINER_INPUT_NV}
+  GL_COMBINER_MAPPING_NV                            = $8543;
+  {$EXTERNALSYM GL_COMBINER_MAPPING_NV}
+  GL_COMBINER_COMPONENT_USAGE_NV                    = $8544;
+  {$EXTERNALSYM GL_COMBINER_COMPONENT_USAGE_NV}
+  GL_COMBINER_AB_DOT_PRODUCT_NV                     = $8545;
+  {$EXTERNALSYM GL_COMBINER_AB_DOT_PRODUCT_NV}
+  GL_COMBINER_CD_DOT_PRODUCT_NV                     = $8546;
+  {$EXTERNALSYM GL_COMBINER_CD_DOT_PRODUCT_NV}
+  GL_COMBINER_MUX_SUM_NV                            = $8547;
+  {$EXTERNALSYM GL_COMBINER_MUX_SUM_NV}
+  GL_COMBINER_SCALE_NV                              = $8548;
+  {$EXTERNALSYM GL_COMBINER_SCALE_NV}
+  GL_COMBINER_BIAS_NV                               = $8549;
+  {$EXTERNALSYM GL_COMBINER_BIAS_NV}
+  GL_COMBINER_AB_OUTPUT_NV                          = $854A;
+  {$EXTERNALSYM GL_COMBINER_AB_OUTPUT_NV}
+  GL_COMBINER_CD_OUTPUT_NV                          = $854B;
+  {$EXTERNALSYM GL_COMBINER_CD_OUTPUT_NV}
+  GL_COMBINER_SUM_OUTPUT_NV                         = $854C;
+  {$EXTERNALSYM GL_COMBINER_SUM_OUTPUT_NV}
+  GL_MAX_GENERAL_COMBINERS_NV                       = $854D;
+  {$EXTERNALSYM GL_MAX_GENERAL_COMBINERS_NV}
+  GL_NUM_GENERAL_COMBINERS_NV                       = $854E;
+  {$EXTERNALSYM GL_NUM_GENERAL_COMBINERS_NV}
+  GL_COLOR_SUM_CLAMP_NV                             = $854F;
+  {$EXTERNALSYM GL_COLOR_SUM_CLAMP_NV}
+  GL_COMBINER0_NV                                   = $8550;
+  {$EXTERNALSYM GL_COMBINER0_NV}
+  GL_COMBINER1_NV                                   = $8551;
+  {$EXTERNALSYM GL_COMBINER1_NV}
+  GL_COMBINER2_NV                                   = $8552;
+  {$EXTERNALSYM GL_COMBINER2_NV}
+  GL_COMBINER3_NV                                   = $8553;
+  {$EXTERNALSYM GL_COMBINER3_NV}
+  GL_COMBINER4_NV                                   = $8554;
+  {$EXTERNALSYM GL_COMBINER4_NV}
+  GL_COMBINER5_NV                                   = $8555;
+  {$EXTERNALSYM GL_COMBINER5_NV}
+  GL_COMBINER6_NV                                   = $8556;
+  {$EXTERNALSYM GL_COMBINER6_NV}
+  GL_COMBINER7_NV                                   = $8557;
+  {$EXTERNALSYM GL_COMBINER7_NV}
+
+  // GL_NV_fog_distance
+  GL_FOG_DISTANCE_MODE_NV                           = $855A;
+  {$EXTERNALSYM GL_FOG_DISTANCE_MODE_NV}
+  GL_EYE_RADIAL_NV                                  = $855B;
+  {$EXTERNALSYM GL_EYE_RADIAL_NV}
+  GL_EYE_PLANE_ABSOLUTE_NV                          = $855C;
+  {$EXTERNALSYM GL_EYE_PLANE_ABSOLUTE_NV}
+
+  // GL_NV_texgen_emboss
+  GL_EMBOSS_LIGHT_NV                                = $855D;
+  {$EXTERNALSYM GL_EMBOSS_LIGHT_NV}
+  GL_EMBOSS_CONSTANT_NV                             = $855E;
+  {$EXTERNALSYM GL_EMBOSS_CONSTANT_NV}
+  GL_EMBOSS_MAP_NV                                  = $855F;
+  {$EXTERNALSYM GL_EMBOSS_MAP_NV}
+
+  // GL_EXT_texture_compression_s3tc
+  GL_COMPRESSED_RGB_S3TC_DXT1_EXT                   = $83F0;
+  {$EXTERNALSYM GL_COMPRESSED_RGB_S3TC_DXT1_EXT}
+  GL_COMPRESSED_RGBA_S3TC_DXT1_EXT                  = $83F1;
+  {$EXTERNALSYM GL_COMPRESSED_RGBA_S3TC_DXT1_EXT}
+  GL_COMPRESSED_RGBA_S3TC_DXT3_EXT                  = $83F2;
+  {$EXTERNALSYM GL_COMPRESSED_RGBA_S3TC_DXT3_EXT}
+  GL_COMPRESSED_RGBA_S3TC_DXT5_EXT                  = $83F3;
+  {$EXTERNALSYM GL_COMPRESSED_RGBA_S3TC_DXT5_EXT}
+
+  // GL_IBM_cull_vertex
+  GL_CULL_VERTEX_IBM                                = 103050;
+  {$EXTERNALSYM GL_CULL_VERTEX_IBM}
+
+  // GL_IBM_vertex_array_lists
+  GL_VERTEX_ARRAY_LIST_IBM                          = 103070;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_LIST_IBM}
+  GL_NORMAL_ARRAY_LIST_IBM                          = 103071;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_LIST_IBM}
+  GL_COLOR_ARRAY_LIST_IBM                           = 103072;
+  {$EXTERNALSYM GL_COLOR_ARRAY_LIST_IBM}
+  GL_INDEX_ARRAY_LIST_IBM                           = 103073;
+  {$EXTERNALSYM GL_INDEX_ARRAY_LIST_IBM}
+  GL_TEXTURE_COORD_ARRAY_LIST_IBM                   = 103074;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_LIST_IBM}
+  GL_EDGE_FLAG_ARRAY_LIST_IBM                       = 103075;
+  {$EXTERNALSYM GL_EDGE_FLAG_ARRAY_LIST_IBM}
+  GL_FOG_COORDINATE_ARRAY_LIST_IBM                  = 103076;
+  {$EXTERNALSYM GL_FOG_COORDINATE_ARRAY_LIST_IBM}
+  GL_SECONDARY_COLOR_ARRAY_LIST_IBM                 = 103077;
+  {$EXTERNALSYM GL_SECONDARY_COLOR_ARRAY_LIST_IBM}
+  GL_VERTEX_ARRAY_LIST_STRIDE_IBM                   = 103080;
+  {$EXTERNALSYM GL_VERTEX_ARRAY_LIST_STRIDE_IBM}
+  GL_NORMAL_ARRAY_LIST_STRIDE_IBM                   = 103081;
+  {$EXTERNALSYM GL_NORMAL_ARRAY_LIST_STRIDE_IBM}
+  GL_COLOR_ARRAY_LIST_STRIDE_IBM                    = 103082;
+  {$EXTERNALSYM GL_COLOR_ARRAY_LIST_STRIDE_IBM}
+  GL_INDEX_ARRAY_LIST_STRIDE_IBM                    = 103083;
+  {$EXTERNALSYM GL_INDEX_ARRAY_LIST_STRIDE_IBM}
+  GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM            = 103084;
+  {$EXTERNALSYM GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM}
+  GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM                = 103085;
+  {$EXTERNALSYM GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM}
+  GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM           = 103086;
+  {$EXTERNALSYM GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM}
+  GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM          = 103087;
+  {$EXTERNALSYM GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM}
+
+  // GL_SGIX_subsample
+  GL_PACK_SUBSAMPLE_RATE_SGIX                       = $85A0;
+  {$EXTERNALSYM GL_PACK_SUBSAMPLE_RATE_SGIX}
+  GL_UNPACK_SUBSAMPLE_RATE_SGIX                     = $85A1;
+  {$EXTERNALSYM GL_UNPACK_SUBSAMPLE_RATE_SGIX}
+  GL_PIXEL_SUBSAMPLE_4444_SGIX                      = $85A2;
+  {$EXTERNALSYM GL_PIXEL_SUBSAMPLE_4444_SGIX}
+  GL_PIXEL_SUBSAMPLE_2424_SGIX                      = $85A3;
+  {$EXTERNALSYM GL_PIXEL_SUBSAMPLE_2424_SGIX}
+  GL_PIXEL_SUBSAMPLE_4242_SGIX                      = $85A4;
+  {$EXTERNALSYM GL_PIXEL_SUBSAMPLE_4242_SGIX}
+
+  // GL_SGIX_ycrcba
+  GL_YCRCB_SGIX                                     = $8318;
+  {$EXTERNALSYM GL_YCRCB_SGIX}
+  GL_YCRCBA_SGIX                                    = $8319;
+  {$EXTERNALSYM GL_YCRCBA_SGIX}
+
+  // GL_SGI_depth_pass_instrument
+  GL_DEPTH_PASS_INSTRUMENT_SGIX                     = $8310;
+  {$EXTERNALSYM GL_DEPTH_PASS_INSTRUMENT_SGIX}
+  GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX            = $8311;
+  {$EXTERNALSYM GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX}
+  GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX                 = $8312;
+  {$EXTERNALSYM GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX}
+
+  // GL_3DFX_texture_compression_FXT1
+  GL_COMPRESSED_RGB_FXT1_3DFX                       = $86B0;
+  {$EXTERNALSYM GL_COMPRESSED_RGB_FXT1_3DFX}
+  GL_COMPRESSED_RGBA_FXT1_3DFX                      = $86B1;
+  {$EXTERNALSYM GL_COMPRESSED_RGBA_FXT1_3DFX}
+
+  // GL_3DFX_multisample
+  GL_MULTISAMPLE_3DFX                               = $86B2;
+  {$EXTERNALSYM GL_MULTISAMPLE_3DFX}
+  GL_SAMPLE_BUFFERS_3DFX                            = $86B3;
+  {$EXTERNALSYM GL_SAMPLE_BUFFERS_3DFX}
+  GL_SAMPLES_3DFX                                   = $86B4;
+  {$EXTERNALSYM GL_SAMPLES_3DFX}
+  GL_MULTISAMPLE_BIT_3DFX                           = $20000000;
+  {$EXTERNALSYM GL_MULTISAMPLE_BIT_3DFX}
+
+  // GL_EXT_multisample
+  GL_MULTISAMPLE_EXT                                = $809D;
+  {$EXTERNALSYM GL_MULTISAMPLE_EXT}
+  GL_SAMPLE_ALPHA_TO_MASK_EXT                       = $809E;
+  {$EXTERNALSYM GL_SAMPLE_ALPHA_TO_MASK_EXT}
+  GL_SAMPLE_ALPHA_TO_ONE_EXT                        = $809F;
+  {$EXTERNALSYM GL_SAMPLE_ALPHA_TO_ONE_EXT}
+  GL_SAMPLE_MASK_EXT                                = $80A0;
+  {$EXTERNALSYM GL_SAMPLE_MASK_EXT}
+  GL_1PASS_EXT                                      = $80A1;
+  {$EXTERNALSYM GL_1PASS_EXT}
+  GL_2PASS_0_EXT                                    = $80A2;
+  {$EXTERNALSYM GL_2PASS_0_EXT}
+  GL_2PASS_1_EXT                                    = $80A3;
+  {$EXTERNALSYM GL_2PASS_1_EXT}
+  GL_4PASS_0_EXT                                    = $80A4;
+  {$EXTERNALSYM GL_4PASS_0_EXT}
+  GL_4PASS_1_EXT                                    = $80A5;
+  {$EXTERNALSYM GL_4PASS_1_EXT}
+  GL_4PASS_2_EXT                                    = $80A6;
+  {$EXTERNALSYM GL_4PASS_2_EXT}
+  GL_4PASS_3_EXT                                    = $80A7;
+  {$EXTERNALSYM GL_4PASS_3_EXT}
+  GL_SAMPLE_BUFFERS_EXT                             = $80A8;
+  {$EXTERNALSYM GL_SAMPLE_BUFFERS_EXT}
+  GL_SAMPLES_EXT                                    = $80A9;
+  {$EXTERNALSYM GL_SAMPLES_EXT}
+  GL_SAMPLE_MASK_VALUE_EXT                          = $80AA;
+  {$EXTERNALSYM GL_SAMPLE_MASK_VALUE_EXT}
+  GL_SAMPLE_MASK_INVERT_EXT                         = $80AB;
+  {$EXTERNALSYM GL_SAMPLE_MASK_INVERT_EXT}
+  GL_SAMPLE_PATTERN_EXT                             = $80AC;
+  {$EXTERNALSYM GL_SAMPLE_PATTERN_EXT}
+
+  // GL_SGIX_vertex_preclip
+  GL_VERTEX_PRECLIP_SGIX                            = $83EE;
+  {$EXTERNALSYM GL_VERTEX_PRECLIP_SGIX}
+  GL_VERTEX_PRECLIP_HINT_SGIX                       = $83EF;
+  {$EXTERNALSYM GL_VERTEX_PRECLIP_HINT_SGIX}
+
+  // GL_SGIX_convolution_accuracy
+  GL_CONVOLUTION_HINT_SGIX                          = $8316;
+  {$EXTERNALSYM GL_CONVOLUTION_HINT_SGIX}
+
+  // GL_SGIX_resample
+  GL_PACK_RESAMPLE_SGIX                             = $842C;
+  {$EXTERNALSYM GL_PACK_RESAMPLE_SGIX}
+  GL_UNPACK_RESAMPLE_SGIX                           = $842D;
+  {$EXTERNALSYM GL_UNPACK_RESAMPLE_SGIX}
+  GL_RESAMPLE_REPLICATE_SGIX                        = $842E;
+  {$EXTERNALSYM GL_RESAMPLE_REPLICATE_SGIX}
+  GL_RESAMPLE_ZERO_FILL_SGIX                        = $842F;
+  {$EXTERNALSYM GL_RESAMPLE_ZERO_FILL_SGIX}
+  GL_RESAMPLE_DECIMATE_SGIX                         = $8430;
+  {$EXTERNALSYM GL_RESAMPLE_DECIMATE_SGIX}
+
+  // GL_SGIS_point_line_texgen
+  GL_EYE_DISTANCE_TO_POINT_SGIS                     = $81F0;
+  {$EXTERNALSYM GL_EYE_DISTANCE_TO_POINT_SGIS}
+  GL_OBJECT_DISTANCE_TO_POINT_SGIS                  = $81F1;
+  {$EXTERNALSYM GL_OBJECT_DISTANCE_TO_POINT_SGIS}
+  GL_EYE_DISTANCE_TO_LINE_SGIS                      = $81F2;
+  {$EXTERNALSYM GL_EYE_DISTANCE_TO_LINE_SGIS}
+  GL_OBJECT_DISTANCE_TO_LINE_SGIS                   = $81F3;
+  {$EXTERNALSYM GL_OBJECT_DISTANCE_TO_LINE_SGIS}
+  GL_EYE_POINT_SGIS                                 = $81F4;
+  {$EXTERNALSYM GL_EYE_POINT_SGIS}
+  GL_OBJECT_POINT_SGIS                              = $81F5;
+  {$EXTERNALSYM GL_OBJECT_POINT_SGIS}
+  GL_EYE_LINE_SGIS                                  = $81F6;
+  {$EXTERNALSYM GL_EYE_LINE_SGIS}
+  GL_OBJECT_LINE_SGIS                               = $81F7;
+  {$EXTERNALSYM GL_OBJECT_LINE_SGIS}
+
+  // GL_SGIS_texture_color_mask
+  GL_TEXTURE_COLOR_WRITEMASK_SGIS                   = $81EF;
+  {$EXTERNALSYM GL_TEXTURE_COLOR_WRITEMASK_SGIS}
+
+  // GL_NV_vertex_program
+  GL_VERTEX_PROGRAM_NV                              = $8620;
+  {$EXTERNALSYM GL_VERTEX_PROGRAM_NV}
+  GL_VERTEX_STATE_PROGRAM_NV                        = $8621;
+  {$EXTERNALSYM GL_VERTEX_STATE_PROGRAM_NV}
+  GL_ATTRIB_ARRAY_SIZE_NV                           = $8623;
+  {$EXTERNALSYM GL_ATTRIB_ARRAY_SIZE_NV}
+  GL_ATTRIB_ARRAY_STRIDE_NV                         = $8624;
+  {$EXTERNALSYM GL_ATTRIB_ARRAY_STRIDE_NV}
+  GL_ATTRIB_ARRAY_TYPE_NV                           = $8625;
+  {$EXTERNALSYM GL_ATTRIB_ARRAY_TYPE_NV}
+  GL_CURRENT_ATTRIB_NV                              = $8626;
+  {$EXTERNALSYM GL_CURRENT_ATTRIB_NV}
+  GL_PROGRAM_LENGTH_NV                              = $8627;
+  {$EXTERNALSYM GL_PROGRAM_LENGTH_NV}
+  GL_PROGRAM_STRING_NV                              = $8628;
+  {$EXTERNALSYM GL_PROGRAM_STRING_NV}
+  GL_MODELVIEW_PROJECTION_NV                        = $8629;
+  {$EXTERNALSYM GL_MODELVIEW_PROJECTION_NV}
+  GL_IDENTITY_NV                                    = $862A;
+  {$EXTERNALSYM GL_IDENTITY_NV}
+  GL_INVERSE_NV                                     = $862B;
+  {$EXTERNALSYM GL_INVERSE_NV}
+  GL_TRANSPOSE_NV                                   = $862C;
+  {$EXTERNALSYM GL_TRANSPOSE_NV}
+  GL_INVERSE_TRANSPOSE_NV                           = $862D;
+  {$EXTERNALSYM GL_INVERSE_TRANSPOSE_NV}
+  GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV                = $862E;
+  {$EXTERNALSYM GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV}
+  GL_MAX_TRACK_MATRICES_NV                          = $862F;
+  {$EXTERNALSYM GL_MAX_TRACK_MATRICES_NV}
+  GL_MATRIX0_NV                                     = $8630;
+  {$EXTERNALSYM GL_MATRIX0_NV}
+  GL_MATRIX1_NV                                     = $8631;
+  {$EXTERNALSYM GL_MATRIX1_NV}
+  GL_MATRIX2_NV                                     = $8632;
+  {$EXTERNALSYM GL_MATRIX2_NV}
+  GL_MATRIX3_NV                                     = $8633;
+  {$EXTERNALSYM GL_MATRIX3_NV}
+  GL_MATRIX4_NV                                     = $8634;
+  {$EXTERNALSYM GL_MATRIX4_NV}
+  GL_MATRIX5_NV                                     = $8635;
+  {$EXTERNALSYM GL_MATRIX5_NV}
+  GL_MATRIX6_NV                                     = $8636;
+  {$EXTERNALSYM GL_MATRIX6_NV}
+  GL_MATRIX7_NV                                     = $8637;
+  {$EXTERNALSYM GL_MATRIX7_NV}
+  GL_CURRENT_MATRIX_STACK_DEPTH_NV                  = $8640;
+  {$EXTERNALSYM GL_CURRENT_MATRIX_STACK_DEPTH_NV}
+  GL_CURRENT_MATRIX_NV                              = $8641;
+  {$EXTERNALSYM GL_CURRENT_MATRIX_NV}
+  GL_VERTEX_PROGRAM_POINT_SIZE_NV                   = $8642;
+  {$EXTERNALSYM GL_VERTEX_PROGRAM_POINT_SIZE_NV}
+  GL_VERTEX_PROGRAM_TWO_SIDE_NV                     = $8643;
+  {$EXTERNALSYM GL_VERTEX_PROGRAM_TWO_SIDE_NV}
+  GL_PROGRAM_PARAMETER_NV                           = $8644;
+  {$EXTERNALSYM GL_PROGRAM_PARAMETER_NV}
+  GL_ATTRIB_ARRAY_POINTER_NV                        = $8645;
+  {$EXTERNALSYM GL_ATTRIB_ARRAY_POINTER_NV}
+  GL_PROGRAM_TARGET_NV                              = $8646;
+  {$EXTERNALSYM GL_PROGRAM_TARGET_NV}
+  GL_PROGRAM_RESIDENT_NV                            = $8647;
+  {$EXTERNALSYM GL_PROGRAM_RESIDENT_NV}
+  GL_TRACK_MATRIX_NV                                = $8648;
+  {$EXTERNALSYM GL_TRACK_MATRIX_NV}
+  GL_TRACK_MATRIX_TRANSFORM_NV                      = $8649;
+  {$EXTERNALSYM GL_TRACK_MATRIX_TRANSFORM_NV}
+  GL_VERTEX_PROGRAM_BINDING_NV                      = $864A;
+  {$EXTERNALSYM GL_VERTEX_PROGRAM_BINDING_NV}
+  GL_PROGRAM_ERROR_POSITION_NV                      = $864B;
+  {$EXTERNALSYM GL_PROGRAM_ERROR_POSITION_NV}
+  GL_VERTEX_ATTRIB_ARRAY0_NV                        = $8650;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY0_NV}
+  GL_VERTEX_ATTRIB_ARRAY1_NV                        = $8651;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY1_NV}
+  GL_VERTEX_ATTRIB_ARRAY2_NV                        = $8652;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY2_NV}
+  GL_VERTEX_ATTRIB_ARRAY3_NV                        = $8653;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY3_NV}
+  GL_VERTEX_ATTRIB_ARRAY4_NV                        = $8654;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY4_NV}
+  GL_VERTEX_ATTRIB_ARRAY5_NV                        = $8655;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY5_NV}
+  GL_VERTEX_ATTRIB_ARRAY6_NV                        = $8656;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY6_NV}
+  GL_VERTEX_ATTRIB_ARRAY7_NV                        = $8657;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY7_NV}
+  GL_VERTEX_ATTRIB_ARRAY8_NV                        = $8658;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY8_NV}
+  GL_VERTEX_ATTRIB_ARRAY9_NV                        = $8659;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY9_NV}
+  GL_VERTEX_ATTRIB_ARRAY10_NV                       = $865A;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY10_NV}
+  GL_VERTEX_ATTRIB_ARRAY11_NV                       = $865B;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY11_NV}
+  GL_VERTEX_ATTRIB_ARRAY12_NV                       = $865C;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY12_NV}
+  GL_VERTEX_ATTRIB_ARRAY13_NV                       = $865D;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY13_NV}
+  GL_VERTEX_ATTRIB_ARRAY14_NV                       = $865E;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY14_NV}
+  GL_VERTEX_ATTRIB_ARRAY15_NV                       = $865F;
+  {$EXTERNALSYM GL_VERTEX_ATTRIB_ARRAY15_NV}
+  GL_MAP1_VERTEX_ATTRIB0_4_NV                       = $8660;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB0_4_NV}
+  GL_MAP1_VERTEX_ATTRIB1_4_NV                       = $8661;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB1_4_NV}
+  GL_MAP1_VERTEX_ATTRIB2_4_NV                       = $8662;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB2_4_NV}
+  GL_MAP1_VERTEX_ATTRIB3_4_NV                       = $8663;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB3_4_NV}
+  GL_MAP1_VERTEX_ATTRIB4_4_NV                       = $8664;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB4_4_NV}
+  GL_MAP1_VERTEX_ATTRIB5_4_NV                       = $8665;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB5_4_NV}
+  GL_MAP1_VERTEX_ATTRIB6_4_NV                       = $8666;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB6_4_NV}
+  GL_MAP1_VERTEX_ATTRIB7_4_NV                       = $8667;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB7_4_NV}
+  GL_MAP1_VERTEX_ATTRIB8_4_NV                       = $8668;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB8_4_NV}
+  GL_MAP1_VERTEX_ATTRIB9_4_NV                       = $8669;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB9_4_NV}
+  GL_MAP1_VERTEX_ATTRIB10_4_NV                      = $866A;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB10_4_NV}
+  GL_MAP1_VERTEX_ATTRIB11_4_NV                      = $866B;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB11_4_NV}
+  GL_MAP1_VERTEX_ATTRIB12_4_NV                      = $866C;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB12_4_NV}
+  GL_MAP1_VERTEX_ATTRIB13_4_NV                      = $866D;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB13_4_NV}
+  GL_MAP1_VERTEX_ATTRIB14_4_NV                      = $866E;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB14_4_NV}
+  GL_MAP1_VERTEX_ATTRIB15_4_NV                      = $866F;
+  {$EXTERNALSYM GL_MAP1_VERTEX_ATTRIB15_4_NV}
+  GL_MAP2_VERTEX_ATTRIB0_4_NV                       = $8670;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB0_4_NV}
+  GL_MAP2_VERTEX_ATTRIB1_4_NV                       = $8671;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB1_4_NV}
+  GL_MAP2_VERTEX_ATTRIB2_4_NV                       = $8672;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB2_4_NV}
+  GL_MAP2_VERTEX_ATTRIB3_4_NV                       = $8673;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB3_4_NV}
+  GL_MAP2_VERTEX_ATTRIB4_4_NV                       = $8674;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB4_4_NV}
+  GL_MAP2_VERTEX_ATTRIB5_4_NV                       = $8675;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB5_4_NV}
+  GL_MAP2_VERTEX_ATTRIB6_4_NV                       = $8676;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB6_4_NV}
+  GL_MAP2_VERTEX_ATTRIB7_4_NV                       = $8677;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB7_4_NV}
+  GL_MAP2_VERTEX_ATTRIB8_4_NV                       = $8678;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB8_4_NV}
+  GL_MAP2_VERTEX_ATTRIB9_4_NV                       = $8679;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB9_4_NV}
+  GL_MAP2_VERTEX_ATTRIB10_4_NV                      = $867A;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB10_4_NV}
+  GL_MAP2_VERTEX_ATTRIB11_4_NV                      = $867B;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB11_4_NV}
+  GL_MAP2_VERTEX_ATTRIB12_4_NV                      = $867C;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB12_4_NV}
+  GL_MAP2_VERTEX_ATTRIB13_4_NV                      = $867D;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB13_4_NV}
+  GL_MAP2_VERTEX_ATTRIB14_4_NV                      = $867E;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB14_4_NV}
+  GL_MAP2_VERTEX_ATTRIB15_4_NV                      = $867F;
+  {$EXTERNALSYM GL_MAP2_VERTEX_ATTRIB15_4_NV}
+
+  // WGL_ARB_pixel_format
+  WGL_NUMBER_PIXEL_FORMATS_ARB                      = $2000;
+  {$EXTERNALSYM WGL_NUMBER_PIXEL_FORMATS_ARB}
+  WGL_DRAW_TO_WINDOW_ARB                            = $2001;
+  {$EXTERNALSYM WGL_DRAW_TO_WINDOW_ARB}
+  WGL_DRAW_TO_BITMAP_ARB                            = $2002;
+  {$EXTERNALSYM WGL_DRAW_TO_BITMAP_ARB}
+  WGL_ACCELERATION_ARB                              = $2003;
+  {$EXTERNALSYM WGL_ACCELERATION_ARB}
+  WGL_NEED_PALETTE_ARB                              = $2004;
+  {$EXTERNALSYM WGL_NEED_PALETTE_ARB}
+  WGL_NEED_SYSTEM_PALETTE_ARB                       = $2005;
+  {$EXTERNALSYM WGL_NEED_SYSTEM_PALETTE_ARB}
+  WGL_SWAP_LAYER_BUFFERS_ARB                        = $2006;
+  {$EXTERNALSYM WGL_SWAP_LAYER_BUFFERS_ARB}
+  WGL_SWAP_METHOD_ARB                               = $2007;
+  {$EXTERNALSYM WGL_SWAP_METHOD_ARB}
+  WGL_NUMBER_OVERLAYS_ARB                           = $2008;
+  {$EXTERNALSYM WGL_NUMBER_OVERLAYS_ARB}
+  WGL_NUMBER_UNDERLAYS_ARB                          = $2009;
+  {$EXTERNALSYM WGL_NUMBER_UNDERLAYS_ARB}
+  WGL_TRANSPARENT_ARB                               = $200A;
+  {$EXTERNALSYM WGL_TRANSPARENT_ARB}
+  WGL_TRANSPARENT_RED_VALUE_ARB                     = $2037;
+  {$EXTERNALSYM WGL_TRANSPARENT_RED_VALUE_ARB}
+  WGL_TRANSPARENT_GREEN_VALUE_ARB                   = $2038;
+  {$EXTERNALSYM WGL_TRANSPARENT_GREEN_VALUE_ARB}
+  WGL_TRANSPARENT_BLUE_VALUE_ARB                    = $2039;
+  {$EXTERNALSYM WGL_TRANSPARENT_BLUE_VALUE_ARB}
+  WGL_TRANSPARENT_ALPHA_VALUE_ARB                   = $203A;
+  {$EXTERNALSYM WGL_TRANSPARENT_ALPHA_VALUE_ARB}
+  WGL_TRANSPARENT_INDEX_VALUE_ARB                   = $203B;
+  {$EXTERNALSYM WGL_TRANSPARENT_INDEX_VALUE_ARB}
+  WGL_SHARE_DEPTH_ARB                               = $200C;
+  {$EXTERNALSYM WGL_SHARE_DEPTH_ARB}
+  WGL_SHARE_STENCIL_ARB                             = $200D;
+  {$EXTERNALSYM WGL_SHARE_STENCIL_ARB}
+  WGL_SHARE_ACCUM_ARB                               = $200E;
+  {$EXTERNALSYM WGL_SHARE_ACCUM_ARB}
+  WGL_SUPPORT_GDI_ARB                               = $200F;
+  {$EXTERNALSYM WGL_SUPPORT_GDI_ARB}
+  WGL_SUPPORT_OPENGL_ARB                            = $2010;
+  {$EXTERNALSYM WGL_SUPPORT_OPENGL_ARB}
+  WGL_DOUBLE_BUFFER_ARB                             = $2011;
+  {$EXTERNALSYM WGL_DOUBLE_BUFFER_ARB}
+  WGL_STEREO_ARB                                    = $2012;
+  {$EXTERNALSYM WGL_STEREO_ARB}
+  WGL_PIXEL_TYPE_ARB                                = $2013;
+  {$EXTERNALSYM WGL_PIXEL_TYPE_ARB}
+  WGL_COLOR_BITS_ARB                                = $2014;
+  {$EXTERNALSYM WGL_COLOR_BITS_ARB}
+  WGL_RED_BITS_ARB                                  = $2015;
+  {$EXTERNALSYM WGL_RED_BITS_ARB}
+  WGL_RED_SHIFT_ARB                                 = $2016;
+  {$EXTERNALSYM WGL_RED_SHIFT_ARB}
+  WGL_GREEN_BITS_ARB                                = $2017;
+  {$EXTERNALSYM WGL_GREEN_BITS_ARB}
+  WGL_GREEN_SHIFT_ARB                               = $2018;
+  {$EXTERNALSYM WGL_GREEN_SHIFT_ARB}
+  WGL_BLUE_BITS_ARB                                 = $2019;
+  {$EXTERNALSYM WGL_BLUE_BITS_ARB}
+  WGL_BLUE_SHIFT_ARB                                = $201A;
+  {$EXTERNALSYM WGL_BLUE_SHIFT_ARB}
+  WGL_ALPHA_BITS_ARB                                = $201B;
+  {$EXTERNALSYM WGL_ALPHA_BITS_ARB}
+  WGL_ALPHA_SHIFT_ARB                               = $201C;
+  {$EXTERNALSYM WGL_ALPHA_SHIFT_ARB}
+  WGL_ACCUM_BITS_ARB                                = $201D;
+  {$EXTERNALSYM WGL_ACCUM_BITS_ARB}
+  WGL_ACCUM_RED_BITS_ARB                            = $201E;
+  {$EXTERNALSYM WGL_ACCUM_RED_BITS_ARB}
+  WGL_ACCUM_GREEN_BITS_ARB                          = $201F;
+  {$EXTERNALSYM WGL_ACCUM_GREEN_BITS_ARB}
+  WGL_ACCUM_BLUE_BITS_ARB                           = $2020;
+  {$EXTERNALSYM WGL_ACCUM_BLUE_BITS_ARB}
+  WGL_ACCUM_ALPHA_BITS_ARB                          = $2021;
+  {$EXTERNALSYM WGL_ACCUM_ALPHA_BITS_ARB}
+  WGL_DEPTH_BITS_ARB                                = $2022;
+  {$EXTERNALSYM WGL_DEPTH_BITS_ARB}
+  WGL_STENCIL_BITS_ARB                              = $2023;
+  {$EXTERNALSYM WGL_STENCIL_BITS_ARB}
+  WGL_AUX_BUFFERS_ARB                               = $2024;
+  {$EXTERNALSYM WGL_AUX_BUFFERS_ARB}
+  WGL_NO_ACCELERATION_ARB                           = $2025;
+  {$EXTERNALSYM WGL_NO_ACCELERATION_ARB}
+  WGL_GENERIC_ACCELERATION_ARB                      = $2026;
+  {$EXTERNALSYM WGL_GENERIC_ACCELERATION_ARB}
+  WGL_FULL_ACCELERATION_ARB                         = $2027;
+  {$EXTERNALSYM WGL_FULL_ACCELERATION_ARB}
+  WGL_SWAP_EXCHANGE_ARB                             = $2028;
+  {$EXTERNALSYM WGL_SWAP_EXCHANGE_ARB}
+  WGL_SWAP_COPY_ARB                                 = $2029;
+  {$EXTERNALSYM WGL_SWAP_COPY_ARB}
+  WGL_SWAP_UNDEFINED_ARB                            = $202A;
+  {$EXTERNALSYM WGL_SWAP_UNDEFINED_ARB}
+  WGL_TYPE_RGBA_ARB                                 = $202B;
+  {$EXTERNALSYM WGL_TYPE_RGBA_ARB}
+  WGL_TYPE_COLORINDEX_ARB                           = $202C;
+  {$EXTERNALSYM WGL_TYPE_COLORINDEX_ARB}
+
+  
+  // ********** GLU generic constants **********
+
+  // Errors: (return value 0 = no error)
+  GLU_INVALID_ENUM                                  = 100900;
+  {$EXTERNALSYM GLU_INVALID_ENUM}
+  GLU_INVALID_VALUE                                 = 100901;
+  {$EXTERNALSYM GLU_INVALID_VALUE}
+  GLU_OUT_OF_MEMORY                                 = 100902;
+  {$EXTERNALSYM GLU_OUT_OF_MEMORY}
+  GLU_INCOMPATIBLE_GL_VERSION                       = 100903;
+  {$EXTERNALSYM GLU_INCOMPATIBLE_GL_VERSION}
+
+  // StringName
+  GLU_VERSION                                       = 100800;
+  {$EXTERNALSYM GLU_VERSION}
+  GLU_EXTENSIONS                                    = 100801;
+  {$EXTERNALSYM GLU_EXTENSIONS}
+
+  // Boolean
+  GLU_TRUE                                          = GL_TRUE;
+  {$EXTERNALSYM GLU_TRUE}
+  GLU_FALSE                                         = GL_FALSE;
+  {$EXTERNALSYM GLU_FALSE}
+
+  // Quadric constants
+  // QuadricNormal
+  GLU_SMOOTH                                        = 100000;
+  {$EXTERNALSYM GLU_SMOOTH}
+  GLU_FLAT                                          = 100001;
+  {$EXTERNALSYM GLU_FLAT}
+  GLU_NONE                                          = 100002;
+  {$EXTERNALSYM GLU_NONE}
+
+  // QuadricDrawStyle
+  GLU_POINT                                         = 100010;
+  {$EXTERNALSYM GLU_POINT}
+  GLU_LINE                                          = 100011;
+  {$EXTERNALSYM GLU_LINE}
+  GLU_FILL                                          = 100012;
+  {$EXTERNALSYM GLU_FILL}
+  GLU_SILHOUETTE                                    = 100013;
+  {$EXTERNALSYM GLU_SILHOUETTE}
+
+  // QuadricOrientation
+  GLU_OUTSIDE                                       = 100020;
+  {$EXTERNALSYM GLU_OUTSIDE}
+  GLU_INSIDE                                        = 100021;
+  {$EXTERNALSYM GLU_INSIDE}
+
+  // Tesselation constants
+  GLU_TESS_MAX_COORD                                = 1.0e150;
+  {$EXTERNALSYM GLU_TESS_MAX_COORD}
+
+  // TessProperty
+  GLU_TESS_WINDING_RULE                             = 100140;
+  {$EXTERNALSYM GLU_TESS_WINDING_RULE}
+  GLU_TESS_BOUNDARY_ONLY                            = 100141;
+  {$EXTERNALSYM GLU_TESS_BOUNDARY_ONLY}
+  GLU_TESS_TOLERANCE                                = 100142;
+  {$EXTERNALSYM GLU_TESS_TOLERANCE}
+
+  // TessWinding
+  GLU_TESS_WINDING_ODD                              = 100130;
+  {$EXTERNALSYM GLU_TESS_WINDING_ODD}
+  GLU_TESS_WINDING_NONZERO                          = 100131;
+  {$EXTERNALSYM GLU_TESS_WINDING_NONZERO}
+  GLU_TESS_WINDING_POSITIVE                         = 100132;
+  {$EXTERNALSYM GLU_TESS_WINDING_POSITIVE}
+  GLU_TESS_WINDING_NEGATIVE                         = 100133;
+  {$EXTERNALSYM GLU_TESS_WINDING_NEGATIVE}
+  GLU_TESS_WINDING_ABS_GEQ_TWO                      = 100134;
+  {$EXTERNALSYM GLU_TESS_WINDING_ABS_GEQ_TWO}
+
+  // TessCallback
+  GLU_TESS_BEGIN                                    = 100100; // TGLUTessBeginProc
+  {$EXTERNALSYM GLU_TESS_BEGIN}
+  GLU_TESS_VERTEX                                   = 100101; // TGLUTessVertexProc
+  {$EXTERNALSYM GLU_TESS_VERTEX}
+  GLU_TESS_END                                      = 100102; // TGLUTessEndProc
+  {$EXTERNALSYM GLU_TESS_END}
+  GLU_TESS_ERROR                                    = 100103; // TGLUTessErrorProc
+  {$EXTERNALSYM GLU_TESS_ERROR}
+  GLU_TESS_EDGE_FLAG                                = 100104; // TGLUTessEdgeFlagProc
+  {$EXTERNALSYM GLU_TESS_EDGE_FLAG}
+  GLU_TESS_COMBINE                                  = 100105; // TGLUTessCombineProc
+  {$EXTERNALSYM GLU_TESS_COMBINE}
+  GLU_TESS_BEGIN_DATA                               = 100106; // TGLUTessBeginDataProc
+  {$EXTERNALSYM GLU_TESS_BEGIN_DATA}
+  GLU_TESS_VERTEX_DATA                              = 100107; // TGLUTessVertexDataProc
+  {$EXTERNALSYM GLU_TESS_VERTEX_DATA}
+  GLU_TESS_END_DATA                                 = 100108; // TGLUTessEndDataProc
+  {$EXTERNALSYM GLU_TESS_END_DATA}
+  GLU_TESS_ERROR_DATA                               = 100109; // TGLUTessErrorDataProc
+  {$EXTERNALSYM GLU_TESS_ERROR_DATA}
+  GLU_TESS_EDGE_FLAG_DATA                           = 100110; // TGLUTessEdgeFlagDataProc
+  {$EXTERNALSYM GLU_TESS_EDGE_FLAG_DATA}
+  GLU_TESS_COMBINE_DATA                             = 100111; // TGLUTessCombineDataProc
+  {$EXTERNALSYM GLU_TESS_COMBINE_DATA}
+
+  // TessError
+  GLU_TESS_ERROR1                                   = 100151;
+  {$EXTERNALSYM GLU_TESS_ERROR1}
+  GLU_TESS_ERROR2                                   = 100152;
+  {$EXTERNALSYM GLU_TESS_ERROR2}
+  GLU_TESS_ERROR3                                   = 100153;
+  {$EXTERNALSYM GLU_TESS_ERROR3}
+  GLU_TESS_ERROR4                                   = 100154;
+  {$EXTERNALSYM GLU_TESS_ERROR4}
+  GLU_TESS_ERROR5                                   = 100155;
+  {$EXTERNALSYM GLU_TESS_ERROR5}
+  GLU_TESS_ERROR6                                   = 100156;
+  {$EXTERNALSYM GLU_TESS_ERROR6}
+  GLU_TESS_ERROR7                                   = 100157;
+  {$EXTERNALSYM GLU_TESS_ERROR7}
+  GLU_TESS_ERROR8                                   = 100158;
+  {$EXTERNALSYM GLU_TESS_ERROR8}
+
+  GLU_TESS_MISSING_BEGIN_POLYGON                    = GLU_TESS_ERROR1;
+  {$EXTERNALSYM GLU_TESS_MISSING_BEGIN_POLYGON}
+  GLU_TESS_MISSING_BEGIN_CONTOUR                    = GLU_TESS_ERROR2;
+  {$EXTERNALSYM GLU_TESS_MISSING_BEGIN_CONTOUR}
+  GLU_TESS_MISSING_END_POLYGON                      = GLU_TESS_ERROR3;
+  {$EXTERNALSYM GLU_TESS_MISSING_END_POLYGON}
+  GLU_TESS_MISSING_END_CONTOUR                      = GLU_TESS_ERROR4;
+  {$EXTERNALSYM GLU_TESS_MISSING_END_CONTOUR}
+  GLU_TESS_COORD_TOO_LARGE                          = GLU_TESS_ERROR5;
+  {$EXTERNALSYM GLU_TESS_COORD_TOO_LARGE}
+  GLU_TESS_NEED_COMBINE_CALLBACK                    = GLU_TESS_ERROR6;
+  {$EXTERNALSYM GLU_TESS_NEED_COMBINE_CALLBACK}
+
+  // NURBS constants
+
+  // NurbsProperty
+  GLU_AUTO_LOAD_MATRIX                              = 100200;
+  {$EXTERNALSYM GLU_AUTO_LOAD_MATRIX}
+  GLU_CULLING                                       = 100201;
+  {$EXTERNALSYM GLU_CULLING}
+  GLU_SAMPLING_TOLERANCE                            = 100203;
+  {$EXTERNALSYM GLU_SAMPLING_TOLERANCE}
+  GLU_DISPLAY_MODE                                  = 100204;
+  {$EXTERNALSYM GLU_DISPLAY_MODE}
+  GLU_PARAMETRIC_TOLERANCE                          = 100202;
+  {$EXTERNALSYM GLU_PARAMETRIC_TOLERANCE}
+  GLU_SAMPLING_METHOD                               = 100205;
+  {$EXTERNALSYM GLU_SAMPLING_METHOD}
+  GLU_U_STEP                                        = 100206;
+  {$EXTERNALSYM GLU_U_STEP}
+  GLU_V_STEP                                        = 100207;
+  {$EXTERNALSYM GLU_V_STEP}
+
+  // NurbsSampling
+  GLU_PATH_LENGTH                                   = 100215;
+  {$EXTERNALSYM GLU_PATH_LENGTH}
+  GLU_PARAMETRIC_ERROR                              = 100216;
+  {$EXTERNALSYM GLU_PARAMETRIC_ERROR}
+  GLU_DOMAIN_DISTANCE                               = 100217;
+  {$EXTERNALSYM GLU_DOMAIN_DISTANCE}
+
+  // NurbsTrim
+  GLU_MAP1_TRIM_2                                   = 100210;
+  {$EXTERNALSYM GLU_MAP1_TRIM_2}
+  GLU_MAP1_TRIM_3                                   = 100211;
+  {$EXTERNALSYM GLU_MAP1_TRIM_3}
+
+  // NurbsDisplay
+  GLU_OUTLINE_POLYGON                               = 100240;
+  {$EXTERNALSYM GLU_OUTLINE_POLYGON}
+  GLU_OUTLINE_PATCH                                 = 100241;
+  {$EXTERNALSYM GLU_OUTLINE_PATCH}
+
+  // NurbsErrors
+  GLU_NURBS_ERROR1                                  = 100251;
+  {$EXTERNALSYM GLU_NURBS_ERROR1}
+  GLU_NURBS_ERROR2                                  = 100252;
+  {$EXTERNALSYM GLU_NURBS_ERROR2}
+  GLU_NURBS_ERROR3                                  = 100253;
+  {$EXTERNALSYM GLU_NURBS_ERROR3}
+  GLU_NURBS_ERROR4                                  = 100254;
+  {$EXTERNALSYM GLU_NURBS_ERROR4}
+  GLU_NURBS_ERROR5                                  = 100255;
+  {$EXTERNALSYM GLU_NURBS_ERROR5}
+  GLU_NURBS_ERROR6                                  = 100256;
+  {$EXTERNALSYM GLU_NURBS_ERROR6}
+  GLU_NURBS_ERROR7                                  = 100257;
+  {$EXTERNALSYM GLU_NURBS_ERROR7}
+  GLU_NURBS_ERROR8                                  = 100258;
+  {$EXTERNALSYM GLU_NURBS_ERROR8}
+  GLU_NURBS_ERROR9                                  = 100259;
+  {$EXTERNALSYM GLU_NURBS_ERROR9}
+  GLU_NURBS_ERROR10                                 = 100260;
+  {$EXTERNALSYM GLU_NURBS_ERROR10}
+  GLU_NURBS_ERROR11                                 = 100261;
+  {$EXTERNALSYM GLU_NURBS_ERROR11}
+  GLU_NURBS_ERROR12                                 = 100262;
+  {$EXTERNALSYM GLU_NURBS_ERROR12}
+  GLU_NURBS_ERROR13                                 = 100263;
+  {$EXTERNALSYM GLU_NURBS_ERROR13}
+  GLU_NURBS_ERROR14                                 = 100264;
+  {$EXTERNALSYM GLU_NURBS_ERROR14}
+  GLU_NURBS_ERROR15                                 = 100265;
+  {$EXTERNALSYM GLU_NURBS_ERROR15}
+  GLU_NURBS_ERROR16                                 = 100266;
+  {$EXTERNALSYM GLU_NURBS_ERROR16}
+  GLU_NURBS_ERROR17                                 = 100267;
+  {$EXTERNALSYM GLU_NURBS_ERROR17}
+  GLU_NURBS_ERROR18                                 = 100268;
+  {$EXTERNALSYM GLU_NURBS_ERROR18}
+  GLU_NURBS_ERROR19                                 = 100269;
+  {$EXTERNALSYM GLU_NURBS_ERROR19}
+  GLU_NURBS_ERROR20                                 = 100270;
+  {$EXTERNALSYM GLU_NURBS_ERROR20}
+  GLU_NURBS_ERROR21                                 = 100271;
+  {$EXTERNALSYM GLU_NURBS_ERROR21}
+  GLU_NURBS_ERROR22                                 = 100272;
+  {$EXTERNALSYM GLU_NURBS_ERROR22}
+  GLU_NURBS_ERROR23                                 = 100273;
+  {$EXTERNALSYM GLU_NURBS_ERROR23}
+  GLU_NURBS_ERROR24                                 = 100274;
+  {$EXTERNALSYM GLU_NURBS_ERROR24}
+  GLU_NURBS_ERROR25                                 = 100275;
+  {$EXTERNALSYM GLU_NURBS_ERROR25}
+  GLU_NURBS_ERROR26                                 = 100276;
+  {$EXTERNALSYM GLU_NURBS_ERROR26}
+  GLU_NURBS_ERROR27                                 = 100277;
+  {$EXTERNALSYM GLU_NURBS_ERROR27}
+  GLU_NURBS_ERROR28                                 = 100278;
+  {$EXTERNALSYM GLU_NURBS_ERROR28}
+  GLU_NURBS_ERROR29                                 = 100279;
+  {$EXTERNALSYM GLU_NURBS_ERROR29}
+  GLU_NURBS_ERROR30                                 = 100280;
+  {$EXTERNALSYM GLU_NURBS_ERROR30}
+  GLU_NURBS_ERROR31                                 = 100281;
+  {$EXTERNALSYM GLU_NURBS_ERROR31}
+  GLU_NURBS_ERROR32                                 = 100282;
+  {$EXTERNALSYM GLU_NURBS_ERROR32}
+  GLU_NURBS_ERROR33                                 = 100283;
+  {$EXTERNALSYM GLU_NURBS_ERROR33}
+  GLU_NURBS_ERROR34                                 = 100284;
+  {$EXTERNALSYM GLU_NURBS_ERROR34}
+  GLU_NURBS_ERROR35                                 = 100285;
+  {$EXTERNALSYM GLU_NURBS_ERROR35}
+  GLU_NURBS_ERROR36                                 = 100286;
+  {$EXTERNALSYM GLU_NURBS_ERROR36}
+  GLU_NURBS_ERROR37                                 = 100287;
+  {$EXTERNALSYM GLU_NURBS_ERROR37}
+
+  // Contours types -- obsolete!
+  GLU_CW                                            = 100120;
+  {$EXTERNALSYM GLU_CW}
+  GLU_CCW                                           = 100121;
+  {$EXTERNALSYM GLU_CCW}
+  GLU_INTERIOR                                      = 100122;
+  {$EXTERNALSYM GLU_INTERIOR}
+  GLU_EXTERIOR                                      = 100123;
+  {$EXTERNALSYM GLU_EXTERIOR}
+  GLU_UNKNOWN                                       = 100124;
+  {$EXTERNALSYM GLU_UNKNOWN}
+
+  // Names without "TESS_" prefix
+  GLU_BEGIN                                         = GLU_TESS_BEGIN;
+  {$EXTERNALSYM GLU_BEGIN}
+  GLU_VERTEX                                        = GLU_TESS_VERTEX;
+  {$EXTERNALSYM GLU_VERTEX}
+  GLU_END                                           = GLU_TESS_END;
+  {$EXTERNALSYM GLU_END}
+  GLU_ERROR                                         = GLU_TESS_ERROR;
+  {$EXTERNALSYM GLU_ERROR}
+  GLU_EDGE_FLAG                                     = GLU_TESS_EDGE_FLAG;
+  {$EXTERNALSYM GLU_EDGE_FLAG}
+
+  GLX_VERSION_1_1                                   = 1;
+  GLX_VERSION_1_2                                   = 1;
+  GLX_VERSION_1_3                                   = 1;
+  GLX_EXTENSION_NAME                                = 'GLX';
+  {$EXTERNALSYM GLX_EXTENSION_NAME}
+  GLX_USE_GL                                        = 1;
+  {$EXTERNALSYM GLX_USE_GL}
+  GLX_BUFFER_SIZE                                   = 2;
+  {$EXTERNALSYM GLX_BUFFER_SIZE}
+  GLX_LEVEL                                         = 3;
+  {$EXTERNALSYM GLX_LEVEL}
+  GLX_RGBA                                          = 4;
+  {$EXTERNALSYM GLX_RGBA}
+  GLX_DOUBLEBUFFER                                  = 5;
+  {$EXTERNALSYM GLX_DOUBLEBUFFER}
+  GLX_STEREO                                        = 6;
+  {$EXTERNALSYM GLX_STEREO}
+  GLX_AUX_BUFFERS                                   = 7;
+  {$EXTERNALSYM GLX_AUX_BUFFERS}
+  GLX_RED_SIZE                                      = 8;
+  {$EXTERNALSYM GLX_RED_SIZE}
+  GLX_GREEN_SIZE                                    = 9;
+  {$EXTERNALSYM GLX_GREEN_SIZE}
+  GLX_BLUE_SIZE                                     = 10;
+  {$EXTERNALSYM GLX_BLUE_SIZE}
+  GLX_ALPHA_SIZE                                    = 11;
+  {$EXTERNALSYM GLX_ALPHA_SIZE}
+  GLX_DEPTH_SIZE                                    = 12;
+  {$EXTERNALSYM GLX_DEPTH_SIZE}
+  GLX_STENCIL_SIZE                                  = 13;
+  {$EXTERNALSYM GLX_STENCIL_SIZE}
+  GLX_ACCUM_RED_SIZE                                = 14;
+  {$EXTERNALSYM GLX_ACCUM_RED_SIZE}
+  GLX_ACCUM_GREEN_SIZE                              = 15;
+  {$EXTERNALSYM GLX_ACCUM_GREEN_SIZE}
+  GLX_ACCUM_BLUE_SIZE                               = 16;
+  {$EXTERNALSYM GLX_ACCUM_BLUE_SIZE}
+  GLX_ACCUM_ALPHA_SIZE                              = 17;
+  {$EXTERNALSYM GLX_ACCUM_ALPHA_SIZE}
+
+  // Error codes returned by glXGetConfig:
+  GLX_BAD_SCREEN                                    = 1;
+  {$EXTERNALSYM GLX_BAD_SCREEN}
+  GLX_BAD_ATTRIBUTE                                 = 2;
+  {$EXTERNALSYM GLX_BAD_ATTRIBUTE}
+  GLX_NO_EXTENSION                                  = 3;
+  {$EXTERNALSYM GLX_NO_EXTENSION}
+  GLX_BAD_VISUAL                                    = 4;
+  {$EXTERNALSYM GLX_BAD_VISUAL}
+  GLX_BAD_CONTEXT                                   = 5;
+  {$EXTERNALSYM GLX_BAD_CONTEXT}
+  GLX_BAD_VALUE                                     = 6;
+  {$EXTERNALSYM GLX_BAD_VALUE}
+  GLX_BAD_ENUM                                      = 7;
+  {$EXTERNALSYM GLX_BAD_ENUM}
+
+  // GLX 1.1 and later:
+  GLX_VENDOR                                        = 1;
+  {$EXTERNALSYM GLX_VENDOR}
+  GLX_VERSION                                       = 2;
+  {$EXTERNALSYM GLX_VERSION}
+  GLX_EXTENSIONS                                    = 3;
+  {$EXTERNALSYM GLX_EXTENSIONS}
+
+  // GLX 1.3 and later:
+  GLX_CONFIG_CAVEAT                                 = $20;
+  {$EXTERNALSYM GLX_CONFIG_CAVEAT}
+  GLX_DONT_CARE                                     = $FFFFFFFF;
+  {$EXTERNALSYM GLX_DONT_CARE}
+  GLX_SLOW_CONFIG                                   = $8001;
+  {$EXTERNALSYM GLX_SLOW_CONFIG}
+  GLX_NON_CONFORMANT_CONFIG                         = $800D;
+  {$EXTERNALSYM GLX_NON_CONFORMANT_CONFIG}
+  GLX_X_VISUAL_TYPE                                 = $22;
+  {$EXTERNALSYM GLX_X_VISUAL_TYPE}
+  GLX_TRANSPARENT_TYPE                              = $23;
+  {$EXTERNALSYM GLX_TRANSPARENT_TYPE}
+  GLX_TRANSPARENT_INDEX_VALUE                       = $24;
+  {$EXTERNALSYM GLX_TRANSPARENT_INDEX_VALUE}
+  GLX_TRANSPARENT_RED_VALUE                         = $25;
+  {$EXTERNALSYM GLX_TRANSPARENT_RED_VALUE}
+  GLX_TRANSPARENT_GREEN_VALUE                       = $26;
+  {$EXTERNALSYM GLX_TRANSPARENT_GREEN_VALUE}
+  GLX_TRANSPARENT_BLUE_VALUE                        = $27;
+  {$EXTERNALSYM GLX_TRANSPARENT_BLUE_VALUE}
+  GLX_TRANSPARENT_ALPHA_VALUE                       = $28;
+  {$EXTERNALSYM GLX_TRANSPARENT_ALPHA_VALUE}
+  GLX_MAX_PBUFFER_WIDTH                             = $8016;
+  {$EXTERNALSYM GLX_MAX_PBUFFER_WIDTH}
+  GLX_MAX_PBUFFER_HEIGHT                            = $8017;
+  {$EXTERNALSYM GLX_MAX_PBUFFER_HEIGHT}
+  GLX_MAX_PBUFFER_PIXELS                            = $8018;
+  {$EXTERNALSYM GLX_MAX_PBUFFER_PIXELS}
+  GLX_PRESERVED_CONTENTS                            = $801B;
+  {$EXTERNALSYM GLX_PRESERVED_CONTENTS}
+  GLX_LARGEST_BUFFER                                = $801C;
+  {$EXTERNALSYM GLX_LARGEST_BUFFER}
+  GLX_DRAWABLE_TYPE                                 = $8010;
+  {$EXTERNALSYM GLX_DRAWABLE_TYPE}
+  GLX_FBCONFIG_ID                                   = $8013;
+  {$EXTERNALSYM GLX_FBCONFIG_ID}
+  GLX_VISUAL_ID                                     = $800B;
+  {$EXTERNALSYM GLX_VISUAL_ID}
+  GLX_WINDOW_BIT                                    = $00000001;
+  {$EXTERNALSYM GLX_WINDOW_BIT}
+  GLX_PIXMAP_BIT                                    = $00000002;
+  {$EXTERNALSYM GLX_PIXMAP_BIT}
+  GLX_PBUFFER_BIT                                   = $00000004;
+  {$EXTERNALSYM GLX_PBUFFER_BIT}
+  GLX_AUX_BUFFERS_BIT                               = $00000010;
+  {$EXTERNALSYM GLX_AUX_BUFFERS_BIT}
+  GLX_FRONT_LEFT_BUFFER_BIT                         = $00000001;
+  {$EXTERNALSYM GLX_FRONT_LEFT_BUFFER_BIT}
+  GLX_FRONT_RIGHT_BUFFER_BIT                        = $00000002;
+  {$EXTERNALSYM GLX_FRONT_RIGHT_BUFFER_BIT}
+  GLX_BACK_LEFT_BUFFER_BIT                          = $00000004;
+  {$EXTERNALSYM GLX_BACK_LEFT_BUFFER_BIT}
+  GLX_BACK_RIGHT_BUFFER_BIT                         = $00000008;
+  {$EXTERNALSYM GLX_BACK_RIGHT_BUFFER_BIT}
+  GLX_DEPTH_BUFFER_BIT                              = $00000020;
+  {$EXTERNALSYM GLX_DEPTH_BUFFER_BIT}
+  GLX_STENCIL_BUFFER_BIT                            = $00000040;
+  {$EXTERNALSYM GLX_STENCIL_BUFFER_BIT}
+  GLX_ACCUM_BUFFER_BIT                              = $00000080;
+  {$EXTERNALSYM GLX_ACCUM_BUFFER_BIT}
+  GLX_RENDER_TYPE                                   = $8011;
+  {$EXTERNALSYM GLX_RENDER_TYPE}
+  GLX_X_RENDERABLE                                  = $8012;
+  {$EXTERNALSYM GLX_X_RENDERABLE}
+  GLX_NONE                                          = $8000;
+  {$EXTERNALSYM GLX_NONE}
+  GLX_TRUE_COLOR                                    = $8002;
+  {$EXTERNALSYM GLX_TRUE_COLOR}
+  GLX_DIRECT_COLOR                                  = $8003;
+  {$EXTERNALSYM GLX_DIRECT_COLOR}
+  GLX_PSEUDO_COLOR                                  = $8004;
+  {$EXTERNALSYM GLX_PSEUDO_COLOR}
+  GLX_STATIC_COLOR                                  = $8005;
+  {$EXTERNALSYM GLX_STATIC_COLOR}
+  GLX_GRAY_SCALE                                    = $8006;
+  {$EXTERNALSYM GLX_GRAY_SCALE}
+  GLX_STATIC_GRAY                                   = $8007;
+  {$EXTERNALSYM GLX_STATIC_GRAY}
+  GLX_TRANSPARENT_INDEX                             = $8009;
+  {$EXTERNALSYM GLX_TRANSPARENT_INDEX}
+  GLX_COLOR_INDEX_TYPE                              = $8015;
+  {$EXTERNALSYM GLX_COLOR_INDEX_TYPE}
+  GLX_COLOR_INDEX_BIT                               = $00000002;
+  {$EXTERNALSYM GLX_COLOR_INDEX_BIT}
+  GLX_SCREEN                                        = $800C;
+  {$EXTERNALSYM GLX_SCREEN}
+  GLX_PBUFFER_CLOBBER_MASK                          = $08000000;
+  {$EXTERNALSYM GLX_PBUFFER_CLOBBER_MASK}
+  GLX_DAMAGED                                       = $8020;
+  {$EXTERNALSYM GLX_DAMAGED}
+  GLX_SAVED                                         = $8021;
+  {$EXTERNALSYM GLX_SAVED}
+  GLX_WINDOW                                        = $8022;
+  {$EXTERNALSYM GLX_WINDOW}
+  GLX_PBUFFER                                       = $8023;
+  {$EXTERNALSYM GLX_PBUFFER}
+  GLX_EXT_visual_info                               = 1;
+  {$EXTERNALSYM GLX_EXT_visual_info}
+  GLX_X_VISUAL_TYPE_EXT                             = $22;
+  {$EXTERNALSYM GLX_X_VISUAL_TYPE_EXT}
+  GLX_TRANSPARENT_TYPE_EXT                          = $23;
+  {$EXTERNALSYM GLX_TRANSPARENT_TYPE_EXT}
+  GLX_TRANSPARENT_INDEX_VALUE_EXT                   = $24;
+  {$EXTERNALSYM GLX_TRANSPARENT_INDEX_VALUE_EXT}
+  GLX_TRANSPARENT_RED_VALUE_EXT                     = $25;
+  {$EXTERNALSYM GLX_TRANSPARENT_RED_VALUE_EXT}
+  GLX_TRANSPARENT_GREEN_VALUE_EXT                   = $26;
+  {$EXTERNALSYM GLX_TRANSPARENT_GREEN_VALUE_EXT}
+  GLX_TRANSPARENT_BLUE_VALUE_EXT                    = $27;
+  {$EXTERNALSYM GLX_TRANSPARENT_BLUE_VALUE_EXT}
+  GLX_TRANSPARENT_ALPHA_VALUE_EXT                   = $28;
+  {$EXTERNALSYM GLX_TRANSPARENT_ALPHA_VALUE_EXT}
+  GLX_TRUE_COLOR_EXT                                = $8002;
+  {$EXTERNALSYM GLX_TRUE_COLOR_EXT}
+  GLX_DIRECT_COLOR_EXT                              = $8003;
+  {$EXTERNALSYM GLX_DIRECT_COLOR_EXT}
+  GLX_PSEUDO_COLOR_EXT                              = $8004;
+  {$EXTERNALSYM GLX_PSEUDO_COLOR_EXT}
+  GLX_STATIC_COLOR_EXT                              = $8005;
+  {$EXTERNALSYM GLX_STATIC_COLOR_EXT}
+  GLX_GRAY_SCALE_EXT                                = $8006;
+  {$EXTERNALSYM GLX_GRAY_SCALE_EXT}
+  GLX_STATIC_GRAY_EXT                               = $8007;
+  {$EXTERNALSYM GLX_STATIC_GRAY_EXT}
+  GLX_NONE_EXT                                      = $8000;
+  {$EXTERNALSYM GLX_NONE_EXT}
+  GLX_TRANSPARENT_RGB_EXT                           = $8008;
+  {$EXTERNALSYM GLX_TRANSPARENT_RGB_EXT}
+  GLX_TRANSPARENT_INDEX_EXT                         = $8009;
+  {$EXTERNALSYM GLX_TRANSPARENT_INDEX_EXT}
+  GLX_VISUAL_CAVEAT_EXT                             = $20;
+  {$EXTERNALSYM GLX_VISUAL_CAVEAT_EXT}
+  GLX_SLOW_VISUAL_EXT                               = $8001;
+  {$EXTERNALSYM GLX_SLOW_VISUAL_EXT}
+  GLX_NON_CONFORMANT_VISUAL_EXT                     = $800D;
+  {$EXTERNALSYM GLX_NON_CONFORMANT_VISUAL_EXT}
+  GLX_SHARE_CONTEXT_EXT                             = $800A;
+  {$EXTERNALSYM GLX_SHARE_CONTEXT_EXT}
+  GLX_VISUAL_ID_EXT                                 = $800B;
+  {$EXTERNALSYM GLX_VISUAL_ID_EXT}
+  GLX_SCREEN_EXT                                    = $800C;
+  {$EXTERNALSYM GLX_SCREEN_EXT}
+  GLX_3DFX_WINDOW_MODE_MESA                         = $1;
+  {$EXTERNALSYM GLX_3DFX_WINDOW_MODE_MESA}
+  GLX_3DFX_FULLSCREEN_MODE_MESA                     = $2;
+  {$EXTERNALSYM GLX_3DFX_FULLSCREEN_MODE_MESA}
+
+
+type
+  // GLU types
+  TGLUNurbs = record end; 
+  TGLUQuadric = record end; 
+  TGLUTesselator = record end; 
+
+  PGLUNurbs = ^TGLUNurbs; 
+  PGLUQuadric = ^TGLUQuadric; 
+  PGLUTesselator = ^TGLUTesselator; 
+
+  // backwards compatibility
+  TGLUNurbsObj = TGLUNurbs; 
+  TGLUQuadricObj = TGLUQuadric; 
+  TGLUTesselatorObj = TGLUTesselator;
+  TGLUTriangulatorObj = TGLUTesselator;
+
+  PGLUNurbsObj = PGLUNurbs;
+  PGLUQuadricObj = PGLUQuadric;
+  PGLUTesselatorObj = PGLUTesselator;
+  PGLUTriangulatorObj = PGLUTesselator;
+
+  {$IFDEF FPC}
+    {$IFDEF UNIX}
+    PALETTEENTRY = record
+       peRed : BYTE;
+       peGreen : BYTE;
+       peBlue : BYTE;
+       peFlags : BYTE;
+    end;
+    LPPALETTEENTRY = ^PALETTEENTRY;
+    tagPALETTEENTRY = PALETTEENTRY;
+    TPaletteEntry = PALETTEENTRY;
+    PPALETTEENTRY = ^PALETTEENTRY;
+    xid = txid;
+    pixmap = tpixmap;
+    font = tfont;
+    window = twindow;
+    colormap = tcolormap;
+  {$ENDIF}
+
+  PMaxLogPalette = ^TMaxLogPalette;
+  TMaxLogPalette = packed record
+    palversion : word;
+    palnumentries : word;
+    palpalentry : array[byte] of TPaletteEntry;
+  end;
+
+  {$ifdef WIN32} // If Windows
+  PWGLSwap = ^TWGLSwap;
+  {$EXTERNALSYM _WGLSWAP}
+  _WGLSWAP = packed record
+    hdc: HDC;
+    uiFlags: Cardinal;
+  end;
+  TWGLSwap = _WGLSWAP;
+  {$EXTERNALSYM WGLSWAP}
+  WGLSWAP = _WGLSWAP;
+  {$endif WIN32}
+
+  {$ENDIF}
+
+  {$ifdef VER100} // Delphi 3
+  PWGLSwap = ^TWGLSwap;
+  {$EXTERNALSYM _WGLSWAP}
+  _WGLSWAP = packed record
+    hdc: HDC;
+    uiFlags: Cardinal;
+  end;
+  TWGLSwap = _WGLSWAP;
+  {$EXTERNALSYM WGLSWAP}
+  WGLSWAP = _WGLSWAP;
+  {$endif VER100}
+
+  // Callback function prototypes
+  // GLUQuadricCallback
+  TGLUQuadricErrorProc = procedure(errorCode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+
+  // GLUTessCallback
+  TGLUTessBeginProc = procedure(AType: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessEdgeFlagProc = procedure(Flag: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessVertexProc = procedure(VertexData: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessEndProc = procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessErrorProc = procedure(ErrNo: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessCombineProc = procedure(Coords: TVector3d; VertexData: TVector4p; Weight: TVector4f; OutData: PPointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessBeginDataProc = procedure(AType: TGLEnum; UserData: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessEdgeFlagDataProc = procedure(Flag: TGLboolean; UserData: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessVertexDataProc = procedure(VertexData: Pointer; UserData: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessEndDataProc = procedure(UserData: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessErrorDataProc = procedure(ErrNo: TGLEnum; UserData: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  TGLUTessCombineDataProc = procedure(Coords: TVector3d; VertexData: TVector4p; Weight: TVector4f; OutData: PPointer; UserData: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+
+  // GLUNurbsCallback
+  TGLUNurbsErrorProc = procedure(ErrorCode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+
+var
+  // GL functions and procedures
+  glAccum: procedure(op: TGLuint; value: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glAccum}
+  glAlphaFunc: procedure(func: TGLEnum; ref: TGLclampf); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glAlphaFunc}
+  glAreTexturesResident: function(n: TGLsizei; Textures: PGLuint; residences: PGLboolean): TGLboolean; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glAreTexturesResident}
+  glArrayElement: procedure(i: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glArrayElement}
+  glBegin: procedure(mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBegin}
+  glBindTexture: procedure(target: TGLEnum; texture: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBindTexture}
+  glBitmap: procedure(width: TGLsizei; height: TGLsizei; xorig, yorig: TGLfloat; xmove: TGLfloat; ymove: TGLfloat; bitmap: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBitmap}
+  glBlendFunc: procedure(sfactor: TGLEnum; dfactor: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBlendFunc}
+  glCallList: procedure(list: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCallList}
+  glCallLists: procedure(n: TGLsizei; atype: TGLEnum; lists: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCallLists}
+  glClear: procedure(mask: TGLbitfield); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glClear}
+  glClearAccum: procedure(red, green, blue, alpha: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glClearAccum}
+  glClearColor: procedure(red, green, blue, alpha: TGLclampf); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glClearColor}
+  glClearDepth: procedure(depth: TGLclampd); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glClearDepth}
+  glClearIndex: procedure(c: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glClearIndex}
+  glClearStencil: procedure(s: TGLint ); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glClearStencil}
+  glClipPlane: procedure(plane: TGLEnum; equation: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glClipPlane}
+  glColor3b: procedure(red, green, blue: TGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3b}
+  glColor3bv: procedure(v: PGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3bv}
+  glColor3d: procedure(red, green, blue: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3d}
+  glColor3dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3dv}
+  glColor3f: procedure(red, green, blue: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3f}
+  glColor3fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3fv}
+  glColor3i: procedure(red, green, blue: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3i}
+  glColor3iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3iv}
+  glColor3s: procedure(red, green, blue: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3s}
+  glColor3sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3sv}
+  glColor3ub: procedure(red, green, blue: TGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3ub}
+  glColor3ubv: procedure(v: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3ubv}
+  glColor3ui: procedure(red, green, blue: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3ui}
+  glColor3uiv: procedure(v: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3uiv}
+  glColor3us: procedure(red, green, blue: TGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3us}
+  glColor3usv: procedure(v: PGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3usv}
+  glColor4b: procedure(red, green, blue, alpha: TGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4b}
+  glColor4bv: procedure(v: PGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4bv}
+  glColor4d: procedure(red, green, blue, alpha: TGLdouble ); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4d}
+  glColor4dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4dv}
+  glColor4f: procedure(red, green, blue, alpha: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4f}
+  glColor4fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4fv}
+  glColor4i: procedure(red, green, blue, alpha: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4i}
+  glColor4iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4iv}
+  glColor4s: procedure(red, green, blue, alpha: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4s}
+  glColor4sv: procedure(v: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4sv}
+  glColor4ub: procedure(red, green, blue, alpha: TGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4ub}
+  glColor4ubv: procedure(v: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4ubv}
+  glColor4ui: procedure(red, green, blue, alpha: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4ui}
+  glColor4uiv: procedure(v: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4uiv}
+  glColor4us: procedure(red, green, blue, alpha: TGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4us}
+  glColor4usv: procedure(v: PGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4usv}
+  glColorMask: procedure(red, green, blue, alpha: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorMask}
+  glColorMaterial: procedure(face: TGLEnum; mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorMaterial}
+  glColorPointer: procedure(size: TGLint; atype: TGLEnum; stride: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorPointer}
+  glCopyPixels: procedure(x, y: TGLint; width, height: TGLsizei; atype: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyPixels}
+  glCopyTexImage1D: procedure(target: TGLEnum; level: TGLint; internalFormat: TGLEnum; x, y: TGLint; width: TGLsizei; border: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyTexImage1D}
+  glCopyTexImage2D: procedure(target: TGLEnum; level: TGLint; internalFormat: TGLEnum; x, y: TGLint; width, height: TGLsizei; border: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyTexImage2D}
+  glCopyTexSubImage1D: procedure(target: TGLEnum; level, xoffset, x, y: TGLint; width: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyTexSubImage1D}
+  glCopyTexSubImage2D: procedure(target: TGLEnum; level, xoffset, yoffset, x, y: TGLint; width, height: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyTexSubImage2D}
+  glCullFace: procedure(mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCullFace}
+  glDeleteLists: procedure(list: TGLuint; range: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDeleteLists}
+  glDeleteTextures: procedure(n: TGLsizei; textures: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDeleteTextures}
+  glDepthFunc: procedure(func: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDepthFunc}
+  glDepthMask: procedure(flag: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDepthMask}
+  glDepthRange: procedure(zNear, zFar: TGLclampd); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDepthRange}
+  glDisable: procedure(cap: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDisable}
+  glDisableClientState: procedure(aarray: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDisableClientState}
+  glDrawArrays: procedure(mode: TGLEnum; first: TGLint; count: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDrawArrays}
+  glDrawBuffer: procedure(mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDrawBuffer}
+  glDrawElements: procedure(mode: TGLEnum; count: TGLsizei; atype: TGLEnum; indices: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDrawElements}
+  glDrawPixels: procedure(width, height: TGLsizei; format, atype: TGLEnum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDrawPixels}
+  glEdgeFlag: procedure(flag: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEdgeFlag}
+  glEdgeFlagPointer: procedure(stride: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEdgeFlagPointer}
+  glEdgeFlagv: procedure(flag: PGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEdgeFlagv}
+  glEnable: procedure(cap: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEnable}
+  glEnableClientState: procedure(aarray: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEnableClientState}
+  glEnd: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEnd}
+  glEndList: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEndList}
+  glEvalCoord1d: procedure(u: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalCoord1d}
+  glEvalCoord1dv: procedure(u: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalCoord1dv}
+  glEvalCoord1f: procedure(u: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalCoord1f}
+  glEvalCoord1fv: procedure(u: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalCoord1fv}
+  glEvalCoord2d: procedure(u: TGLdouble; v: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalCoord2d}
+  glEvalCoord2dv: procedure(u: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalCoord2dv}
+  glEvalCoord2f: procedure(u, v: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalCoord2f}
+  glEvalCoord2fv: procedure(u: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalCoord2fv}
+  glEvalMesh1: procedure(mode: TGLEnum; i1, i2: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalMesh1}
+  glEvalMesh2: procedure(mode: TGLEnum; i1, i2, j1, j2: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalMesh2}
+  glEvalPoint1: procedure(i: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalPoint1}
+  glEvalPoint2: procedure(i, j: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEvalPoint2}
+  glFeedbackBuffer: procedure(size: TGLsizei; atype: TGLEnum; buffer: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFeedbackBuffer}
+  glFinish: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFinish}
+  glFlush: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFlush}
+  glFogf: procedure(pname: TGLEnum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogf}
+  glFogfv: procedure(pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogfv}
+  glFogi: procedure(pname: TGLEnum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogi}
+  glFogiv: procedure(pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogiv}
+  glFrontFace: procedure(mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFrontFace}
+  glFrustum: procedure(left, right, bottom, top, zNear, zFar: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFrustum}
+  glGenLists: function(range: TGLsizei): TGLuint; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGenLists}
+  glGenTextures: procedure(n: TGLsizei; textures: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGenTextures}
+  glGetBooleanv: procedure(pname: TGLEnum; params: PGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetBooleanv}
+  glGetClipPlane: procedure(plane: TGLEnum; equation: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetClipPlane}
+  glGetDoublev: procedure(pname: TGLEnum; params: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetDoublev}
+  glGetError: function: TGLuint; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetError}
+  glGetFloatv: procedure(pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetFloatv}
+  glGetIntegerv: procedure(pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetIntegerv}
+  glGetLightfv: procedure(light, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetLightfv}
+  glGetLightiv: procedure(light, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetLightiv}
+  glGetMapdv: procedure(target, query: TGLEnum; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMapdv}
+  glGetMapfv: procedure(target, query: TGLEnum; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMapfv}
+  glGetMapiv: procedure(target, query: TGLEnum; v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMapiv}
+  glGetMaterialfv: procedure(face, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMaterialfv}
+  glGetMaterialiv: procedure(face, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMaterialiv}
+  glGetPixelMapfv: procedure(map: TGLEnum; values: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetPixelMapfv}
+  glGetPixelMapuiv: procedure(map: TGLEnum; values: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetPixelMapuiv}
+  glGetPixelMapusv: procedure(map: TGLEnum; values: PGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetPixelMapusv}
+  glGetPointerv: procedure(pname: TGLEnum; var params); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetPointerv}
+  glGetPolygonStipple: procedure(mask: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetPolygonStipple}
+  glGetString: function(name: TGLEnum): PChar; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetString}
+  glGetTexEnvfv: procedure(target, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexEnvfv}
+  glGetTexEnviv: procedure(target, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexEnviv}
+  glGetTexGendv: procedure(coord, pname: TGLEnum; params: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexGendv}
+  glGetTexGenfv: procedure(coord, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexGenfv}
+  glGetTexGeniv: procedure(coord, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexGeniv}
+  glGetTexImage: procedure(target: TGLEnum; level: TGLint; format, atype: TGLEnum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexImage}
+  glGetTexLevelParameterfv: procedure(target: TGLEnum; level: TGLint; pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexLevelParameterfv}
+  glGetTexLevelParameteriv: procedure(target: TGLEnum; level: TGLint; pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexLevelParameteriv}
+  glGetTexParameterfv: procedure(target, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexParameterfv}
+  glGetTexParameteriv: procedure(target, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexParameteriv}
+  glHint: procedure(target, mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glHint}
+  glIndexMask: procedure(mask: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexMask}
+  glIndexPointer: procedure(atype: TGLEnum; stride: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexPointer}
+  glIndexd: procedure(c: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexd}
+  glIndexdv: procedure(c: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexdv}
+  glIndexf: procedure(c: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexf}
+  glIndexfv: procedure(c: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexfv}
+  glIndexi: procedure(c: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexi}
+  glIndexiv: procedure(c: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexiv}
+  glIndexs: procedure(c: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexs}
+  glIndexsv: procedure(c: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexsv}
+  glIndexub: procedure(c: TGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexub}
+  glIndexubv: procedure(c: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexubv}
+  glInitNames: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glInitNames}
+  glInterleavedArrays: procedure(format: TGLEnum; stride: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glInterleavedArrays}
+  glIsEnabled: function(cap: TGLEnum): TGLboolean; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIsEnabled}
+  glIsList: function(list: TGLuint): TGLboolean; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIsList}
+  glIsTexture: function(texture: TGLuint): TGLboolean; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIsTexture}
+  glLightModelf: procedure(pname: TGLEnum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLightModelf}
+  glLightModelfv: procedure(pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLightModelfv}
+  glLightModeli: procedure(pname: TGLEnum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLightModeli}
+  glLightModeliv: procedure(pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLightModeliv}
+  glLightf: procedure(light, pname: TGLEnum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLightf}
+  glLightfv: procedure(light, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLightfv}
+  glLighti: procedure(light, pname: TGLEnum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLighti}
+  glLightiv: procedure(light, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLightiv}
+  glLineStipple: procedure(factor: TGLint; pattern: TGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLineStipple}
+  glLineWidth: procedure(width: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLineWidth}
+  glListBase: procedure(base: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glListBase}
+  glLoadIdentity: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLoadIdentity}
+  glLoadMatrixd: procedure(m: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLoadMatrixd}
+  glLoadMatrixf: procedure(m: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLoadMatrixf}
+  glLoadName: procedure(name: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLoadName}
+  glLogicOp: procedure(opcode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLogicOp}
+  glMap1d: procedure(target: TGLEnum; u1, u2: TGLdouble; stride, order: TGLint; points: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMap1d}
+  glMap1f: procedure(target: TGLEnum; u1, u2: TGLfloat; stride, order: TGLint; points: PGLfloat);   {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMap1f}
+  glMap2d: procedure(target: TGLEnum; u1, u2: TGLdouble; ustride, uorder: TGLint; v1, v2: TGLdouble; vstride,
+    vorder: TGLint; points: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMap2d}
+  glMap2f: procedure(target: TGLEnum; u1, u2: TGLfloat; ustride, uorder: TGLint; v1, v2: TGLfloat; vstride,
+    vorder: TGLint; points: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMap2f}
+  glMapGrid1d: procedure(un: TGLint; u1, u2: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMapGrid1d}
+  glMapGrid1f: procedure(un: TGLint; u1, u2: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMapGrid1f}
+  glMapGrid2d: procedure(un: TGLint; u1, u2: TGLdouble; vn: TGLint; v1, v2: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMapGrid2d}
+  glMapGrid2f: procedure(un: TGLint; u1, u2: TGLfloat; vn: TGLint; v1, v2: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMapGrid2f}
+  glMaterialf: procedure(face, pname: TGLEnum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMaterialf}
+  glMaterialfv: procedure(face, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMaterialfv}
+  glMateriali: procedure(face, pname: TGLEnum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMateriali}
+  glMaterialiv: procedure(face, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMaterialiv}
+  glMatrixMode: procedure(mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMatrixMode}
+  glMultMatrixd: procedure(m: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultMatrixd}
+  glMultMatrixf: procedure(m: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultMatrixf}
+  glNewList: procedure(list: TGLuint; mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNewList}
+  glNormal3b: procedure(nx, ny, nz: TGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3b}
+  glNormal3bv: procedure(v: PGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3bv}
+  glNormal3d: procedure(nx, ny, nz: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3d}
+  glNormal3dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3dv}
+  glNormal3f: procedure(nx, ny, nz: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3f}
+  glNormal3fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3fv}
+  glNormal3i: procedure(nx, ny, nz: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3i}
+  glNormal3iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3iv}
+  glNormal3s: procedure(nx, ny, nz: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3s}
+  glNormal3sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3sv}
+  glNormalPointer: procedure(atype: TGLEnum; stride: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormalPointer}
+  glOrtho: procedure(left, right, bottom, top, zNear, zFar: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glOrtho}
+  glPassThrough: procedure(token: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPassThrough}
+  glPixelMapfv: procedure(map: TGLEnum; mapsize: TGLsizei; values: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelMapfv}
+  glPixelMapuiv: procedure(map: TGLEnum; mapsize: TGLsizei; values: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelMapuiv}
+  glPixelMapusv: procedure(map: TGLEnum; mapsize: TGLsizei; values: PGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelMapusv}
+  glPixelStoref: procedure(pname: TGLEnum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelStoref}
+  glPixelStorei: procedure(pname: TGLEnum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelStorei}
+  glPixelTransferf: procedure(pname: TGLEnum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTransferf}
+  glPixelTransferi: procedure(pname: TGLEnum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTransferi}
+  glPixelZoom: procedure(xfactor, yfactor: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelZoom}
+  glPointSize: procedure(size: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPointSize}
+  glPolygonMode: procedure(face, mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPolygonMode}
+  glPolygonOffset: procedure(factor, units: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPolygonOffset}
+  glPolygonStipple: procedure(mask: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPolygonStipple}
+  glPopAttrib: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPopAttrib}
+  glPopClientAttrib: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPopClientAttrib}
+  glPopMatrix: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPopMatrix}
+  glPopName: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPopName}
+  glPrioritizeTextures: procedure(n: TGLsizei; textures: PGLuint; priorities: PGLclampf); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPrioritizeTextures}
+  glPushAttrib: procedure(mask: TGLbitfield); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPushAttrib}
+  glPushClientAttrib: procedure(mask: TGLbitfield); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPushClientAttrib}
+  glPushMatrix: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPushMatrix}
+  glPushName: procedure(name: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPushName}
+  glRasterPos2d: procedure(x, y: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos2d}
+  glRasterPos2dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos2dv}
+  glRasterPos2f: procedure(x, y: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos2f}
+  glRasterPos2fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos2fv}
+  glRasterPos2i: procedure(x, y: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos2i}
+  glRasterPos2iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos2iv}
+  glRasterPos2s: procedure(x, y: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos2s}
+  glRasterPos2sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos2sv}
+  glRasterPos3d: procedure(x, y, z: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos3d}
+  glRasterPos3dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos3dv}
+  glRasterPos3f: procedure(x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos3f}
+  glRasterPos3fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos3fv}
+  glRasterPos3i: procedure(x, y, z: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos3i}
+  glRasterPos3iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos3iv}
+  glRasterPos3s: procedure(x, y, z: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos3s}
+  glRasterPos3sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos3sv}
+  glRasterPos4d: procedure(x, y, z, w: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos4d}
+  glRasterPos4dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos4dv}
+  glRasterPos4f: procedure(x, y, z, w: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos4f}
+  glRasterPos4fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos4fv}
+  glRasterPos4i: procedure(x, y, z, w: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos4i}
+  glRasterPos4iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos4iv}
+  glRasterPos4s: procedure(x, y, z, w: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos4s}
+  glRasterPos4sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRasterPos4sv}
+  glReadBuffer: procedure(mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReadBuffer}
+  glReadPixels: procedure(x, y: TGLint; width, height: TGLsizei; format, atype: TGLEnum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReadPixels}
+  glRectd: procedure(x1, y1, x2, y2: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRectd}
+  glRectdv: procedure(v1, v2: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRectdv}
+  glRectf: procedure(x1, y1, x2, y2: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRectf}
+  glRectfv: procedure(v1, v2: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRectfv}
+  glRecti: procedure(x1, y1, x2, y2: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRecti}
+  glRectiv: procedure(v1, v2: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRectiv}
+  glRects: procedure(x1, y1, x2, y2: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRects}
+  glRectsv: procedure(v1, v2: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRectsv}
+  glRenderMode: function(mode: TGLEnum): TGLint; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRenderMode}
+  glRotated: procedure(angle, x, y, z: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRotated}
+  glRotatef: procedure(angle, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRotatef}
+  glScaled: procedure(x, y, z: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glScaled}
+  glScalef: procedure(x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glScalef}
+  glScissor: procedure(x, y: TGLint; width, height: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glScissor}
+  glSelectBuffer: procedure(size: TGLsizei; buffer: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSelectBuffer}
+  glShadeModel: procedure(mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glShadeModel}
+  glStencilFunc: procedure(func: TGLEnum; ref: TGLint; mask: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glStencilFunc}
+  glStencilMask: procedure(mask: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glStencilMask}
+  glStencilOp: procedure(fail, zfail, zpass: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glStencilOp}
+  glTexCoord1d: procedure(s: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord1d}
+  glTexCoord1dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord1dv}
+  glTexCoord1f: procedure(s: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord1f}
+  glTexCoord1fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord1fv}
+  glTexCoord1i: procedure(s: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord1i}
+  glTexCoord1iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord1iv}
+  glTexCoord1s: procedure(s: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord1s}
+  glTexCoord1sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord1sv}
+  glTexCoord2d: procedure(s, t: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2d}
+  glTexCoord2dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2dv}
+  glTexCoord2f: procedure(s, t: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2f}
+  glTexCoord2fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fv}
+  glTexCoord2i: procedure(s, t: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2i}
+  glTexCoord2iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2iv}
+  glTexCoord2s: procedure(s, t: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2s}
+  glTexCoord2sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2sv}
+  glTexCoord3d: procedure(s, t, r: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord3d}
+  glTexCoord3dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord3dv}
+  glTexCoord3f: procedure(s, t, r: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord3f}
+  glTexCoord3fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord3fv}
+  glTexCoord3i: procedure(s, t, r: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord3i}
+  glTexCoord3iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord3iv}
+  glTexCoord3s: procedure(s, t, r: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord3s}
+  glTexCoord3sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord3sv}
+  glTexCoord4d: procedure(s, t, r, q: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4d}
+  glTexCoord4dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4dv}
+  glTexCoord4f: procedure(s, t, r, q: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4f}
+  glTexCoord4fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4fv}
+  glTexCoord4i: procedure(s, t, r, q: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4i}
+  glTexCoord4iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4iv}
+  glTexCoord4s: procedure(s, t, r, q: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4s}
+  glTexCoord4sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4sv}
+  glTexCoordPointer: procedure(size: TGLint; atype: TGLEnum; stride: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoordPointer}
+  glTexEnvf: procedure(target, pname: TGLEnum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexEnvf}
+  glTexEnvfv: procedure(target, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexEnvfv}
+  glTexEnvi: procedure(target, pname: TGLEnum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexEnvi}
+  glTexEnviv: procedure(target, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexEnviv}
+  glTexGend: procedure(coord, pname: TGLEnum; param: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexGend}
+  glTexGendv: procedure(coord, pname: TGLEnum; params: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexGendv}
+  glTexGenf: procedure(coord, pname: TGLEnum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexGenf}
+  glTexGenfv: procedure(coord, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexGenfv}
+  glTexGeni: procedure(coord, pname: TGLEnum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexGeni}
+  glTexGeniv: procedure(coord, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexGeniv}
+  glTexImage1D: procedure(target: TGLEnum; level, internalformat: TGLint; width: TGLsizei; border: TGLint; format,
+    atype: TGLEnum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexImage1D}
+  glTexImage2D: procedure(target: TGLEnum; level, internalformat: TGLint; width, height: TGLsizei; border: TGLint;
+    format, atype: TGLEnum; Pixels:Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexImage2D}
+  glTexParameterf: procedure(target, pname: TGLEnum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexParameterf}
+  glTexParameterfv: procedure(target, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexParameterfv}
+  glTexParameteri: procedure(target, pname: TGLEnum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexParameteri}
+  glTexParameteriv: procedure(target, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexParameteriv}
+  glTexSubImage1D: procedure(target: TGLEnum; level, xoffset: TGLint; width: TGLsizei; format, atype: TGLEnum;
+    pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexSubImage1D}
+  glTexSubImage2D: procedure(target: TGLEnum; level, xoffset, yoffset: TGLint; width, height: TGLsizei; format,
+    atype: TGLEnum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexSubImage2D}
+  glTranslated: procedure(x, y, z: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTranslated}
+  glTranslatef: procedure(x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTranslatef}
+  glVertex2d: procedure(x, y: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex2d}
+  glVertex2dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex2dv}
+  glVertex2f: procedure(x, y: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex2f}
+  glVertex2fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex2fv}
+  glVertex2i: procedure(x, y: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex2i}
+  glVertex2iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex2iv}
+  glVertex2s: procedure(x, y: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex2s}
+  glVertex2sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex2sv}
+  glVertex3d: procedure(x, y, z: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex3d}
+  glVertex3dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex3dv}
+  glVertex3f: procedure(x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex3f}
+  glVertex3fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex3fv}
+  glVertex3i: procedure(x, y, z: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex3i}
+  glVertex3iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex3iv}
+  glVertex3s: procedure(x, y, z: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex3s}
+  glVertex3sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex3sv}
+  glVertex4d: procedure(x, y, z, w: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex4d}
+  glVertex4dv: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex4dv}
+  glVertex4f: procedure(x, y, z, w: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex4f}
+  glVertex4fv: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex4fv}
+  glVertex4i: procedure(x, y, z, w: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex4i}
+  glVertex4iv: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex4iv}
+  glVertex4s: procedure(x, y, z, w: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex4s}
+  glVertex4sv: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertex4sv}
+  glVertexPointer: procedure(size: TGLint; atype: TGLEnum; stride: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexPointer}
+  glViewport: procedure(x, y: TGLint; width, height: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glViewport}
+
+  // GL 1.2
+  glDrawRangeElements: procedure(mode: TGLEnum; Astart, Aend: TGLuint; count: TGLsizei; Atype: TGLEnum;
+    indices: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDrawRangeElements}
+  glTexImage3D: procedure(target: TGLEnum; level: TGLint; internalformat: TGLEnum; width, height, depth: TGLsizei;
+    border: TGLint; format: TGLEnum; Atype: TGLEnum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexImage3D}
+
+  // GL 1.2 ARB imaging
+  glBlendColor: procedure(red, green, blue, alpha: TGLclampf); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBlendColor}
+  glBlendEquation: procedure(mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBlendEquation}
+  glColorSubTable: procedure(target: TGLEnum; start, count: TGLsizei; format, Atype: TGLEnum; data: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorSubTable}
+  glCopyColorSubTable: procedure(target: TGLEnum; start: TGLsizei; x, y: TGLint; width: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyColorSubTable}
+  glColorTable: procedure(target, internalformat: TGLEnum; width: TGLsizei; format, Atype: TGLEnum;
+    table: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorTable}
+  glCopyColorTable: procedure(target, internalformat: TGLEnum; x, y: TGLint; width: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyColorTable}
+  glColorTableParameteriv: procedure(target, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorTableParameteriv}
+  glColorTableParameterfv: procedure(target, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorTableParameterfv}
+  glGetColorTable: procedure(target, format, Atype: TGLEnum; table: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTable}
+  glGetColorTableParameteriv: procedure(target, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTableParameteriv}
+  glGetColorTableParameterfv: procedure(target, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTableParameterfv}
+  glConvolutionFilter1D: procedure(target, internalformat: TGLEnum; width: TGLsizei; format, Atype: TGLEnum;
+    image: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionFilter1D}
+  glConvolutionFilter2D: procedure(target, internalformat: TGLEnum; width, height: TGLsizei; format, Atype: TGLEnum;
+    image: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionFilter2D}
+  glCopyConvolutionFilter1D: procedure(target, internalformat: TGLEnum; x, y: TGLint; width: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyConvolutionFilter1D}
+  glCopyConvolutionFilter2D: procedure(target, internalformat: TGLEnum; x, y: TGLint; width, height: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyConvolutionFilter2D}
+  glGetConvolutionFilter: procedure(target, internalformat, Atype: TGLEnum; image: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetConvolutionFilter}
+  glSeparableFilter2D: procedure(target, internalformat: TGLEnum; width, height: TGLsizei; format, Atype: TGLEnum; row,
+    column: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSeparableFilter2D}
+  glGetSeparableFilter: procedure(target, format, Atype: TGLEnum; row, column, span: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetSeparableFilter}
+  glConvolutionParameteri: procedure(target, pname: TGLEnum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionParameteri}
+  glConvolutionParameteriv: procedure(target, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionParameteriv}
+  glConvolutionParameterf: procedure(target, pname: TGLEnum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionParameterf}
+  glConvolutionParameterfv: procedure(target, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionParameterfv}
+  glGetConvolutionParameteriv: procedure(target, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetConvolutionParameteriv}
+  glGetConvolutionParameterfv: procedure(target, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetConvolutionParameterfv}
+  glHistogram: procedure(target: TGLEnum; width: TGLsizei; internalformat: TGLEnum; sink: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glHistogram}
+  glResetHistogram: procedure(target: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glResetHistogram}
+  glGetHistogram: procedure(target: TGLEnum; reset: TGLboolean; format, Atype: TGLEnum; values: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetHistogram}
+  glGetHistogramParameteriv: procedure(target, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetHistogramParameteriv}
+  glGetHistogramParameterfv: procedure(target, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetHistogramParameterfv}
+  glMinmax: procedure(target, internalformat: TGLEnum; sink: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMinmax}
+  glResetMinmax: procedure(target: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glResetMinmax}
+  glGetMinmax: procedure(target: TGLEnum; reset: TGLboolean; format, Atype: TGLEnum; values: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMinmax}
+  glGetMinmaxParameteriv: procedure(target, pname: TGLEnum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMinmaxParameteriv}
+  glGetMinmaxParameterfv: procedure(target, pname: TGLEnum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMinmaxParameterfv}
+
+  // GL utility functions and procedures
+  gluErrorString: function(errCode: TGLEnum): PChar; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluErrorString}
+  gluGetString: function(name: TGLEnum): PChar; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluGetString}
+  gluOrtho2D: procedure(left, right, bottom, top: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluOrtho2D}
+  gluPerspective: procedure(fovy, aspect, zNear, zFar: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluPerspective}
+  gluPickMatrix: procedure(x, y, width, height: TGLdouble; viewport: TVector4i); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluPickMatrix}
+  gluLookAt: procedure(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluLookAt}
+  gluProject: function(objx, objy, objz: TGLdouble; modelMatrix: TMatrix4d; projMatrix: TMatrix4d; viewport: TVector4i;
+    winx, winy, winz: PGLdouble): TGLint; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluProject}
+  gluUnProject: function(winx, winy, winz: TGLdouble; modelMatrix: TMatrix4d; projMatrix: TMatrix4d; viewport: TVector4i;
+    objx, objy, objz: PGLdouble): TGLint; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluUnProject}
+  gluScaleImage: function(format: TGLEnum; widthin, heightin: TGLint; typein: TGLEnum; datain: Pointer; widthout,
+    heightout: TGLint; typeout: TGLEnum; dataout: Pointer): TGLint; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluScaleImage}
+  gluBuild1DMipmaps: function(target: TGLEnum; components, width: TGLint; format, atype: TGLEnum;
+    data: Pointer): TGLint; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluBuild1DMipmaps}
+  gluBuild2DMipmaps: function(target: TGLEnum; components, width, height: TGLint; format, atype: TGLEnum;
+    Data: Pointer): TGLint; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluBuild2DMipmaps}
+  gluNewQuadric: function: PGLUquadric; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluNewQuadric}
+  gluDeleteQuadric: procedure(state: PGLUquadric); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluDeleteQuadric}
+  gluQuadricNormals: procedure(quadObject: PGLUquadric; normals: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluQuadricNormals}
+  gluQuadricTexture: procedure(quadObject: PGLUquadric; textureCoords: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluQuadricTexture}
+  gluQuadricOrientation: procedure(quadObject: PGLUquadric; orientation: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluQuadricOrientation}
+  gluQuadricDrawStyle: procedure(quadObject: PGLUquadric; drawStyle: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluQuadricDrawStyle}
+  gluCylinder: procedure(quadObject: PGLUquadric; baseRadius, topRadius, height: TGLdouble; slices,
+    stacks: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluCylinder}
+  gluDisk: procedure(quadObject: PGLUquadric; innerRadius, outerRadius: TGLdouble; slices, loops: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluDisk}
+  gluPartialDisk: procedure(quadObject: PGLUquadric; innerRadius, outerRadius: TGLdouble; slices, loops: TGLint;
+    startAngle, sweepAngle: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluPartialDisk}
+  gluSphere: procedure(quadObject: PGLUquadric; radius: TGLdouble; slices, stacks: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluSphere}
+  gluQuadricCallback: procedure(quadObject: PGLUquadric; which: TGLEnum; fn: TGLUQuadricErrorProc); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluQuadricCallback}
+  gluNewTess: function: PGLUtesselator; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluNewTess}
+  gluDeleteTess: procedure(tess: PGLUtesselator); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluDeleteTess}
+  gluTessBeginPolygon: procedure(tess: PGLUtesselator; polygon_data: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluTessBeginPolygon}
+  gluTessBeginContour: procedure(tess: PGLUtesselator); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluTessBeginContour}
+  gluTessVertex: procedure(tess: PGLUtesselator; coords: TVector3d; data: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluTessVertex}
+  gluTessEndContour: procedure(tess: PGLUtesselator); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluTessEndContour}
+  gluTessEndPolygon: procedure(tess: PGLUtesselator); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluTessEndPolygon}
+  gluTessProperty: procedure(tess: PGLUtesselator; which: TGLEnum; value: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluTessProperty}
+  gluTessNormal: procedure(tess: PGLUtesselator; x, y, z: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluTessNormal}
+  gluTessCallback: procedure(tess: PGLUtesselator; which: TGLEnum; fn: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluTessCallback}
+  gluGetTessProperty: procedure(tess: PGLUtesselator; which: TGLEnum; value: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluGetTessProperty}
+  gluNewNurbsRenderer: function: PGLUnurbs; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluNewNurbsRenderer}
+  gluDeleteNurbsRenderer: procedure(nobj: PGLUnurbs); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluDeleteNurbsRenderer}
+  gluBeginSurface: procedure(nobj: PGLUnurbs); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluBeginSurface}
+  gluBeginCurve: procedure(nobj: PGLUnurbs); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluBeginCurve}
+  gluEndCurve: procedure(nobj: PGLUnurbs); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluEndCurve}
+  gluEndSurface: procedure(nobj: PGLUnurbs); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluEndSurface}
+  gluBeginTrim: procedure(nobj: PGLUnurbs); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluBeginTrim}
+  gluEndTrim: procedure(nobj: PGLUnurbs); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluEndTrim}
+  gluPwlCurve: procedure(nobj: PGLUnurbs; count: TGLint; points: PGLfloat; stride: TGLint; atype: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluPwlCurve}
+  gluNurbsCurve: procedure(nobj: PGLUnurbs; nknots: TGLint; knot: PGLfloat; stride: TGLint; ctlarray: PGLfloat; order: TGLint; atype: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluNurbsCurve}
+  gluNurbsSurface: procedure(nobj: PGLUnurbs; sknot_count: TGLint; sknot: PGLfloat; tknot_count: TGLint; tknot: PGLfloat; s_stride, t_stride: TGLint; ctlarray: PGLfloat; sorder, torder: TGLint; atype: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluNurbsSurface}
+  gluLoadSamplingMatrices: procedure(nobj: PGLUnurbs; modelMatrix, projMatrix: TMatrix4f; viewport: TVector4i); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluLoadSamplingMatrices}
+  gluNurbsProperty: procedure(nobj: PGLUnurbs; aproperty: TGLEnum; value: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluNurbsProperty}
+  gluGetNurbsProperty: procedure(nobj: PGLUnurbs; aproperty: TGLEnum; value: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluGetNurbsProperty}
+  gluNurbsCallback: procedure(nobj: PGLUnurbs; which: TGLEnum; fn: TGLUNurbsErrorProc); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluNurbsCallback}
+  gluBeginPolygon: procedure(tess: PGLUtesselator); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluBeginPolygon}
+  gluNextContour: procedure(tess: PGLUtesselator; atype: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluNextContour}
+  gluEndPolygon: procedure(tess: PGLUtesselator); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluEndPolygon}
+
+  // window support functions
+  {$ifdef Win32}
+  wglGetProcAddress: function(ProcName: PChar): Pointer; stdcall;
+  {$EXTERNALSYM wglGetProcAddress}
+  wglCopyContext: function(p1: HGLRC; p2: HGLRC; p3: Cardinal): BOOL; stdcall;
+  {$EXTERNALSYM wglCopyContext}
+  wglCreateContext: function(DC: HDC): HGLRC; stdcall;
+  {$EXTERNALSYM wglCreateContext}
+  wglCreateLayerContext: function(p1: HDC; p2: Integer): HGLRC; stdcall;
+  {$EXTERNALSYM wglCreateLayerContext}
+  wglDeleteContext: function(p1: HGLRC): BOOL; stdcall;
+  {$EXTERNALSYM wglDeleteContext}
+  wglDescribeLayerPlane:function(p1: HDC; p2, p3: Integer; p4: Cardinal; var p5: TLayerPlaneDescriptor): BOOL; stdcall;
+  {$EXTERNALSYM wglDescribeLayerPlane}
+  wglGetCurrentContext: function: HGLRC; stdcall;
+  {$EXTERNALSYM wglGetCurrentContext}
+  wglGetCurrentDC: function: HDC; stdcall;
+  {$EXTERNALSYM wglGetCurrentDC}
+  wglGetLayerPaletteEntries: function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;
+  {$EXTERNALSYM wglGetLayerPaletteEntries}
+  wglMakeCurrent: function(DC: HDC; p2: HGLRC): BOOL; stdcall;
+  {$EXTERNALSYM wglMakeCurrent}
+  wglRealizeLayerPalette: function(p1: HDC; p2: Integer; p3: BOOL): BOOL; stdcall;
+  {$EXTERNALSYM wglRealizeLayerPalette}
+  wglSetLayerPaletteEntries: function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;
+  {$EXTERNALSYM wglSetLayerPaletteEntries}
+  wglShareLists: function(p1, p2: HGLRC): BOOL; stdcall;
+  {$EXTERNALSYM wglShareLists}
+  wglSwapLayerBuffers: function(p1: HDC; p2: Cardinal): BOOL; stdcall;
+  {$EXTERNALSYM wglSwapLayerBuffers}
+  wglSwapMultipleBuffers: function(p1: Cardinal; const p2: PWGLSwap): DWORD; stdcall;
+  {$EXTERNALSYM wglSwapMultipleBuffers}
+  wglUseFontBitmapsA: function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
+  {$EXTERNALSYM wglUseFontBitmapsA}
+  wglUseFontOutlinesA: function (p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
+  {$EXTERNALSYM wglUseFontOutlinesA}
+  wglUseFontBitmapsW: function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
+  {$EXTERNALSYM wglUseFontBitmapsW}
+  wglUseFontOutlinesW: function (p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
+  {$EXTERNALSYM wglUseFontOutlinesW}
+  wglUseFontBitmaps: function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
+  {$EXTERNALSYM wglUseFontBitmaps}
+  wglUseFontOutlines: function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
+  {$EXTERNALSYM wglUseFontOutlines}
+
+  // ARB wgl extensions
+  wglGetExtensionsStringARB: function(DC: HDC): PChar; stdcall;
+  {$EXTERNALSYM wglGetExtensionsStringARB}
+  wglGetPixelFormatAttribivARB: function(DC: HDC; iPixelFormat, iLayerPlane: Integer; nAttributes: Cardinal;
+    const piAttributes: PInteger; piValues : PInteger) : BOOL; stdcall;
+  {$EXTERNALSYM wglGetPixelFormatAttribivARB}
+  wglGetPixelFormatAttribfvARB: function(DC: HDC; iPixelFormat, iLayerPlane: Integer; nAttributes: Cardinal;
+    const piAttributes: PInteger; piValues: PGLFloat) : BOOL; stdcall;
+  {$EXTERNALSYM wglGetPixelFormatAttribfvARB}
+  wglChoosePixelFormatARB: function(DC: HDC; const piAttribIList: PInteger; const pfAttribFList: PGLFloat;
+    nMaxFormats: Cardinal; piFormats: PInteger; nNumFormats: PCardinal) : BOOL; stdcall;
+  {$EXTERNALSYM wglChoosePixelFormatARB}
+  {$endif}
+
+  // ARB_multitexture
+  glMultiTexCoord1dARB: procedure(target: TGLenum; s: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord1dARB}
+  glMultiTexCoord1dVARB: procedure(target: TGLenum; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord1dVARB}
+  glMultiTexCoord1fARBP: procedure(target: TGLenum; s: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord1fARBP}
+  glMultiTexCoord1fVARB: procedure(target: TGLenum; v: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord1fVARB}
+  glMultiTexCoord1iARB: procedure(target: TGLenum; s: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord1iARB}
+  glMultiTexCoord1iVARB: procedure(target: TGLenum; v: PGLInt); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord1iVARB}
+  glMultiTexCoord1sARBP: procedure(target: TGLenum; s: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord1sARBP}
+  glMultiTexCoord1sVARB: procedure(target: TGLenum; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord1sVARB}
+  glMultiTexCoord2dARB: procedure(target: TGLenum; s, t: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord2dARB}
+  glMultiTexCoord2dvARB: procedure(target: TGLenum; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord2dvARB}
+  glMultiTexCoord2fARB: procedure(target: TGLenum; s, t: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord2fARB}
+  glMultiTexCoord2fvARB: procedure(target: TGLenum; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord2fvARB}
+  glMultiTexCoord2iARB: procedure(target: TGLenum; s, t: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord2iARB}
+  glMultiTexCoord2ivARB: procedure(target: TGLenum; v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord2ivARB}
+  glMultiTexCoord2sARB: procedure(target: TGLenum; s, t: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord2sARB}
+  glMultiTexCoord2svARB: procedure(target: TGLenum; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord2svARB}
+  glMultiTexCoord3dARB: procedure(target: TGLenum; s, t, r: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord3dARB}
+  glMultiTexCoord3dvARB: procedure(target: TGLenum; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord3dvARB}
+  glMultiTexCoord3fARB: procedure(target: TGLenum; s, t, r: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord3fARB}
+  glMultiTexCoord3fvARB: procedure(target: TGLenum; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord3fvARB}
+  glMultiTexCoord3iARB: procedure(target: TGLenum; s, t, r: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord3iARB}
+  glMultiTexCoord3ivARB: procedure(target: TGLenum; v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord3ivARB}
+  glMultiTexCoord3sARB: procedure(target: TGLenum; s, t, r: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord3sARB}
+  glMultiTexCoord3svARB: procedure(target: TGLenum; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord3svARB}
+  glMultiTexCoord4dARB: procedure(target: TGLenum; s, t, r, q: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord4dARB}
+  glMultiTexCoord4dvARB: procedure(target: TGLenum; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord4dvARB}
+  glMultiTexCoord4fARB: procedure(target: TGLenum; s, t, r, q: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord4fARB}
+  glMultiTexCoord4fvARB: procedure(target: TGLenum; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord4fvARB}
+  glMultiTexCoord4iARB: procedure(target: TGLenum; s, t, r, q: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord4iARB}
+  glMultiTexCoord4ivARB: procedure(target: TGLenum; v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord4ivARB}
+  glMultiTexCoord4sARB: procedure(target: TGLenum; s, t, r, q: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord4sARB}
+  glMultiTexCoord4svARB: procedure(target: TGLenum; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiTexCoord4svARB}
+  glActiveTextureARB: procedure(target: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glActiveTextureARB}
+  glClientActiveTextureARB: procedure(target: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glClientActiveTextureARB}
+
+  // GLU extensions
+  gluNurbsCallbackDataEXT: procedure(nurb: PGLUnurbs; userData: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluNurbsCallbackDataEXT}
+  gluNewNurbsTessellatorEXT: function: PGLUnurbs; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluNewNurbsTessellatorEXT}
+  gluDeleteNurbsTessellatorEXT: procedure(nurb: PGLUnurbs); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM gluDeleteNurbsTessellatorEXT}
+
+{$ifndef FPC} 
+  {$ifdef MULTITHREADOPENGL}
+  threadvar
+  {$else}
+  var
+  {$endif}
+{$else}
+var 
+{$endif} 
+  // Extension functions
+  glAreTexturesResidentEXT: function(n: TGLsizei; textures: PGLuint; residences: PGLBoolean): TGLboolean; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glAreTexturesResidentEXT}
+  glArrayElementArrayEXT: procedure(mode: TGLEnum; count: TGLsizei; pi: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glArrayElementArrayEXT}
+  glBeginSceneEXT: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBeginSceneEXT}
+  glBindTextureEXT: procedure(target: TGLEnum; texture: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBindTextureEXT}
+  glColorTableEXT: procedure(target, internalFormat: TGLEnum; width: TGLsizei; format, atype: TGLEnum; data: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorTableEXT}
+  glColorSubTableExt: procedure(target: TGLEnum; start, count: TGLsizei; format, atype: TGLEnum; data: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorSubTableExt}
+  glCopyTexImage1DEXT: procedure(target: TGLEnum; level: TGLint; internalFormat: TGLEnum; x, y: TGLint; width: TGLsizei; border: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyTexImage1DEXT}
+  glCopyTexSubImage1DEXT: procedure(target: TGLEnum; level, xoffset, x, y: TGLint; width: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyTexSubImage1DEXT}
+  glCopyTexImage2DEXT: procedure(target: TGLEnum; level: TGLint; internalFormat: TGLEnum; x, y: TGLint; width, height: TGLsizei; border: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyTexImage2DEXT}
+  glCopyTexSubImage2DEXT: procedure(target: TGLEnum; level, xoffset, yoffset, x, y: TGLint; width, height: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyTexSubImage2DEXT}
+  glCopyTexSubImage3DEXT: procedure(target: TGLEnum; level, xoffset, yoffset, zoffset, x, y: TGLint; width, height: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyTexSubImage3DEXT}
+  glDeleteTexturesEXT: procedure(n: TGLsizei; textures: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDeleteTexturesEXT}
+  glEndSceneEXT: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEndSceneEXT}
+  glGenTexturesEXT: procedure(n: TGLsizei; textures: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGenTexturesEXT}
+  glGetColorTableEXT: procedure(target, format, atype: TGLEnum; data: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTableEXT}
+  glGetColorTablePameterfvEXT: procedure(target, pname: TGLEnum; params: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTablePameterfvEXT}
+  glGetColorTablePameterivEXT: procedure(target, pname: TGLEnum; params: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTablePameterivEXT}
+  glIndexFuncEXT: procedure(func: TGLEnum; ref: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexFuncEXT}
+  glIndexMaterialEXT: procedure(face: TGLEnum; mode: TGLEnum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexMaterialEXT}
+  glIsTextureEXT: function(texture: TGLuint): TGLboolean; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIsTextureEXT}
+  glLockArraysEXT: procedure(first: TGLint; count: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLockArraysEXT}
+  glPolygonOffsetEXT: procedure(factor, bias: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPolygonOffsetEXT}
+  glPrioritizeTexturesEXT: procedure(n: TGLsizei; textures: PGLuint; priorities: PGLclampf); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPrioritizeTexturesEXT}
+  glTexSubImage1DEXT: procedure(target: TGLEnum; level, xoffset: TGLint; width: TGLsizei; format, Atype: TGLEnum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexSubImage1DEXT}
+  glTexSubImage2DEXT: procedure(target: TGLEnum; level, xoffset, yoffset: TGLint; width, height: TGLsizei; format, Atype: TGLEnum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexSubImage2DEXT}
+  glTexSubImage3DEXT: procedure(target: TGLEnum; level, xoffset, yoffset, zoffset: TGLint; width, height, depth: TGLsizei; format, Atype: TGLEnum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexSubImage3DEXT}
+  glUnlockArraysEXT: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glUnlockArraysEXT}
+
+  // EXT_vertex_array
+  glArrayElementEXT: procedure(I: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glArrayElementEXT}
+  glColorPointerEXT: procedure(size: TGLInt; atype: TGLenum; stride, count: TGLsizei; data: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorPointerEXT}
+  glDrawArraysEXT: procedure(mode: TGLenum; first: TGLInt; count: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDrawArraysEXT}
+  glEdgeFlagPointerEXT: procedure(stride, count: TGLsizei; data: PGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEdgeFlagPointerEXT}
+  glGetPointervEXT: procedure(pname: TGLEnum; var params); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetPointervEXT}
+  glIndexPointerEXT: procedure(AType: TGLEnum; stride, count: TGLsizei; P: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexPointerEXT}
+  glNormalPointerEXT: procedure(AType: TGLsizei; stride, count: TGLsizei; P: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormalPointerEXT}
+  glTexCoordPointerEXT: procedure(size: TGLint; AType: TGLenum;  stride, count: TGLsizei; P: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoordPointerEXT}
+  glVertexPointerEXT: procedure(size: TGLint; AType: TGLenum; stride, count: TGLsizei; P: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexPointerEXT}
+
+  // EXT_compiled_vertex_array
+  glLockArrayEXT: procedure(first: TGLint; count: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLockArrayEXT}
+  glUnlockArrayEXT: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glUnlockArrayEXT}
+
+  // EXT_cull_vertex
+  glCullParameterdvEXT: procedure(pname: TGLenum; params: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCullParameterdvEXT}
+  glCullParameterfvEXT: procedure(pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCullParameterfvEXT}
+
+  // WIN_swap_hint
+  glAddSwapHintRectWIN: procedure(x, y: TGLint; width, height: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glAddSwapHintRectWIN}
+
+  // EXT_point_parameter
+  glPointParameterfEXT: procedure(pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPointParameterfEXT}
+  glPointParameterfvEXT: procedure(pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPointParameterfvEXT}
+
+  // GL_ARB_transpose_matrix
+  glLoadTransposeMatrixfARB: procedure(m: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLoadTransposeMatrixfARB}
+  glLoadTransposeMatrixdARB: procedure(m: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLoadTransposeMatrixdARB}
+  glMultTransposeMatrixfARB: procedure(m: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultTransposeMatrixfARB}
+  glMultTransposeMatrixdARB: procedure(m: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultTransposeMatrixdARB}
+
+  // GL_ARB_multisample
+  glSampleCoverageARB: procedure(Value: TGLclampf; invert: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSampleCoverageARB}
+  glSamplePassARB: procedure(pass: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSamplePassARB}
+
+  // GL_ARB_texture_compression
+  glCompressedTexImage3DARB: procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; Width, Height, depth: TGLsizei; border: TGLint; imageSize: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCompressedTexImage3DARB}
+  glCompressedTexImage2DARB: procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; Width, Height: TGLsizei; border: TGLint; imageSize: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCompressedTexImage2DARB}
+  glCompressedTexImage1DARB: procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; Width: TGLsizei; border: TGLint; imageSize: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCompressedTexImage1DARB}
+  glCompressedTexSubImage3DARB: procedure(target: TGLenum; level: TGLint; xoffset, yoffset, zoffset: TGLint; width, height, depth: TGLsizei; Format: TGLenum; imageSize: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCompressedTexSubImage3DARB}
+  glCompressedTexSubImage2DARB: procedure(target: TGLenum; level: TGLint; xoffset, yoffset: TGLint; width, height: TGLsizei; Format: TGLenum; imageSize: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCompressedTexSubImage2DARB}
+  glCompressedTexSubImage1DARB: procedure(target: TGLenum; level: TGLint; xoffset: TGLint; width: TGLsizei; Format: TGLenum; imageSize: TGLsizei; data: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCompressedTexSubImage1DARB}
+  glGetCompressedTexImageARB: procedure(target: TGLenum; level: TGLint; img: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetCompressedTexImageARB}
+
+  // GL_EXT_blend_color
+  glBlendColorEXT: procedure(red, green, blue: TGLclampf; alpha: TGLclampf); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBlendColorEXT}
+
+  // GL_EXT_texture3D
+  glTexImage3DEXT: procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; width, height, depth: TGLsizei; border: TGLint; Format, AType: TGLenum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexImage3DEXT}
+
+  // GL_SGIS_texture_filter4
+  glGetTexFilterFuncSGIS: procedure(target, Filter: TGLenum; weights: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTexFilterFuncSGIS}
+  glTexFilterFuncSGIS: procedure(target, Filter: TGLenum; n: TGLsizei; weights: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexFilterFuncSGIS}
+
+  // GL_EXT_histogram
+  glGetHistogramEXT: procedure(target: TGLenum; reset: TGLboolean; Format, AType: TGLenum; values: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetHistogramEXT}
+  glGetHistogramParameterfvEXT: procedure(target, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetHistogramParameterfvEXT}
+  glGetHistogramParameterivEXT: procedure(target, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetHistogramParameterivEXT}
+  glGetMinmaxEXT: procedure(target: TGLenum; reset: TGLboolean; Format, AType: TGLenum; values: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMinmaxEXT}
+  glGetMinmaxParameterfvEXT: procedure(target, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMinmaxParameterfvEXT}
+  glGetMinmaxParameterivEXT: procedure(target, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetMinmaxParameterivEXT}
+  glHistogramEXT: procedure(target: TGLenum; Width: TGLsizei; internalformat: TGLenum; sink: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glHistogramEXT}
+  glMinmaxEXT: procedure(target, internalformat: TGLenum; sink: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMinmaxEXT}
+  glResetHistogramEXT: procedure(target: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glResetHistogramEXT}
+  glResetMinmaxEXT: procedure(target: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glResetMinmaxEXT}
+
+  // GL_EXT_convolution
+  glConvolutionFilter1DEXT: procedure(target, internalformat: TGLenum; Width: TGLsizei; Format, AType: TGLenum; image: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionFilter1DEXT}
+  glConvolutionFilter2DEXT: procedure(target, internalformat: TGLenum; Width, Height: TGLsizei; Format, AType: TGLenum; image: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionFilter2DEXT}
+  glConvolutionParameterfEXT: procedure(target, pname: TGLenum; params: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionParameterfEXT}
+  glConvolutionParameterfvEXT: procedure(target, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionParameterfvEXT}
+  glConvolutionParameteriEXT: procedure(target, pname: TGLenum; params: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionParameteriEXT}
+  glConvolutionParameterivEXT: procedure(target, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glConvolutionParameterivEXT}
+  glCopyConvolutionFilter1DEXT: procedure(target, internalformat: TGLenum; x, y: TGLint; Width: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyConvolutionFilter1DEXT}
+  glCopyConvolutionFilter2DEXT: procedure(target, internalformat: TGLenum; x, y: TGLint; Width, Height: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyConvolutionFilter2DEXT}
+  glGetConvolutionFilterEXT: procedure(target, Format, AType: TGLenum; image: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetConvolutionFilterEXT}
+  glGetConvolutionParameterfvEXT: procedure(target, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetConvolutionParameterfvEXT}
+  glGetConvolutionParameterivEXT: procedure(target, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetConvolutionParameterivEXT}
+  glGetSeparableFilterEXT: procedure(target, Format, AType: TGLenum; row, column, span: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetSeparableFilterEXT}
+  glSeparableFilter2DEXT: procedure(target, internalformat: TGLenum; Width, Height: TGLsizei; Format, AType: TGLenum; row, column: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSeparableFilter2DEXT}
+
+  // GL_SGI_color_table
+  glColorTableSGI: procedure(target, internalformat: TGLenum; Width: TGLsizei; Format, AType: TGLenum; Table: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorTableSGI}
+  glColorTableParameterfvSGI: procedure(target, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorTableParameterfvSGI}
+  glColorTableParameterivSGI: procedure(target, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorTableParameterivSGI}
+  glCopyColorTableSGI: procedure(target, internalformat: TGLenum; x, y: TGLint; Width: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyColorTableSGI}
+  glGetColorTableSGI: procedure(target, Format, AType: TGLenum; Table: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTableSGI}
+  glGetColorTableParameterfvSGI: procedure(target, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTableParameterfvSGI}
+  glGetColorTableParameterivSGI: procedure(target, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTableParameterivSGI}
+
+  // GL_SGIX_pixel_texture
+  glPixelTexGenSGIX: procedure(mode: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTexGenSGIX}
+
+  // GL_SGIS_pixel_texture
+  glPixelTexGenParameteriSGIS: procedure(pname: TGLenum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTexGenParameteriSGIS}
+  glPixelTexGenParameterivSGIS: procedure(pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTexGenParameterivSGIS}
+  glPixelTexGenParameterfSGIS: procedure(pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTexGenParameterfSGIS}
+  glPixelTexGenParameterfvSGIS: procedure(pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTexGenParameterfvSGIS}
+  glGetPixelTexGenParameterivSGIS: procedure(pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetPixelTexGenParameterivSGIS}
+  glGetPixelTexGenParameterfvSGIS: procedure(pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetPixelTexGenParameterfvSGIS}
+
+  // GL_SGIS_texture4D
+  glTexImage4DSGIS: procedure(target: TGLenum; level: TGLint; internalformat: TGLenum; Width, Height, depth, size4d: TGLsizei; border: TGLint; Format, AType: TGLenum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexImage4DSGIS}
+  glTexSubImage4DSGIS: procedure(target: TGLenum; level, xoffset, yoffset, zoffset, woffset: TGLint; Width, Height, depth, size4d: TGLsizei; Format, AType: TGLenum; pixels: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexSubImage4DSGIS}
+
+  // GL_SGIS_detail_texture
+  glDetailTexFuncSGIS: procedure(target: TGLenum; n: TGLsizei; points: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDetailTexFuncSGIS}
+  glGetDetailTexFuncSGIS: procedure(target: TGLenum; points: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetDetailTexFuncSGIS}
+
+  // GL_SGIS_sharpen_texture
+  glSharpenTexFuncSGIS: procedure(target: TGLenum; n: TGLsizei; points: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSharpenTexFuncSGIS}
+  glGetSharpenTexFuncSGIS: procedure(target: TGLenum; points: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetSharpenTexFuncSGIS}
+
+  // GL_SGIS_multisample
+  glSampleMaskSGIS: procedure(Value: TGLclampf; invert: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSampleMaskSGIS}
+  glSamplePatternSGIS: procedure(pattern: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSamplePatternSGIS}
+
+  // GL_EXT_blend_minmax
+  glBlendEquationEXT: procedure(mode: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBlendEquationEXT}
+
+  // GL_SGIX_sprite
+  glSpriteParameterfSGIX: procedure(pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSpriteParameterfSGIX}
+  glSpriteParameterfvSGIX: procedure(pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSpriteParameterfvSGIX}
+  glSpriteParameteriSGIX: procedure(pname: TGLenum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSpriteParameteriSGIX}
+  glSpriteParameterivSGIX: procedure(pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSpriteParameterivSGIX}
+
+  // GL_EXT_point_parameters
+  glPointParameterfSGIS: procedure(pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPointParameterfSGIS}
+  glPointParameterfvSGIS: procedure(pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPointParameterfvSGIS}
+
+  // GL_SGIX_instruments
+  glGetInstrumentsSGIX: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetInstrumentsSGIX}
+  glInstrumentsBufferSGIX: procedure(Size: TGLsizei; buffer: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glInstrumentsBufferSGIX}
+  glPollInstrumentsSGIX: procedure(marker_p: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPollInstrumentsSGIX}
+  glReadInstrumentsSGIX: procedure(marker: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReadInstrumentsSGIX}
+  glStartInstrumentsSGIX: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glStartInstrumentsSGIX}
+  glStopInstrumentsSGIX: procedure(marker: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glStopInstrumentsSGIX}
+
+  // GL_SGIX_framezoom
+  glFrameZoomSGIX: procedure(factor: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFrameZoomSGIX}
+
+  // GL_SGIX_tag_sample_buffer
+  glTagSampleBufferSGIX: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTagSampleBufferSGIX}
+
+  // GL_SGIX_polynomial_ffd
+  glDeformationMap3dSGIX: procedure(target: TGLenum; u1, u2: TGLdouble; ustride, uorder: TGLint; v1, v2: TGLdouble; vstride, vorder: TGLint; w1, w2: TGLdouble; wstride, worder: TGLint; points: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDeformationMap3dSGIX}
+  glDeformationMap3fSGIX: procedure(target: TGLenum; u1, u2: TGLfloat; ustride, uorder: TGLint; v1, v2: TGLfloat; vstride, vorder: TGLint; w1, w2: TGLfloat; wstride, worder: TGLint; points: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDeformationMap3fSGIX}
+  glDeformSGIX: procedure(mask: TGLbitfield); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDeformSGIX}
+  glLoadIdentityDeformationMapSGIX: procedure(mask: TGLbitfield); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLoadIdentityDeformationMapSGIX}
+
+  // GL_SGIX_reference_plane
+  glReferencePlaneSGIX: procedure(equation: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReferencePlaneSGIX}
+
+  // GL_SGIX_flush_raster
+  glFlushRasterSGIX: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFlushRasterSGIX}
+
+  // GL_SGIS_fog_function
+  glFogFuncSGIS: procedure(n: TGLsizei; points: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogFuncSGIS}
+  glGetFogFuncSGIS: procedure(points: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetFogFuncSGIS}
+
+  // GL_HP_image_transform
+  glImageTransformParameteriHP: procedure(target, pname: TGLenum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glImageTransformParameteriHP}
+  glImageTransformParameterfHP: procedure(target, pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glImageTransformParameterfHP}
+  glImageTransformParameterivHP: procedure(target, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glImageTransformParameterivHP}
+  glImageTransformParameterfvHP: procedure(target, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glImageTransformParameterfvHP}
+  glGetImageTransformParameterivHP: procedure(target, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetImageTransformParameterivHP}
+  glGetImageTransformParameterfvHP: procedure(target, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetImageTransformParameterfvHP}
+
+  // GL_EXT_color_subtable
+  glCopyColorSubTableEXT: procedure(target: TGLenum; start: TGLsizei; x, y: TGLint; Width: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCopyColorSubTableEXT}
+
+  // GL_PGI_misc_hints
+  glHintPGI: procedure(target: TGLenum; mode: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glHintPGI}
+
+  // GL_EXT_paletted_texture
+  glGetColorTableParameterivEXT: procedure(target, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTableParameterivEXT}
+  glGetColorTableParameterfvEXT: procedure(target, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetColorTableParameterfvEXT}
+
+  // GL_SGIX_list_priority
+  glGetListParameterfvSGIX: procedure(list: TGLuint; pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetListParameterfvSGIX}
+  glGetListParameterivSGIX: procedure(list: TGLuint; pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetListParameterivSGIX}
+  glListParameterfSGIX: procedure(list: TGLuint; pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glListParameterfSGIX}
+  glListParameterfvSGIX: procedure(list: TGLuint; pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glListParameterfvSGIX}
+  glListParameteriSGIX: procedure(list: TGLuint; pname: TGLenum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glListParameteriSGIX}
+  glListParameterivSGIX: procedure(list: TGLuint; pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glListParameterivSGIX}
+
+  // GL_SGIX_fragment_lighting
+  glFragmentColorMaterialSGIX: procedure(face, mode: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentColorMaterialSGIX}
+  glFragmentLightfSGIX: procedure(light, pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentLightfSGIX}
+  glFragmentLightfvSGIX: procedure(light, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentLightfvSGIX}
+  glFragmentLightiSGIX: procedure(light, pname: TGLenum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentLightiSGIX}
+  glFragmentLightivSGIX: procedure(light, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentLightivSGIX}
+  glFragmentLightModelfSGIX: procedure(pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentLightModelfSGIX}
+  glFragmentLightModelfvSGIX: procedure(pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentLightModelfvSGIX}
+  glFragmentLightModeliSGIX: procedure(pname: TGLenum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentLightModeliSGIX}
+  glFragmentLightModelivSGIX: procedure(pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentLightModelivSGIX}
+  glFragmentMaterialfSGIX: procedure(face, pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentMaterialfSGIX}
+  glFragmentMaterialfvSGIX: procedure(face, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentMaterialfvSGIX}
+  glFragmentMaterialiSGIX: procedure(face, pname: TGLenum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentMaterialiSGIX}
+  glFragmentMaterialivSGIX: procedure(face, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFragmentMaterialivSGIX}
+  glGetFragmentLightfvSGIX: procedure(light, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetFragmentLightfvSGIX}
+  glGetFragmentLightivSGIX: procedure(light, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetFragmentLightivSGIX}
+  glGetFragmentMaterialfvSGIX: procedure(face, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetFragmentMaterialfvSGIX}
+  glGetFragmentMaterialivSGIX: procedure(face, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetFragmentMaterialivSGIX}
+  glLightEnviSGIX: procedure(pname: TGLenum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLightEnviSGIX}
+
+  // GL_EXT_draw_range_elements
+  glDrawRangeElementsEXT: procedure(mode: TGLenum; start, Aend: TGLuint; Count: TGLsizei; Atype: TGLenum; indices: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDrawRangeElementsEXT}
+
+  // GL_EXT_light_texture
+  glApplyTextureEXT: procedure(mode: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glApplyTextureEXT}
+  glTextureLightEXT: procedure(pname: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTextureLightEXT}
+  glTextureMaterialEXT: procedure(face, mode: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTextureMaterialEXT}
+
+  // GL_SGIX_async
+  glAsyncMarkerSGIX: procedure(marker: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glAsyncMarkerSGIX}
+  glFinishAsyncSGIX: procedure(markerp: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFinishAsyncSGIX}
+  glPollAsyncSGIX: procedure(markerp: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPollAsyncSGIX}
+  glGenAsyncMarkersSGIX: procedure(range: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGenAsyncMarkersSGIX}
+  glDeleteAsyncMarkersSGIX: procedure(marker: TGLuint; range: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDeleteAsyncMarkersSGIX}
+  glIsAsyncMarkerSGIX: procedure(marker: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIsAsyncMarkerSGIX}
+
+  // GL_INTEL_parallel_arrays
+  glVertexPointervINTEL: procedure(size: TGLint; Atype: TGLenum; var P); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexPointervINTEL}
+  glNormalPointervINTEL: procedure(Atype: TGLenum; var P); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormalPointervINTEL}
+  glColorPointervINTEL: procedure(size: TGLint; Atype: TGLenum; var P); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorPointervINTEL}
+  glTexCoordPointervINTEL: procedure(size: TGLint; Atype: TGLenum; var P); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoordPointervINTEL}
+
+  // GL_EXT_pixel_transform
+  glPixelTransformParameteriEXT: procedure(target, pname: TGLenum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTransformParameteriEXT}
+  glPixelTransformParameterfEXT: procedure(target, pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTransformParameterfEXT}
+  glPixelTransformParameterivEXT: procedure(target, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTransformParameterivEXT}
+  glPixelTransformParameterfvEXT: procedure(target, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glPixelTransformParameterfvEXT}
+
+  // GL_EXT_secondary_color
+  glSecondaryColor3bEXT: procedure(red, green, blue: TGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3bEXT}
+  glSecondaryColor3bvEXT: procedure(v: PGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3bvEXT}
+  glSecondaryColor3dEXT: procedure(red, green, blue: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3dEXT}
+  glSecondaryColor3dvEXT: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3dvEXT}
+  glSecondaryColor3fEXT: procedure(red, green, blue: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3fEXT}
+  glSecondaryColor3fvEXT: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3fvEXT}
+  glSecondaryColor3iEXT: procedure(red, green, blue: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3iEXT}
+  glSecondaryColor3ivEXT: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3ivEXT}
+
+  glSecondaryColor3sEXT: procedure(red, green, blue: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3sEXT}
+  glSecondaryColor3svEXT: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3svEXT}
+  glSecondaryColor3ubEXT: procedure(red, green, blue: TGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3ubEXT}
+  glSecondaryColor3ubvEXT: procedure(v: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3ubvEXT}
+  glSecondaryColor3uiEXT: procedure(red, green, blue: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3uiEXT}
+  glSecondaryColor3uivEXT: procedure(v: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3uivEXT}
+  glSecondaryColor3usEXT: procedure(red, green, blue: TGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3usEXT}
+  glSecondaryColor3usvEXT: procedure(v: PGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColor3usvEXT}
+  glSecondaryColorPointerEXT: procedure(Size: TGLint; Atype: TGLenum; stride: TGLsizei; p: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColorPointerEXT}
+
+  // GL_EXT_texture_perturb_normal
+  glTextureNormalEXT: procedure(mode: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTextureNormalEXT}
+
+  // GL_EXT_multi_draw_arrays
+  glMultiDrawArraysEXT: procedure(mode: TGLenum; First: PGLint; Count: PGLsizei; primcount: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiDrawArraysEXT}
+  glMultiDrawElementsEXT: procedure(mode: TGLenum; Count: PGLsizei; AType: TGLenum; var indices; primcount: TGLsizei); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiDrawElementsEXT}
+
+  // GL_EXT_fog_coord
+  glFogCoordfEXT: procedure(coord: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogCoordfEXT}
+  glFogCoordfvEXT: procedure(coord: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogCoordfvEXT}
+  glFogCoorddEXT: procedure(coord: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogCoorddEXT}
+  glFogCoorddvEXT: procedure(coord: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogCoorddvEXT}
+  glFogCoordPointerEXT: procedure(AType: TGLenum; stride: TGLsizei; p: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogCoordPointerEXT}
+
+  // GL_EXT_coordinate_frame
+  glTangent3bEXT: procedure(tx, ty, tz: TGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangent3bEXT}
+  glTangent3bvEXT: procedure(v: PGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangent3bvEXT}
+  glTangent3dEXT: procedure(tx, ty, tz: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangent3dEXT}
+  glTangent3dvEXT: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangent3dvEXT}
+  glTangent3fEXT: procedure(tx, ty, tz: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangent3fEXT}
+  glTangent3fvEXT: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangent3fvEXT}
+  glTangent3iEXT: procedure(tx, ty, tz: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangent3iEXT}
+  glTangent3ivEXT: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangent3ivEXT}
+  glTangent3sEXT: procedure(tx, ty, tz: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangent3sEXT}
+  glTangent3svEXT: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangent3svEXT}
+
+  glBinormal3bEXT: procedure(bx, by, bz: TGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormal3bEXT}
+  glBinormal3bvEXT: procedure(v: PGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormal3bvEXT}
+  glBinormal3dEXT: procedure(bx, by, bz: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormal3dEXT}
+  glBinormal3dvEXT: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormal3dvEXT}
+  glBinormal3fEXT: procedure(bx, by, bz: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormal3fEXT}
+  glBinormal3fvEXT: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormal3fvEXT}
+  glBinormal3iEXT: procedure(bx, by, bz: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormal3iEXT}
+  glBinormal3ivEXT: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormal3ivEXT}
+  glBinormal3sEXT: procedure(bx, by, bz: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormal3sEXT}
+  glBinormal3svEXT: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormal3svEXT}
+  glTangentPointerEXT: procedure(Atype: TGLenum; stride: TGLsizei; p: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTangentPointerEXT}
+  glBinormalPointerEXT: procedure(Atype: TGLenum; stride: TGLsizei; p: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBinormalPointerEXT}
+
+  // GL_SUNX_constant_data
+  glFinishTextureSUNX: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFinishTextureSUNX}
+
+  // GL_SUN_global_alpha
+  glGlobalAlphaFactorbSUN: procedure(factor: TGLbyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGlobalAlphaFactorbSUN}
+  glGlobalAlphaFactorsSUN: procedure(factor: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGlobalAlphaFactorsSUN}
+  glGlobalAlphaFactoriSUN: procedure(factor: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGlobalAlphaFactoriSUN}
+  glGlobalAlphaFactorfSUN: procedure(factor: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGlobalAlphaFactorfSUN}
+  glGlobalAlphaFactordSUN: procedure(factor: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGlobalAlphaFactordSUN}
+  glGlobalAlphaFactorubSUN: procedure(factor: TGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGlobalAlphaFactorubSUN}
+  glGlobalAlphaFactorusSUN: procedure(factor: TGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGlobalAlphaFactorusSUN}
+  glGlobalAlphaFactoruiSUN: procedure(factor: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGlobalAlphaFactoruiSUN}
+
+  // GL_SUN_triangle_list
+  glReplacementCodeuiSUN: procedure(code: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiSUN}
+  glReplacementCodeusSUN: procedure(code: TGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeusSUN}
+  glReplacementCodeubSUN: procedure(code: TGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeubSUN}
+  glReplacementCodeuivSUN: procedure(code: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuivSUN}
+  glReplacementCodeusvSUN: procedure(code: PGLushort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeusvSUN}
+  glReplacementCodeubvSUN: procedure(code: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeubvSUN}
+  glReplacementCodePointerSUN: procedure(Atype: TGLenum; stride: TGLsizei; var p); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodePointerSUN}
+
+  // GL_SUN_vertex
+  glColor4ubVertex2fSUN: procedure(r, g, b, a: TGLubyte; x, y: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4ubVertex2fSUN}
+  glColor4ubVertex2fvSUN: procedure(c: PGLubyte; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4ubVertex2fvSUN}
+  glColor4ubVertex3fSUN: procedure(r, g, b, a: TGLubyte; x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4ubVertex3fSUN}
+  glColor4ubVertex3fvSUN: procedure(c: PGLubyte; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4ubVertex3fvSUN}
+  glColor3fVertex3fSUN: procedure(r, g, b, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3fVertex3fSUN}
+  glColor3fVertex3fvSUN: procedure(c, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor3fVertex3fvSUN}
+  glNormal3fVertex3fSUN: procedure(nx, ny, nz: TGLfloat; x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3fVertex3fSUN}
+  glNormal3fVertex3fvSUN: procedure(n, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormal3fVertex3fvSUN}
+  glColor4fNormal3fVertex3fSUN: procedure(r, g, b, a, nx, ny, nz, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4fNormal3fVertex3fSUN}
+  glColor4fNormal3fVertex3fvSUN: procedure(c, n, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColor4fNormal3fVertex3fvSUN}
+  glTexCoord2fVertex3fSUN: procedure(s, t, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fVertex3fSUN}
+  glTexCoord2fVertex3fvSUN: procedure(tc, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fVertex3fvSUN}
+  glTexCoord4fVertex4fSUN: procedure(s, t, p, q, x, y, z, w: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4fVertex4fSUN}
+  glTexCoord4fVertex4fvSUN: procedure(tc, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4fVertex4fvSUN}
+  glTexCoord2fColor4ubVertex3fSUN: procedure(s, t, r, g, b, a, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fColor4ubVertex3fSUN}
+  glTexCoord2fColor4ubVertex3fvSUN: procedure(tc: PGLfloat; c: PGLubyte; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fColor4ubVertex3fvSUN}
+  glTexCoord2fColor3fVertex3fSUN: procedure(s, t, r, g, b, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fColor3fVertex3fSUN}
+  glTexCoord2fColor3fVertex3fvSUN: procedure(tc, c, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fColor3fVertex3fvSUN}
+  glTexCoord2fNormal3fVertex3fSUN: procedure(s, t, nx, ny, nz, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fNormal3fVertex3fSUN}
+  glTexCoord2fNormal3fVertex3fvSUN: procedure(tc, n, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fNormal3fVertex3fvSUN}
+  glTexCoord2fColor4fNormal3fVertex3fSUN: procedure(s, t, r, g, b, a, nx, ny, nz, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fColor4fNormal3fVertex3fSUN}
+  glTexCoord2fColor4fNormal3fVertex3fvSUN: procedure(tc, c, n, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord2fColor4fNormal3fVertex3fvSUN}
+  glTexCoord4fColor4fNormal3fVertex4fSUN: procedure(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4fColor4fNormal3fVertex4fSUN}
+  glTexCoord4fColor4fNormal3fVertex4fvSUN: procedure(tc, c, n, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoord4fColor4fNormal3fVertex4fvSUN}
+  glReplacementCodeuiVertex3fSUN: procedure(rc: TGLenum; x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiVertex3fSUN}
+  glReplacementCodeuiVertex3fvSUN: procedure(rc: PGLenum; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiVertex3fvSUN}
+  glReplacementCodeuiColor4ubVertex3fSUN: procedure(rc: TGLenum; r, g, b, a: TGLubyte; x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiColor4ubVertex3fSUN}
+  glReplacementCodeuiColor4ubVertex3fvSUN: procedure(rc: PGLenum; c: PGLubyte; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiColor4ubVertex3fvSUN}
+  glReplacementCodeuiColor3fVertex3fSUN: procedure(rc: TGLenum; r, g, b, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiColor3fVertex3fSUN}
+  glReplacementCodeuiColor3fVertex3fvSUN: procedure(rc: PGLenum; c, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiColor3fVertex3fvSUN}
+  glReplacementCodeuiNormal3fVertex3fSUN: procedure(rc: TGLenum; nx, ny, nz, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiNormal3fVertex3fSUN}
+  glReplacementCodeuiNormal3fVertex3fvSUN: procedure(rc: PGLenum; n, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiNormal3fVertex3fvSUN}
+  glReplacementCodeuiColor4fNormal3fVertex3fSUN: procedure(rc: TGLenum; r, g, b, a, nx, ny, nz, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiColor4fNormal3fVertex3fSUN}
+  glReplacementCodeuiColor4fNormal3fVertex3fvSUN: procedure(rc: PGLenum; c, n, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiColor4fNormal3fVertex3fvSUN}
+  glReplacementCodeuiTexCoord2fVertex3fSUN: procedure(rc: TGLenum; s, t, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiTexCoord2fVertex3fSUN}
+  glReplacementCodeuiTexCoord2fVertex3fvSUN: procedure(rc: PGLenum; tc, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiTexCoord2fVertex3fvSUN}
+  glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN: procedure(rc: TGLenum; s, t, nx, ny, nz, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN}
+  glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN: procedure(rc: PGLenum; tc, n, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN}
+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN: procedure(rc: TGLenum; s, t, r, g, b, a, nx, ny, nz, x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN}
+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN: procedure(rc: PGLenum; tc, c, n, v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN}
+
+  // GL_EXT_blend_func_separate
+  glBlendFuncSeparateEXT: procedure(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBlendFuncSeparateEXT}
+
+  // GL_EXT_vertex_weighting
+  glVertexWeightfEXT: procedure(weight: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexWeightfEXT}
+  glVertexWeightfvEXT: procedure(weight: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexWeightfvEXT}
+  glVertexWeightPointerEXT: procedure(Size: TGLsizei; Atype: TGLenum; stride: TGLsizei; p: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexWeightPointerEXT}
+
+  // GL_NV_vertex_array_range
+  glFlushVertexArrayRangeNV: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFlushVertexArrayRangeNV}
+  glVertexArrayRangeNV: procedure(Size: TGLsizei; p: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexArrayRangeNV}
+  wglAllocateMemoryNV: function(size: TGLsizei; readFrequency, writeFrequency, priority: Single): Pointer; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM wglAllocateMemoryNV}
+  wglFreeMemoryNV: procedure(ptr: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM wglFreeMemoryNV}
+
+  // GL_NV_register_combiners
+  glCombinerParameterfvNV: procedure(pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCombinerParameterfvNV}
+  glCombinerParameterfNV: procedure(pname: TGLenum; param: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCombinerParameterfNV}
+  glCombinerParameterivNV: procedure(pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCombinerParameterivNV}
+  glCombinerParameteriNV: procedure(pname: TGLenum; param: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCombinerParameteriNV}
+  glCombinerInputNV: procedure(stage, portion, variable, input, mapping, componentUsage: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCombinerInputNV}
+  glCombinerOutputNV: procedure(stage, portion, abOutput, cdOutput, sumOutput, scale, bias: TGLenum; abDotProduct, cdDotProduct, muxSum: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glCombinerOutputNV}
+  glFinalCombinerInputNV: procedure(variable, input, mapping, componentUsage: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFinalCombinerInputNV}
+  glGetCombinerInputParameterfvNV: procedure(stage, portion, variable, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetCombinerInputParameterfvNV}
+  glGetCombinerInputParameterivNV: procedure(stage, portion, variable, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetCombinerInputParameterivNV}
+  glGetCombinerOutputParameterfvNV: procedure(stage, portion, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetCombinerOutputParameterfvNV}
+  glGetCombinerOutputParameterivNV: procedure(stage, portion, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetCombinerOutputParameterivNV}
+  glGetFinalCombinerInputParameterfvNV: procedure(variable, pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetFinalCombinerInputParameterfvNV}
+  glGetFinalCombinerInputParameterivNV: procedure(variable, pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetFinalCombinerInputParameterivNV}
+
+  // GL_MESA_resize_buffers
+  glResizeBuffersMESA: procedure; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glResizeBuffersMESA}
+
+  // GL_MESA_window_pos
+  glWindowPos2dMESA: procedure(x, y: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos2dMESA}
+  glWindowPos2dvMESA: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos2dvMESA}
+  glWindowPos2fMESA: procedure(x, y: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos2fMESA}
+  glWindowPos2fvMESA: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos2fvMESA}
+  glWindowPos2iMESA: procedure(x, y: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos2iMESA}
+  glWindowPos2ivMESA: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos2ivMESA}
+  glWindowPos2sMESA: procedure(x, y: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos2sMESA}
+  glWindowPos2svMESA: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos2svMESA}
+  glWindowPos3dMESA: procedure(x, y, z: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos3dMESA}
+  glWindowPos3dvMESA: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos3dvMESA}
+  glWindowPos3fMESA: procedure(x, y, z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos3fMESA}
+  glWindowPos3fvMESA: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos3fvMESA}
+  glWindowPos3iMESA: procedure(x, y, z: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos3iMESA}
+  glWindowPos3ivMESA: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos3ivMESA}
+  glWindowPos3sMESA: procedure(x, y, z: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos3sMESA}
+  glWindowPos3svMESA: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos3svMESA}
+  glWindowPos4dMESA: procedure(x, y, z, w: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos4dMESA}
+  glWindowPos4dvMESA: procedure(v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos4dvMESA}
+  glWindowPos4fMESA: procedure(x, y, z, w: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos4fMESA}
+  glWindowPos4fvMESA: procedure(v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos4fvMESA}
+  glWindowPos4iMESA: procedure(x, y, z, w: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos4iMESA}
+  glWindowPos4ivMESA: procedure(v: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos4ivMESA}
+  glWindowPos4sMESA: procedure(x, y, z, w: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos4sMESA}
+  glWindowPos4svMESA: procedure(v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glWindowPos4svMESA}
+
+  // GL_IBM_multimode_draw_arrays
+  glMultiModeDrawArraysIBM: procedure(mode: TGLenum; First: PGLint; Count: PGLsizei; primcount: TGLsizei; modestride: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiModeDrawArraysIBM}
+  glMultiModeDrawElementsIBM: procedure(mode: PGLenum; Count: PGLsizei; Atype: TGLenum; var indices; primcount: TGLsizei; modestride: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glMultiModeDrawElementsIBM}
+
+  // GL_IBM_vertex_array_lists
+  glColorPointerListIBM: procedure(Size: TGLint; Atype: TGLenum; stride: TGLint; var p; ptrstride: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glColorPointerListIBM}
+  glSecondaryColorPointerListIBM: procedure(Size: TGLint; Atype: TGLenum; stride: TGLint; var p; ptrstride: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSecondaryColorPointerListIBM}
+  glEdgeFlagPointerListIBM: procedure(stride: TGLint; var p: PGLboolean; ptrstride: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glEdgeFlagPointerListIBM}
+  glFogCoordPointerListIBM: procedure(Atype: TGLenum; stride: TGLint; var p; ptrstride: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glFogCoordPointerListIBM}
+  glIndexPointerListIBM: procedure(Atype: TGLenum; stride: TGLint; var p; ptrstride: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIndexPointerListIBM}
+  glNormalPointerListIBM: procedure(Atype: TGLenum; stride: TGLint; var p; ptrstride: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glNormalPointerListIBM}
+  glTexCoordPointerListIBM: procedure(Size: TGLint; Atype: TGLenum; stride: TGLint; var p; ptrstride: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTexCoordPointerListIBM}
+  glVertexPointerListIBM: procedure(Size: TGLint; Atype: TGLenum; stride: TGLint; var p; ptrstride: TGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexPointerListIBM}
+
+  // GL_3DFX_tbuffer
+  glTbufferMask3DFX: procedure(mask: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTbufferMask3DFX}
+
+  // GL_EXT_multisample
+  glSampleMaskEXT: procedure(Value: TGLclampf; invert: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSampleMaskEXT}
+  glSamplePatternEXT: procedure(pattern: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glSamplePatternEXT}
+
+  // GL_SGIS_texture_color_mask
+  glTextureColorMaskSGIS: procedure(red, green, blue, alpha: TGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTextureColorMaskSGIS}
+
+  // GL_SGIX_igloo_interface
+  glIglooInterfaceSGIX: procedure(pname: TGLenum; params: pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIglooInterfaceSGIX}
+
+  // GL_NV_vertex_program
+  glAreProgramsResidentNV: procedure(n: TGLSizei; programs: PGLuint; residences: PGLboolean); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glAreProgramsResidentNV}
+  glBindProgramNV: procedure(target: TGLenum; id: TGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glBindProgramNV}
+  glDeleteProgramsNV: procedure(n: TGLSizei; programs: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glDeleteProgramsNV}
+  glExecuteProgramNV: procedure(target: TGLenum; id: TGLuint; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glExecuteProgramNV}
+  glGenProgramsNV: procedure(n: TGLSizei; programs: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGenProgramsNV}
+  glGetProgramParameterdvNV: procedure (target: TGLenum; index: TGLuint; pname: TGLenum; params: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetProgramParameterdvNV}
+  glGetProgramParameterfvNV: procedure (target: TGLenum; index: TGLuint; pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetProgramParameterfvNV}
+  glGetProgramivNV: procedure (id: TGLuint; pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetProgramivNV}
+  glGetProgramStringNV: procedure (id: TGLuint; pname: TGLenum; programIdx: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetProgramStringNV}
+  glGetTrackMatrixivNV: procedure (target: TGLenum; address: TGLuint; pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetTrackMatrixivNV}
+  glGetVertexAttribdvNV: procedure (index: TGLuint; pname: TGLenum; params: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetVertexAttribdvNV}
+  glGetVertexAttribfvNV: procedure (index: TGLuint; pname: TGLenum; params: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetVertexAttribfvNV}
+  glGetVertexAttribivNV: procedure (index: TGLuint; pname: TGLenum; params: PGLint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetVertexAttribivNV}
+  glGetVertexAttribPointervNV: procedure (index: TGLuint; pname: TGLenum; pointer: PPointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glGetVertexAttribPointervNV}
+  glIsProgramNV: function (id: TGLuint): TGLboolean; {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glIsProgramNV}
+  glLoadProgramNV: procedure (target: TGLenum; id: TGLuint; len: TGLSizei; programIdx: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glLoadProgramNV}
+  glProgramParameter4dNV: procedure (target: TGLenum; index: TGLuint; x, y, z, w: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glProgramParameter4dNV}
+  glProgramParameter4dvNV: procedure (target: TGLenum; index: TGLuint; v: PGLdouble ); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glProgramParameter4dvNV}
+  glProgramParameter4fNV: procedure (target: TGLenum; index: TGLuint; x, y, z, w: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glProgramParameter4fNV}
+  glProgramParameter4fvNV: procedure (target: TGLenum; index: TGLuint; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glProgramParameter4fvNV}
+  glProgramParameters4dvNV: procedure (target: TGLenum; index: TGLuint; count: TGLSizei; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glProgramParameters4dvNV}
+  glProgramParameters4fvNV: procedure (target: TGLenum; index: TGLuint; count: TGLSizei; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glProgramParameters4fvNV}
+  glRequestResidentProgramsNV: procedure (n: TGLSizei; programs: PGLuint); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glRequestResidentProgramsNV}
+  glTrackMatrixNV: procedure (target: TGLenum; address: TGLuint; matrix: TGLenum; transform: TGLenum); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glTrackMatrixNV}
+  glVertexAttribPointerNV: procedure (index: TGLuint; fsize: TGLint; vertextype: TGLenum; stride: TGLSizei; pointer: Pointer); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribPointerNV}
+  glVertexAttrib1dNV: procedure (index: TGLuint; x: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib1dNV}
+  glVertexAttrib1dvNV: procedure (index: TGLuint; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib1dvNV}
+  glVertexAttrib1fNV: procedure (index: TGLuint; x: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib1fNV}
+  glVertexAttrib1fvNV: procedure (index: TGLuint; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib1fvNV}
+  glVertexAttrib1sNV: procedure (index: TGLuint; x: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib1sNV}
+  glVertexAttrib1svNV: procedure (index: TGLuint; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib1svNV}
+  glVertexAttrib2dNV: procedure (index: TGLuint; x: TGLdouble; y: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib2dNV}
+  glVertexAttrib2dvNV: procedure (index: TGLuint; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib2dvNV}
+  glVertexAttrib2fNV: procedure (index: TGLuint; x: TGLfloat; y: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib2fNV}
+  glVertexAttrib2fvNV: procedure (index: TGLuint; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib2fvNV}
+  glVertexAttrib2sNV: procedure (index: TGLuint; x: TGLshort; y: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib2sNV}
+  glVertexAttrib2svNV: procedure (index: TGLuint; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib2svNV}
+  glVertexAttrib3dNV: procedure (index: TGLuint; x: TGLdouble; y: TGLdouble; z: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib3dNV}
+  glVertexAttrib3dvNV: procedure (index: TGLuint; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib3dvNV}
+  glVertexAttrib3fNV: procedure (index: TGLuint; x: TGLfloat; y: TGLfloat; z: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib3fNV}
+  glVertexAttrib3fvNV: procedure (index: TGLuint; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib3fvNV}
+  glVertexAttrib3sNV: procedure (index: TGLuint; x: TGLshort; y: TGLshort; z: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib3sNV}
+  glVertexAttrib3svNV: procedure (index: TGLuint; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib3svNV}
+  glVertexAttrib4dNV: procedure (index: TGLuint; x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib4dNV}
+  glVertexAttrib4dvNV: procedure (index: TGLuint; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib4dvNV}
+  glVertexAttrib4fNV: procedure(index: TGLuint; x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib4fNV}
+  glVertexAttrib4fvNV: procedure(index: TGLuint; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib4fvNV}
+  glVertexAttrib4sNV: procedure (index: TGLuint; x: TGLshort; y: TGLshort; z: TGLdouble; w: TGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib4sNV}
+  glVertexAttrib4svNV: procedure (index: TGLuint; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib4svNV}
+  glVertexAttrib4ubvNV: procedure (index: TGLuint; v: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttrib4ubvNV}
+  glVertexAttribs1dvNV: procedure (index: TGLuint; count: TGLSizei; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs1dvNV}
+  glVertexAttribs1fvNV: procedure (index: TGLuint; count: TGLSizei; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs1fvNV}
+  glVertexAttribs1svNV: procedure (index: TGLuint; count: TGLSizei; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs1svNV}
+  glVertexAttribs2dvNV: procedure (index: TGLuint; count: TGLSizei; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs2dvNV}
+  glVertexAttribs2fvNV: procedure (index: TGLuint; count: TGLSizei; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs2fvNV}
+  glVertexAttribs2svNV: procedure (index: TGLuint; count: TGLSizei; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs2svNV}
+  glVertexAttribs3dvNV: procedure (index: TGLuint; count: TGLSizei; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs3dvNV}
+  glVertexAttribs3fvNV: procedure (index: TGLuint; count: TGLSizei; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs3fvNV}
+  glVertexAttribs3svNV: procedure (index: TGLuint; count: TGLSizei; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs3svNV}
+  glVertexAttribs4dvNV: procedure (index: TGLuint; count: TGLSizei; v: PGLdouble); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs4dvNV}
+  glVertexAttribs4fvNV: procedure (index: TGLuint; count: TGLSizei; v: PGLfloat); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs4fvNV}
+  glVertexAttribs4svNV: procedure (index: TGLuint; count: TGLSizei; v: PGLshort); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs4svNV}
+  glVertexAttribs4ubvNV: procedure (index: TGLuint; count: TGLSizei; v: PGLubyte); {$ifdef Win32} stdcall; {$endif} {$ifdef UNIX} cdecl; {$endif}
+  {$EXTERNALSYM glVertexAttribs4ubvNV}
+
+{$ifdef UNIX}
+type
+  GLXContext     = Pointer; 
+  GLXPixmap      = XID; 
+  GLXDrawable    = XID; 
+
+  // GLX 1.3 and later
+  GLXFBConfig    = Pointer; 
+  GLXFBConfigID  = XID; 
+  GLXContextID   = XID; 
+  GLXWindow      = XID; 
+  GLXPbuffer     = XID;
+
+var
+  glXChooseVisual: function(dpy: PDisplay; screen: TGLint; attribList: PGLint): PXVisualInfo; cdecl;
+  {$EXTERNALSYM glXChooseVisual}
+  glXCreateContext: function(dpy: PDisplay; vis: PXVisualInfo; shareList: GLXContext; direct: TGLboolean): GLXContext; cdecl;
+  {$EXTERNALSYM glXCreateContext}
+  glXDestroyContext: procedure(dpy: PDisplay; ctx: GLXContext); cdecl;
+  {$EXTERNALSYM glXDestroyContext}
+  glXMakeCurrent: function(dpy: PDisplay; drawable: GLXDrawable; ctx: GLXContext): TGLboolean; cdecl;
+  {$EXTERNALSYM glXMakeCurrent}
+  glXCopyContext: procedure(dpy: PDisplay; src: GLXContext; dst: GLXContext; mask: TGLuint); cdecl;
+  {$EXTERNALSYM glXCopyContext}
+  glXSwapBuffers: procedure(dpy: PDisplay; drawable: GLXDrawable); cdecl;
+  {$EXTERNALSYM glXSwapBuffers}
+  glXCreateGLXPixmap: function(dpy: PDisplay; visual: PXVisualInfo; pixmap: Pixmap): GLXPixmap; cdecl;
+  {$EXTERNALSYM glXCreateGLXPixmap}
+  glXDestroyGLXPixmap: procedure(dpy: PDisplay; pixmap: GLXPixmap); cdecl;
+  {$EXTERNALSYM glXDestroyGLXPixmap}
+  glXQueryExtension: function(dpy: PDisplay; errorb: PGLInt; event: PGLInt): TGLboolean; cdecl;
+  {$EXTERNALSYM glXQueryExtension}
+  glXQueryVersion: function(dpy: PDisplay; maj: PGLInt; min: PGLINT): TGLboolean; cdecl;
+  {$EXTERNALSYM glXQueryVersion}
+  glXIsDirect: function(dpy: PDisplay; ctx: GLXContext): TGLboolean; cdecl;
+  {$EXTERNALSYM glXIsDirect}
+  glXGetConfig: function(dpy: PDisplay; visual: PXVisualInfo; attrib: TGLInt; value: PGLInt): TGLInt; cdecl;
+  {$EXTERNALSYM glXGetConfig}
+  glXGetCurrentContext: function: GLXContext; cdecl;
+  {$EXTERNALSYM glXGetCurrentContext}
+  glXGetCurrentDrawable: function: GLXDrawable; cdecl;
+  {$EXTERNALSYM glXGetCurrentDrawable}
+  glXWaitGL: procedure; cdecl;
+  {$EXTERNALSYM glXWaitGL}
+  glXWaitX: procedure; cdecl;
+  {$EXTERNALSYM glXWaitX}
+  glXUseXFont: procedure(font: Font; first: TGLInt; count: TGLInt; list: TGLint); cdecl;
+  {$EXTERNALSYM glXUseXFont}
+
+  // GLX 1.1 and later
+  glXQueryExtensionsString: function(dpy: PDisplay; screen: TGLInt): PChar; cdecl;
+  {$EXTERNALSYM glXQueryExtensionsString}
+  glXQueryServerString: function(dpy: PDisplay; screen: TGLInt; name: TGLInt): PChar; cdecl;
+  {$EXTERNALSYM glXQueryServerString}
+  glXGetClientString: function(dpy: PDisplay; name: TGLInt): PChar; cdecl;
+  {$EXTERNALSYM glXGetClientString}
+
+  // GLX 1.2 and later
+  glXGetCurrentDisplay: function: PDisplay; cdecl;
+  {$EXTERNALSYM glXGetCurrentDisplay}
+
+  // GLX 1.3 and later
+  glXChooseFBConfig: function(dpy: PDisplay; screen: TGLInt; attribList: PGLInt; nitems: PGLInt): GLXFBConfig; cdecl;
+  {$EXTERNALSYM glXChooseFBConfig}
+  glXGetFBConfigAttrib: function(dpy: PDisplay; config: GLXFBConfig; attribute: TGLInt; value: PGLInt): TGLInt; cdecl;
+  {$EXTERNALSYM glXGetFBConfigAttrib}
+  glXGetFBConfigs: function(dpy: PDisplay; screen: TGLInt; nelements: PGLInt): GLXFBConfig; cdecl;
+  {$EXTERNALSYM glXGetFBConfigs}
+  glXGetVisualFromFBConfig: function(dpy: PDisplay; config: GLXFBConfig): PXVisualInfo; cdecl;
+  {$EXTERNALSYM glXGetVisualFromFBConfig}
+  glXCreateWindow: function(dpy: PDisplay; config: GLXFBConfig; win: Window; const attribList: PGLInt): GLXWindow; cdecl;
+  {$EXTERNALSYM glXCreateWindow}
+  glXDestroyWindow: procedure(dpy: PDisplay; window: GLXWindow); cdecl;
+  {$EXTERNALSYM glXDestroyWindow}
+  glXCreatePixmap: function(dpy: PDisplay; config: GLXFBConfig; pixmap: Pixmap; attribList: PGLInt): GLXPixmap; cdecl;
+  {$EXTERNALSYM glXCreatePixmap}
+  glXDestroyPixmap: procedure(dpy: PDisplay; pixmap: GLXPixmap); cdecl;
+  {$EXTERNALSYM glXDestroyPixmap}
+  glXCreatePbuffer: function(dpy: PDisplay; config: GLXFBConfig; attribList: PGLInt): GLXPBuffer; cdecl;
+  {$EXTERNALSYM glXCreatePbuffer}
+  glXDestroyPbuffer: procedure(dpy: PDisplay; pbuf: GLXPBuffer); cdecl;
+  {$EXTERNALSYM glXDestroyPbuffer}
+  glXQueryDrawable: procedure(dpy: PDisplay; draw: GLXDrawable; attribute: TGLInt; value: PGLuint); cdecl;
+  {$EXTERNALSYM glXQueryDrawable}
+  glXCreateNewContext: function(dpy: PDisplay; config: GLXFBConfig; renderType: TGLInt; shareList: GLXContext; direct: TGLboolean): GLXContext; cdecl;
+  {$EXTERNALSYM glXCreateNewContext}
+  glXMakeContextCurrent: function(dpy: PDisplay; draw: GLXDrawable; read: GLXDrawable; ctx: GLXContext): TGLboolean; cdecl;
+  {$EXTERNALSYM glXMakeContextCurrent}
+  glXGetCurrentReadDrawable: function: GLXDrawable; cdecl;
+  {$EXTERNALSYM glXGetCurrentReadDrawable}
+  glXQueryContext: function(dpy: PDisplay; ctx: GLXContext; attribute: TGLInt; value: PGLInt): TGLInt; cdecl;
+  {$EXTERNALSYM glXQueryContext}
+  glXSelectEvent: procedure(dpy: PDisplay; drawable: GLXDrawable; mask: TGLsizei); cdecl;
+  {$EXTERNALSYM glXSelectEvent}
+  glXGetSelectedEvent: procedure(dpy: PDisplay; drawable: GLXDrawable; mask: TGLsizei); cdecl;
+  {$EXTERNALSYM glXGetSelectedEvent}
+  glXGetVideoSyncSGI: function(count: PGLuint): TGLInt; cdecl;
+  {$EXTERNALSYM glXGetVideoSyncSGI}
+  glXWaitVideoSyncSGI: function(divisor: TGLInt; remainder: TGLInt; count: PGLuint): TGLInt; cdecl;
+  {$EXTERNALSYM glXWaitVideoSyncSGI}
+  glXFreeContextEXT: procedure(dpy: PDisplay; context: GLXContext); cdecl;
+  {$EXTERNALSYM glXFreeContextEXT}
+  glXGetContextIDEXT: function(const context: GLXContext): GLXContextID; cdecl;
+  {$EXTERNALSYM glXGetContextIDEXT}
+  glXGetCurrentDisplayEXT: function: PDisplay; cdecl;
+  {$EXTERNALSYM glXGetCurrentDisplayEXT}
+  glXImportContextEXT: function(dpy: PDisplay; contextID: GLXContextID): GLXContext; cdecl;
+  {$EXTERNALSYM glXImportContextEXT}
+  glXQueryContextInfoEXT: function(dpy: PDisplay; context: GLXContext; attribute: TGLInt; value: PGLInt): TGLInt; cdecl;
+  {$EXTERNALSYM glXQueryContextInfoEXT}
+  glXCopySubBufferMESA: procedure(dpy: PDisplay; drawable: GLXDrawable; x: TGLInt; y: TGLInt; width: TGLInt; height: TGLInt); cdecl;
+  {$EXTERNALSYM glXCopySubBufferMESA}
+  glXCreateGLXPixmapMESA: function(dpy: PDisplay; visual: PXVisualInfo; pixmap: Pixmap; cmap: Colormap): GLXPixmap; cdecl;
+  {$EXTERNALSYM glXCreateGLXPixmapMESA}
+  glXReleaseBuffersMESA: function(dpy: PDisplay; d: GLXDrawable): TGLboolean; cdecl;
+  {$EXTERNALSYM glXReleaseBuffersMESA}
+  glXSet3DfxModeMESA: function(mode: TGLint): TGLboolean; cdecl;
+  {$EXTERNALSYM glXSet3DfxModeMESA}
+{$endif}
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure CloseOpenGL;
+function InitOpenGL: Boolean;
+function InitOpenGLFromLibrary(GLName, GLUName: PChar): Boolean;
+function IsOpenGLInitialized: Boolean;
+
+// Compatibility routines
+procedure UnloadOpenGL;
+function LoadOpenGL: Boolean;
+function LoadOpenGLFromLibrary(GLName, GLUName: PChar): Boolean;
+function IsOpenGLLoaded: Boolean;
+
+{$ifdef Win32}
+procedure ActivateRenderingContext(DC: HDC; RC: HGLRC); 
+function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer; var Palette: HPALETTE): HGLRC; 
+function CurrentDC: HDC;
+procedure DeactivateRenderingContext;
+procedure DestroyRenderingContext(RC: HGLRC); 
+procedure ClearExtensions; 
+function HasActiveContext: Boolean; 
+procedure ReadExtensions;
+procedure ReadImplementationProperties;
+{$endif}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+implementation
+
+uses
+  SysUtils,
+  Classes,
+  sdl,
+  moduleloader;
+
+type
+  EOpenGLException = class(Exception);
+
+{$ifndef FPC} 
+threadvar
+{$else}
+var 
+{$endif}
+  LastPixelFormat: Integer; 
+  ActivationRefCount: Integer;       
+
+{$ifdef Win32}
+const
+  INVALID_MODULEHANDLE = 0; 
+
+var
+  GLHandle: TModuleHandle;
+  GLUHandle: TModuleHandle; 
+{$endif}
+
+{$ifdef UNIX}
+const
+  INVALID_MODULEHANDLE = nil; 
+
+var
+  GLHandle: TModuleHandle;
+  GLUHandle: TModuleHandle; 
+{$endif}
+
+  // The context list is used to determine if a context is active already in any thread.
+  ContextList: TThreadList; 
+
+resourcestring
+  SRCAlreadyActive = 'Rendering context already active in another thread.'; 
+  SMakeCurrentFailed = 'wglMakeCurrent failed'; 
+  SDeleteContextFailed = 'wglDeleteContext failed'; 
+  SContextInUse = 'Cannot delete rendering context. It is still in use by another thread.'; 
+
+{$ifdef Win32}
+  SDefaultGLLibrary = 'OpenGL32.dll'; 
+  SDefaultGLULibrary = 'GLU32.dll'; 
+{$endif}
+
+{$ifdef UNIX}
+  SDefaultGLLibrary = 'libGL.so'; 
+  SDefaultGLULibrary = 'libGLU.so'; 
+{$endif}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure ShowError(const Message: string);
+
+begin
+  raise EOpenGLException.Create(Message);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+{$ifndef VER140}
+
+procedure RaiseLastOSError;
+begin
+  {$ifndef FPC}
+  RaiseLastWin32Error;
+  {$endif}
+end;
+
+{$endif VER140}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure ClearProcAddresses;
+
+begin
+  glAccum := nil; 
+  glAlphaFunc := nil; 
+  glAreTexturesResident := nil; 
+  glArrayElement := nil; 
+  glBegin := nil; 
+  glBindTexture := nil; 
+  glBitmap := nil; 
+  glBlendFunc := nil; 
+  glCallList := nil; 
+  glCallLists := nil; 
+  glClear := nil; 
+  glClearAccum := nil; 
+  glClearColor := nil; 
+  glClearDepth := nil; 
+  glClearIndex := nil; 
+  glClearStencil := nil; 
+  glClipPlane := nil; 
+  glColor3b := nil; 
+  glColor3bv := nil; 
+  glColor3d := nil; 
+  glColor3dv := nil;
+  glColor3f := nil; 
+  glColor3fv := nil; 
+  glColor3i := nil; 
+  glColor3iv := nil; 
+  glColor3s := nil; 
+  glColor3sv := nil; 
+  glColor3ub := nil; 
+  glColor3ubv := nil; 
+  glColor3ui := nil; 
+  glColor3uiv := nil; 
+  glColor3us := nil; 
+  glColor3usv := nil; 
+  glColor4b := nil; 
+  glColor4bv := nil; 
+  glColor4d := nil; 
+  glColor4dv := nil; 
+  glColor4f := nil; 
+  glColor4fv := nil; 
+  glColor4i := nil; 
+  glColor4iv := nil; 
+  glColor4s := nil; 
+  glColor4sv := nil; 
+  glColor4ub := nil; 
+  glColor4ubv := nil; 
+  glColor4ui := nil;
+  glColor4uiv := nil; 
+  glColor4us := nil; 
+  glColor4usv := nil; 
+  glColorMask := nil; 
+  glColorMaterial := nil; 
+  glColorPointer := nil; 
+  glCopyPixels := nil; 
+  glCopyTexImage1D := nil; 
+  glCopyTexImage2D := nil; 
+  glCopyTexSubImage1D := nil; 
+  glCopyTexSubImage2D := nil; 
+  glCullFace := nil; 
+  glDeleteLists := nil; 
+  glDeleteTextures := nil; 
+  glDepthFunc := nil; 
+  glDepthMask := nil; 
+  glDepthRange := nil; 
+  glDisable := nil; 
+  glDisableClientState := nil; 
+  glDrawArrays := nil; 
+  glDrawBuffer := nil; 
+  glDrawElements := nil; 
+  glDrawPixels := nil; 
+  glEdgeFlag := nil; 
+  glEdgeFlagPointer := nil;
+  glEdgeFlagv := nil; 
+  glEnable := nil; 
+  glEnableClientState := nil; 
+  glEnd := nil; 
+  glEndList := nil; 
+  glEvalCoord1d := nil; 
+  glEvalCoord1dv := nil; 
+  glEvalCoord1f := nil; 
+  glEvalCoord1fv := nil; 
+  glEvalCoord2d := nil; 
+  glEvalCoord2dv := nil; 
+  glEvalCoord2f := nil; 
+  glEvalCoord2fv := nil; 
+  glEvalMesh1 := nil; 
+  glEvalMesh2 := nil; 
+  glEvalPoint1 := nil; 
+  glEvalPoint2 := nil; 
+  glFeedbackBuffer := nil; 
+  glFinish := nil; 
+  glFlush := nil; 
+  glFogf := nil; 
+  glFogfv := nil; 
+  glFogi := nil; 
+  glFogiv := nil; 
+  glFrontFace := nil;
+  glFrustum := nil; 
+  glGenLists := nil; 
+  glGenTextures := nil; 
+  glGetBooleanv := nil; 
+  glGetClipPlane := nil; 
+  glGetDoublev := nil; 
+  glGetError := nil; 
+  glGetFloatv := nil; 
+  glGetIntegerv := nil; 
+  glGetLightfv := nil; 
+  glGetLightiv := nil; 
+  glGetMapdv := nil; 
+  glGetMapfv := nil; 
+  glGetMapiv := nil; 
+  glGetMaterialfv := nil; 
+  glGetMaterialiv := nil; 
+  glGetPixelMapfv := nil; 
+  glGetPixelMapuiv := nil; 
+  glGetPixelMapusv := nil; 
+  glGetPointerv := nil; 
+  glGetPolygonStipple := nil; 
+  glGetString := nil; 
+  glGetTexEnvfv := nil; 
+  glGetTexEnviv := nil; 
+  glGetTexGendv := nil;
+  glGetTexGenfv := nil; 
+  glGetTexGeniv := nil; 
+  glGetTexImage := nil; 
+  glGetTexLevelParameterfv := nil; 
+  glGetTexLevelParameteriv := nil; 
+  glGetTexParameterfv := nil; 
+  glGetTexParameteriv := nil; 
+  glHint := nil; 
+  glIndexMask := nil; 
+  glIndexPointer := nil; 
+  glIndexd := nil; 
+  glIndexdv := nil; 
+  glIndexf := nil; 
+  glIndexfv := nil; 
+  glIndexi := nil; 
+  glIndexiv := nil; 
+  glIndexs := nil; 
+  glIndexsv := nil; 
+  glIndexub := nil; 
+  glIndexubv := nil; 
+  glInitNames := nil; 
+  glInterleavedArrays := nil; 
+  glIsEnabled := nil; 
+  glIsList := nil; 
+  glIsTexture := nil;
+  glLightModelf := nil; 
+  glLightModelfv := nil; 
+  glLightModeli := nil; 
+  glLightModeliv := nil; 
+  glLightf := nil; 
+  glLightfv := nil; 
+  glLighti := nil; 
+  glLightiv := nil; 
+  glLineStipple := nil; 
+  glLineWidth := nil; 
+  glListBase := nil; 
+  glLoadIdentity := nil; 
+  glLoadMatrixd := nil; 
+  glLoadMatrixf := nil; 
+  glLoadName := nil; 
+  glLogicOp := nil; 
+  glMap1d := nil; 
+  glMap1f := nil; 
+  glMap2d := nil; 
+  glMap2f := nil; 
+  glMapGrid1d := nil; 
+  glMapGrid1f := nil; 
+  glMapGrid2d := nil; 
+  glMapGrid2f := nil; 
+  glMaterialf := nil;
+  glMaterialfv := nil; 
+  glMateriali := nil; 
+  glMaterialiv := nil; 
+  glMatrixMode := nil; 
+  glMultMatrixd := nil; 
+  glMultMatrixf := nil; 
+  glNewList := nil; 
+  glNormal3b := nil; 
+  glNormal3bv := nil; 
+  glNormal3d := nil; 
+  glNormal3dv := nil; 
+  glNormal3f := nil; 
+  glNormal3fv := nil; 
+  glNormal3i := nil; 
+  glNormal3iv := nil; 
+  glNormal3s := nil; 
+  glNormal3sv := nil; 
+  glNormalPointer := nil; 
+  glOrtho := nil; 
+  glPassThrough := nil; 
+  glPixelMapfv := nil; 
+  glPixelMapuiv := nil; 
+  glPixelMapusv := nil; 
+  glPixelStoref := nil; 
+  glPixelStorei := nil;
+  glPixelTransferf := nil; 
+  glPixelTransferi := nil; 
+  glPixelZoom := nil; 
+  glPointSize := nil; 
+  glPolygonMode := nil; 
+  glPolygonOffset := nil; 
+  glPolygonStipple := nil; 
+  glPopAttrib := nil; 
+  glPopClientAttrib := nil; 
+  glPopMatrix := nil; 
+  glPopName := nil; 
+  glPrioritizeTextures := nil; 
+  glPushAttrib := nil; 
+  glPushClientAttrib := nil; 
+  glPushMatrix := nil; 
+  glPushName := nil; 
+  glRasterPos2d := nil; 
+  glRasterPos2dv := nil; 
+  glRasterPos2f := nil; 
+  glRasterPos2fv := nil; 
+  glRasterPos2i := nil; 
+  glRasterPos2iv := nil; 
+  glRasterPos2s := nil; 
+  glRasterPos2sv := nil; 
+  glRasterPos3d := nil;
+  glRasterPos3dv := nil; 
+  glRasterPos3f := nil; 
+  glRasterPos3fv := nil; 
+  glRasterPos3i := nil; 
+  glRasterPos3iv := nil; 
+  glRasterPos3s := nil; 
+  glRasterPos3sv := nil; 
+  glRasterPos4d := nil; 
+  glRasterPos4dv := nil; 
+  glRasterPos4f := nil; 
+  glRasterPos4fv := nil; 
+  glRasterPos4i := nil; 
+  glRasterPos4iv := nil; 
+  glRasterPos4s := nil; 
+  glRasterPos4sv := nil; 
+  glReadBuffer := nil; 
+  glReadPixels := nil; 
+  glRectd := nil; 
+  glRectdv := nil; 
+  glRectf := nil; 
+  glRectfv := nil; 
+  glRecti := nil; 
+  glRectiv := nil; 
+  glRects := nil; 
+  glRectsv := nil;
+  glRenderMode := nil; 
+  glRotated := nil; 
+  glRotatef := nil; 
+  glScaled := nil; 
+  glScalef := nil; 
+  glScissor := nil; 
+  glSelectBuffer := nil; 
+  glShadeModel := nil; 
+  glStencilFunc := nil; 
+  glStencilMask := nil; 
+  glStencilOp := nil; 
+  glTexCoord1d := nil; 
+  glTexCoord1dv := nil; 
+  glTexCoord1f := nil; 
+  glTexCoord1fv := nil; 
+  glTexCoord1i := nil; 
+  glTexCoord1iv := nil; 
+  glTexCoord1s := nil; 
+  glTexCoord1sv := nil; 
+  glTexCoord2d := nil; 
+  glTexCoord2dv := nil; 
+  glTexCoord2f := nil; 
+  glTexCoord2fv := nil; 
+  glTexCoord2i := nil; 
+  glTexCoord2iv := nil;
+  glTexCoord2s := nil; 
+  glTexCoord2sv := nil; 
+  glTexCoord3d := nil; 
+  glTexCoord3dv := nil; 
+  glTexCoord3f := nil; 
+  glTexCoord3fv := nil; 
+  glTexCoord3i := nil; 
+  glTexCoord3iv := nil; 
+  glTexCoord3s := nil; 
+  glTexCoord3sv := nil; 
+  glTexCoord4d := nil; 
+  glTexCoord4dv := nil; 
+  glTexCoord4f := nil; 
+  glTexCoord4fv := nil; 
+  glTexCoord4i := nil; 
+  glTexCoord4iv := nil; 
+  glTexCoord4s := nil; 
+  glTexCoord4sv := nil; 
+  glTexCoordPointer := nil; 
+  glTexEnvf := nil; 
+  glTexEnvfv := nil; 
+  glTexEnvi := nil; 
+  glTexEnviv := nil; 
+  glTexGend := nil; 
+  glTexGendv := nil;
+  glTexGenf := nil; 
+  glTexGenfv := nil; 
+  glTexGeni := nil; 
+  glTexGeniv := nil; 
+  glTexImage1D := nil; 
+  glTexImage2D := nil; 
+  glTexParameterf := nil; 
+  glTexParameterfv := nil; 
+  glTexParameteri := nil; 
+  glTexParameteriv := nil; 
+  glTexSubImage1D := nil; 
+  glTexSubImage2D := nil; 
+  glTranslated := nil; 
+  glTranslatef := nil; 
+  glVertex2d := nil; 
+  glVertex2dv := nil; 
+  glVertex2f := nil; 
+  glVertex2fv := nil; 
+  glVertex2i := nil; 
+  glVertex2iv := nil; 
+  glVertex2s := nil; 
+  glVertex2sv := nil; 
+  glVertex3d := nil; 
+  glVertex3dv := nil; 
+  glVertex3f := nil;
+  glVertex3fv := nil; 
+  glVertex3i := nil; 
+  glVertex3iv := nil; 
+  glVertex3s := nil; 
+  glVertex3sv := nil; 
+  glVertex4d := nil; 
+  glVertex4dv := nil; 
+  glVertex4f := nil; 
+  glVertex4fv := nil; 
+  glVertex4i := nil; 
+  glVertex4iv := nil; 
+  glVertex4s := nil; 
+  glVertex4sv := nil; 
+  glVertexPointer := nil; 
+  glViewport := nil; 
+
+  {$ifdef Win32}
+  wglGetProcAddress := nil; 
+  wglCopyContext := nil; 
+  wglCreateContext := nil; 
+  wglCreateLayerContext := nil; 
+  wglDeleteContext := nil; 
+  wglDescribeLayerPlane := nil; 
+  wglGetCurrentContext := nil; 
+  wglGetCurrentDC := nil;
+  wglGetLayerPaletteEntries := nil; 
+  wglMakeCurrent := nil; 
+  wglRealizeLayerPalette := nil; 
+  wglSetLayerPaletteEntries := nil; 
+  wglShareLists := nil; 
+  wglSwapLayerBuffers := nil; 
+  wglSwapMultipleBuffers := nil; 
+  wglUseFontBitmapsA := nil; 
+  wglUseFontOutlinesA := nil; 
+  wglUseFontBitmapsW := nil; 
+  wglUseFontOutlinesW := nil; 
+  wglUseFontBitmaps := nil; 
+  wglUseFontOutlines := nil; 
+  {$endif}
+
+  // GL 1.2
+  glDrawRangeElements := nil; 
+  glTexImage3D := nil; 
+
+  // GL 1.2 ARB imaging
+  glBlendColor := nil; 
+  glBlendEquation := nil; 
+  glColorSubTable := nil; 
+  glCopyColorSubTable := nil; 
+  glColorTable := nil;
+  glCopyColorTable := nil; 
+  glColorTableParameteriv := nil; 
+  glColorTableParameterfv := nil; 
+  glGetColorTable := nil; 
+  glGetColorTableParameteriv := nil; 
+  glGetColorTableParameterfv := nil; 
+  glConvolutionFilter1D := nil; 
+  glConvolutionFilter2D := nil; 
+  glCopyConvolutionFilter1D := nil; 
+  glCopyConvolutionFilter2D := nil; 
+  glGetConvolutionFilter := nil; 
+  glSeparableFilter2D := nil; 
+  glGetSeparableFilter := nil; 
+  glConvolutionParameteri := nil; 
+  glConvolutionParameteriv := nil; 
+  glConvolutionParameterf := nil; 
+  glConvolutionParameterfv := nil; 
+  glGetConvolutionParameteriv := nil; 
+  glGetConvolutionParameterfv := nil; 
+  glHistogram := nil; 
+  glResetHistogram := nil; 
+  glGetHistogram := nil; 
+  glGetHistogramParameteriv := nil; 
+  glGetHistogramParameterfv := nil; 
+  glMinmax := nil;
+  glResetMinmax := nil; 
+  glGetMinmax := nil; 
+  glGetMinmaxParameteriv := nil; 
+  glGetMinmaxParameterfv := nil; 
+
+  // GLX
+  {$ifdef UNIX}
+  glXChooseVisual := nil; 
+  glXCreateContext := nil; 
+  glXDestroyContext := nil; 
+  glXMakeCurrent := nil; 
+  glXCopyContext := nil; 
+  glXSwapBuffers := nil; 
+  glXCreateGLXPixmap := nil; 
+  glXDestroyGLXPixmap := nil; 
+  glXQueryExtension := nil; 
+  glXQueryVersion := nil; 
+  glXIsDirect := nil; 
+  glXGetConfig := nil; 
+  glXGetCurrentContext := nil; 
+  glXGetCurrentDrawable := nil; 
+  glXWaitGL := nil; 
+  glXWaitX := nil; 
+  glXUseXFont := nil; 
+
+  // GLX 1.1 and later
+  glXQueryExtensionsString := nil;
+  glXQueryServerString := nil;
+  glXGetClientString := nil;
+
+  // GLX 1.2 and later
+  glXGetCurrentDisplay := nil;
+
+  // GLX 1.3 and later
+  glXChooseFBConfig := nil;
+  glXGetFBConfigAttrib := nil;
+  glXGetFBConfigs := nil;
+  glXGetVisualFromFBConfig := nil;
+  glXCreateWindow := nil;
+  glXDestroyWindow := nil;
+  glXCreatePixmap := nil;
+  glXDestroyPixmap := nil;
+  glXCreatePbuffer := nil;
+  glXDestroyPbuffer := nil;
+  glXQueryDrawable := nil;
+  glXCreateNewContext := nil;
+  glXMakeContextCurrent := nil;
+  glXGetCurrentReadDrawable := nil;
+  glXQueryContext := nil;
+  glXSelectEvent := nil;
+  glXGetSelectedEvent := nil;
+  glXGetVideoSyncSGI := nil;
+  glXWaitVideoSyncSGI := nil;
+  glXFreeContextEXT := nil;
+  glXGetContextIDEXT := nil;
+  glXGetCurrentDisplayEXT := nil;
+  glXImportContextEXT := nil;
+  glXQueryContextInfoEXT := nil; 
+  glXCopySubBufferMESA := nil; 
+  glXCreateGLXPixmapMESA := nil; 
+  glXReleaseBuffersMESA := nil; 
+  glXSet3DfxModeMESA := nil; 
+  {$endif}
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure LoadProcAddresses;
+begin
+  if GLHandle <> INVALID_MODULEHANDLE then
+  begin
+    glAccum := GetModuleSymbol( GLHandle, 'glAccum');
+    glAlphaFunc := GetModuleSymbol( GLHandle, 'glAlphaFunc'); 
+    glAreTexturesResident := GetModuleSymbol( GLHandle, 'glAreTexturesResident'); 
+    glArrayElement := GetModuleSymbol( GLHandle, 'glArrayElement'); 
+    glBegin := GetModuleSymbol( GLHandle, 'glBegin'); 
+    glBindTexture := GetModuleSymbol( GLHandle, 'glBindTexture'); 
+    glBitmap := GetModuleSymbol( GLHandle, 'glBitmap'); 
+    glBlendFunc := GetModuleSymbol( GLHandle, 'glBlendFunc'); 
+    glCallList := GetModuleSymbol( GLHandle, 'glCallList'); 
+    glCallLists := GetModuleSymbol( GLHandle, 'glCallLists'); 
+    glClear := GetModuleSymbol( GLHandle, 'glClear'); 
+    glClearAccum := GetModuleSymbol( GLHandle, 'glClearAccum'); 
+    glClearColor := GetModuleSymbol( GLHandle, 'glClearColor'); 
+    glClearDepth := GetModuleSymbol( GLHandle, 'glClearDepth'); 
+    glClearIndex := GetModuleSymbol( GLHandle, 'glClearIndex'); 
+    glClearStencil := GetModuleSymbol( GLHandle, 'glClearStencil'); 
+    glClipPlane := GetModuleSymbol( GLHandle, 'glClipPlane'); 
+    glColor3b := GetModuleSymbol( GLHandle, 'glColor3b'); 
+    glColor3bv := GetModuleSymbol( GLHandle, 'glColor3bv'); 
+    glColor3d := GetModuleSymbol( GLHandle, 'glColor3d'); 
+    glColor3dv := GetModuleSymbol( GLHandle, 'glColor3dv'); 
+    glColor3f := GetModuleSymbol( GLHandle, 'glColor3f'); 
+    glColor3fv := GetModuleSymbol( GLHandle, 'glColor3fv'); 
+    glColor3i := GetModuleSymbol( GLHandle, 'glColor3i'); 
+    glColor3iv := GetModuleSymbol( GLHandle, 'glColor3iv');
+    glColor3s := GetModuleSymbol( GLHandle, 'glColor3s'); 
+    glColor3sv := GetModuleSymbol( GLHandle, 'glColor3sv'); 
+    glColor3ub := GetModuleSymbol( GLHandle, 'glColor3ub');
+    glColor3ubv := GetModuleSymbol( GLHandle, 'glColor3ubv'); 
+    glColor3ui := GetModuleSymbol( GLHandle, 'glColor3ui'); 
+    glColor3uiv := GetModuleSymbol( GLHandle, 'glColor3uiv'); 
+    glColor3us := GetModuleSymbol( GLHandle, 'glColor3us'); 
+    glColor3usv := GetModuleSymbol( GLHandle, 'glColor3usv'); 
+    glColor4b := GetModuleSymbol( GLHandle, 'glColor4b'); 
+    glColor4bv := GetModuleSymbol( GLHandle, 'glColor4bv'); 
+    glColor4d := GetModuleSymbol( GLHandle, 'glColor4d'); 
+    glColor4dv := GetModuleSymbol( GLHandle, 'glColor4dv'); 
+    glColor4f := GetModuleSymbol( GLHandle, 'glColor4f'); 
+    glColor4fv := GetModuleSymbol( GLHandle, 'glColor4fv'); 
+    glColor4i := GetModuleSymbol( GLHandle, 'glColor4i'); 
+    glColor4iv := GetModuleSymbol( GLHandle, 'glColor4iv'); 
+    glColor4s := GetModuleSymbol( GLHandle, 'glColor4s'); 
+    glColor4sv := GetModuleSymbol( GLHandle, 'glColor4sv'); 
+    glColor4ub := GetModuleSymbol( GLHandle, 'glColor4ub'); 
+    glColor4ubv := GetModuleSymbol( GLHandle, 'glColor4ubv'); 
+    glColor4ui := GetModuleSymbol( GLHandle, 'glColor4ui'); 
+    glColor4uiv := GetModuleSymbol( GLHandle, 'glColor4uiv'); 
+    glColor4us := GetModuleSymbol( GLHandle, 'glColor4us'); 
+    glColor4usv := GetModuleSymbol( GLHandle, 'glColor4usv'); 
+    glColorMask := GetModuleSymbol( GLHandle, 'glColorMask');
+    glColorMaterial := GetModuleSymbol( GLHandle, 'glColorMaterial'); 
+    glColorPointer := GetModuleSymbol( GLHandle, 'glColorPointer'); 
+    glCopyPixels := GetModuleSymbol( GLHandle, 'glCopyPixels'); 
+    glCopyTexImage1D := GetModuleSymbol( GLHandle, 'glCopyTexImage1D'); 
+    glCopyTexImage2D := GetModuleSymbol( GLHandle, 'glCopyTexImage2D'); 
+    glCopyTexSubImage1D := GetModuleSymbol( GLHandle, 'glCopyTexSubImage1D'); 
+    glCopyTexSubImage2D := GetModuleSymbol( GLHandle, 'glCopyTexSubImage2D'); 
+    glCullFace := GetModuleSymbol( GLHandle, 'glCullFace'); 
+    glDeleteLists := GetModuleSymbol( GLHandle, 'glDeleteLists'); 
+    glDeleteTextures := GetModuleSymbol( GLHandle, 'glDeleteTextures'); 
+    glDepthFunc := GetModuleSymbol( GLHandle, 'glDepthFunc');
+    glDepthMask := GetModuleSymbol( GLHandle, 'glDepthMask'); 
+    glDepthRange := GetModuleSymbol( GLHandle, 'glDepthRange'); 
+    glDisable := GetModuleSymbol( GLHandle, 'glDisable'); 
+    glDisableClientState := GetModuleSymbol( GLHandle, 'glDisableClientState'); 
+    glDrawArrays := GetModuleSymbol( GLHandle, 'glDrawArrays'); 
+    glDrawBuffer := GetModuleSymbol( GLHandle, 'glDrawBuffer'); 
+    glDrawElements := GetModuleSymbol( GLHandle, 'glDrawElements'); 
+    glDrawPixels := GetModuleSymbol( GLHandle, 'glDrawPixels'); 
+    glEdgeFlag := GetModuleSymbol( GLHandle, 'glEdgeFlag'); 
+    glEdgeFlagPointer := GetModuleSymbol( GLHandle, 'glEdgeFlagPointer'); 
+    glEdgeFlagv := GetModuleSymbol( GLHandle, 'glEdgeFlagv'); 
+    glEnable := GetModuleSymbol( GLHandle, 'glEnable'); 
+    glEnableClientState := GetModuleSymbol( GLHandle, 'glEnableClientState'); 
+    glEnd := GetModuleSymbol( GLHandle, 'glEnd');
+    glEndList := GetModuleSymbol( GLHandle, 'glEndList'); 
+    glEvalCoord1d := GetModuleSymbol( GLHandle, 'glEvalCoord1d'); 
+    glEvalCoord1dv := GetModuleSymbol( GLHandle, 'glEvalCoord1dv'); 
+    glEvalCoord1f := GetModuleSymbol( GLHandle, 'glEvalCoord1f'); 
+    glEvalCoord1fv := GetModuleSymbol( GLHandle, 'glEvalCoord1fv'); 
+    glEvalCoord2d := GetModuleSymbol( GLHandle, 'glEvalCoord2d'); 
+    glEvalCoord2dv := GetModuleSymbol( GLHandle, 'glEvalCoord2dv'); 
+    glEvalCoord2f := GetModuleSymbol( GLHandle, 'glEvalCoord2f'); 
+    glEvalCoord2fv := GetModuleSymbol( GLHandle, 'glEvalCoord2fv'); 
+    glEvalMesh1 := GetModuleSymbol( GLHandle, 'glEvalMesh1'); 
+    glEvalMesh2 := GetModuleSymbol( GLHandle, 'glEvalMesh2'); 
+    glEvalPoint1 := GetModuleSymbol( GLHandle, 'glEvalPoint1'); 
+    glEvalPoint2 := GetModuleSymbol( GLHandle, 'glEvalPoint2'); 
+    glFeedbackBuffer := GetModuleSymbol( GLHandle, 'glFeedbackBuffer'); 
+    glFinish := GetModuleSymbol( GLHandle, 'glFinish'); 
+    glFlush := GetModuleSymbol( GLHandle, 'glFlush'); 
+    glFogf := GetModuleSymbol( GLHandle, 'glFogf'); 
+    glFogfv := GetModuleSymbol( GLHandle, 'glFogfv'); 
+    glFogi := GetModuleSymbol( GLHandle, 'glFogi');
+    glFogiv := GetModuleSymbol( GLHandle, 'glFogiv'); 
+    glFrontFace := GetModuleSymbol( GLHandle, 'glFrontFace'); 
+    glFrustum := GetModuleSymbol( GLHandle, 'glFrustum'); 
+    glGenLists := GetModuleSymbol( GLHandle, 'glGenLists'); 
+    glGenTextures := GetModuleSymbol( GLHandle, 'glGenTextures'); 
+    glGetBooleanv := GetModuleSymbol( GLHandle, 'glGetBooleanv');
+    glGetClipPlane := GetModuleSymbol( GLHandle, 'glGetClipPlane'); 
+    glGetDoublev := GetModuleSymbol( GLHandle, 'glGetDoublev'); 
+    glGetError := GetModuleSymbol( GLHandle, 'glGetError'); 
+    glGetFloatv := GetModuleSymbol( GLHandle, 'glGetFloatv'); 
+    glGetIntegerv := GetModuleSymbol( GLHandle, 'glGetIntegerv'); 
+    glGetLightfv := GetModuleSymbol( GLHandle, 'glGetLightfv'); 
+    glGetLightiv := GetModuleSymbol( GLHandle, 'glGetLightiv'); 
+    glGetMapdv := GetModuleSymbol( GLHandle, 'glGetMapdv'); 
+    glGetMapfv := GetModuleSymbol( GLHandle, 'glGetMapfv'); 
+    glGetMapiv := GetModuleSymbol( GLHandle, 'glGetMapiv'); 
+    glGetMaterialfv := GetModuleSymbol( GLHandle, 'glGetMaterialfv'); 
+    glGetMaterialiv := GetModuleSymbol( GLHandle, 'glGetMaterialiv'); 
+    glGetPixelMapfv := GetModuleSymbol( GLHandle, 'glGetPixelMapfv'); 
+    glGetPixelMapuiv := GetModuleSymbol( GLHandle, 'glGetPixelMapuiv'); 
+    glGetPixelMapusv := GetModuleSymbol( GLHandle, 'glGetPixelMapusv'); 
+    glGetPointerv := GetModuleSymbol( GLHandle, 'glGetPointerv'); 
+    glGetPolygonStipple := GetModuleSymbol( GLHandle, 'glGetPolygonStipple'); 
+    glGetString := GetModuleSymbol( GLHandle, 'glGetString'); 
+    glGetTexEnvfv := GetModuleSymbol( GLHandle, 'glGetTexEnvfv'); 
+    glGetTexEnviv := GetModuleSymbol( GLHandle, 'glGetTexEnviv'); 
+    glGetTexGendv := GetModuleSymbol( GLHandle, 'glGetTexGendv'); 
+    glGetTexGenfv := GetModuleSymbol( GLHandle, 'glGetTexGenfv'); 
+    glGetTexGeniv := GetModuleSymbol( GLHandle, 'glGetTexGeniv'); 
+    glGetTexImage := GetModuleSymbol( GLHandle, 'glGetTexImage'); 
+    glGetTexLevelParameterfv := GetModuleSymbol( GLHandle, 'glGetTexLevelParameterfv');
+    glGetTexLevelParameteriv := GetModuleSymbol( GLHandle, 'glGetTexLevelParameteriv'); 
+    glGetTexParameterfv := GetModuleSymbol( GLHandle, 'glGetTexParameterfv');
+    glGetTexParameteriv := GetModuleSymbol( GLHandle, 'glGetTexParameteriv'); 
+    glHint := GetModuleSymbol( GLHandle, 'glHint'); 
+    glIndexMask := GetModuleSymbol( GLHandle, 'glIndexMask'); 
+    glIndexPointer := GetModuleSymbol( GLHandle, 'glIndexPointer'); 
+    glIndexd := GetModuleSymbol( GLHandle, 'glIndexd'); 
+    glIndexdv := GetModuleSymbol( GLHandle, 'glIndexdv'); 
+    glIndexf := GetModuleSymbol( GLHandle, 'glIndexf'); 
+    glIndexfv := GetModuleSymbol( GLHandle, 'glIndexfv'); 
+    glIndexi := GetModuleSymbol( GLHandle, 'glIndexi'); 
+    glIndexiv := GetModuleSymbol( GLHandle, 'glIndexiv'); 
+    glIndexs := GetModuleSymbol( GLHandle, 'glIndexs'); 
+    glIndexsv := GetModuleSymbol( GLHandle, 'glIndexsv'); 
+    glIndexub := GetModuleSymbol( GLHandle, 'glIndexub'); 
+    glIndexubv := GetModuleSymbol( GLHandle, 'glIndexubv'); 
+    glInitNames := GetModuleSymbol( GLHandle, 'glInitNames'); 
+    glInterleavedArrays := GetModuleSymbol( GLHandle, 'glInterleavedArrays'); 
+    glIsEnabled := GetModuleSymbol( GLHandle, 'glIsEnabled'); 
+    glIsList := GetModuleSymbol( GLHandle, 'glIsList'); 
+    glIsTexture := GetModuleSymbol( GLHandle, 'glIsTexture'); 
+    glLightModelf := GetModuleSymbol( GLHandle, 'glLightModelf'); 
+    glLightModelfv := GetModuleSymbol( GLHandle, 'glLightModelfv'); 
+    glLightModeli := GetModuleSymbol( GLHandle, 'glLightModeli'); 
+    glLightModeliv := GetModuleSymbol( GLHandle, 'glLightModeliv');
+    glLightf := GetModuleSymbol( GLHandle, 'glLightf'); 
+    glLightfv := GetModuleSymbol( GLHandle, 'glLightfv'); 
+    glLighti := GetModuleSymbol( GLHandle, 'glLighti'); 
+    glLightiv := GetModuleSymbol( GLHandle, 'glLightiv'); 
+    glLineStipple := GetModuleSymbol( GLHandle, 'glLineStipple'); 
+    glLineWidth := GetModuleSymbol( GLHandle, 'glLineWidth'); 
+    glListBase := GetModuleSymbol( GLHandle, 'glListBase'); 
+    glLoadIdentity := GetModuleSymbol( GLHandle, 'glLoadIdentity'); 
+    glLoadMatrixd := GetModuleSymbol( GLHandle, 'glLoadMatrixd'); 
+    glLoadMatrixf := GetModuleSymbol( GLHandle, 'glLoadMatrixf');
+    glLoadName := GetModuleSymbol( GLHandle, 'glLoadName'); 
+    glLogicOp := GetModuleSymbol( GLHandle, 'glLogicOp'); 
+    glMap1d := GetModuleSymbol( GLHandle, 'glMap1d'); 
+    glMap1f := GetModuleSymbol( GLHandle, 'glMap1f'); 
+    glMap2d := GetModuleSymbol( GLHandle, 'glMap2d'); 
+    glMap2f := GetModuleSymbol( GLHandle, 'glMap2f'); 
+    glMapGrid1d := GetModuleSymbol( GLHandle, 'glMapGrid1d'); 
+    glMapGrid1f := GetModuleSymbol( GLHandle, 'glMapGrid1f'); 
+    glMapGrid2d := GetModuleSymbol( GLHandle, 'glMapGrid2d'); 
+    glMapGrid2f := GetModuleSymbol( GLHandle, 'glMapGrid2f'); 
+    glMaterialf := GetModuleSymbol( GLHandle, 'glMaterialf'); 
+    glMaterialfv := GetModuleSymbol( GLHandle, 'glMaterialfv'); 
+    glMateriali := GetModuleSymbol( GLHandle, 'glMateriali'); 
+    glMaterialiv := GetModuleSymbol( GLHandle, 'glMaterialiv'); 
+    glMatrixMode := GetModuleSymbol( GLHandle, 'glMatrixMode');
+    glMultMatrixd := GetModuleSymbol( GLHandle, 'glMultMatrixd'); 
+    glMultMatrixf := GetModuleSymbol( GLHandle, 'glMultMatrixf'); 
+    glNewList := GetModuleSymbol( GLHandle, 'glNewList'); 
+    glNormal3b := GetModuleSymbol( GLHandle, 'glNormal3b'); 
+    glNormal3bv := GetModuleSymbol( GLHandle, 'glNormal3bv'); 
+    glNormal3d := GetModuleSymbol( GLHandle, 'glNormal3d'); 
+    glNormal3dv := GetModuleSymbol( GLHandle, 'glNormal3dv'); 
+    glNormal3f := GetModuleSymbol( GLHandle, 'glNormal3f'); 
+    glNormal3fv := GetModuleSymbol( GLHandle, 'glNormal3fv'); 
+    glNormal3i := GetModuleSymbol( GLHandle, 'glNormal3i'); 
+    glNormal3iv := GetModuleSymbol( GLHandle, 'glNormal3iv'); 
+    glNormal3s := GetModuleSymbol( GLHandle, 'glNormal3s'); 
+    glNormal3sv := GetModuleSymbol( GLHandle, 'glNormal3sv'); 
+    glNormalPointer := GetModuleSymbol( GLHandle, 'glNormalPointer'); 
+    glOrtho := GetModuleSymbol( GLHandle, 'glOrtho'); 
+    glPassThrough := GetModuleSymbol( GLHandle, 'glPassThrough'); 
+    glPixelMapfv := GetModuleSymbol( GLHandle, 'glPixelMapfv'); 
+    glPixelMapuiv := GetModuleSymbol( GLHandle, 'glPixelMapuiv');
+    glPixelMapusv := GetModuleSymbol( GLHandle, 'glPixelMapusv'); 
+    glPixelStoref := GetModuleSymbol( GLHandle, 'glPixelStoref'); 
+    glPixelStorei := GetModuleSymbol( GLHandle, 'glPixelStorei'); 
+    glPixelTransferf := GetModuleSymbol( GLHandle, 'glPixelTransferf'); 
+    glPixelTransferi := GetModuleSymbol( GLHandle, 'glPixelTransferi'); 
+    glPixelZoom := GetModuleSymbol( GLHandle, 'glPixelZoom'); 
+    glPointSize := GetModuleSymbol( GLHandle, 'glPointSize');
+    glPolygonMode := GetModuleSymbol( GLHandle, 'glPolygonMode'); 
+    glPolygonOffset := GetModuleSymbol( GLHandle, 'glPolygonOffset'); 
+    glPolygonStipple := GetModuleSymbol( GLHandle, 'glPolygonStipple'); 
+    glPopAttrib := GetModuleSymbol( GLHandle, 'glPopAttrib'); 
+    glPopClientAttrib := GetModuleSymbol( GLHandle, 'glPopClientAttrib'); 
+    glPopMatrix := GetModuleSymbol( GLHandle, 'glPopMatrix'); 
+    glPopName := GetModuleSymbol( GLHandle, 'glPopName'); 
+    glPrioritizeTextures := GetModuleSymbol( GLHandle, 'glPrioritizeTextures'); 
+    glPushAttrib := GetModuleSymbol( GLHandle, 'glPushAttrib'); 
+    glPushClientAttrib := GetModuleSymbol( GLHandle, 'glPushClientAttrib'); 
+    glPushMatrix := GetModuleSymbol( GLHandle, 'glPushMatrix'); 
+    glPushName := GetModuleSymbol( GLHandle, 'glPushName'); 
+    glRasterPos2d := GetModuleSymbol( GLHandle, 'glRasterPos2d'); 
+    glRasterPos2dv := GetModuleSymbol( GLHandle, 'glRasterPos2dv'); 
+    glRasterPos2f := GetModuleSymbol( GLHandle, 'glRasterPos2f'); 
+    glRasterPos2fv := GetModuleSymbol( GLHandle, 'glRasterPos2fv'); 
+    glRasterPos2i := GetModuleSymbol( GLHandle, 'glRasterPos2i'); 
+    glRasterPos2iv := GetModuleSymbol( GLHandle, 'glRasterPos2iv'); 
+    glRasterPos2s := GetModuleSymbol( GLHandle, 'glRasterPos2s'); 
+    glRasterPos2sv := GetModuleSymbol( GLHandle, 'glRasterPos2sv'); 
+    glRasterPos3d := GetModuleSymbol( GLHandle, 'glRasterPos3d'); 
+    glRasterPos3dv := GetModuleSymbol( GLHandle, 'glRasterPos3dv'); 
+    glRasterPos3f := GetModuleSymbol( GLHandle, 'glRasterPos3f'); 
+    glRasterPos3fv := GetModuleSymbol( GLHandle, 'glRasterPos3fv'); 
+    glRasterPos3i := GetModuleSymbol( GLHandle, 'glRasterPos3i');
+    glRasterPos3iv := GetModuleSymbol( GLHandle, 'glRasterPos3iv');
+    glRasterPos3s := GetModuleSymbol( GLHandle, 'glRasterPos3s'); 
+    glRasterPos3sv := GetModuleSymbol( GLHandle, 'glRasterPos3sv'); 
+    glRasterPos4d := GetModuleSymbol( GLHandle, 'glRasterPos4d'); 
+    glRasterPos4dv := GetModuleSymbol( GLHandle, 'glRasterPos4dv'); 
+    glRasterPos4f := GetModuleSymbol( GLHandle, 'glRasterPos4f'); 
+    glRasterPos4fv := GetModuleSymbol( GLHandle, 'glRasterPos4fv'); 
+    glRasterPos4i := GetModuleSymbol( GLHandle, 'glRasterPos4i'); 
+    glRasterPos4iv := GetModuleSymbol( GLHandle, 'glRasterPos4iv'); 
+    glRasterPos4s := GetModuleSymbol( GLHandle, 'glRasterPos4s'); 
+    glRasterPos4sv := GetModuleSymbol( GLHandle, 'glRasterPos4sv'); 
+    glReadBuffer := GetModuleSymbol( GLHandle, 'glReadBuffer'); 
+    glReadPixels := GetModuleSymbol( GLHandle, 'glReadPixels'); 
+    glRectd := GetModuleSymbol( GLHandle, 'glRectd'); 
+    glRectdv := GetModuleSymbol( GLHandle, 'glRectdv'); 
+    glRectf := GetModuleSymbol( GLHandle, 'glRectf'); 
+    glRectfv := GetModuleSymbol( GLHandle, 'glRectfv'); 
+    glRecti := GetModuleSymbol( GLHandle, 'glRecti'); 
+    glRectiv := GetModuleSymbol( GLHandle, 'glRectiv'); 
+    glRects := GetModuleSymbol( GLHandle, 'glRects'); 
+    glRectsv := GetModuleSymbol( GLHandle, 'glRectsv'); 
+    glRenderMode := GetModuleSymbol( GLHandle, 'glRenderMode'); 
+    glRotated := GetModuleSymbol( GLHandle, 'glRotated'); 
+    glRotatef := GetModuleSymbol( GLHandle, 'glRotatef'); 
+    glScaled := GetModuleSymbol( GLHandle, 'glScaled');
+    glScalef := GetModuleSymbol( GLHandle, 'glScalef'); 
+    glScissor := GetModuleSymbol( GLHandle, 'glScissor'); 
+    glSelectBuffer := GetModuleSymbol( GLHandle, 'glSelectBuffer'); 
+    glShadeModel := GetModuleSymbol( GLHandle, 'glShadeModel'); 
+    glStencilFunc := GetModuleSymbol( GLHandle, 'glStencilFunc'); 
+    glStencilMask := GetModuleSymbol( GLHandle, 'glStencilMask'); 
+    glStencilOp := GetModuleSymbol( GLHandle, 'glStencilOp'); 
+    glTexCoord1d := GetModuleSymbol( GLHandle, 'glTexCoord1d'); 
+    glTexCoord1dv := GetModuleSymbol( GLHandle, 'glTexCoord1dv');
+    glTexCoord1f := GetModuleSymbol( GLHandle, 'glTexCoord1f'); 
+    glTexCoord1fv := GetModuleSymbol( GLHandle, 'glTexCoord1fv'); 
+    glTexCoord1i := GetModuleSymbol( GLHandle, 'glTexCoord1i'); 
+    glTexCoord1iv := GetModuleSymbol( GLHandle, 'glTexCoord1iv'); 
+    glTexCoord1s := GetModuleSymbol( GLHandle, 'glTexCoord1s'); 
+    glTexCoord1sv := GetModuleSymbol( GLHandle, 'glTexCoord1sv'); 
+    glTexCoord2d := GetModuleSymbol( GLHandle, 'glTexCoord2d'); 
+    glTexCoord2dv := GetModuleSymbol( GLHandle, 'glTexCoord2dv'); 
+    glTexCoord2f := GetModuleSymbol( GLHandle, 'glTexCoord2f'); 
+    glTexCoord2fv := GetModuleSymbol( GLHandle, 'glTexCoord2fv'); 
+    glTexCoord2i := GetModuleSymbol( GLHandle, 'glTexCoord2i'); 
+    glTexCoord2iv := GetModuleSymbol( GLHandle, 'glTexCoord2iv'); 
+    glTexCoord2s := GetModuleSymbol( GLHandle, 'glTexCoord2s'); 
+    glTexCoord2sv := GetModuleSymbol( GLHandle, 'glTexCoord2sv'); 
+    glTexCoord3d := GetModuleSymbol( GLHandle, 'glTexCoord3d'); 
+    glTexCoord3dv := GetModuleSymbol( GLHandle, 'glTexCoord3dv');
+    glTexCoord3f := GetModuleSymbol( GLHandle, 'glTexCoord3f'); 
+    glTexCoord3fv := GetModuleSymbol( GLHandle, 'glTexCoord3fv'); 
+    glTexCoord3i := GetModuleSymbol( GLHandle, 'glTexCoord3i'); 
+    glTexCoord3iv := GetModuleSymbol( GLHandle, 'glTexCoord3iv'); 
+    glTexCoord3s := GetModuleSymbol( GLHandle, 'glTexCoord3s'); 
+    glTexCoord3sv := GetModuleSymbol( GLHandle, 'glTexCoord3sv'); 
+    glTexCoord4d := GetModuleSymbol( GLHandle, 'glTexCoord4d'); 
+    glTexCoord4dv := GetModuleSymbol( GLHandle, 'glTexCoord4dv'); 
+    glTexCoord4f := GetModuleSymbol( GLHandle, 'glTexCoord4f'); 
+    glTexCoord4fv := GetModuleSymbol( GLHandle, 'glTexCoord4fv'); 
+    glTexCoord4i := GetModuleSymbol( GLHandle, 'glTexCoord4i'); 
+    glTexCoord4iv := GetModuleSymbol( GLHandle, 'glTexCoord4iv'); 
+    glTexCoord4s := GetModuleSymbol( GLHandle, 'glTexCoord4s'); 
+    glTexCoord4sv := GetModuleSymbol( GLHandle, 'glTexCoord4sv'); 
+    glTexCoordPointer := GetModuleSymbol( GLHandle, 'glTexCoordPointer'); 
+    glTexEnvf := GetModuleSymbol( GLHandle, 'glTexEnvf'); 
+    glTexEnvfv := GetModuleSymbol( GLHandle, 'glTexEnvfv');
+    glTexEnvi := GetModuleSymbol( GLHandle, 'glTexEnvi'); 
+    glTexEnviv := GetModuleSymbol( GLHandle, 'glTexEnviv'); 
+    glTexGend := GetModuleSymbol( GLHandle, 'glTexGend'); 
+    glTexGendv := GetModuleSymbol( GLHandle, 'glTexGendv'); 
+    glTexGenf := GetModuleSymbol( GLHandle, 'glTexGenf'); 
+    glTexGenfv := GetModuleSymbol( GLHandle, 'glTexGenfv'); 
+    glTexGeni := GetModuleSymbol( GLHandle, 'glTexGeni'); 
+    glTexGeniv := GetModuleSymbol( GLHandle, 'glTexGeniv');
+    glTexImage1D := GetModuleSymbol( GLHandle, 'glTexImage1D'); 
+    glTexImage2D := GetModuleSymbol( GLHandle, 'glTexImage2D'); 
+    glTexParameterf := GetModuleSymbol( GLHandle, 'glTexParameterf'); 
+    glTexParameterfv := GetModuleSymbol( GLHandle, 'glTexParameterfv'); 
+    glTexParameteri := GetModuleSymbol( GLHandle, 'glTexParameteri'); 
+    glTexParameteriv := GetModuleSymbol( GLHandle, 'glTexParameteriv'); 
+    glTexSubImage1D := GetModuleSymbol( GLHandle, 'glTexSubImage1D'); 
+    glTexSubImage2D := GetModuleSymbol( GLHandle, 'glTexSubImage2D'); 
+    glTranslated := GetModuleSymbol( GLHandle, 'glTranslated'); 
+    glTranslatef := GetModuleSymbol( GLHandle, 'glTranslatef'); 
+    glVertex2d := GetModuleSymbol( GLHandle, 'glVertex2d'); 
+    glVertex2dv := GetModuleSymbol( GLHandle, 'glVertex2dv'); 
+    glVertex2f := GetModuleSymbol( GLHandle, 'glVertex2f'); 
+    glVertex2fv := GetModuleSymbol( GLHandle, 'glVertex2fv'); 
+    glVertex2i := GetModuleSymbol( GLHandle, 'glVertex2i'); 
+    glVertex2iv := GetModuleSymbol( GLHandle, 'glVertex2iv'); 
+    glVertex2s := GetModuleSymbol( GLHandle, 'glVertex2s'); 
+    glVertex2sv := GetModuleSymbol( GLHandle, 'glVertex2sv'); 
+    glVertex3d := GetModuleSymbol( GLHandle, 'glVertex3d'); 
+    glVertex3dv := GetModuleSymbol( GLHandle, 'glVertex3dv'); 
+    glVertex3f := GetModuleSymbol( GLHandle, 'glVertex3f'); 
+    glVertex3fv := GetModuleSymbol( GLHandle, 'glVertex3fv'); 
+    glVertex3i := GetModuleSymbol( GLHandle, 'glVertex3i'); 
+    glVertex3iv := GetModuleSymbol( GLHandle, 'glVertex3iv'); 
+    glVertex3s := GetModuleSymbol( GLHandle, 'glVertex3s');
+    glVertex3sv := GetModuleSymbol( GLHandle, 'glVertex3sv'); 
+    glVertex4d := GetModuleSymbol( GLHandle, 'glVertex4d'); 
+    glVertex4dv := GetModuleSymbol( GLHandle, 'glVertex4dv'); 
+    glVertex4f := GetModuleSymbol( GLHandle, 'glVertex4f'); 
+    glVertex4fv := GetModuleSymbol( GLHandle, 'glVertex4fv'); 
+    glVertex4i := GetModuleSymbol( GLHandle, 'glVertex4i'); 
+    glVertex4iv := GetModuleSymbol( GLHandle, 'glVertex4iv'); 
+    glVertex4s := GetModuleSymbol( GLHandle, 'glVertex4s'); 
+    glVertex4sv := GetModuleSymbol( GLHandle, 'glVertex4sv'); 
+    glVertexPointer := GetModuleSymbol( GLHandle, 'glVertexPointer'); 
+    glViewport := GetModuleSymbol( GLHandle, 'glViewport'); 
+
+    // window support routines
+    {$ifdef Win32}
+    wglGetProcAddress := GetModuleSymbol( GLHandle, 'wglGetProcAddress'); 
+    wglCopyContext := GetModuleSymbol( GLHandle, 'wglCopyContext'); 
+    wglCreateContext := GetModuleSymbol( GLHandle, 'wglCreateContext'); 
+    wglCreateLayerContext := GetModuleSymbol( GLHandle, 'wglCreateLayerContext'); 
+    wglDeleteContext := GetModuleSymbol( GLHandle, 'wglDeleteContext'); 
+    wglDescribeLayerPlane := GetModuleSymbol( GLHandle, 'wglDescribeLayerPlane'); 
+    wglGetCurrentContext := GetModuleSymbol( GLHandle, 'wglGetCurrentContext'); 
+    wglGetCurrentDC := GetModuleSymbol( GLHandle, 'wglGetCurrentDC'); 
+    wglGetLayerPaletteEntries := GetModuleSymbol( GLHandle, 'wglGetLayerPaletteEntries'); 
+    wglMakeCurrent := GetModuleSymbol( GLHandle, 'wglMakeCurrent'); 
+    wglRealizeLayerPalette := GetModuleSymbol( GLHandle, 'wglRealizeLayerPalette');
+    wglSetLayerPaletteEntries := GetModuleSymbol( GLHandle, 'wglSetLayerPaletteEntries'); 
+    wglShareLists := GetModuleSymbol( GLHandle, 'wglShareLists'); 
+    wglSwapLayerBuffers := GetModuleSymbol( GLHandle, 'wglSwapLayerBuffers'); 
+    wglSwapMultipleBuffers := GetModuleSymbol( GLHandle, 'wglSwapMultipleBuffers'); 
+    wglUseFontBitmapsA := GetModuleSymbol( GLHandle, 'wglUseFontBitmapsA'); 
+    wglUseFontOutlinesA := GetModuleSymbol( GLHandle, 'wglUseFontOutlinesA'); 
+    wglUseFontBitmapsW := GetModuleSymbol( GLHandle, 'wglUseFontBitmapsW'); 
+    wglUseFontOutlinesW := GetModuleSymbol( GLHandle, 'wglUseFontOutlinesW');
+    wglUseFontBitmaps := GetModuleSymbol( GLHandle, 'wglUseFontBitmapsA'); 
+    wglUseFontOutlines := GetModuleSymbol( GLHandle, 'wglUseFontOutlinesA');
+    {$endif}
+
+    // GL 1.2
+    glDrawRangeElements := GetModuleSymbol( GLHandle, 'glDrawRangeElements'); 
+    glTexImage3D := GetModuleSymbol( GLHandle, 'glTexImage3D'); 
+
+    // GL 1.2 ARB imaging
+    glBlendColor := GetModuleSymbol( GLHandle, 'glBlendColor'); 
+    glBlendEquation := GetModuleSymbol( GLHandle, 'glBlendEquation'); 
+    glColorSubTable := GetModuleSymbol( GLHandle, 'glColorSubTable'); 
+    glCopyColorSubTable := GetModuleSymbol( GLHandle, 'glCopyColorSubTable'); 
+    glColorTable := GetModuleSymbol( GLHandle, 'glCopyColorSubTable'); 
+    glCopyColorTable := GetModuleSymbol( GLHandle, 'glCopyColorTable'); 
+    glColorTableParameteriv := GetModuleSymbol( GLHandle, 'glColorTableParameteriv'); 
+    glColorTableParameterfv := GetModuleSymbol( GLHandle, 'glColorTableParameterfv');
+    glGetColorTable := GetModuleSymbol( GLHandle, 'glGetColorTable'); 
+    glGetColorTableParameteriv := GetModuleSymbol( GLHandle, 'glGetColorTableParameteriv'); 
+    glGetColorTableParameterfv := GetModuleSymbol( GLHandle, 'glGetColorTableParameterfv'); 
+    glConvolutionFilter1D := GetModuleSymbol( GLHandle, 'glConvolutionFilter1D'); 
+    glConvolutionFilter2D := GetModuleSymbol( GLHandle, 'glConvolutionFilter2D'); 
+    glCopyConvolutionFilter1D := GetModuleSymbol( GLHandle, 'glCopyConvolutionFilter1D'); 
+    glCopyConvolutionFilter2D := GetModuleSymbol( GLHandle, 'glCopyConvolutionFilter2D'); 
+    glGetConvolutionFilter := GetModuleSymbol( GLHandle, 'glGetConvolutionFilter'); 
+    glSeparableFilter2D := GetModuleSymbol( GLHandle, 'glSeparableFilter2D'); 
+    glGetSeparableFilter := GetModuleSymbol( GLHandle, 'glGetSeparableFilter'); 
+    glConvolutionParameteri := GetModuleSymbol( GLHandle, 'glConvolutionParameteri'); 
+    glConvolutionParameteriv := GetModuleSymbol( GLHandle, 'glConvolutionParameteriv'); 
+    glConvolutionParameterf := GetModuleSymbol( GLHandle, 'glConvolutionParameterf'); 
+    glConvolutionParameterfv := GetModuleSymbol( GLHandle, 'glConvolutionParameterfv'); 
+    glGetConvolutionParameteriv := GetModuleSymbol( GLHandle, 'glGetConvolutionParameteriv'); 
+    glGetConvolutionParameterfv := GetModuleSymbol( GLHandle, 'glGetConvolutionParameterfv');
+    glHistogram := GetModuleSymbol( GLHandle, 'glHistogram'); 
+    glResetHistogram := GetModuleSymbol( GLHandle, 'glResetHistogram');
+    glGetHistogram := GetModuleSymbol( GLHandle, 'glGetHistogram');
+    glGetHistogramParameteriv := GetModuleSymbol( GLHandle, 'glGetHistogramParameteriv'); 
+    glGetHistogramParameterfv := GetModuleSymbol( GLHandle, 'glGetHistogramParameterfv'); 
+    glMinmax := GetModuleSymbol( GLHandle, 'glMinmax'); 
+    glResetMinmax := GetModuleSymbol( GLHandle, 'glResetMinmax'); 
+    glGetMinmax := GetModuleSymbol( GLHandle, 'glGetMinmax'); 
+    glGetMinmaxParameteriv := GetModuleSymbol( GLHandle, 'glGetMinmaxParameteriv');
+    glGetMinmaxParameterfv := GetModuleSymbol( GLHandle, 'glGetMinmaxParameterfv'); 
+
+    {$ifdef UNIX}
+    glXChooseVisual := GetModuleSymbol( GLHandle, 'glXChooseVisual'); 
+    glXCreateContext := GetModuleSymbol( GLHandle, 'glXCreateContext'); 
+    glXDestroyContext := GetModuleSymbol( GLHandle, 'glXDestroyContext'); 
+    glXMakeCurrent := GetModuleSymbol( GLHandle, 'glXMakeCurrent'); 
+    glXCopyContext := GetModuleSymbol( GLHandle, 'glXCopyContext'); 
+    glXSwapBuffers := GetModuleSymbol( GLHandle, 'glXSwapBuffers'); 
+    glXCreateGLXPixmap := GetModuleSymbol( GLHandle, 'glXCreateGLXPixmap'); 
+    glXDestroyGLXPixmap := GetModuleSymbol( GLHandle, 'glXDestroyGLXPixmap'); 
+    glXQueryExtension := GetModuleSymbol( GLHandle, 'glXQueryExtension'); 
+    glXQueryVersion := GetModuleSymbol( GLHandle, 'glXQueryVersion'); 
+    glXIsDirect := GetModuleSymbol( GLHandle, 'glXIsDirect'); 
+    glXGetConfig := GetModuleSymbol( GLHandle, 'glXGetConfig'); 
+    glXGetCurrentContext := GetModuleSymbol( GLHandle, 'glXGetCurrentContext'); 
+    glXGetCurrentDrawable := GetModuleSymbol( GLHandle, 'glXGetCurrentDrawable'); 
+    glXWaitGL := GetModuleSymbol( GLHandle, 'glXWaitGL'); 
+    glXWaitX := GetModuleSymbol( GLHandle, 'glXWaitX'); 
+    glXUseXFont := GetModuleSymbol( GLHandle, 'glXUseXFont'); 
+    glXQueryExtensionsString := GetModuleSymbol( GLHandle, 'glXQueryExtensionsString'); 
+    glXQueryServerString := GetModuleSymbol( GLHandle, 'glXQueryServerString'); 
+    glXGetClientString := GetModuleSymbol( GLHandle, 'glXGetClientString'); 
+    glXGetCurrentDisplay := GetModuleSymbol( GLHandle, 'glXGetCurrentDisplay');
+    glXChooseFBConfig := GetModuleSymbol( GLHandle, 'glXChooseFBConfig');
+    glXGetFBConfigAttrib := GetModuleSymbol( GLHandle, 'glXGetFBConfigAttrib'); 
+    glXGetFBConfigs := GetModuleSymbol( GLHandle, 'glXGetFBConfigs'); 
+    glXGetVisualFromFBConfig := GetModuleSymbol( GLHandle, 'glXGetVisualFromFBConfig'); 
+    glXCreateWindow := GetModuleSymbol( GLHandle, 'glXCreateWindow'); 
+    glXDestroyWindow := GetModuleSymbol( GLHandle, 'glXDestroyWindow'); 
+    glXCreatePixmap := GetModuleSymbol( GLHandle, 'glXCreatePixmap'); 
+    glXDestroyPixmap := GetModuleSymbol( GLHandle, 'glXDestroyPixmap'); 
+    glXCreatePbuffer := GetModuleSymbol( GLHandle, 'glXCreatePbuffer'); 
+    glXDestroyPbuffer := GetModuleSymbol( GLHandle, 'glXDestroyPbuffer'); 
+    glXQueryDrawable := GetModuleSymbol( GLHandle, 'glXQueryDrawable'); 
+    glXCreateNewContext := GetModuleSymbol( GLHandle, 'glXCreateNewContext'); 
+    glXMakeContextCurrent := GetModuleSymbol( GLHandle, 'glXMakeContextCurrent'); 
+    glXGetCurrentReadDrawable := GetModuleSymbol( GLHandle, 'glXGetCurrentReadDrawable'); 
+    glXQueryContext := GetModuleSymbol( GLHandle, 'glXQueryContext'); 
+    glXSelectEvent := GetModuleSymbol( GLHandle, 'glXSelectEvent'); 
+    glXGetSelectedEvent := GetModuleSymbol( GLHandle, 'glXGetSelectedEvent'); 
+    glXGetVideoSyncSGI := GetModuleSymbol( GLHandle, 'glXGetVideoSyncSGI'); 
+    glXWaitVideoSyncSGI := GetModuleSymbol( GLHandle, 'glXWaitVideoSyncSGI'); 
+    glXFreeContextEXT := GetModuleSymbol( GLHandle, 'glXFreeContextEXT'); 
+    glXGetContextIDEXT := GetModuleSymbol( GLHandle, 'glXGetContextIDEXT'); 
+    glXGetCurrentDisplayEXT := GetModuleSymbol( GLHandle, 'glXGetCurrentDisplayEXT'); 
+    glXImportContextEXT := GetModuleSymbol( GLHandle, 'glXImportContextEXT'); 
+    glXQueryContextInfoEXT := GetModuleSymbol( GLHandle, 'glXQueryContextInfoEXT'); 
+    glXCopySubBufferMESA := GetModuleSymbol( GLHandle, 'glXCopySubBufferMESA'); 
+    glXCreateGLXPixmapMESA := GetModuleSymbol( GLHandle, 'glXCreateGLXPixmapMESA');
+    glXReleaseBuffersMESA := GetModuleSymbol( GLHandle, 'glXReleaseBuffersMESA'); 
+    glXSet3DfxModeMESA := GetModuleSymbol( GLHandle, 'glXSet3DfxModeMESA'); 
+    {$endif}
+  end; 
+
+  if GLUHandle <> INVALID_MODULEHANDLE then
+  begin
+    GLHandle := TModuleHandle(GLUHandle); // Kylix compatiblilty trick
+
+    gluBeginCurve := GetModuleSymbol( GLUHandle, 'gluBeginCurve');
+    gluBeginPolygon := GetModuleSymbol( GLUHandle, 'gluBeginPolygon');
+    gluBeginSurface := GetModuleSymbol( GLUHandle, 'gluBeginSurface');
+    gluBeginTrim := GetModuleSymbol( GLUHandle, 'gluBeginTrim');
+    gluBuild1DMipmaps := GetModuleSymbol( GLUHandle, 'gluBuild1DMipmaps');
+    gluBuild2DMipmaps := GetModuleSymbol( GLUHandle, 'gluBuild2DMipmaps');
+    gluCylinder := GetModuleSymbol( GLUHandle, 'gluCylinder');
+    gluDeleteNurbsRenderer := GetModuleSymbol( GLUHandle, 'gluDeleteNurbsRenderer');
+    gluDeleteQuadric := GetModuleSymbol( GLUHandle, 'gluDeleteQuadric');
+    gluDeleteTess := GetModuleSymbol( GLUHandle, 'gluDeleteTess');
+    gluDisk := GetModuleSymbol( GLUHandle, 'gluDisk');
+    gluEndCurve := GetModuleSymbol( GLUHandle, 'gluEndCurve');
+    gluEndPolygon := GetModuleSymbol( GLUHandle, 'gluEndPolygon');
+    gluEndSurface := GetModuleSymbol( GLUHandle, 'gluEndSurface');
+    gluEndTrim := GetModuleSymbol( GLUHandle, 'gluEndTrim');
+    gluErrorString := GetModuleSymbol( GLUHandle, 'gluErrorString');
+    gluGetNurbsProperty := GetModuleSymbol( GLUHandle, 'gluGetNurbsProperty');
+    gluGetString := GetModuleSymbol( GLUHandle, 'gluGetString');
+    gluGetTessProperty := GetModuleSymbol( GLUHandle, 'gluGetTessProperty');
+    gluLoadSamplingMatrices := GetModuleSymbol( GLUHandle, 'gluLoadSamplingMatrices');
+    gluLookAt := GetModuleSymbol( GLUHandle, 'gluLookAt');
+    gluNewNurbsRenderer := GetModuleSymbol( GLUHandle, 'gluNewNurbsRenderer');
+    gluNewQuadric := GetModuleSymbol( GLUHandle, 'gluNewQuadric');
+    gluNewTess := GetModuleSymbol( GLUHandle, 'gluNewTess');
+    gluNextContour := GetModuleSymbol( GLUHandle, 'gluNextContour');
+    gluNurbsCallback := GetModuleSymbol( GLUHandle, 'gluNurbsCallback');
+    gluNurbsCurve := GetModuleSymbol( GLUHandle, 'gluNurbsCurve');
+    gluNurbsProperty := GetModuleSymbol( GLUHandle, 'gluNurbsProperty');
+    gluNurbsSurface := GetModuleSymbol( GLUHandle, 'gluNurbsSurface');
+    gluOrtho2D := GetModuleSymbol( GLUHandle, 'gluOrtho2D');
+    gluPartialDisk := GetModuleSymbol( GLUHandle, 'gluPartialDisk');
+    gluPerspective := GetModuleSymbol( GLUHandle, 'gluPerspective');
+    gluPickMatrix := GetModuleSymbol( GLUHandle, 'gluPickMatrix');
+    gluProject := GetModuleSymbol( GLUHandle, 'gluProject');
+    gluPwlCurve := GetModuleSymbol( GLUHandle, 'gluPwlCurve');
+    gluQuadricCallback := GetModuleSymbol( GLUHandle, 'gluQuadricCallback');
+    gluQuadricDrawStyle := GetModuleSymbol( GLUHandle, 'gluQuadricDrawStyle');
+    gluQuadricNormals := GetModuleSymbol( GLUHandle, 'gluQuadricNormals');
+    gluQuadricOrientation := GetModuleSymbol( GLUHandle, 'gluQuadricOrientation');
+    gluQuadricTexture := GetModuleSymbol( GLUHandle, 'gluQuadricTexture');
+    gluScaleImage := GetModuleSymbol( GLUHandle, 'gluScaleImage');
+    gluSphere := GetModuleSymbol( GLUHandle, 'gluSphere');
+    gluTessBeginContour := GetModuleSymbol( GLUHandle, 'gluTessBeginContour');
+    gluTessBeginPolygon := GetModuleSymbol( GLUHandle, 'gluTessBeginPolygon');
+    gluTessCallback := GetModuleSymbol( GLUHandle, 'gluTessCallback');
+    gluTessEndContour := GetModuleSymbol( GLUHandle, 'gluTessEndContour');
+    gluTessEndPolygon := GetModuleSymbol( GLUHandle, 'gluTessEndPolygon');
+    gluTessNormal := GetModuleSymbol( GLUHandle, 'gluTessNormal');
+    gluTessProperty := GetModuleSymbol( GLUHandle, 'gluTessProperty');
+    gluTessVertex := GetModuleSymbol( GLUHandle, 'gluTessVertex');
+    gluUnProject := GetModuleSymbol( GLUHandle, 'gluUnProject'); 
+  end; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure ClearExtensions; 
+
+begin
+  glArrayElementEXT := nil;
+  glDrawArraysEXT := nil;
+  glVertexPointerEXT := nil;
+  glNormalPointerEXT := nil;
+  glColorPointerEXT := nil;
+  glIndexPointerEXT := nil;
+  glTexCoordPointerEXT := nil; 
+  glEdgeFlagPointerEXT := nil;
+  glGetPointervEXT := nil; 
+  glArrayElementArrayEXT := nil; 
+  glAddSwapHintRectWIN := nil; 
+  glColorTableEXT := nil; 
+  glColorSubTableEXT := nil; 
+  glGetColorTableEXT := nil; 
+  glGetColorTablePameterivEXT := nil; 
+  glGetColorTablePameterfvEXT := nil; 
+  gluNurbsCallbackDataEXT := nil; 
+  gluNewNurbsTessellatorEXT := nil; 
+  gluDeleteNurbsTessellatorEXT := nil; 
+  glLockArraysEXT := nil; 
+  glUnlockArraysEXT := nil; 
+  glCopyTexImage1DEXT := nil; 
+  glCopyTexSubImage1DEXT := nil; 
+  glCopyTexImage2DEXT := nil; 
+  glCopyTexSubImage2DEXT := nil; 
+  glCopyTexSubImage3DEXT := nil; 
+  glCullParameterfvEXT := nil; 
+  glCullParameterdvEXT := nil; 
+  glIndexFuncEXT := nil; 
+  glIndexMaterialEXT := nil; 
+  glPolygonOffsetEXT := nil; 
+  glTexSubImage1DEXT := nil; 
+  glTexSubImage2DEXT := nil;
+  glTexSubImage3DEXT := nil; 
+  glGenTexturesEXT := nil; 
+  glDeleteTexturesEXT := nil; 
+  glBindTextureEXT := nil; 
+  glPrioritizeTexturesEXT := nil; 
+  glAreTexturesResidentEXT := nil;
+  glIsTextureEXT := nil; 
+
+  glMultiTexCoord1dARB := nil; 
+  glMultiTexCoord1dVARB := nil; 
+  glMultiTexCoord1fARBP := nil; 
+  glMultiTexCoord1fVARB := nil; 
+  glMultiTexCoord1iARB := nil; 
+  glMultiTexCoord1iVARB := nil; 
+  glMultiTexCoord1sARBP := nil; 
+  glMultiTexCoord1sVARB := nil; 
+  glMultiTexCoord2dARB := nil; 
+  glMultiTexCoord2dvARB := nil; 
+  glMultiTexCoord2fARB := nil; 
+  glMultiTexCoord2fvARB := nil; 
+  glMultiTexCoord2iARB := nil; 
+  glMultiTexCoord2ivARB := nil; 
+  glMultiTexCoord2sARB := nil; 
+  glMultiTexCoord2svARB := nil; 
+  glMultiTexCoord3dARB := nil;
+  glMultiTexCoord3dvARB := nil; 
+  glMultiTexCoord3fARB := nil; 
+  glMultiTexCoord3fvARB := nil; 
+  glMultiTexCoord3iARB := nil; 
+  glMultiTexCoord3ivARB := nil; 
+  glMultiTexCoord3sARB := nil; 
+  glMultiTexCoord3svARB := nil; 
+  glMultiTexCoord4dARB := nil;
+  glMultiTexCoord4dvARB := nil; 
+  glMultiTexCoord4fARB := nil; 
+  glMultiTexCoord4fvARB := nil; 
+  glMultiTexCoord4iARB := nil; 
+  glMultiTexCoord4ivARB := nil; 
+  glMultiTexCoord4sARB := nil; 
+  glMultiTexCoord4svARB := nil; 
+  glActiveTextureARB := nil; 
+  glClientActiveTextureARB := nil; 
+
+  // EXT_compiled_vertex_array
+  glLockArrayEXT := nil; 
+  glUnlockArrayEXT := nil; 
+
+  // EXT_cull_vertex
+  glCullParameterdvEXT := nil; 
+  glCullParameterfvEXT := nil;
+
+  // WIN_swap_hint
+  glAddSwapHintRectWIN := nil; 
+
+  // EXT_point_parameter
+  glPointParameterfEXT := nil; 
+  glPointParameterfvEXT := nil; 
+
+  // GL_ARB_transpose_matrix
+  glLoadTransposeMatrixfARB := nil; 
+  glLoadTransposeMatrixdARB := nil; 
+  glMultTransposeMatrixfARB := nil; 
+  glMultTransposeMatrixdARB := nil; 
+
+  glSampleCoverageARB := nil; 
+  glSamplePassARB := nil;
+
+  // GL_ARB_multisample
+  glCompressedTexImage3DARB := nil; 
+  glCompressedTexImage2DARB := nil; 
+  glCompressedTexImage1DARB := nil; 
+  glCompressedTexSubImage3DARB := nil; 
+  glCompressedTexSubImage2DARB := nil; 
+  glCompressedTexSubImage1DARB := nil; 
+  glGetCompressedTexImageARB := nil;
+
+  // GL_EXT_blend_color
+  glBlendColorEXT := nil; 
+
+  // GL_EXT_texture3D
+  glTexImage3DEXT := nil; 
+
+  // GL_SGIS_texture_filter4
+  glGetTexFilterFuncSGIS := nil; 
+  glTexFilterFuncSGIS := nil; 
+
+  // GL_EXT_histogram
+  glGetHistogramEXT := nil; 
+  glGetHistogramParameterfvEXT := nil; 
+  glGetHistogramParameterivEXT := nil; 
+  glGetMinmaxEXT := nil; 
+  glGetMinmaxParameterfvEXT := nil; 
+  glGetMinmaxParameterivEXT := nil; 
+  glHistogramEXT := nil; 
+  glMinmaxEXT := nil; 
+  glResetHistogramEXT := nil; 
+  glResetMinmaxEXT := nil; 
+
+  // GL_EXT_convolution
+  glConvolutionFilter1DEXT := nil;
+  glConvolutionFilter2DEXT := nil; 
+  glConvolutionParameterfEXT := nil; 
+  glConvolutionParameterfvEXT := nil; 
+  glConvolutionParameteriEXT := nil; 
+  glConvolutionParameterivEXT := nil; 
+  glCopyConvolutionFilter1DEXT := nil; 
+  glCopyConvolutionFilter2DEXT := nil; 
+  glGetConvolutionFilterEXT := nil; 
+  glGetConvolutionParameterfvEXT := nil; 
+  glGetConvolutionParameterivEXT := nil; 
+  glGetSeparableFilterEXT := nil; 
+  glSeparableFilter2DEXT := nil; 
+
+  // GL_SGI_color_table
+  glColorTableSGI := nil; 
+  glColorTableParameterfvSGI := nil; 
+  glColorTableParameterivSGI := nil; 
+  glCopyColorTableSGI := nil; 
+  glGetColorTableSGI := nil; 
+  glGetColorTableParameterfvSGI := nil; 
+  glGetColorTableParameterivSGI := nil; 
+
+  // GL_SGIX_pixel_texture
+  glPixelTexGenSGIX := nil; 
+
+  // GL_SGIS_pixel_texture
+  glPixelTexGenParameteriSGIS := nil; 
+  glPixelTexGenParameterivSGIS := nil; 
+  glPixelTexGenParameterfSGIS := nil; 
+  glPixelTexGenParameterfvSGIS := nil; 
+  glGetPixelTexGenParameterivSGIS := nil; 
+  glGetPixelTexGenParameterfvSGIS := nil;
+
+  // GL_SGIS_texture4D
+  glTexImage4DSGIS := nil; 
+  glTexSubImage4DSGIS := nil; 
+
+  // GL_SGIS_detail_texture
+  glDetailTexFuncSGIS := nil; 
+  glGetDetailTexFuncSGIS := nil; 
+
+  // GL_SGIS_sharpen_texture
+  glSharpenTexFuncSGIS := nil; 
+  glGetSharpenTexFuncSGIS := nil; 
+
+  // GL_SGIS_multisample
+  glSampleMaskSGIS := nil; 
+  glSamplePatternSGIS := nil; 
+
+  // GL_EXT_blend_minmax
+  glBlendEquationEXT := nil; 
+
+  // GL_SGIX_sprite
+  glSpriteParameterfSGIX := nil; 
+  glSpriteParameterfvSGIX := nil; 
+  glSpriteParameteriSGIX := nil; 
+  glSpriteParameterivSGIX := nil; 
+
+  // GL_EXT_point_parameters
+  glPointParameterfSGIS := nil; 
+  glPointParameterfvSGIS := nil; 
+
+  // GL_SGIX_instruments
+  glGetInstrumentsSGIX := nil; 
+  glInstrumentsBufferSGIX := nil;
+  glPollInstrumentsSGIX := nil; 
+  glReadInstrumentsSGIX := nil; 
+  glStartInstrumentsSGIX := nil; 
+  glStopInstrumentsSGIX := nil; 
+
+  // GL_SGIX_framezoom
+  glFrameZoomSGIX := nil; 
+
+  // GL_SGIX_tag_sample_buffer
+  glTagSampleBufferSGIX := nil;
+
+  // GL_SGIX_polynomial_ffd
+  glDeformationMap3dSGIX := nil; 
+  glDeformationMap3fSGIX := nil; 
+  glDeformSGIX := nil; 
+  glLoadIdentityDeformationMapSGIX := nil; 
+
+  // GL_SGIX_reference_plane
+  glReferencePlaneSGIX := nil; 
+
+  // GL_SGIX_flush_raster
+  glFlushRasterSGIX := nil; 
+
+  // GL_SGIS_fog_function
+  glFogFuncSGIS := nil; 
+  glGetFogFuncSGIS := nil; 
+
+  // GL_HP_image_transform
+  glImageTransformParameteriHP := nil; 
+  glImageTransformParameterfHP := nil; 
+  glImageTransformParameterivHP := nil; 
+  glImageTransformParameterfvHP := nil; 
+  glGetImageTransformParameterivHP := nil;
+  glGetImageTransformParameterfvHP := nil; 
+
+  // GL_EXT_color_subtable
+  glCopyColorSubTableEXT := nil; 
+
+  // GL_PGI_misc_hints
+  glHintPGI := nil; 
+
+  // GL_EXT_paletted_texture
+  glGetColorTableParameterivEXT := nil; 
+  glGetColorTableParameterfvEXT := nil; 
+
+  // GL_SGIX_list_priority
+  glGetListParameterfvSGIX := nil; 
+  glGetListParameterivSGIX := nil; 
+  glListParameterfSGIX := nil; 
+  glListParameterfvSGIX := nil; 
+  glListParameteriSGIX := nil; 
+  glListParameterivSGIX := nil; 
+
+  // GL_SGIX_fragment_lighting
+  glFragmentColorMaterialSGIX := nil; 
+  glFragmentLightfSGIX := nil; 
+  glFragmentLightfvSGIX := nil; 
+  glFragmentLightiSGIX := nil; 
+  glFragmentLightivSGIX := nil; 
+  glFragmentLightModelfSGIX := nil;
+  glFragmentLightModelfvSGIX := nil; 
+  glFragmentLightModeliSGIX := nil; 
+  glFragmentLightModelivSGIX := nil; 
+  glFragmentMaterialfSGIX := nil; 
+  glFragmentMaterialfvSGIX := nil; 
+  glFragmentMaterialiSGIX := nil;
+  glFragmentMaterialivSGIX := nil; 
+  glGetFragmentLightfvSGIX := nil; 
+  glGetFragmentLightivSGIX := nil; 
+  glGetFragmentMaterialfvSGIX := nil; 
+  glGetFragmentMaterialivSGIX := nil; 
+  glLightEnviSGIX := nil; 
+
+  // GL_EXT_draw_range_elements
+  glDrawRangeElementsEXT := nil; 
+
+  // GL_EXT_light_texture
+  glApplyTextureEXT := nil; 
+  glTextureLightEXT := nil; 
+  glTextureMaterialEXT := nil; 
+
+  // GL_SGIX_async
+  glAsyncMarkerSGIX := nil; 
+  glFinishAsyncSGIX := nil; 
+  glPollAsyncSGIX := nil;
+  glGenAsyncMarkersSGIX := nil; 
+  glDeleteAsyncMarkersSGIX := nil; 
+  glIsAsyncMarkerSGIX := nil; 
+
+  // GL_INTEL_parallel_arrays
+  glVertexPointervINTEL := nil; 
+  glNormalPointervINTEL := nil; 
+  glColorPointervINTEL := nil; 
+  glTexCoordPointervINTEL := nil; 
+
+  // GL_EXT_pixel_transform
+  glPixelTransformParameteriEXT := nil; 
+  glPixelTransformParameterfEXT := nil; 
+  glPixelTransformParameterivEXT := nil;
+  glPixelTransformParameterfvEXT := nil; 
+
+  // GL_EXT_secondary_color
+  glSecondaryColor3bEXT := nil; 
+  glSecondaryColor3bvEXT := nil; 
+  glSecondaryColor3dEXT := nil; 
+  glSecondaryColor3dvEXT := nil; 
+  glSecondaryColor3fEXT := nil; 
+  glSecondaryColor3fvEXT := nil; 
+  glSecondaryColor3iEXT := nil; 
+  glSecondaryColor3ivEXT := nil;
+  glSecondaryColor3sEXT := nil; 
+  glSecondaryColor3svEXT := nil; 
+  glSecondaryColor3ubEXT := nil; 
+  glSecondaryColor3ubvEXT := nil; 
+  glSecondaryColor3uiEXT := nil; 
+  glSecondaryColor3uivEXT := nil; 
+  glSecondaryColor3usEXT := nil; 
+  glSecondaryColor3usvEXT := nil; 
+  glSecondaryColorPointerEXT := nil; 
+
+  // GL_EXT_texture_perturb_normal
+  glTextureNormalEXT := nil; 
+
+  // GL_EXT_multi_draw_arrays
+  glMultiDrawArraysEXT := nil; 
+  glMultiDrawElementsEXT := nil; 
+
+  // GL_EXT_fog_coord
+  glFogCoordfEXT := nil; 
+  glFogCoordfvEXT := nil; 
+  glFogCoorddEXT := nil; 
+  glFogCoorddvEXT := nil;
+  glFogCoordPointerEXT := nil; 
+
+  // GL_EXT_coordinate_frame
+  glTangent3bEXT := nil; 
+  glTangent3bvEXT := nil; 
+  glTangent3dEXT := nil; 
+  glTangent3dvEXT := nil; 
+  glTangent3fEXT := nil; 
+  glTangent3fvEXT := nil; 
+  glTangent3iEXT := nil; 
+  glTangent3ivEXT := nil; 
+  glTangent3sEXT := nil; 
+  glTangent3svEXT := nil; 
+  glBinormal3bEXT := nil; 
+  glBinormal3bvEXT := nil; 
+  glBinormal3dEXT := nil; 
+  glBinormal3dvEXT := nil; 
+  glBinormal3fEXT := nil; 
+  glBinormal3fvEXT := nil; 
+  glBinormal3iEXT := nil; 
+  glBinormal3ivEXT := nil; 
+  glBinormal3sEXT := nil; 
+  glBinormal3svEXT := nil; 
+  glTangentPointerEXT := nil; 
+  glBinormalPointerEXT := nil; 
+
+  // GL_SUNX_constant_data
+  glFinishTextureSUNX := nil;
+  
+  // GL_SUN_global_alpha
+  glGlobalAlphaFactorbSUN := nil; 
+  glGlobalAlphaFactorsSUN := nil; 
+  glGlobalAlphaFactoriSUN := nil;
+  glGlobalAlphaFactorfSUN := nil; 
+  glGlobalAlphaFactordSUN := nil; 
+  glGlobalAlphaFactorubSUN := nil; 
+  glGlobalAlphaFactorusSUN := nil; 
+  glGlobalAlphaFactoruiSUN := nil; 
+
+  // GL_SUN_triangle_list
+  glReplacementCodeuiSUN := nil; 
+  glReplacementCodeusSUN := nil; 
+  glReplacementCodeubSUN := nil; 
+  glReplacementCodeuivSUN := nil; 
+  glReplacementCodeusvSUN := nil; 
+  glReplacementCodeubvSUN := nil; 
+  glReplacementCodePointerSUN := nil; 
+
+  // GL_SUN_vertex
+  glColor4ubVertex2fSUN := nil; 
+  glColor4ubVertex2fvSUN := nil; 
+  glColor4ubVertex3fSUN := nil; 
+  glColor4ubVertex3fvSUN := nil;
+  glColor3fVertex3fSUN := nil; 
+  glColor3fVertex3fvSUN := nil; 
+  glNormal3fVertex3fSUN := nil; 
+  glNormal3fVertex3fvSUN := nil; 
+  glColor4fNormal3fVertex3fSUN := nil; 
+  glColor4fNormal3fVertex3fvSUN := nil; 
+  glTexCoord2fVertex3fSUN := nil; 
+  glTexCoord2fVertex3fvSUN := nil; 
+  glTexCoord4fVertex4fSUN := nil; 
+  glTexCoord4fVertex4fvSUN := nil; 
+  glTexCoord2fColor4ubVertex3fSUN := nil; 
+  glTexCoord2fColor4ubVertex3fvSUN := nil; 
+  glTexCoord2fColor3fVertex3fSUN := nil;
+  glTexCoord2fColor3fVertex3fvSUN := nil; 
+  glTexCoord2fNormal3fVertex3fSUN := nil; 
+  glTexCoord2fNormal3fVertex3fvSUN := nil; 
+  glTexCoord2fColor4fNormal3fVertex3fSUN := nil; 
+  glTexCoord2fColor4fNormal3fVertex3fvSUN := nil; 
+  glTexCoord4fColor4fNormal3fVertex4fSUN := nil; 
+  glTexCoord4fColor4fNormal3fVertex4fvSUN := nil; 
+  glReplacementCodeuiVertex3fSUN := nil; 
+  glReplacementCodeuiVertex3fvSUN := nil; 
+  glReplacementCodeuiColor4ubVertex3fSUN := nil; 
+  glReplacementCodeuiColor4ubVertex3fvSUN := nil; 
+  glReplacementCodeuiColor3fVertex3fSUN := nil;
+  glReplacementCodeuiColor3fVertex3fvSUN := nil; 
+  glReplacementCodeuiNormal3fVertex3fSUN := nil; 
+  glReplacementCodeuiNormal3fVertex3fvSUN := nil; 
+  glReplacementCodeuiColor4fNormal3fVertex3fSUN := nil; 
+  glReplacementCodeuiColor4fNormal3fVertex3fvSUN := nil; 
+  glReplacementCodeuiTexCoord2fVertex3fSUN := nil; 
+  glReplacementCodeuiTexCoord2fVertex3fvSUN := nil; 
+  glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN := nil; 
+  glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN := nil; 
+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN := nil; 
+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN := nil; 
+
+  // GL_EXT_blend_func_separate
+  glBlendFuncSeparateEXT := nil; 
+
+  // GL_EXT_vertex_weighting
+  glVertexWeightfEXT := nil; 
+  glVertexWeightfvEXT := nil; 
+  glVertexWeightPointerEXT := nil; 
+
+  // GL_NV_vertex_array_range
+  glFlushVertexArrayRangeNV := nil; 
+  glVertexArrayRangeNV := nil; 
+  wglAllocateMemoryNV := nil; 
+  wglFreeMemoryNV := nil;
+
+  // GL_NV_register_combiners
+  glCombinerParameterfvNV := nil; 
+  glCombinerParameterfNV := nil; 
+  glCombinerParameterivNV := nil; 
+  glCombinerParameteriNV := nil; 
+  glCombinerInputNV := nil; 
+  glCombinerOutputNV := nil; 
+  glFinalCombinerInputNV := nil; 
+  glGetCombinerInputParameterfvNV := nil; 
+  glGetCombinerInputParameterivNV := nil; 
+  glGetCombinerOutputParameterfvNV := nil; 
+  glGetCombinerOutputParameterivNV := nil; 
+  glGetFinalCombinerInputParameterfvNV := nil; 
+  glGetFinalCombinerInputParameterivNV := nil; 
+
+  // GL_MESA_resize_buffers
+  glResizeBuffersMESA := nil; 
+
+  // GL_MESA_window_pos
+  glWindowPos2dMESA := nil; 
+  glWindowPos2dvMESA := nil; 
+  glWindowPos2fMESA := nil; 
+  glWindowPos2fvMESA := nil; 
+  glWindowPos2iMESA := nil;
+  glWindowPos2ivMESA := nil; 
+  glWindowPos2sMESA := nil; 
+  glWindowPos2svMESA := nil; 
+  glWindowPos3dMESA := nil;
+  glWindowPos3dvMESA := nil; 
+  glWindowPos3fMESA := nil; 
+  glWindowPos3fvMESA := nil; 
+  glWindowPos3iMESA := nil; 
+  glWindowPos3ivMESA := nil; 
+  glWindowPos3sMESA := nil; 
+  glWindowPos3svMESA := nil; 
+  glWindowPos4dMESA := nil; 
+  glWindowPos4dvMESA := nil; 
+  glWindowPos4fMESA := nil; 
+  glWindowPos4fvMESA := nil; 
+  glWindowPos4iMESA := nil; 
+  glWindowPos4ivMESA := nil; 
+  glWindowPos4sMESA := nil; 
+  glWindowPos4svMESA := nil; 
+
+  // GL_IBM_multimode_draw_arrays
+  glMultiModeDrawArraysIBM := nil; 
+  glMultiModeDrawElementsIBM := nil; 
+
+  // GL_IBM_vertex_array_lists
+  glColorPointerListIBM := nil; 
+  glSecondaryColorPointerListIBM := nil; 
+  glEdgeFlagPointerListIBM := nil; 
+  glFogCoordPointerListIBM := nil; 
+  glIndexPointerListIBM := nil; 
+  glNormalPointerListIBM := nil; 
+  glTexCoordPointerListIBM := nil; 
+  glVertexPointerListIBM := nil; 
+
+  // GL_3DFX_tbuffer
+  glTbufferMask3DFX := nil; 
+
+  // GL_EXT_multisample
+  glSampleMaskEXT := nil; 
+  glSamplePatternEXT := nil; 
+
+  // GL_SGIS_texture_color_mask
+  glTextureColorMaskSGIS := nil; 
+
+  // GL_SGIX_igloo_interface
+  glIglooInterfaceSGIX := nil; 
+
+  // GLU extensions
+  gluNurbsCallbackDataEXT := nil; 
+  gluNewNurbsTessellatorEXT := nil;
+  gluDeleteNurbsTessellatorEXT := nil; 
+
+  // GL_NV_vertex_program
+  glAreProgramsResidentNV := nil; 
+  glBindProgramNV := nil; 
+  glDeleteProgramsNV := nil; 
+  glExecuteProgramNV := nil; 
+  glGenProgramsNV := nil; 
+  glGetProgramParameterdvNV := nil; 
+  glGetProgramParameterfvNV := nil; 
+  glGetProgramivNV := nil; 
+  glGetProgramStringNV := nil; 
+  glGetTrackMatrixivNV := nil; 
+  glGetVertexAttribdvNV:= nil; 
+  glGetVertexAttribfvNV:= nil; 
+  glGetVertexAttribivNV:= nil; 
+  glGetVertexAttribPointervNV := nil; 
+  glIsProgramNV := nil; 
+  glLoadProgramNV := nil; 
+  glProgramParameter4dNV := nil;
+  glProgramParameter4dvNV := nil; 
+  glProgramParameter4fNV := nil; 
+  glProgramParameter4fvNV := nil; 
+  glProgramParameters4dvNV := nil; 
+  glProgramParameters4fvNV := nil;
+  glRequestResidentProgramsNV := nil; 
+  glTrackMatrixNV := nil; 
+  glVertexAttribPointerNV := nil; 
+  glVertexAttrib1dNV := nil; 
+  glVertexAttrib1dvNV := nil; 
+  glVertexAttrib1fNV := nil; 
+  glVertexAttrib1fvNV := nil; 
+  glVertexAttrib1sNV := nil; 
+  glVertexAttrib1svNV := nil; 
+  glVertexAttrib2dNV := nil; 
+  glVertexAttrib2dvNV := nil; 
+  glVertexAttrib2fNV := nil; 
+  glVertexAttrib2fvNV := nil; 
+  glVertexAttrib2sNV := nil; 
+  glVertexAttrib2svNV := nil; 
+  glVertexAttrib3dNV := nil; 
+  glVertexAttrib3dvNV := nil; 
+  glVertexAttrib3fNV := nil; 
+  glVertexAttrib3fvNV := nil; 
+  glVertexAttrib3sNV := nil; 
+  glVertexAttrib3svNV := nil; 
+  glVertexAttrib4dNV := nil; 
+  glVertexAttrib4dvNV := nil; 
+  glVertexAttrib4fNV := nil; 
+  glVertexAttrib4fvNV := nil;
+  glVertexAttrib4sNV := nil; 
+  glVertexAttrib4svNV := nil; 
+  glVertexAttrib4ubvNV := nil;
+  glVertexAttribs1dvNV := nil;
+  glVertexAttribs1fvNV := nil;
+  glVertexAttribs1svNV := nil;
+  glVertexAttribs2dvNV := nil;
+  glVertexAttribs2fvNV := nil;
+  glVertexAttribs2svNV := nil;
+  glVertexAttribs3dvNV := nil;
+  glVertexAttribs3fvNV := nil;
+  glVertexAttribs3svNV := nil;
+  glVertexAttribs4dvNV := nil;
+  glVertexAttribs4fvNV := nil;
+  glVertexAttribs4svNV := nil;
+  glVertexAttribs4ubvNV := nil;
+
+  LastPixelFormat := 0; // to get synchronized again, if this proc was called from outside
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+{$ifdef Win32}
+
+function HasActiveContext: Boolean;
+
+// Returns True if the caller thread has an active (current) rendering context.
+
+begin
+  Result := ActivationRefCount > 0;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure ReadExtensions;
+begin
+  if GLHandle <> INVALID_MODULEHANDLE then
+  begin
+    // GL extensions
+    glArrayElementArrayEXT := SDL_GL_GetProcAddress( 'glArrayElementArrayEXT');
+    glColorTableEXT := SDL_GL_GetProcAddress( 'glColorTableEXT');
+    glColorSubTableEXT := SDL_GL_GetProcAddress( 'glColorSubTableEXT');
+    glGetColorTableEXT := SDL_GL_GetProcAddress( 'glGetColorTableEXT');
+    glGetColorTablePameterivEXT := SDL_GL_GetProcAddress( 'glGetColorTablePameterivEXT');
+    glGetColorTablePameterfvEXT := SDL_GL_GetProcAddress( 'glGetColorTablePameterfvEXT');
+    glLockArraysEXT := SDL_GL_GetProcAddress( 'glLockArraysEXT');
+    glUnlockArraysEXT := SDL_GL_GetProcAddress( 'glUnlockArraysEXT');
+    glCopyTexImage1DEXT := SDL_GL_GetProcAddress( 'glCopyTexImage1DEXT');
+    glCopyTexSubImage1DEXT := SDL_GL_GetProcAddress( 'glCopyTexSubImage1DEXT');
+    glCopyTexImage2DEXT := SDL_GL_GetProcAddress( 'glCopyTexImage2DEXT');
+    glCopyTexSubImage2DEXT := SDL_GL_GetProcAddress( 'glCopyTexSubImage2DEXT');
+    glCopyTexSubImage3DEXT := SDL_GL_GetProcAddress( 'glCopyTexSubImage3DEXT');
+    glIndexFuncEXT := GetModuleSymbol( GLHandle, 'glIndexFuncEXT');
+    glIndexMaterialEXT := SDL_GL_GetProcAddress( 'glIndexMaterialEXT');
+    glPolygonOffsetEXT := SDL_GL_GetProcAddress( 'glPolygonOffsetEXT');
+    glTexSubImage1dEXT := SDL_GL_GetProcAddress( 'glTexSubImage1DEXT');
+    glTexSubImage2dEXT := SDL_GL_GetProcAddress( 'glTexSubImage2DEXT');
+    glTexSubImage3dEXT := SDL_GL_GetProcAddress( 'glTexSubImage3DEXT');
+    glGenTexturesEXT := SDL_GL_GetProcAddress( 'glGenTexturesEXT');
+    glDeleteTexturesEXT := SDL_GL_GetProcAddress( 'glDeleteTexturesEXT');
+    glBindTextureEXT := SDL_GL_GetProcAddress( 'glBindTextureEXT');
+    glPrioritizeTexturesEXT := SDL_GL_GetProcAddress( 'glPrioritizeTexturesEXT');
+    glAreTexturesResidentEXT := SDL_GL_GetProcAddress( 'glAreTexturesResidentEXT');
+    glIsTextureEXT := GetModuleSymbol( GLHandle, 'glIsTextureEXT');
+
+    // EXT_vertex_array
+    glArrayElementEXT := SDL_GL_GetProcAddress( 'glArrayElementEXT');
+    glColorPointerEXT := SDL_GL_GetProcAddress( 'glColorPointerEXT');
+    glDrawArraysEXT := SDL_GL_GetProcAddress( 'glDrawArraysEXT');
+    glEdgeFlagPointerEXT := SDL_GL_GetProcAddress( 'glEdgeFlagPointerEXT');
+    glGetPointervEXT := SDL_GL_GetProcAddress( 'glGetPointervEXT');
+    glIndexPointerEXT := SDL_GL_GetProcAddress( 'glIndexPointerEXT');
+    glNormalPointerEXT := SDL_GL_GetProcAddress( 'glNormalPointerEXT');
+    glTexCoordPointerEXT := SDL_GL_GetProcAddress( 'glTexCoordPointerEXT');
+    glVertexPointerEXT := SDL_GL_GetProcAddress( 'glVertexPointerEXT');
+
+    // ARB_multitexture
+    glMultiTexCoord1dARB := SDL_GL_GetProcAddress( 'glMultiTexCoord1dARB');
+    glMultiTexCoord1dVARB := SDL_GL_GetProcAddress( 'glMultiTexCoord1dVARB');
+    glMultiTexCoord1fARBP := SDL_GL_GetProcAddress( 'glMultiTexCoord1fARBP');
+    glMultiTexCoord1fVARB := SDL_GL_GetProcAddress( 'glMultiTexCoord1fVARB');
+    glMultiTexCoord1iARB := SDL_GL_GetProcAddress( 'glMultiTexCoord1iARB');
+    glMultiTexCoord1iVARB := SDL_GL_GetProcAddress( 'glMultiTexCoord1iVARB');
+    glMultiTexCoord1sARBP := SDL_GL_GetProcAddress( 'glMultiTexCoord1sARBP');
+    glMultiTexCoord1sVARB := SDL_GL_GetProcAddress( 'glMultiTexCoord1sVARB');
+    glMultiTexCoord2dARB := SDL_GL_GetProcAddress( 'glMultiTexCoord2dARB');
+    glMultiTexCoord2dvARB := SDL_GL_GetProcAddress( 'glMultiTexCoord2dvARB');
+    glMultiTexCoord2fARB := SDL_GL_GetProcAddress( 'glMultiTexCoord2fARB');
+    glMultiTexCoord2fvARB := SDL_GL_GetProcAddress( 'glMultiTexCoord2fvARB');
+    glMultiTexCoord2iARB := SDL_GL_GetProcAddress( 'glMultiTexCoord2iARB');
+    glMultiTexCoord2ivARB := SDL_GL_GetProcAddress( 'glMultiTexCoord2ivARB');
+    glMultiTexCoord2sARB := SDL_GL_GetProcAddress( 'glMultiTexCoord2sARB');
+    glMultiTexCoord2svARB := SDL_GL_GetProcAddress( 'glMultiTexCoord2svARB');
+    glMultiTexCoord3dARB := SDL_GL_GetProcAddress( 'glMultiTexCoord3dARB');
+    glMultiTexCoord3dvARB := SDL_GL_GetProcAddress( 'glMultiTexCoord3dvARB');
+    glMultiTexCoord3fARB := SDL_GL_GetProcAddress( 'glMultiTexCoord3fARB');
+    glMultiTexCoord3fvARB := SDL_GL_GetProcAddress( 'glMultiTexCoord3fvARB');
+    glMultiTexCoord3iARB := SDL_GL_GetProcAddress( 'glMultiTexCoord3iARB');
+    glMultiTexCoord3ivARB := SDL_GL_GetProcAddress( 'glMultiTexCoord3ivARB');
+    glMultiTexCoord3sARB := SDL_GL_GetProcAddress( 'glMultiTexCoord3sARB');
+    glMultiTexCoord3svARB := SDL_GL_GetProcAddress( 'glMultiTexCoord3svARB');
+    glMultiTexCoord4dARB := SDL_GL_GetProcAddress( 'glMultiTexCoord4dARB');
+    glMultiTexCoord4dvARB := SDL_GL_GetProcAddress( 'glMultiTexCoord4dvARB');
+    glMultiTexCoord4fARB := SDL_GL_GetProcAddress( 'glMultiTexCoord4fARB');
+    glMultiTexCoord4fvARB := SDL_GL_GetProcAddress( 'glMultiTexCoord4fvARB');
+    glMultiTexCoord4iARB := SDL_GL_GetProcAddress( 'glMultiTexCoord4iARB');
+    glMultiTexCoord4ivARB := SDL_GL_GetProcAddress( 'glMultiTexCoord4ivARB');
+    glMultiTexCoord4sARB := SDL_GL_GetProcAddress( 'glMultiTexCoord4sARB');
+    glMultiTexCoord4svARB := SDL_GL_GetProcAddress( 'glMultiTexCoord4svARB');
+    glActiveTextureARB := SDL_GL_GetProcAddress( 'glActiveTextureARB');
+    glClientActiveTextureARB := SDL_GL_GetProcAddress( 'glClientActiveTextureARB');
+
+    // EXT_compiled_vertex_array
+    glLockArrayEXT := SDL_GL_GetProcAddress( 'glLockArrayEXT');
+    glUnlockArrayEXT := SDL_GL_GetProcAddress( 'glUnlockArrayEXT');
+
+    // EXT_cull_vertex
+    glCullParameterdvEXT := SDL_GL_GetProcAddress( 'glCullParameterdvEXT');
+    glCullParameterfvEXT := SDL_GL_GetProcAddress( 'glCullParameterfvEXT');
+
+    // WIN_swap_hint
+    glAddSwapHintRectWIN := SDL_GL_GetProcAddress( 'glAddSwapHintRectWIN');
+
+    // EXT_point_parameter
+    glPointParameterfEXT := SDL_GL_GetProcAddress( 'glPointParameterfEXT');
+    glPointParameterfvEXT := SDL_GL_GetProcAddress( 'glPointParameterfvEXT');
+
+    // GL_ARB_transpose_matrix
+    glLoadTransposeMatrixfARB := SDL_GL_GetProcAddress( 'glLoadTransposeMatrixfARB');
+    glLoadTransposeMatrixdARB := SDL_GL_GetProcAddress( 'glLoadTransposeMatrixdARB');
+    glMultTransposeMatrixfARB := SDL_GL_GetProcAddress( 'glMultTransposeMatrixfARB');
+    glMultTransposeMatrixdARB := SDL_GL_GetProcAddress( 'glMultTransposeMatrixdARB');
+
+    glSampleCoverageARB := SDL_GL_GetProcAddress( 'glSampleCoverageARB');
+    glSamplePassARB := SDL_GL_GetProcAddress( 'glSamplePassARB');
+
+    // GL_ARB_multisample
+    glCompressedTexImage3DARB := SDL_GL_GetProcAddress( 'glCompressedTexImage3DARB');
+    glCompressedTexImage2DARB := SDL_GL_GetProcAddress( 'glCompressedTexImage2DARB');
+    glCompressedTexImage1DARB := SDL_GL_GetProcAddress( 'glCompressedTexImage1DARB');
+    glCompressedTexSubImage3DARB := SDL_GL_GetProcAddress( 'glCompressedTexSubImage3DARB');
+    glCompressedTexSubImage2DARB := SDL_GL_GetProcAddress( 'glCompressedTexSubImage2DARB');
+    glCompressedTexSubImage1DARB := SDL_GL_GetProcAddress( 'glCompressedTexSubImage1DARB');
+    glGetCompressedTexImageARB := SDL_GL_GetProcAddress( 'glGetCompressedTexImageARB');
+
+    // GL_EXT_blend_color
+    glBlendColorEXT := SDL_GL_GetProcAddress( 'glBlendColorEXT');
+
+    // GL_EXT_texture3D
+    glTexImage3DEXT := SDL_GL_GetProcAddress( 'glTexImage3DEXT');
+
+    // GL_SGIS_texture_filter4
+    glGetTexFilterFuncSGIS := SDL_GL_GetProcAddress( 'glGetTexFilterFuncSGIS'); 
+    glTexFilterFuncSGIS := SDL_GL_GetProcAddress( 'glTexFilterFuncSGIS');
+
+    // GL_EXT_histogram
+    glGetHistogramEXT := SDL_GL_GetProcAddress( 'glGetHistogramEXT'); 
+    glGetHistogramParameterfvEXT := SDL_GL_GetProcAddress( 'glGetHistogramParameterfvEXT'); 
+    glGetHistogramParameterivEXT := SDL_GL_GetProcAddress( 'glGetHistogramParameterivEXT'); 
+    glGetMinmaxEXT := SDL_GL_GetProcAddress( 'glGetMinmaxEXT'); 
+    glGetMinmaxParameterfvEXT := SDL_GL_GetProcAddress( 'glGetMinmaxParameterfvEXT'); 
+    glGetMinmaxParameterivEXT := SDL_GL_GetProcAddress( 'glGetMinmaxParameterivEXT'); 
+    glHistogramEXT := SDL_GL_GetProcAddress( 'glHistogramEXT'); 
+    glMinmaxEXT := SDL_GL_GetProcAddress( 'glMinmaxEXT'); 
+    glResetHistogramEXT := SDL_GL_GetProcAddress( 'glResetHistogramEXT'); 
+    glResetMinmaxEXT := SDL_GL_GetProcAddress( 'glResetMinmaxEXT'); 
+
+    // GL_EXT_convolution
+    glConvolutionFilter1DEXT := SDL_GL_GetProcAddress( 'glConvolutionFilter1DEXT'); 
+    glConvolutionFilter2DEXT := SDL_GL_GetProcAddress( 'glConvolutionFilter2DEXT'); 
+    glConvolutionParameterfEXT := SDL_GL_GetProcAddress( 'glConvolutionParameterfEXT');
+    glConvolutionParameterfvEXT := SDL_GL_GetProcAddress( 'glConvolutionParameterfvEXT'); 
+    glConvolutionParameteriEXT := SDL_GL_GetProcAddress( 'glConvolutionParameteriEXT'); 
+    glConvolutionParameterivEXT := SDL_GL_GetProcAddress( 'glConvolutionParameterivEXT'); 
+    glCopyConvolutionFilter1DEXT := SDL_GL_GetProcAddress( 'glCopyConvolutionFilter1DEXT'); 
+    glCopyConvolutionFilter2DEXT := SDL_GL_GetProcAddress( 'glCopyConvolutionFilter2DEXT'); 
+    glGetConvolutionFilterEXT := SDL_GL_GetProcAddress( 'glGetConvolutionFilterEXT'); 
+    glGetConvolutionParameterfvEXT := SDL_GL_GetProcAddress( 'glGetConvolutionParameterfvEXT'); 
+    glGetConvolutionParameterivEXT := SDL_GL_GetProcAddress( 'glGetConvolutionParameterivEXT');
+    glGetSeparableFilterEXT := SDL_GL_GetProcAddress( 'glGetSeparableFilterEXT'); 
+    glSeparableFilter2DEXT := SDL_GL_GetProcAddress( 'glSeparableFilter2DEXT'); 
+
+    // GL_SGI_color_table
+    glColorTableSGI := SDL_GL_GetProcAddress( 'glColorTableSGI'); 
+    glColorTableParameterfvSGI := SDL_GL_GetProcAddress( 'glColorTableParameterfvSGI'); 
+    glColorTableParameterivSGI := SDL_GL_GetProcAddress( 'glColorTableParameterivSGI'); 
+    glCopyColorTableSGI := SDL_GL_GetProcAddress( 'glCopyColorTableSGI');
+    glGetColorTableSGI := SDL_GL_GetProcAddress( 'glGetColorTableSGI'); 
+    glGetColorTableParameterfvSGI := SDL_GL_GetProcAddress( 'glGetColorTableParameterfvSGI'); 
+    glGetColorTableParameterivSGI := SDL_GL_GetProcAddress( 'glGetColorTableParameterivSGI'); 
+
+    // GL_SGIX_pixel_texture
+    glPixelTexGenSGIX := SDL_GL_GetProcAddress( 'glPixelTexGenSGIX'); 
+
+    // GL_SGIS_pixel_texture
+    glPixelTexGenParameteriSGIS := SDL_GL_GetProcAddress( 'glPixelTexGenParameteriSGIS'); 
+    glPixelTexGenParameterivSGIS := SDL_GL_GetProcAddress( 'glPixelTexGenParameterivSGIS'); 
+    glPixelTexGenParameterfSGIS := SDL_GL_GetProcAddress( 'glPixelTexGenParameterfSGIS'); 
+    glPixelTexGenParameterfvSGIS := SDL_GL_GetProcAddress( 'glPixelTexGenParameterfvSGIS'); 
+    glGetPixelTexGenParameterivSGIS := SDL_GL_GetProcAddress( 'glGetPixelTexGenParameterivSGIS'); 
+    glGetPixelTexGenParameterfvSGIS := SDL_GL_GetProcAddress( 'glGetPixelTexGenParameterfvSGIS'); 
+
+    // GL_SGIS_texture4D
+    glTexImage4DSGIS := SDL_GL_GetProcAddress( 'glTexImage4DSGIS');
+    glTexSubImage4DSGIS := SDL_GL_GetProcAddress( 'glTexSubImage4DSGIS'); 
+
+    // GL_SGIS_detail_texture
+    glDetailTexFuncSGIS := SDL_GL_GetProcAddress( 'glDetailTexFuncSGIS'); 
+    glGetDetailTexFuncSGIS := SDL_GL_GetProcAddress( 'glGetDetailTexFuncSGIS'); 
+
+    // GL_SGIS_sharpen_texture
+    glSharpenTexFuncSGIS := SDL_GL_GetProcAddress( 'glSharpenTexFuncSGIS'); 
+    glGetSharpenTexFuncSGIS := SDL_GL_GetProcAddress( 'glGetSharpenTexFuncSGIS'); 
+
+    // GL_SGIS_multisample
+    glSampleMaskSGIS := SDL_GL_GetProcAddress( 'glSampleMaskSGIS'); 
+    glSamplePatternSGIS := SDL_GL_GetProcAddress( 'glSamplePatternSGIS'); 
+
+    // GL_EXT_blend_minmax
+    glBlendEquationEXT := SDL_GL_GetProcAddress( 'glBlendEquationEXT'); 
+
+    // GL_SGIX_sprite
+    glSpriteParameterfSGIX := SDL_GL_GetProcAddress( 'glSpriteParameterfSGIX'); 
+    glSpriteParameterfvSGIX := SDL_GL_GetProcAddress( 'glSpriteParameterfvSGIX'); 
+    glSpriteParameteriSGIX := SDL_GL_GetProcAddress( 'glSpriteParameteriSGIX'); 
+    glSpriteParameterivSGIX := SDL_GL_GetProcAddress( 'glSpriteParameterivSGIX'); 
+
+    // GL_EXT_point_parameters
+    glPointParameterfSGIS := SDL_GL_GetProcAddress( 'glPointParameterfSGIS');
+    glPointParameterfvSGIS := SDL_GL_GetProcAddress( 'glPointParameterfvSGIS'); 
+
+    // GL_SGIX_instruments
+    glGetInstrumentsSGIX := SDL_GL_GetProcAddress( 'glGetInstrumentsSGIX'); 
+    glInstrumentsBufferSGIX := SDL_GL_GetProcAddress( 'glInstrumentsBufferSGIX'); 
+    glPollInstrumentsSGIX := SDL_GL_GetProcAddress( 'glPollInstrumentsSGIX');
+    glReadInstrumentsSGIX := SDL_GL_GetProcAddress( 'glReadInstrumentsSGIX'); 
+    glStartInstrumentsSGIX := SDL_GL_GetProcAddress( 'glStartInstrumentsSGIX'); 
+    glStopInstrumentsSGIX := SDL_GL_GetProcAddress( 'glStopInstrumentsSGIX'); 
+
+    // GL_SGIX_framezoom
+    glFrameZoomSGIX := SDL_GL_GetProcAddress( 'glFrameZoomSGIX'); 
+
+    // GL_SGIX_tag_sample_buffer
+    glTagSampleBufferSGIX := SDL_GL_GetProcAddress( 'glTagSampleBufferSGIX'); 
+
+    // GL_SGIX_polynomial_ffd
+    glDeformationMap3dSGIX := SDL_GL_GetProcAddress( 'glDeformationMap3dSGIX'); 
+    glDeformationMap3fSGIX := SDL_GL_GetProcAddress( 'glDeformationMap3fSGIX'); 
+    glDeformSGIX := SDL_GL_GetProcAddress( 'glDeformSGIX'); 
+    glLoadIdentityDeformationMapSGIX := SDL_GL_GetProcAddress( 'glLoadIdentityDeformationMapSGIX'); 
+
+    // GL_SGIX_reference_plane
+    glReferencePlaneSGIX := SDL_GL_GetProcAddress( 'glReferencePlaneSGIX'); 
+
+    // GL_SGIX_flush_raster
+    glFlushRasterSGIX := SDL_GL_GetProcAddress( 'glFlushRasterSGIX'); 
+
+    // GL_SGIS_fog_function
+    glFogFuncSGIS := SDL_GL_GetProcAddress( 'glFogFuncSGIS'); 
+    glGetFogFuncSGIS := SDL_GL_GetProcAddress( 'glGetFogFuncSGIS'); 
+
+    // GL_HP_image_transform
+    glImageTransformParameteriHP := SDL_GL_GetProcAddress( 'glImageTransformParameteriHP'); 
+    glImageTransformParameterfHP := SDL_GL_GetProcAddress( 'glImageTransformParameterfHP'); 
+    glImageTransformParameterivHP := SDL_GL_GetProcAddress( 'glImageTransformParameterivHP'); 
+    glImageTransformParameterfvHP := SDL_GL_GetProcAddress( 'glImageTransformParameterfvHP'); 
+    glGetImageTransformParameterivHP := SDL_GL_GetProcAddress( 'glGetImageTransformParameterivHP');
+    glGetImageTransformParameterfvHP := SDL_GL_GetProcAddress( 'glGetImageTransformParameterfvHP'); 
+
+    // GL_EXT_color_subtable
+    glCopyColorSubTableEXT := SDL_GL_GetProcAddress( 'glCopyColorSubTableEXT'); 
+
+    // GL_PGI_misc_hints
+    glHintPGI := SDL_GL_GetProcAddress( 'glHintPGI'); 
+
+    // GL_EXT_paletted_texture
+    glGetColorTableParameterivEXT := SDL_GL_GetProcAddress( 'glGetColorTableParameterivEXT'); 
+    glGetColorTableParameterfvEXT := SDL_GL_GetProcAddress( 'glGetColorTableParameterfvEXT'); 
+
+    // GL_SGIX_list_priority
+    glGetListParameterfvSGIX := SDL_GL_GetProcAddress( 'glGetListParameterfvSGIX'); 
+    glGetListParameterivSGIX := SDL_GL_GetProcAddress( 'glGetListParameterivSGIX'); 
+    glListParameterfSGIX := SDL_GL_GetProcAddress( 'glListParameterfSGIX');
+    glListParameterfvSGIX := SDL_GL_GetProcAddress( 'glListParameterfvSGIX'); 
+    glListParameteriSGIX := SDL_GL_GetProcAddress( 'glListParameteriSGIX'); 
+    glListParameterivSGIX := SDL_GL_GetProcAddress( 'glListParameterivSGIX'); 
+
+    // GL_SGIX_fragment_lighting
+    glFragmentColorMaterialSGIX := SDL_GL_GetProcAddress( 'glFragmentColorMaterialSGIX'); 
+    glFragmentLightfSGIX := SDL_GL_GetProcAddress( 'glFragmentLightfSGIX'); 
+    glFragmentLightfvSGIX := SDL_GL_GetProcAddress( 'glFragmentLightfvSGIX'); 
+    glFragmentLightiSGIX := SDL_GL_GetProcAddress( 'glFragmentLightiSGIX'); 
+    glFragmentLightivSGIX := SDL_GL_GetProcAddress( 'glFragmentLightivSGIX'); 
+    glFragmentLightModelfSGIX := SDL_GL_GetProcAddress( 'glFragmentLightModelfSGIX'); 
+    glFragmentLightModelfvSGIX := SDL_GL_GetProcAddress( 'glFragmentLightModelfvSGIX'); 
+    glFragmentLightModeliSGIX := SDL_GL_GetProcAddress( 'glFragmentLightModeliSGIX'); 
+    glFragmentLightModelivSGIX := SDL_GL_GetProcAddress( 'glFragmentLightModelivSGIX'); 
+    glFragmentMaterialfSGIX := SDL_GL_GetProcAddress( 'glFragmentMaterialfSGIX'); 
+    glFragmentMaterialfvSGIX := SDL_GL_GetProcAddress( 'glFragmentMaterialfvSGIX');
+    glFragmentMaterialiSGIX := SDL_GL_GetProcAddress( 'glFragmentMaterialiSGIX'); 
+    glFragmentMaterialivSGIX := SDL_GL_GetProcAddress( 'glFragmentMaterialivSGIX'); 
+    glGetFragmentLightfvSGIX := SDL_GL_GetProcAddress( 'glGetFragmentLightfvSGIX'); 
+    glGetFragmentLightivSGIX := SDL_GL_GetProcAddress( 'glGetFragmentLightivSGIX'); 
+    glGetFragmentMaterialfvSGIX := SDL_GL_GetProcAddress( 'glGetFragmentMaterialfvSGIX');
+    glGetFragmentMaterialivSGIX := SDL_GL_GetProcAddress( 'glGetFragmentMaterialivSGIX'); 
+    glLightEnviSGIX := SDL_GL_GetProcAddress( 'glLightEnviSGIX'); 
+
+    // GL_EXT_draw_range_elements
+    glDrawRangeElementsEXT := SDL_GL_GetProcAddress( 'glDrawRangeElementsEXT'); 
+
+    // GL_EXT_light_texture
+    glApplyTextureEXT := SDL_GL_GetProcAddress( 'glApplyTextureEXT'); 
+    glTextureLightEXT := SDL_GL_GetProcAddress( 'glTextureLightEXT'); 
+    glTextureMaterialEXT := SDL_GL_GetProcAddress( 'glTextureMaterialEXT'); 
+
+    // GL_SGIX_async
+    glAsyncMarkerSGIX := SDL_GL_GetProcAddress( 'glAsyncMarkerSGIX'); 
+    glFinishAsyncSGIX := SDL_GL_GetProcAddress( 'glFinishAsyncSGIX'); 
+    glPollAsyncSGIX := SDL_GL_GetProcAddress( 'glPollAsyncSGIX'); 
+    glGenAsyncMarkersSGIX := SDL_GL_GetProcAddress( 'glGenAsyncMarkersSGIX'); 
+    glDeleteAsyncMarkersSGIX := SDL_GL_GetProcAddress( 'glDeleteAsyncMarkersSGIX'); 
+    glIsAsyncMarkerSGIX := SDL_GL_GetProcAddress( 'glIsAsyncMarkerSGIX'); 
+
+    // GL_INTEL_parallel_arrays
+    glVertexPointervINTEL := SDL_GL_GetProcAddress( 'glVertexPointervINTEL'); 
+    glNormalPointervINTEL := SDL_GL_GetProcAddress( 'glNormalPointervINTEL'); 
+    glColorPointervINTEL := SDL_GL_GetProcAddress( 'glColorPointervINTEL'); 
+    glTexCoordPointervINTEL := SDL_GL_GetProcAddress( 'glTexCoordPointervINTEL'); 
+
+    // GL_EXT_pixel_transform
+    glPixelTransformParameteriEXT := SDL_GL_GetProcAddress( 'glPixelTransformParameteriEXT');
+    glPixelTransformParameterfEXT := SDL_GL_GetProcAddress( 'glPixelTransformParameterfEXT'); 
+    glPixelTransformParameterivEXT := SDL_GL_GetProcAddress( 'glPixelTransformParameterivEXT'); 
+    glPixelTransformParameterfvEXT := SDL_GL_GetProcAddress( 'glPixelTransformParameterfvEXT'); 
+
+    // GL_EXT_secondary_color
+    glSecondaryColor3bEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3bEXT'); 
+    glSecondaryColor3bvEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3bvEXT'); 
+    glSecondaryColor3dEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3dEXT'); 
+    glSecondaryColor3dvEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3dvEXT'); 
+    glSecondaryColor3fEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3fEXT'); 
+    glSecondaryColor3fvEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3fvEXT'); 
+    glSecondaryColor3iEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3iEXT'); 
+    glSecondaryColor3ivEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3ivEXT'); 
+    glSecondaryColor3sEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3sEXT'); 
+    glSecondaryColor3svEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3svEXT'); 
+    glSecondaryColor3ubEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3ubEXT');
+    glSecondaryColor3ubvEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3ubvEXT'); 
+    glSecondaryColor3uiEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3uiEXT'); 
+    glSecondaryColor3uivEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3uivEXT'); 
+    glSecondaryColor3usEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3usEXT'); 
+    glSecondaryColor3usvEXT := SDL_GL_GetProcAddress( 'glSecondaryColor3usvEXT'); 
+    glSecondaryColorPointerEXT := SDL_GL_GetProcAddress( 'glSecondaryColorPointerEXT'); 
+
+    // GL_EXT_texture_perturb_normal
+    glTextureNormalEXT := SDL_GL_GetProcAddress( 'glTextureNormalEXT'); 
+
+    // GL_EXT_multi_draw_arrays
+    glMultiDrawArraysEXT := SDL_GL_GetProcAddress( 'glMultiDrawArraysEXT'); 
+    glMultiDrawElementsEXT := SDL_GL_GetProcAddress( 'glMultiDrawElementsEXT'); 
+
+    // GL_EXT_fog_coord
+    glFogCoordfEXT := SDL_GL_GetProcAddress( 'glFogCoordfEXT');
+    glFogCoordfvEXT := SDL_GL_GetProcAddress( 'glFogCoordfvEXT'); 
+    glFogCoorddEXT := SDL_GL_GetProcAddress( 'glFogCoorddEXT'); 
+    glFogCoorddvEXT := SDL_GL_GetProcAddress( 'glFogCoorddvEXT'); 
+    glFogCoordPointerEXT := SDL_GL_GetProcAddress( 'glFogCoordPointerEXT'); 
+
+    // GL_EXT_coordinate_frame
+    glTangent3bEXT := SDL_GL_GetProcAddress( 'glTangent3bEXT'); 
+    glTangent3bvEXT := SDL_GL_GetProcAddress( 'glTangent3bvEXT'); 
+    glTangent3dEXT := SDL_GL_GetProcAddress( 'glTangent3dEXT'); 
+    glTangent3dvEXT := SDL_GL_GetProcAddress( 'glTangent3dvEXT'); 
+    glTangent3fEXT := SDL_GL_GetProcAddress( 'glTangent3fEXT'); 
+    glTangent3fvEXT := SDL_GL_GetProcAddress( 'glTangent3fvEXT'); 
+    glTangent3iEXT := SDL_GL_GetProcAddress( 'glTangent3iEXT'); 
+    glTangent3ivEXT := SDL_GL_GetProcAddress( 'glTangent3ivEXT'); 
+    glTangent3sEXT := SDL_GL_GetProcAddress( 'glTangent3sEXT'); 
+    glTangent3svEXT := SDL_GL_GetProcAddress( 'glTangent3svEXT');
+    glBinormal3bEXT := SDL_GL_GetProcAddress( 'glBinormal3bEXT'); 
+    glBinormal3bvEXT := SDL_GL_GetProcAddress( 'glBinormal3bvEXT'); 
+    glBinormal3dEXT := SDL_GL_GetProcAddress( 'glBinormal3dEXT'); 
+    glBinormal3dvEXT := SDL_GL_GetProcAddress( 'glBinormal3dvEXT'); 
+    glBinormal3fEXT := SDL_GL_GetProcAddress( 'glBinormal3fEXT'); 
+    glBinormal3fvEXT := SDL_GL_GetProcAddress( 'glBinormal3fvEXT'); 
+    glBinormal3iEXT := SDL_GL_GetProcAddress( 'glBinormal3iEXT'); 
+    glBinormal3ivEXT := SDL_GL_GetProcAddress( 'glBinormal3ivEXT'); 
+    glBinormal3sEXT := SDL_GL_GetProcAddress( 'glBinormal3sEXT'); 
+    glBinormal3svEXT := SDL_GL_GetProcAddress( 'glBinormal3svEXT'); 
+    glTangentPointerEXT := SDL_GL_GetProcAddress( 'glTangentPointerEXT'); 
+    glBinormalPointerEXT := SDL_GL_GetProcAddress( 'glBinormalPointerEXT'); 
+
+    // GL_SUNX_constant_data
+    glFinishTextureSUNX := SDL_GL_GetProcAddress( 'glFinishTextureSUNX'); 
+
+    // GL_SUN_global_alpha
+    glGlobalAlphaFactorbSUN := SDL_GL_GetProcAddress( 'glGlobalAlphaFactorbSUN'); 
+    glGlobalAlphaFactorsSUN := SDL_GL_GetProcAddress( 'glGlobalAlphaFactorsSUN'); 
+    glGlobalAlphaFactoriSUN := SDL_GL_GetProcAddress( 'glGlobalAlphaFactoriSUN'); 
+    glGlobalAlphaFactorfSUN := SDL_GL_GetProcAddress( 'glGlobalAlphaFactorfSUN'); 
+    glGlobalAlphaFactordSUN := SDL_GL_GetProcAddress( 'glGlobalAlphaFactordSUN'); 
+    glGlobalAlphaFactorubSUN := SDL_GL_GetProcAddress( 'glGlobalAlphaFactorubSUN'); 
+    glGlobalAlphaFactorusSUN := SDL_GL_GetProcAddress( 'glGlobalAlphaFactorusSUN'); 
+    glGlobalAlphaFactoruiSUN := SDL_GL_GetProcAddress( 'glGlobalAlphaFactoruiSUN');
+
+    // GL_SUN_triangle_list
+    glReplacementCodeuiSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiSUN'); 
+    glReplacementCodeusSUN := SDL_GL_GetProcAddress( 'glReplacementCodeusSUN'); 
+    glReplacementCodeubSUN := SDL_GL_GetProcAddress( 'glReplacementCodeubSUN'); 
+    glReplacementCodeuivSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuivSUN'); 
+    glReplacementCodeusvSUN := SDL_GL_GetProcAddress( 'glReplacementCodeusvSUN');
+    glReplacementCodeubvSUN := SDL_GL_GetProcAddress( 'glReplacementCodeubvSUN'); 
+    glReplacementCodePointerSUN := SDL_GL_GetProcAddress( 'glReplacementCodePointerSUN'); 
+
+    // GL_SUN_vertex
+    glColor4ubVertex2fSUN := SDL_GL_GetProcAddress( 'glColor4ubVertex2fSUN'); 
+    glColor4ubVertex2fvSUN := SDL_GL_GetProcAddress( 'glColor4ubVertex2fvSUN'); 
+    glColor4ubVertex3fSUN := SDL_GL_GetProcAddress( 'glColor4ubVertex3fSUN'); 
+    glColor4ubVertex3fvSUN := SDL_GL_GetProcAddress( 'glColor4ubVertex3fvSUN'); 
+    glColor3fVertex3fSUN := SDL_GL_GetProcAddress( 'glColor3fVertex3fSUN'); 
+    glColor3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glColor3fVertex3fvSUN'); 
+    glNormal3fVertex3fSUN := SDL_GL_GetProcAddress( 'glNormal3fVertex3fSUN'); 
+    glNormal3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glNormal3fVertex3fvSUN'); 
+    glColor4fNormal3fVertex3fSUN := SDL_GL_GetProcAddress( 'glColor4fNormal3fVertex3fSUN'); 
+    glColor4fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glColor4fNormal3fVertex3fvSUN'); 
+    glTexCoord2fVertex3fSUN := SDL_GL_GetProcAddress( 'glTexCoord2fVertex3fSUN'); 
+    glTexCoord2fVertex3fvSUN := SDL_GL_GetProcAddress( 'glTexCoord2fVertex3fvSUN');
+    glTexCoord4fVertex4fSUN := SDL_GL_GetProcAddress( 'glTexCoord4fVertex4fSUN'); 
+    glTexCoord4fVertex4fvSUN := SDL_GL_GetProcAddress( 'glTexCoord4fVertex4fvSUN');
+    glTexCoord2fColor4ubVertex3fSUN := SDL_GL_GetProcAddress( 'glTexCoord2fColor4ubVertex3fSUN'); 
+    glTexCoord2fColor4ubVertex3fvSUN := SDL_GL_GetProcAddress( 'glTexCoord2fColor4ubVertex3fvSUN'); 
+    glTexCoord2fColor3fVertex3fSUN := SDL_GL_GetProcAddress( 'glTexCoord2fColor3fVertex3fSUN'); 
+    glTexCoord2fColor3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glTexCoord2fColor3fVertex3fvSUN'); 
+    glTexCoord2fNormal3fVertex3fSUN := SDL_GL_GetProcAddress( 'glTexCoord2fNormal3fVertex3fSUN'); 
+    glTexCoord2fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glTexCoord2fNormal3fVertex3fvSUN'); 
+    glTexCoord2fColor4fNormal3fVertex3fSUN := SDL_GL_GetProcAddress( 'glTexCoord2fColor4fNormal3fVertex3fSUN'); 
+    glTexCoord2fColor4fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glTexCoord2fColor4fNormal3fVertex3fvSUN'); 
+    glTexCoord4fColor4fNormal3fVertex4fSUN := SDL_GL_GetProcAddress( 'glTexCoord4fColor4fNormal3fVertex4fSUN'); 
+    glTexCoord4fColor4fNormal3fVertex4fvSUN := SDL_GL_GetProcAddress( 'glTexCoord4fColor4fNormal3fVertex4fvSUN'); 
+    glReplacementCodeuiVertex3fSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiVertex3fSUN'); 
+    glReplacementCodeuiVertex3fvSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiVertex3fvSUN'); 
+    glReplacementCodeuiColor4ubVertex3fSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiColor4ubVertex3fSUN'); 
+    glReplacementCodeuiColor4ubVertex3fvSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiColor4ubVertex3fvSUN');
+    glReplacementCodeuiColor3fVertex3fSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiColor3fVertex3fSUN'); 
+    glReplacementCodeuiColor3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiColor3fVertex3fvSUN'); 
+    glReplacementCodeuiNormal3fVertex3fSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiNormal3fVertex3fSUN'); 
+    glReplacementCodeuiNormal3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiNormal3fVertex3fvSUN'); 
+    glReplacementCodeuiColor4fNormal3fVertex3fSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiColor4fNormal3fVertex3fSUN'); 
+    glReplacementCodeuiColor4fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiColor4fNormal3fVertex3fvSUN'); 
+    glReplacementCodeuiTexCoord2fVertex3fSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiTexCoord2fVertex3fSUN'); 
+    glReplacementCodeuiTexCoord2fVertex3fvSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiTexCoord2fVertex3fvSUN'); 
+    glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN'); 
+    glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN'); 
+    glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN');
+    glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN := SDL_GL_GetProcAddress( 'glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN'); 
+
+    // GL_EXT_blend_func_separate
+    glBlendFuncSeparateEXT := SDL_GL_GetProcAddress( 'glBlendFuncSeparateEXT'); 
+
+    // GL_EXT_vertex_weighting
+    glVertexWeightfEXT := SDL_GL_GetProcAddress( 'glVertexWeightfEXT'); 
+    glVertexWeightfvEXT := SDL_GL_GetProcAddress( 'glVertexWeightfvEXT'); 
+    glVertexWeightPointerEXT := SDL_GL_GetProcAddress( 'glVertexWeightPointerEXT'); 
+
+    // GL_NV_vertex_array_range
+    glFlushVertexArrayRangeNV := SDL_GL_GetProcAddress( 'glFlushVertexArrayRangeNV'); 
+    glVertexArrayRangeNV := SDL_GL_GetProcAddress( 'glVertexArrayRangeNV'); 
+    wglAllocateMemoryNV := SDL_GL_GetProcAddress( 'wglAllocateMemoryNV'); 
+    wglFreeMemoryNV := SDL_GL_GetProcAddress( 'wglFreeMemoryNV'); 
+
+    // GL_NV_register_combiners
+    glCombinerParameterfvNV := SDL_GL_GetProcAddress( 'glCombinerParameterfvNV'); 
+    glCombinerParameterfNV := SDL_GL_GetProcAddress( 'glCombinerParameterfNV'); 
+    glCombinerParameterivNV := SDL_GL_GetProcAddress( 'glCombinerParameterivNV'); 
+    glCombinerParameteriNV := SDL_GL_GetProcAddress( 'glCombinerParameteriNV');
+    glCombinerInputNV := SDL_GL_GetProcAddress( 'glCombinerInputNV'); 
+    glCombinerOutputNV := SDL_GL_GetProcAddress( 'glCombinerOutputNV'); 
+    glFinalCombinerInputNV := SDL_GL_GetProcAddress( 'glFinalCombinerInputNV'); 
+    glGetCombinerInputParameterfvNV := SDL_GL_GetProcAddress( 'glGetCombinerInputParameterfvNV');
+    glGetCombinerInputParameterivNV := SDL_GL_GetProcAddress( 'glGetCombinerInputParameterivNV'); 
+    glGetCombinerOutputParameterfvNV := SDL_GL_GetProcAddress( 'glGetCombinerOutputParameterfvNV'); 
+    glGetCombinerOutputParameterivNV := SDL_GL_GetProcAddress( 'glGetCombinerOutputParameterivNV'); 
+    glGetFinalCombinerInputParameterfvNV := SDL_GL_GetProcAddress( 'glGetFinalCombinerInputParameterfvNV'); 
+    glGetFinalCombinerInputParameterivNV := SDL_GL_GetProcAddress( 'glGetFinalCombinerInputParameterivNV'); 
+
+    // GL_MESA_resize_buffers
+    glResizeBuffersMESA := SDL_GL_GetProcAddress( 'glResizeBuffersMESA'); 
+
+    // GL_MESA_window_pos
+    glWindowPos2dMESA := SDL_GL_GetProcAddress( 'glWindowPos2dMESA'); 
+    glWindowPos2dvMESA := SDL_GL_GetProcAddress( 'glWindowPos2dvMESA');
+    glWindowPos2fMESA := SDL_GL_GetProcAddress( 'glWindowPos2fMESA'); 
+    glWindowPos2fvMESA := SDL_GL_GetProcAddress( 'glWindowPos2fvMESA'); 
+    glWindowPos2iMESA := SDL_GL_GetProcAddress( 'glWindowPos2iMESA'); 
+    glWindowPos2ivMESA := SDL_GL_GetProcAddress( 'glWindowPos2ivMESA'); 
+    glWindowPos2sMESA := SDL_GL_GetProcAddress( 'glWindowPos2sMESA'); 
+    glWindowPos2svMESA := SDL_GL_GetProcAddress( 'glWindowPos2svMESA'); 
+    glWindowPos3dMESA := SDL_GL_GetProcAddress( 'glWindowPos3dMESA'); 
+    glWindowPos3dvMESA := SDL_GL_GetProcAddress( 'glWindowPos3dvMESA'); 
+    glWindowPos3fMESA := SDL_GL_GetProcAddress( 'glWindowPos3fMESA'); 
+    glWindowPos3fvMESA := SDL_GL_GetProcAddress( 'glWindowPos3fvMESA'); 
+    glWindowPos3iMESA := SDL_GL_GetProcAddress( 'glWindowPos3iMESA'); 
+    glWindowPos3ivMESA := SDL_GL_GetProcAddress( 'glWindowPos3ivMESA'); 
+    glWindowPos3sMESA := SDL_GL_GetProcAddress( 'glWindowPos3sMESA');
+    glWindowPos3svMESA := SDL_GL_GetProcAddress( 'glWindowPos3svMESA'); 
+    glWindowPos4dMESA := SDL_GL_GetProcAddress( 'glWindowPos4dMESA'); 
+    glWindowPos4dvMESA := SDL_GL_GetProcAddress( 'glWindowPos4dvMESA');
+    glWindowPos4fMESA := SDL_GL_GetProcAddress( 'glWindowPos4fMESA'); 
+    glWindowPos4fvMESA := SDL_GL_GetProcAddress( 'glWindowPos4fvMESA'); 
+    glWindowPos4iMESA := SDL_GL_GetProcAddress( 'glWindowPos4iMESA'); 
+    glWindowPos4ivMESA := SDL_GL_GetProcAddress( 'glWindowPos4ivMESA'); 
+    glWindowPos4sMESA := SDL_GL_GetProcAddress( 'glWindowPos4sMESA'); 
+    glWindowPos4svMESA := SDL_GL_GetProcAddress( 'glWindowPos4svMESA'); 
+
+    // GL_IBM_multimode_draw_arrays
+    glMultiModeDrawArraysIBM := SDL_GL_GetProcAddress( 'glMultiModeDrawArraysIBM'); 
+    glMultiModeDrawElementsIBM := SDL_GL_GetProcAddress( 'glMultiModeDrawElementsIBM'); 
+
+    // GL_IBM_vertex_array_lists
+    glColorPointerListIBM := SDL_GL_GetProcAddress( 'glColorPointerListIBM'); 
+    glSecondaryColorPointerListIBM := SDL_GL_GetProcAddress( 'glSecondaryColorPointerListIBM'); 
+    glEdgeFlagPointerListIBM := SDL_GL_GetProcAddress( 'glEdgeFlagPointerListIBM'); 
+    glFogCoordPointerListIBM := SDL_GL_GetProcAddress( 'glFogCoordPointerListIBM');
+    glIndexPointerListIBM := SDL_GL_GetProcAddress( 'glIndexPointerListIBM'); 
+    glNormalPointerListIBM := SDL_GL_GetProcAddress( 'glNormalPointerListIBM'); 
+    glTexCoordPointerListIBM := SDL_GL_GetProcAddress( 'glTexCoordPointerListIBM'); 
+    glVertexPointerListIBM := SDL_GL_GetProcAddress( 'glVertexPointerListIBM'); 
+
+    // GL_3DFX_tbuffer
+    glTbufferMask3DFX := SDL_GL_GetProcAddress( 'glTbufferMask3DFX'); 
+
+    // GL_EXT_multisample
+    glSampleMaskEXT := SDL_GL_GetProcAddress( 'glSampleMaskEXT'); 
+    glSamplePatternEXT := SDL_GL_GetProcAddress( 'glSamplePatternEXT'); 
+
+    // GL_SGIS_texture_color_mask
+    glTextureColorMaskSGIS := SDL_GL_GetProcAddress( 'glTextureColorMaskSGIS'); 
+
+    // GL_SGIX_igloo_interface
+    glIglooInterfaceSGIX := SDL_GL_GetProcAddress( 'glIglooInterfaceSGIX'); 
+
+    // GLU extensions
+    gluNurbsCallbackDataEXT := SDL_GL_GetProcAddress( 'gluNurbsCallbackDataEXT'); 
+    gluNewNurbsTessellatorEXT := SDL_GL_GetProcAddress( 'gluNewNurbsTessellatorEXT'); 
+    gluDeleteNurbsTessellatorEXT := SDL_GL_GetProcAddress( 'gluDeleteNurbsTessellatorEXT'); 
+
+    // GL_NV_vertex_program
+    glAreProgramsResidentNV := SDL_GL_GetProcAddress( 'glAreProgramsResidentNV'); 
+    glBindProgramNV := SDL_GL_GetProcAddress( 'glBindProgramNV'); 
+    glDeleteProgramsNV := SDL_GL_GetProcAddress( 'glDeleteProgramsNV'); 
+    glExecuteProgramNV := SDL_GL_GetProcAddress( 'glExecuteProgramNV'); 
+    glGenProgramsNV := SDL_GL_GetProcAddress( 'glGenProgramsNV'); 
+    glGetProgramParameterdvNV := SDL_GL_GetProcAddress( 'glGetProgramParameterdvNV'); 
+    glGetProgramParameterfvNV := SDL_GL_GetProcAddress( 'glGetProgramParameterfvNV');
+    glGetProgramivNV := SDL_GL_GetProcAddress( 'glGetProgramivNV');
+    glGetProgramStringNV := SDL_GL_GetProcAddress( 'glGetProgramStringNV'); 
+    glGetTrackMatrixivNV := SDL_GL_GetProcAddress( 'glGetTrackMatrixivNV'); 
+    glGetVertexAttribdvNV:= SDL_GL_GetProcAddress( 'glGetVertexAttribdvNV'); 
+    glGetVertexAttribfvNV:= SDL_GL_GetProcAddress( 'glGetVertexAttribfvNV'); 
+    glGetVertexAttribivNV:= SDL_GL_GetProcAddress( 'glGetVertexAttribivNV'); 
+    glGetVertexAttribPointervNV := wglGetProcAddress ('glGetVertexAttribPointervNV'); 
+    glIsProgramNV := SDL_GL_GetProcAddress( 'glIsProgramNV'); 
+    glLoadProgramNV := SDL_GL_GetProcAddress( 'glLoadProgramNV'); 
+    glProgramParameter4dNV := SDL_GL_GetProcAddress( 'glProgramParameter4dNV'); 
+    glProgramParameter4dvNV := SDL_GL_GetProcAddress( 'glProgramParameter4dvNV'); 
+    glProgramParameter4fNV := SDL_GL_GetProcAddress( 'glProgramParameter4fNV'); 
+    glProgramParameter4fvNV := SDL_GL_GetProcAddress( 'glProgramParameter4fvNV'); 
+    glProgramParameters4dvNV := wglGetProcAddress ('glProgramParameters4dvNV'); 
+    glProgramParameters4fvNV := wglGetProcAddress ('glProgramParameters4fvNV'); 
+    glRequestResidentProgramsNV := wglGetProcAddress ('glRequestResidentProgramsNV'); 
+    glTrackMatrixNV := SDL_GL_GetProcAddress( 'glTrackMatrixNV');
+    glVertexAttribPointerNV := SDL_GL_GetProcAddress( 'glVertexAttribPointerNV'); 
+    glVertexAttrib1dNV := SDL_GL_GetProcAddress( 'glVertexAttrib1dNV'); 
+    glVertexAttrib1dvNV := SDL_GL_GetProcAddress( 'glVertexAttrib1dvNV'); 
+    glVertexAttrib1fNV := SDL_GL_GetProcAddress( 'glVertexAttrib1fNV'); 
+    glVertexAttrib1fvNV := SDL_GL_GetProcAddress( 'glVertexAttrib1fvNV'); 
+    glVertexAttrib1sNV := SDL_GL_GetProcAddress( 'glVertexAttrib1sNV'); 
+    glVertexAttrib1svNV := SDL_GL_GetProcAddress( 'glVertexAttrib1svNV'); 
+    glVertexAttrib2dNV := SDL_GL_GetProcAddress( 'glVertexAttrib2dNV');
+    glVertexAttrib2dvNV := SDL_GL_GetProcAddress( 'glVertexAttrib2dvNV'); 
+    glVertexAttrib2fNV := SDL_GL_GetProcAddress( 'glVertexAttrib2fNV'); 
+    glVertexAttrib2fvNV := SDL_GL_GetProcAddress( 'glVertexAttrib2fvNV'); 
+    glVertexAttrib2sNV := SDL_GL_GetProcAddress( 'glVertexAttrib2sNV'); 
+    glVertexAttrib2svNV := SDL_GL_GetProcAddress( 'glVertexAttrib2svNV'); 
+    glVertexAttrib3dNV := SDL_GL_GetProcAddress( 'glVertexAttrib3dNV'); 
+    glVertexAttrib3dvNV := SDL_GL_GetProcAddress( 'glVertexAttrib3dvNV'); 
+    glVertexAttrib3fNV := SDL_GL_GetProcAddress( 'glVertexAttrib3fNV');
+    glVertexAttrib3fvNV := SDL_GL_GetProcAddress( 'glVertexAttrib3fvNV'); 
+    glVertexAttrib3sNV := SDL_GL_GetProcAddress( 'glVertexAttrib3sNV'); 
+    glVertexAttrib3svNV := SDL_GL_GetProcAddress( 'glVertexAttrib3svNV'); 
+    glVertexAttrib4dNV := SDL_GL_GetProcAddress( 'glVertexAttrib4dNV'); 
+    glVertexAttrib4dvNV := SDL_GL_GetProcAddress( 'glVertexAttrib4dvNV'); 
+    glVertexAttrib4fNV := SDL_GL_GetProcAddress( 'glVertexAttrib4fNV'); 
+    glVertexAttrib4fvNV := SDL_GL_GetProcAddress( 'glVertexAttrib4fvNV'); 
+    glVertexAttrib4sNV := SDL_GL_GetProcAddress( 'glVertexAttrib4sNV'); 
+    glVertexAttrib4svNV := SDL_GL_GetProcAddress( 'glVertexAttrib4svNV'); 
+    glVertexAttrib4ubvNV := SDL_GL_GetProcAddress( 'glVertexAttrib4ubvNV'); 
+    glVertexAttribs1dvNV := SDL_GL_GetProcAddress( 'glVertexAttribs1dvNV'); 
+    glVertexAttribs1fvNV := SDL_GL_GetProcAddress( 'glVertexAttribs1fvNV'); 
+    glVertexAttribs1svNV := SDL_GL_GetProcAddress( 'glVertexAttribs1svNV'); 
+    glVertexAttribs2dvNV := SDL_GL_GetProcAddress( 'glVertexAttribs2dvNV'); 
+    glVertexAttribs2fvNV := SDL_GL_GetProcAddress( 'glVertexAttribs2fvNV'); 
+    glVertexAttribs2svNV := SDL_GL_GetProcAddress( 'glVertexAttribs2svNV');
+    glVertexAttribs3dvNV := SDL_GL_GetProcAddress( 'glVertexAttribs3dvNV');
+    glVertexAttribs3fvNV := SDL_GL_GetProcAddress( 'glVertexAttribs3fvNV'); 
+    glVertexAttribs3svNV := SDL_GL_GetProcAddress( 'glVertexAttribs3svNV'); 
+    glVertexAttribs4dvNV := SDL_GL_GetProcAddress( 'glVertexAttribs4dvNV'); 
+    glVertexAttribs4fvNV := SDL_GL_GetProcAddress( 'glVertexAttribs4fvNV'); 
+    glVertexAttribs4svNV := SDL_GL_GetProcAddress( 'glVertexAttribs4svNV'); 
+    glVertexAttribs4ubvNV := SDL_GL_GetProcAddress( 'glVertexAttribs4ubvN'); 
+
+    // ARB wgl extensions
+    wglGetExtensionsStringARB := SDL_GL_GetProcAddress( 'wglGetExtensionsStringARB');
+    wglGetPixelFormatAttribivARB := SDL_GL_GetProcAddress( 'wglGetPixelFormatAttribivARB');
+    wglGetPixelFormatAttribfvARB := SDL_GL_GetProcAddress( 'wglGetPixelFormatAttribfvARB');
+    wglChoosePixelFormatARB := SDL_GL_GetProcAddress( 'wglChoosePixelFormatARB');
+
+    // To get synchronized again, if this proc was called externally.
+    LastPixelFormat := 0;
+  end;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure TrimAndSplitVersionString(Buffer: String; var Max, Min: Integer);
+
+// Peels out the X.Y form from the given Buffer which must contain a version string like "text Minor.Major.Build text"
+// at least however "Major.Minor".
+
+var
+  Separator: Integer;
+   
+begin
+  try
+    // There must be at least one dot to separate major and minor version number.
+    Separator := Pos('.', Buffer);
+    // At least one number must be before and one after the dot.
+    if (Separator > 1) and (Separator < Length(Buffer)) and (Buffer[Separator - 1] in ['0'..'9']) and
+      (Buffer[Separator + 1] in ['0'..'9']) then
+    begin
+      // OK, it's a valid version string. Now remove unnecessary parts.
+      Dec(Separator); 
+      // Find last non-numeric character before version number.
+      while (Separator > 0) and (Buffer[Separator] in ['0'..'9']) do
+        Dec(Separator); 
+      // Delete leading characters which do not belong to the version string.
+      Delete(Buffer, 1, Separator);
+      Separator := Pos('.', Buffer) + 1;
+      // Find first non-numeric character after version number
+      while (Separator <= Length(Buffer)) and (Buffer[Separator] in ['0'..'9']) do
+        Inc(Separator); 
+      // delete trailing characters not belonging to the version string
+      Delete(Buffer, Separator, 255); 
+      // Now translate the numbers.
+      Separator := Pos('.', Buffer); // This is necessary because the buffer length might have changed.
+      Max := StrToInt(Copy(Buffer, 1, Separator - 1)); 
+      Min := StrToInt(Copy(Buffer, Separator + 1, 255)); 
+    end
+    else
+      Abort; 
+  except
+    Min := 0; 
+    Max := 0; 
+  end; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure ReadImplementationProperties;
+ 
+var
+  Buffer: string; 
+  MajorVersion,
+  MinorVersion: Integer;
+
+  //--------------- local function --------------------------------------------
+
+   function CheckExtension(const Extension: string): Boolean;
+
+   // Checks if the given Extension string is in Buffer.
+
+   var
+     ExtPos: Integer;
+
+   begin
+     // First find the position of the extension string as substring in Buffer.
+     ExtPos := Pos(Extension, Buffer);
+     Result := ExtPos > 0;
+     // Now check that it isn't only a substring of another extension.
+     if Result then
+       Result := ((ExtPos + Length(Extension) - 1) = Length(Buffer)) or
+         not (Buffer[ExtPos + Length(Extension)] in ['_', 'A'..'Z', 'a'..'z']);
+   end; 
+
+  //--------------- end local function ----------------------------------------
+
+begin
+  // determine version of implementation
+  // GL
+  Buffer := glGetString(GL_VERSION); 
+  TrimAndSplitVersionString(Buffer, Majorversion, MinorVersion); 
+  GL_VERSION_1_0 := True; 
+  GL_VERSION_1_1 := False; 
+  GL_VERSION_1_2 := False; 
+  if MajorVersion > 0 then
+  begin
+    if MinorVersion > 0 then
+    begin
+      GL_VERSION_1_1 := True; 
+      if MinorVersion > 1 then
+        GL_VERSION_1_2 := True;
+    end; 
+  end; 
+
+  // GLU
+  GLU_VERSION_1_1 := False; 
+  GLU_VERSION_1_2 := False; 
+  GLU_VERSION_1_3 := False; 
+  // gluGetString is valid for version 1.1 or later
+  if Assigned(gluGetString) then
+  begin
+    Buffer := gluGetString(GLU_VERSION); 
+    TrimAndSplitVersionString(Buffer, Majorversion, MinorVersion); 
+    GLU_VERSION_1_1 := True; 
+    if MinorVersion > 1 then
+    begin
+      GLU_VERSION_1_2 := True; 
+      if MinorVersion > 2 then
+        GLU_VERSION_1_3 := True; 
+    end; 
+  end; 
+
+  // check supported extensions
+  // GL
+  Buffer := glGetString(GL_EXTENSIONS); 
+  GL_3DFX_multisample :=CheckExtension('GL_3DFX_multisample');
+  GL_3DFX_tbuffer := CheckExtension('GL_3DFX_tbuffer'); 
+  GL_3DFX_texture_compression_FXT1 := CheckExtension('GL_3DFX_texture_compression_FXT1'); 
+
+  GL_APPLE_specular_vector := CheckExtension('GL_APPLE_specular_vector'); 
+  GL_APPLE_transform_hint := CheckExtension('GL_APPLE_transform_hint'); 
+
+  GL_ARB_imaging := CheckExtension('GL_ARB_imaging'); 
+  GL_ARB_multisample := CheckExtension('GL_ARB_multisample'); 
+  GL_ARB_multitexture := CheckExtension('GL_ARB_multitexture'); 
+  GL_ARB_texture_compression := CheckExtension('GL_ARB_texture_compression'); 
+  GL_ARB_texture_cube_map := CheckExtension('GL_ARB_texture_cube_map'); 
+  GL_ARB_transpose_matrix := CheckExtension('GL_ARB_transpose_matrix'); 
+  GL_ARB_vertex_blend := CheckExtension('GL_ARB_vertex_blend'); 
+
+  GL_EXT_422_pixels := CheckExtension('GL_EXT_422_pixels'); 
+  GL_EXT_abgr := CheckExtension('GL_EXT_abgr'); 
+  GL_EXT_bgra := CheckExtension('GL_EXT_bgra'); 
+  GL_EXT_blend_color := CheckExtension('GL_EXT_blend_color'); 
+  GL_EXT_blend_func_separate := CheckExtension('GL_EXT_blend_func_separate'); 
+  GL_EXT_blend_logic_op := CheckExtension('GL_EXT_blend_logic_op'); 
+  GL_EXT_blend_minmax := CheckExtension('GL_EXT_blend_minmax'); 
+  GL_EXT_blend_subtract := CheckExtension('GL_EXT_blend_subtract'); 
+  GL_EXT_clip_volume_hint := CheckExtension('GL_EXT_clip_volume_hint'); 
+  GL_EXT_cmyka := CheckExtension('GL_EXT_cmyka'); 
+  GL_EXT_color_subtable := CheckExtension('GL_EXT_color_subtable');
+  GL_EXT_compiled_vertex_array := CheckExtension('GL_EXT_compiled_vertex_array'); 
+  GL_EXT_convolution := CheckExtension('GL_EXT_convolution'); 
+  GL_EXT_coordinate_frame := CheckExtension('GL_EXT_coordinate_frame'); 
+  GL_EXT_copy_texture := CheckExtension('GL_EXT_copy_texture'); 
+  GL_EXT_cull_vertex := CheckExtension('GL_EXT_cull_vertex'); 
+  GL_EXT_draw_range_elements := CheckExtension('GL_EXT_draw_range_elements'); 
+  GL_EXT_fog_coord := CheckExtension('GL_EXT_fog_coord'); 
+  GL_EXT_histogram := CheckExtension('GL_EXT_histogram'); 
+  GL_EXT_index_array_formats := CheckExtension('GL_EXT_index_array_formats'); 
+  GL_EXT_index_func := CheckExtension('GL_EXT_index_func'); 
+  GL_EXT_index_material := CheckExtension('GL_EXT_index_material'); 
+  GL_EXT_index_texture := CheckExtension('GL_EXT_index_texture'); 
+  GL_EXT_light_max_exponent := CheckExtension('GL_EXT_light_max_exponent'); 
+  GL_EXT_light_texture := CheckExtension('GL_EXT_light_texture'); 
+  GL_EXT_misc_attribute := CheckExtension('GL_EXT_misc_attribute'); 
+  GL_EXT_multi_draw_arrays := CheckExtension('GL_EXT_multi_draw_arrays'); 
+  GL_EXT_multisample := CheckExtension('GL_EXT_multisample'); 
+  GL_EXT_packed_pixels := CheckExtension('GL_EXT_packed_pixels'); 
+  GL_EXT_paletted_texture := CheckExtension('GL_EXT_paletted_texture'); 
+  GL_EXT_pixel_transform := CheckExtension('GL_EXT_pixel_transform'); 
+  GL_EXT_point_parameters := CheckExtension('GL_EXT_point_parameters'); 
+  GL_EXT_polygon_offset := CheckExtension('GL_EXT_polygon_offset'); 
+  GL_EXT_rescale_normal := CheckExtension('GL_EXT_rescale_normal'); 
+  GL_EXT_scene_marker := CheckExtension('GL_EXT_scene_marker'); 
+  GL_EXT_secondary_color := CheckExtension('GL_EXT_secondary_color');
+  GL_EXT_separate_specular_color := CheckExtension('GL_EXT_separate_specular_color'); 
+  GL_EXT_shared_texture_palette := CheckExtension('GL_EXT_shared_texture_palette'); 
+  GL_EXT_stencil_wrap := CheckExtension('GL_EXT_stencil_wrap'); 
+  GL_EXT_subtexture := CheckExtension('GL_EXT_subtexture'); 
+  GL_EXT_texture_color_table := CheckExtension('GL_EXT_texture_color_table'); 
+  GL_EXT_texture_compression_s3tc := CheckExtension('GL_EXT_texture_compression_s3tc'); 
+  GL_EXT_texture_cube_map := CheckExtension('GL_EXT_texture_cube_map'); 
+  GL_EXT_texture_edge_clamp := CheckExtension('GL_EXT_texture_edge_clamp'); 
+  GL_EXT_texture_env_add := CheckExtension('GL_EXT_texture_env_add'); 
+  GL_EXT_texture_env_combine := CheckExtension('GL_EXT_texture_env_combine'); 
+  GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic'); 
+  GL_EXT_texture_lod_bias := CheckExtension('GL_EXT_texture_lod_bias'); 
+  GL_EXT_texture_object := CheckExtension('GL_EXT_texture_object'); 
+  GL_EXT_texture_perturb_normal := CheckExtension('GL_EXT_texture_perturb_normal'); 
+  GL_EXT_texture3D := CheckExtension('GL_EXT_texture3D'); 
+  GL_EXT_vertex_array := CheckExtension('GL_EXT_vertex_array'); 
+  GL_EXT_vertex_weighting := CheckExtension('GL_EXT_vertex_weighting'); 
+
+  GL_FfdMaskSGIX := CheckExtension('GL_FfdMaskSGIX'); 
+  GL_HP_convolution_border_modes := CheckExtension('GL_HP_convolution_border_modes'); 
+  GL_HP_image_transform := CheckExtension('GL_HP_image_transform'); 
+  GL_HP_occlusion_test := CheckExtension('GL_HP_occlusion_test'); 
+  GL_HP_texture_lighting := CheckExtension('GL_HP_texture_lighting'); 
+
+  GL_IBM_cull_vertex := CheckExtension('GL_IBM_cull_vertex');
+  GL_IBM_multimode_draw_arrays := CheckExtension('GL_IBM_multimode_draw_arrays'); 
+  GL_IBM_rasterpos_clip := CheckExtension('GL_IBM_rasterpos_clip'); 
+  GL_IBM_vertex_array_lists := CheckExtension('GL_IBM_vertex_array_lists'); 
+
+  GL_INGR_color_clamp := CheckExtension('GL_INGR_color_clamp'); 
+  GL_INGR_interlace_read := CheckExtension('GL_INGR_interlace_read'); 
+
+  GL_INTEL_parallel_arrays := CheckExtension('GL_INTEL_parallel_arrays'); 
+
+  GL_KTX_buffer_region := CheckExtension('GL_KTX_buffer_region'); 
+
+  GL_MESA_resize_buffers := CheckExtension('GL_MESA_resize_buffers'); 
+  GL_MESA_window_pos := CheckExtension('GL_MESA_window_pos'); 
+
+  GL_NV_blend_square := CheckExtension('GL_NV_blend_square'); 
+  GL_NV_fog_distance := CheckExtension('GL_NV_fog_distance'); 
+  GL_NV_light_max_exponent := CheckExtension('GL_NV_light_max_exponent'); 
+  GL_NV_register_combiners := CheckExtension('GL_NV_register_combiners'); 
+  GL_NV_texgen_emboss := CheckExtension('GL_NV_texgen_emboss'); 
+  GL_NV_texgen_reflection := CheckExtension('GL_NV_texgen_reflection'); 
+  GL_NV_texture_env_combine4 := CheckExtension('GL_NV_texture_env_combine4'); 
+  GL_NV_vertex_array_range := CheckExtension('GL_NV_vertex_array_range'); 
+  GL_NV_vertex_program := CheckExtension('GL_NV_vertex_program'); 
+
+  GL_PGI_misc_hints := CheckExtension('GL_PGI_misc_hints');
+  GL_PGI_vertex_hints := CheckExtension('GL_PGI_vertex_hints'); 
+
+  GL_REND_screen_coordinates := CheckExtension('GL_REND_screen_coordinates'); 
+
+  GL_SGI_color_matrix := CheckExtension('GL_SGI_color_matrix'); 
+  GL_SGI_color_table := CheckExtension('GL_SGI_color_table'); 
+  GL_SGI_depth_pass_instrument := CheckExtension('GL_SGI_depth_pass_instrument'); 
+
+  GL_SGIS_detail_texture := CheckExtension('GL_SGIS_detail_texture'); 
+  GL_SGIS_fog_function := CheckExtension('GL_SGIS_fog_function'); 
+  GL_SGIS_generate_mipmap := CheckExtension('GL_SGIS_generate_mipmap'); 
+  GL_SGIS_multisample := CheckExtension('GL_SGIS_multisample'); 
+  GL_SGIS_multitexture := CheckExtension('GL_SGIS_multitexture'); 
+  GL_SGIS_pixel_texture := CheckExtension('GL_SGIS_pixel_texture'); 
+  GL_SGIS_point_line_texgen := CheckExtension('GL_SGIS_point_line_texgen'); 
+  GL_SGIS_point_parameters := CheckExtension('GL_SGIS_point_parameters'); 
+  GL_SGIS_sharpen_texture := CheckExtension('GL_SGIS_sharpen_texture'); 
+  GL_SGIS_texture_border_clamp := CheckExtension('GL_SGIS_texture_border_clamp'); 
+  GL_SGIS_texture_color_mask := CheckExtension('GL_SGIS_texture_color_mask'); 
+  GL_SGIS_texture_edge_clamp := CheckExtension('GL_SGIS_texture_edge_clamp'); 
+  GL_SGIS_texture_filter4 := CheckExtension('GL_SGIS_texture_filter4'); 
+  GL_SGIS_texture_lod := CheckExtension('GL_SGIS_texture_lod'); 
+  GL_SGIS_texture_select := CheckExtension('GL_SGIS_texture_select'); 
+  GL_SGIS_texture4D := CheckExtension('GL_SGIS_texture4D'); 
+
+  GL_SGIX_async := CheckExtension('GL_SGIX_async'); 
+  GL_SGIX_async_histogram := CheckExtension('GL_SGIX_async_histogram'); 
+  GL_SGIX_async_pixel := CheckExtension('GL_SGIX_async_pixel'); 
+  GL_SGIX_blend_alpha_minmax := CheckExtension('GL_SGIX_blend_alpha_minmax'); 
+  GL_SGIX_calligraphic_fragment := CheckExtension('GL_SGIX_calligraphic_fragment'); 
+  GL_SGIX_clipmap := CheckExtension('GL_SGIX_clipmap'); 
+  GL_SGIX_convolution_accuracy := CheckExtension('GL_SGIX_convolution_accuracy'); 
+  GL_SGIX_depth_texture := CheckExtension('GL_SGIX_depth_texture'); 
+  GL_SGIX_flush_raster := CheckExtension('GL_SGIX_flush_raster'); 
+  GL_SGIX_fog_offset := CheckExtension('GL_SGIX_fog_offset'); 
+  GL_SGIX_fog_scale := CheckExtension('GL_SGIX_fog_scale'); 
+  GL_SGIX_fragment_lighting := CheckExtension('GL_SGIX_fragment_lighting'); 
+  GL_SGIX_framezoom := CheckExtension('GL_SGIX_framezoom'); 
+  GL_SGIX_igloo_interface := CheckExtension('GL_SGIX_igloo_interface'); 
+  GL_SGIX_instruments := CheckExtension('GL_SGIX_instruments'); 
+  GL_SGIX_interlace := CheckExtension('GL_SGIX_interlace'); 
+  GL_SGIX_ir_instrument1 := CheckExtension('GL_SGIX_ir_instrument1'); 
+  GL_SGIX_list_priority := CheckExtension('GL_SGIX_list_priority'); 
+  GL_SGIX_pixel_texture := CheckExtension('GL_SGIX_pixel_texture'); 
+  GL_SGIX_pixel_tiles := CheckExtension('GL_SGIX_pixel_tiles'); 
+  GL_SGIX_polynomial_ffd := CheckExtension('GL_SGIX_polynomial_ffd'); 
+  GL_SGIX_reference_plane := CheckExtension('GL_SGIX_reference_plane'); 
+  GL_SGIX_resample := CheckExtension('GL_SGIX_resample'); 
+  GL_SGIX_shadow := CheckExtension('GL_SGIX_shadow'); 
+  GL_SGIX_shadow_ambient := CheckExtension('GL_SGIX_shadow_ambient');
+  GL_SGIX_sprite := CheckExtension('GL_SGIX_sprite'); 
+  GL_SGIX_subsample := CheckExtension('GL_SGIX_subsample'); 
+  GL_SGIX_tag_sample_buffer := CheckExtension('GL_SGIX_tag_sample_buffer'); 
+  GL_SGIX_texture_add_env := CheckExtension('GL_SGIX_texture_add_env'); 
+  GL_SGIX_texture_lod_bias := CheckExtension('GL_SGIX_texture_lod_bias'); 
+  GL_SGIX_texture_multi_buffer := CheckExtension('GL_SGIX_texture_multi_buffer'); 
+  GL_SGIX_texture_scale_bias := CheckExtension('GL_SGIX_texture_scale_bias'); 
+  GL_SGIX_vertex_preclip := CheckExtension('GL_SGIX_vertex_preclip'); 
+  GL_SGIX_ycrcb := CheckExtension('GL_SGIX_ycrcb'); 
+  GL_SGIX_ycrcba := CheckExtension('GL_SGIX_ycrcba'); 
+
+  GL_SUN_convolution_border_modes := CheckExtension('GL_SUN_convolution_border_modes'); 
+  GL_SUN_global_alpha := CheckExtension('GL_SUN_global_alpha'); 
+  GL_SUN_triangle_list := CheckExtension('GL_SUN_triangle_list'); 
+  GL_SUN_vertex := CheckExtension('GL_SUN_vertex'); 
+
+  GL_SUNX_constant_data := CheckExtension('GL_SUNX_constant_data'); 
+
+  GL_WIN_phong_shading := CheckExtension('GL_WIN_phong_shading'); 
+  GL_WIN_specular_fog := CheckExtension('GL_WIN_specular_fog'); 
+  GL_WIN_swap_hint := CheckExtension('GL_WIN_swap_hint'); 
+
+  WGL_EXT_swap_control := CheckExtension('WGL_EXT_swap_control');
+  WGL_ARB_extensions_string := CheckExtension('WGL_ARB_extensions_string');
+  WGL_ARB_pixel_format := CheckExtension('WGL_ARB_pixel_format');
+
+  // GLU
+  Buffer := gluGetString(GLU_EXTENSIONS); 
+  GLU_EXT_TEXTURE := CheckExtension('GLU_EXT_TEXTURE'); 
+  GLU_EXT_object_space_tess := CheckExtension('GLU_EXT_object_space_tess'); 
+  GLU_EXT_nurbs_tessellator := CheckExtension('GLU_EXT_nurbs_tessellator');
+
+  // ARB wgl extensions
+  if Assigned(wglGetExtensionsStringARB) then
+  begin
+    Buffer := wglGetExtensionsStringARB(wglGetCurrentDC);
+    WGL_ARB_extensions_string := CheckExtension('WGL_ARB_extensions_string');
+    WGL_ARB_pixel_format := CheckExtension('WGL_ARB_pixel_format');
+  end
+  else
+  begin
+    WGL_ARB_extensions_string := False;
+    WGL_ARB_pixel_format := False;
+  end;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function SetupPalette(DC: HDC; PFD: TPixelFormatDescriptor): HPalette;
+
+var
+  nColors,
+  I: Integer;
+  LogPalette: TMaxLogPalette;
+  RedMask,                                   
+  GreenMask,
+  BlueMask: Byte;
+   
+begin
+  nColors := 1 shl Pfd.cColorBits; 
+  LogPalette.palVersion := $300; 
+  LogPalette.palNumEntries := nColors; 
+  RedMask := (1 shl Pfd.cRedBits  ) - 1; 
+  GreenMask := (1 shl Pfd.cGreenBits) - 1; 
+  BlueMask := (1 shl Pfd.cBlueBits ) - 1;
+  with LogPalette, PFD do
+    for I := 0 to nColors - 1 do
+    begin
+      palPalEntry[I].peRed := (((I shr cRedShift  ) and RedMask  ) * 255) div RedMask; 
+      palPalEntry[I].peGreen := (((I shr cGreenShift) and GreenMask) * 255) div GreenMask; 
+      palPalEntry[I].peBlue := (((I shr cBlueShift ) and BlueMask ) * 255) div BlueMask; 
+      palPalEntry[I].peFlags := 0; 
+    end; 
+
+  Result := CreatePalette(PLogPalette(@LogPalette)^); 
+  if Result <> 0 then
+  begin
+    SelectPalette(DC, Result, False); 
+    RealizePalette(DC); 
+  end
+  else
+    RaiseLastOSError; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, StencilBits, AccumBits, AuxBuffers: Integer; 
+  Layer: Integer; var Palette: HPALETTE): HGLRC; 
+
+// Set the OpenGL properties required to draw to the given canvas and create a rendering context for it.
+
+const
+  MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC]; 
+
+var
+  PFDescriptor: TPixelFormatDescriptor; 
+  PixelFormat: Integer; 
+  AType: DWORD; 
+
+begin
+  FillChar(PFDescriptor, SizeOf(PFDescriptor), 0); 
+  with PFDescriptor do
+  begin
+    nSize := SizeOf(PFDescriptor); 
+    nVersion := 1; 
+    dwFlags := PFD_SUPPORT_OPENGL; 
+    AType := GetObjectType(DC); 
+    if AType = 0 then
+      RaiseLastOSError; 
+      
+    if AType in MemoryDCs then
+      dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
+    else
+      dwFlags := dwFlags or PFD_DRAW_TO_WINDOW; 
+    if opDoubleBuffered in Options then
+      dwFlags := dwFlags or PFD_DOUBLEBUFFER; 
+    if opGDI in Options then
+      dwFlags := dwFlags or PFD_SUPPORT_GDI; 
+    if opStereo in Options then
+      dwFlags := dwFlags or PFD_STEREO; 
+    iPixelType := PFD_TYPE_RGBA; 
+    cColorBits := ColorBits; 
+    cDepthBits := 32; 
+    cStencilBits := StencilBits; 
+    cAccumBits := AccumBits; 
+    cAuxBuffers := AuxBuffers; 
+    if Layer = 0 then
+      iLayerType := PFD_MAIN_PLANE
+    else
+      if Layer > 0 then
+        iLayerType := PFD_OVERLAY_PLANE
+      else
+        iLayerType := Byte(PFD_UNDERLAY_PLANE); 
+  end; 
+
+  // Just in case it didn't happen already.
+  if not InitOpenGL then
+    RaiseLastOSError; 
+  PixelFormat := ChoosePixelFormat(DC, {$ifndef FPC}@{$endif}PFDescriptor); 
+  if PixelFormat = 0 then
+    RaiseLastOSError; 
+
+  // NOTE: It is not allowed to change a pixel format of a device context once it has been set.
+  //       Hence you may create more than one rendering context for one single device only if it
+  //       uses the same pixel format as the first created RC.
+  if GetPixelFormat(DC) <> PixelFormat then
+  begin
+    if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then
+      RaiseLastOSError; 
+  end; 
+
+  // Check the properties we just set.
+  DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor); 
+  with PFDescriptor do
+    if (dwFlags and PFD_NEED_PALETTE) <> 0 then
+      Palette := SetupPalette(DC, PFDescriptor)
+    else
+      Palette := 0; 
+    
+  Result := wglCreateLayerContext(DC, Layer);
+  if Result = 0 then
+    RaiseLastOSError
+  else
+    LastPixelFormat := 0; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure ActivateRenderingContext(DC: HDC; RC: HGLRC); 
+
+var
+  PixelFormat: Integer; 
+
+begin
+  Assert((DC <> 0), 'DC must not be 0'); 
+  Assert((RC <> 0), 'RC must not be 0'); 
+
+  if ActivationRefCount = 0 then
+  begin
+    // Before activating the rendering context check if it is not already used by another thread.
+    with ContextList.LockList do
+    try
+      if IndexOf(Pointer(RC)) = -1 then
+      begin
+        if wglMakeCurrent(DC, RC) then
+          Add(Pointer(RC))
+        else
+          ShowError(SMakeCurrentFailed); 
+      end
+      else
+        ShowError(SRCAlreadyActive)
+    finally
+      ContextList.UnlockList; 
+    end; 
+
+    Inc(ActivationRefCount); 
+
+    // The extension function addresses are unique for each pixel format. All rendering
+    // contexts of a given pixel format share the same extension function addresses.
+    PixelFormat := GetPixelFormat(DC); 
+    if PixelFormat <> LastPixelFormat then
+    begin
+      ReadExtensions; 
+      ReadImplementationProperties; 
+      LastPixelFormat := PixelFormat;
+    end; 
+  end
+  else
+  begin
+    Assert((wglGetCurrentDC = DC) and (wglGetCurrentContext = RC), 'Incoherent DC/RC pair.'); 
+    Inc(ActivationRefCount); 
+  end; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure DeactivateRenderingContext; 
+
+begin
+  Assert(ActivationRefCount > 0, 'Unbalanced deactivation.'); 
+  if ActivationRefCount > 0 then
+  begin
+    Dec(ActivationRefCount); 
+
+    if ActivationRefCount = 0 then
+    begin
+      // If the rendering context is no longer used then remove it from the context list to indicate
+      // it can now be used in any thread.
+      with ContextList.LockList do
+      try
+        Remove(Pointer(wglGetCurrentContext));
+        if not wglMakeCurrent(0, 0) then
+          ShowError(SMakeCurrentFailed);
+      finally
+        ContextList.UnlockList;
+      end;
+    end;
+  end; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure DestroyRenderingContext(RC: HGLRC); 
+
+// Used to destroy the given rendering context. Only contexts which are no longer in use by any thread can be deleted.
+
+begin
+  Assert((ActivationRefCount = 0), 'Active contexts cannot be deleted.'); 
+  
+  with ContextList.LockList do
+  try
+    if not wglDeleteContext(RC) then
+      ShowError(SDeleteContextFailed);
+    if IndexOf(Pointer(RC)) > -1 then
+      ShowError(SContextInUse);
+  finally
+    ContextList.UnlockList;
+  end;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function CurrentDC: HDC; 
+
+// Returns the device context which is used for the current rendering context of the caller thread.
+
+begin
+  Result := wglGetCurrentDC; 
+end;
+
+{$endif}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure CloseOpenGL; 
+begin
+  if GLHandle <> INVALID_MODULEHANDLE then
+  begin
+    UnloadModule( GLHandle );
+    GLHandle := INVALID_MODULEHANDLE;
+  end;
+
+  if GLUHandle <> INVALID_MODULEHANDLE then
+  begin
+    UnloadModule( GLUHandle );
+    GLUHandle := INVALID_MODULEHANDLE;
+  end;
+
+  ClearProcAddresses;
+  ClearExtensions;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function InitOpenGL: Boolean;
+
+begin
+  if (GLHandle = INVALID_MODULEHANDLE) or (GLUHandle = INVALID_MODULEHANDLE) then
+    Result := InitOpenGLFromLibrary(PChar( SDefaultGLLibrary ), PChar( SDefaultGLULibrary ) )
+  else
+    Result := True;
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function InitOpenGLFromLibrary(GLName, GLUName: PChar): Boolean;
+
+begin
+  Result := False; 
+  CloseOpenGL;
+
+  LoadModule( GLHandle, GLName );
+  LoadModule( GLUHandle, GLUName );
+
+  if (GLHandle <> INVALID_MODULEHANDLE) and (GLUHandle <> INVALID_MODULEHANDLE) then
+  begin
+    LoadProcAddresses;
+    Result := True; 
+  end
+  else
+  begin
+    if GLHandle <>  INVALID_MODULEHANDLE then
+      UnloadModule( GLHandle );
+
+    if GLUHandle <>  INVALID_MODULEHANDLE then
+      UnloadModule( GLUHandle );
+  end; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function IsOpenGLInitialized: Boolean;
+
+begin
+  Result := GLHandle <> INVALID_MODULEHANDLE; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+procedure UnloadOpenGL;
+
+// compatibility routine
+
+begin
+  CloseOpenGL; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function LoadOpenGL: Boolean;
+
+// compatibility routine
+
+begin
+  Result := InitOpenGL; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function LoadOpenGLFromLibrary(GLName, GLUName: PChar): Boolean; 
+
+// compatibility routine
+
+begin
+  Result := InitOpenGLFromLibrary(GLName, GLUName);
+end;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+function IsOpenGLLoaded: Boolean;
+
+// compatibility routine
+
+begin
+  Result := GLHandle <> INVALID_MODULEHANDLE; 
+end; 
+
+//----------------------------------------------------------------------------------------------------------------------
+{$ifdef FPC}
+const Default8087CW: Word = $1332;
+
+{$ASMMODE INTEL}
+procedure Set8087CW(NewCW: Word); Assembler;
+asm
+  MOV Default8087CW, AX
+end;
+{$endif}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+initialization
+  ContextList := TThreadList.Create; 
+  Set8087CW($133F); 
+finalization
+  CloseOpenGL; 
+  ContextList.Free; 
+  // We don't need to reset the FPU control word as the previous set call is process specific.
+end.
diff --git a/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/opengl12.rst b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/opengl12.rst
new file mode 100644
index 00000000..857993e7
--- /dev/null
+++ b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/opengl12.rst
@@ -0,0 +1,26 @@
+
+# hash value = 79191886
+opengl12.srcalreadyactive='Rendering context already active in another th'+
+'read.'
+
+
+# hash value = 191308692
+opengl12.smakecurrentfailed='wglMakeCurrent failed'
+
+
+# hash value = 214729876
+opengl12.sdeletecontextfailed='wglDeleteContext failed'
+
+
+# hash value = 230190814
+opengl12.scontextinuse='Cannot delete rendering context. It is still in u'+
+'se by another thread.'
+
+
+# hash value = 168003996
+opengl12.sdefaultgllibrary='OpenGL32.dll'
+
+
+# hash value = 140838716
+opengl12.sdefaultglulibrary='GLU32.dll'
+