updated to latest version of JEDI SDL

    JEDI-SDL v1.0 Final RC ( 2008-01-29 05:46 )

git-svn-id: svn://svn.code.sf.net/p/ultrastardx/svn/trunk@811 b956fd51-792f-4845-bead-9b4dfca2ff2c

17 files changed, 4253 insertions, 2490 deletions

diff --git a/Game/Code/lib/JEDI-SDL/JEDI-SDL-README.txt b/Game/Code/lib/JEDI-SDL/JEDI-SDL-README.txt
index 968c5311..a068e943 100644
--- a/Game/Code/lib/JEDI-SDL/JEDI-SDL-README.txt
+++ b/Game/Code/lib/JEDI-SDL/JEDI-SDL-README.txt
@@ -19,11 +19,13 @@ Both documents can be found in the "documentation" directory.
 Release History

 ---------------

 1.0  :   Yeah!! The Official v1.0 Release of JEDI-SDL!!

-           JEDI-SDL now updated to SDL v1.2.8, SDL_Image v1.2.4, SDL_Mixer v1.2.6, SDL_Net v1.2.1 & SDL_ttf v2.0.7

+           JEDI-SDL now updated to SDL v1.2.11, SDL_Image v1.2.5, SDL_Mixer v1.2.7, SDL_Net v1.2.6 & SDL_ttf v2.0.8

            Added Improved FreePascal, TMT Pascal and GnuPascal support as well as maintaining Delphi/Kylix support.

            Fixed Various bugs as pointed out on the JEDI-SDL mailing list.

            Added SDL_GL_STEREO, SDL_GL_MULTISAMPLEBUFFERS, SDL_GL_MULTISAMPLESAMPLES

 

+Now works on MacOS X and a MacOS X disk image is available for download.

+

 // DLL/Shared object functions

 function SDL_LoadObject( const sofile : PChar ) : Pointer;

 

diff --git a/Game/Code/lib/JEDI-SDL/OpenGL/Pas/gl.pas b/Game/Code/lib/JEDI-SDL/OpenGL/Pas/gl.pas
index aa0dd169..d2bdcf8b 100644
--- a/Game/Code/lib/JEDI-SDL/OpenGL/Pas/gl.pas
+++ b/Game/Code/lib/JEDI-SDL/OpenGL/Pas/gl.pas
@@ -1,6 +1,6 @@
 unit gl;

 {

-  $Id: gl.pas,v 1.2 2004/08/14 22:54:30 savage Exp $

+  $Id: gl.pas,v 1.5 2007/05/20 20:28:31 savage Exp $

 

   Adaption of the delphi3d.net OpenGL units to FreePascal

   Sebastian Guenther (sg@freepascal.org) in 2002

@@ -52,6 +52,15 @@ Abstract:
 

 {

   $Log: gl.pas,v $

+  Revision 1.5  2007/05/20 20:28:31  savage

+  Initial Changes to Handle 64 Bits

+

+  Revision 1.4  2006/11/20 21:20:59  savage

+  Updated to work in MacOS X

+

+  Revision 1.3  2005/05/22 18:52:09  savage

+  Changes as suggested by Michalis Kamburelis. Thanks again.

+

   Revision 1.2  2004/08/14 22:54:30  savage

   Updated so that Library name defines are correctly defined for MacOS X.

 

@@ -85,7 +94,7 @@ uses
   gpc,

 {$ENDIF}

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   Windows,

 {$ENDIF}

   moduleloader;

@@ -114,13 +123,13 @@ type
 {******************************************************************************}

 

 const

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   GLLibName = 'OpenGL32.dll';

 {$ENDIF}

 

 {$IFDEF UNIX}

 {$IFDEF DARWIN}

-  GLLibName = 'libGL.dylib';

+  GLLibName = '/System/Library/Frameworks/OpenGL.framework/Libraries/libGL.dylib';

 {$ELSE}

   GLLibName = 'libGL.so';

 {$ENDIF}

@@ -1201,377 +1210,377 @@ const
 {******************************************************************************}

 

 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}

+  glAccum: procedure(op: GLenum; value: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glAlphaFunc: procedure(func: GLenum; ref: GLclampf); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glAreTexturesResident: function (n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glArrayElement: procedure(i: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBegin: procedure(mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindTexture: procedure(target: GLenum; texture: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBitmap: procedure (width, height: GLsizei; xorig, yorig: GLfloat; xmove, ymove: GLfloat; const bitmap: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBlendFunc: procedure(sfactor, dfactor: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCallList: procedure(list: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCallLists: procedure(n: GLsizei; atype: GLenum; const lists: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glClear: procedure(mask: GLbitfield); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glClearAccum: procedure(red, green, blue, alpha: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glClearColor: procedure(red, green, blue, alpha: GLclampf); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glClearDepth: procedure(depth: GLclampd); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glClearIndex: procedure(c: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glClearStencil: procedure(s: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glClipPlane: procedure(plane: GLenum; const equation: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3b: procedure(red, green, blue: GLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3bv: procedure(const v: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3d: procedure(red, green, blue: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3f: procedure(red, green, blue: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3i: procedure(red, green, blue: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3s: procedure(red, green, blue: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3ub: procedure(red, green, blue: GLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3ubv: procedure(const v: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3ui: procedure(red, green, blue: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3uiv: procedure(const v: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3us: procedure(red, green, blue: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3usv: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4b: procedure(red, green, blue, alpha: GLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4bv: procedure(const v: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4d: procedure(red, green, blue, alpha: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4f: procedure(red, green, blue, alpha: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4i: procedure(red, green, blue, alpha: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4s: procedure(red, green, blue, alpha: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4ub: procedure(red, green, blue, alpha: GLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4ubv: procedure(const v: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4ui: procedure(red, green, blue, alpha: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4uiv: procedure(const v: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4us: procedure(red, green, blue, alpha: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4usv: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColorMask: procedure(red, green, blue, alpha: GLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColorMaterial: procedure(face, mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColorPointer: procedure(size: GLint; atype: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyPixels: procedure(x, y: GLint; width, height: GLsizei; atype: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyTexImage1D: procedure (target: GLenum; level: GLint; internalFormat: GLenum; x, y: GLint; width: GLsizei; border: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyTexImage2D: procedure(target: GLenum; level: GLint; internalFormat: GLenum; x, y: GLint; width, height: GLsizei; border: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyTexSubImage1D: procedure(target: GLenum; level, xoffset, x, y: GLint; width: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset, x, y: GLint; width, height: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCullFace: procedure(mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteLists: procedure(list: GLuint; range: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteTextures: procedure(n: GLsizei; const textures: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDepthFunc: procedure(func: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDepthMask: procedure(flag: GLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDepthRange: procedure(zNear, zFar: GLclampd); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDisable: procedure(cap: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDisableClientState: procedure(aarray: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawArrays: procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawBuffer: procedure(mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawElements: procedure(mode: GLenum; count: GLsizei; atype: GLenum; const indices: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawPixels: procedure(width, height: GLsizei; format, atype: GLenum; const pixels: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEdgeFlag: procedure(flag: GLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEdgeFlagPointer: procedure(stride: GLsizei; const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEdgeFlagv: procedure(const flag: PGLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEnable: procedure(cap: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEnableClientState: procedure(aarray: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEnd: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEndList: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalCoord1d: procedure(u: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalCoord1dv: procedure(const u: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalCoord1f: procedure(u: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalCoord1fv: procedure(const u: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalCoord2d: procedure(u, v: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalCoord2dv: procedure(const u: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalCoord2f: procedure(u, v: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalCoord2fv: procedure(const u: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalMesh1: procedure(mode: GLenum; i1, i2: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalMesh2: procedure(mode: GLenum; i1, i2, j1, j2: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalPoint1: procedure(i: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalPoint2: procedure(i, j: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFeedbackBuffer: procedure(size: GLsizei; atype: GLenum; buffer: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFinish: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFlush: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogf: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogfv: procedure(pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogi: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogiv: procedure(pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFrontFace: procedure(mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFrustum: procedure(left, right, bottom, top, zNear, zFar: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenLists: function(range: GLsizei): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenTextures: procedure(n: GLsizei; textures: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetBooleanv: procedure(pname: GLenum; params: PGLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetClipPlane: procedure(plane: GLenum; equation: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetDoublev: procedure(pname: GLenum; params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetError: function: GLenum; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetFloatv: procedure(pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetIntegerv: procedure(pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetLightfv: procedure(light, pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetLightiv: procedure(light, pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMapdv: procedure(target, query: GLenum; v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMapfv: procedure(target, query: GLenum; v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMapiv: procedure(target, query: GLenum; v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMaterialfv: procedure(face, pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMaterialiv: procedure(face, pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetPixelMapfv: procedure(map: GLenum; values: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetPixelMapuiv: procedure(map: GLenum; values: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetPixelMapusv: procedure(map: GLenum; values: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetPointerv: procedure(pname: GLenum; params: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetPolygonStipple: procedure(mask: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetString: function(name: GLenum): PChar; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexEnvfv: procedure(target, pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexEnviv: procedure(target, pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexGendv: procedure(coord, pname: GLenum; params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexGenfv: procedure(coord, pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexGeniv: procedure(coord, pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexImage: procedure(target: GLenum; level: GLint; format: GLenum; atype: GLenum; pixels: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexLevelParameterfv: procedure(target: GLenum; level: GLint; pname: GLenum; params: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexLevelParameteriv: procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexParameterfv: procedure(target, pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexParameteriv: procedure(target, pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glHint: procedure(target, mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexMask: procedure(mask: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexPointer: procedure(atype: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexd: procedure(c: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexdv: procedure(const c: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexf: procedure(c: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexfv: procedure(const c: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexi: procedure(c: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexiv: procedure(const c: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexs: procedure(c: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexsv: procedure(const c: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexub: procedure(c: GLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexubv: procedure(const c: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glInitNames: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glInterleavedArrays: procedure(format: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsEnabled: function(cap: GLenum): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsList: function(list: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsTexture: function(texture: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLightModelf: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLightModelfv: procedure(pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLightModeli: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLightModeliv: procedure(pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLightf: procedure(light, pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLightfv: procedure(light, pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLighti: procedure(light, pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLightiv: procedure(light, pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLineStipple: procedure(factor: GLint; pattern: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLineWidth: procedure(width: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glListBase: procedure(base: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLoadIdentity: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLoadMatrixd: procedure(const m: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLoadMatrixf: procedure(const m: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLoadName: procedure(name: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLogicOp: procedure(opcode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMap1d: procedure(target: GLenum; u1, u2: GLdouble; stride, order: GLint; const points: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMap1f: procedure(target: GLenum; u1, u2: GLfloat; stride, order: GLint; const points: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMap2d: procedure(target: GLenum; u1, u2: GLdouble; ustride, uorder: GLint; v1, v2: GLdouble; vstride, vorder: GLint; const points: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMap2f: procedure(target: GLenum; u1, u2: GLfloat; ustride, uorder: GLint; v1, v2: GLfloat; vstride, vorder: GLint; const points: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMapGrid1d: procedure(un: GLint; u1, u2: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMapGrid1f: procedure(un: GLint; u1, u2: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMapGrid2d: procedure(un: GLint; u1, u2: GLdouble; vn: GLint; v1, v2: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMapGrid2f: procedure(un: GLint; u1, u2: GLfloat; vn: GLint; v1, v2: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMaterialf: procedure(face, pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMaterialfv: procedure(face, pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMateriali: procedure(face, pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMaterialiv: procedure(face, pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMatrixMode: procedure(mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultMatrixd: procedure(const m: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultMatrixf: procedure(const m: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNewList: procedure(list: GLuint; mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3b: procedure(nx, ny, nz: GLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3bv: procedure(const v: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3d: procedure(nx, ny, nz: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3f: procedure(nx, ny, nz: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3i: procedure(nx, ny, nz: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3s: procedure(nx, ny, nz: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalPointer: procedure(atype: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glOrtho: procedure(left, right, bottom, top, zNear, zFar: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPassThrough: procedure(token: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPixelMapfv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPixelMapuiv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPixelMapusv: procedure(map: GLenum; mapsize: GLsizei; const values: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPixelStoref: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPixelStorei: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPixelTransferf: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPixelTransferi: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPixelZoom: procedure(xfactor, yfactor: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPointSize: procedure(size: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPolygonMode: procedure(face, mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPolygonOffset: procedure(factor, units: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPolygonStipple: procedure(const mask: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPopAttrib: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPopClientAttrib: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPopMatrix: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPopName: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPrioritizeTextures: procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPushAttrib: procedure(mask: GLbitfield); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPushClientAttrib: procedure(mask: GLbitfield); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPushMatrix: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPushName: procedure(name: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos2d: procedure(x, y: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos2dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos2f: procedure(x, y: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos2fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos2i: procedure(x, y: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos2iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos2s: procedure(x, y: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos2sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos3d: procedure(x, y, z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos3dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos3f: procedure(x, y, z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos3fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos3i: procedure(x, y, z: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos3iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos3s: procedure(x, y, z: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos3sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos4d: procedure(x, y, z, w: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos4dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos4f: procedure(x, y, z, w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos4fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos4i: procedure(x, y, z, w: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos4iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos4s: procedure(x, y, z, w: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRasterPos4sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReadBuffer: procedure(mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReadPixels: procedure(x, y: GLint; width, height: GLsizei; format, atype: GLenum; pixels: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRectd: procedure(x1, y1, x2, y2: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRectdv: procedure(const v1: PGLdouble; const v2: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRectf: procedure(x1, y1, x2, y2: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRectfv: procedure(const v1: PGLfloat; const v2: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRecti: procedure(x1, y1, x2, y2: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRectiv: procedure(const v1: PGLint; const v2: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRects: procedure(x1, y1, x2, y2: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRectsv: procedure(const v1: PGLshort; const v2: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRenderMode: function(mode: GLint): GLint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRotated: procedure(angle, x, y, z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRotatef: procedure(angle, x, y, z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glScaled: procedure(x, y, z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glScalef: procedure(x, y, z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glScissor: procedure(x, y: GLint; width, height: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSelectBuffer: procedure(size: GLsizei; buffer: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glShadeModel: procedure(mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glStencilFunc: procedure(func: GLenum; ref: GLint; mask: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glStencilMask: procedure(mask: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glStencilOp: procedure(fail, zfail, zpass: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord1d: procedure(s: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord1dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord1f: procedure(s: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord1fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord1i: procedure(s: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord1iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord1s: procedure(s: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord1sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2d: procedure(s, t: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2f: procedure(s, t: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2i: procedure(s, t: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2s: procedure(s, t: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord3d: procedure(s, t, r: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord3dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord3f: procedure(s, t, r: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord3fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord3i: procedure(s, t, r: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord3iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord3s: procedure(s, t, r: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord3sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4d: procedure(s, t, r, q: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4f: procedure(s, t, r, q: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4i: procedure(s, t, r, q: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4s: procedure(s, t, r, q: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoordPointer: procedure(size: GLint; atype: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexEnvf: procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexEnvfv: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexEnvi: procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexEnviv: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexGend: procedure(coord: GLenum; pname: GLenum; param: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexGendv: procedure(coord: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexGenf: procedure(coord: GLenum; pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexGenfv: procedure(coord: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexGeni: procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexGeniv: procedure(coord: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexImage1D: procedure(target: GLenum; level, internalformat: GLint; width: GLsizei; border: GLint; format, atype: GLenum; const pixels: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexImage2D: procedure(target: GLenum; level, internalformat: GLint; width, height: GLsizei; border: GLint; format, atype: GLenum; const pixels: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexParameterf: procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexParameterfv: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexParameteri: procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexParameteriv: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexSubImage1D: procedure(target: GLenum; level, xoffset: GLint; width: GLsizei; format, atype: GLenum; const pixels: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset: GLint; width, height: GLsizei; format, atype: GLenum; const pixels: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTranslated: procedure(x, y, z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTranslatef: procedure(x, y, z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex2d: procedure(x, y: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex2dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex2f: procedure(x, y: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex2fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex2i: procedure(x, y: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex2iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex2s: procedure(x, y: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex2sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex3d: procedure(x, y, z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex3dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex3f: procedure(x, y, z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex3fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex3i: procedure(x, y, z: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex3iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex3s: procedure(x, y, z: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex3sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex4d: procedure(x, y, z, w: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex4dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex4f: procedure(x, y, z, w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex4fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex4i: procedure(x, y, z, w: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex4iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex4s: procedure(x, y, z, w: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex4sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexPointer: procedure(size: GLint; atype: GLenum; stride: GLsizei; const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glViewport: procedure(x, y: GLint; width, height: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  {$IFDEF WINDOWS}

+  ChoosePixelFormat: function(DC: HDC; p2: PPixelFormatDescriptor): Integer; {$IFDEF WINDOWS}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}

+  PFNGLARRAYELEMENTEXTPROC = procedure(i: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  PFNGLDRAWARRAYSEXTPROC = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

   PFNGLVERTEXPOINTEREXTPROC = procedure(size: GLint; atype: GLenum;

-                                        stride, count: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+                                        stride, count: GLsizei; const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

   PFNGLNORMALPOINTEREXTPROC = procedure(atype: GLenum; stride, count: GLsizei;

-                                        const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+                                        const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

   PFNGLCOLORPOINTEREXTPROC = procedure(size: GLint; atype: GLenum; stride, count: GLsizei;

-                                       const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+                                       const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

   PFNGLINDEXPOINTEREXTPROC = procedure(atype: GLenum; stride, count: GLsizei;

-                                       const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+                                       const pointer: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

   PFNGLTEXCOORDPOINTEREXTPROC = procedure(size: GLint; atype: GLenum;

-                                          stride, count: GLsizei; const pointer: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+                                          stride, count: GLsizei; const pointer: Pointer); {$IFDEF WINDOWS}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}

+                                          const pointer: PGLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  PFNGLGETPOINTERVEXTPROC = procedure(pname: GLenum; params: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

   PFNGLARRAYELEMENTARRAYEXTPROC = procedure(mode: GLenum; count: GLsizei;

-                                            const pi: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+                                            const pi: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

   // WIN_swap_hint

-  PFNGLADDSWAPHINTRECTWINPROC = procedure(x, y: GLint; width, height: GLsizei); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  PFNGLADDSWAPHINTRECTWINPROC = procedure(x, y: GLint; width, height: GLsizei); {$IFDEF WINDOWS}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}

+                                     format, atype: GLenum; const data: Pointer); {$IFDEF WINDOWS}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}

+                                        format, atype: GLenum; const data: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  PFNGLGETCOLORTABLEEXTPROC = procedure(target, format, atype: GLenum; data: Pointer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  PFNGLGETCOLORTABLEPARAMETERIVEXTPROC = procedure(target, pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  PFNGLGETCOLORTABLEPARAMETERFVEXTPROC = procedure(target, pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 procedure LoadOpenGL( const dll: PChar );

 procedure FreeOpenGL;

@@ -1917,7 +1926,7 @@ begin
   @glVertex4sv := nil;

   @glVertexPointer := nil;

   @glViewport := nil;

-  {$IFDEF Win32}

+  {$IFDEF WINDOWS}

   @ChoosePixelFormat := nil;

   {$ENDIF}

 

@@ -2269,7 +2278,7 @@ begin
     @glVertexPointer := GetModuleSymbol(LibGL, 'glVertexPointer');

     @glViewport := GetModuleSymbol(LibGL, 'glViewport');

 

-    {$IFDEF WIN32}

+    {$IFDEF WINDOWS}

     @ChoosePixelFormat := GetModuleSymbol(LibGL, 'ChoosePixelFormat');

     if not Assigned(ChoosePixelFormat) then

       {$IFNDEF FPC}@{$ENDIF}ChoosePixelFormat := @Windows.ChoosePixelFormat;

@@ -2278,11 +2287,9 @@ begin
 end;

 

 initialization

-  {$IFNDEF FPC}

-  {$IFNDEF __GPC__}

+  {$ifdef x86}

   Set8087CW($133F);

-  {$ENDIF}

-  {$ENDIF}

+  {$endif x86}

 

   LoadOpenGL( GLLibName );

 

diff --git a/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glext.pas b/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glext.pas
index 19ed2023..835c1703 100644
--- a/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glext.pas
+++ b/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glext.pas
@@ -1,6 +1,6 @@
 unit glext;

 {

-  $Id: glext.pas,v 1.3 2004/08/24 19:33:06 savage Exp $

+  $Id: glext.pas,v 1.6 2007/05/20 20:28:31 savage Exp $

   

 }

 (**************************************************

@@ -11,6 +11,15 @@ unit glext;
 

 {

   $Log: glext.pas,v $

+  Revision 1.6  2007/05/20 20:28:31  savage

+  Initial Changes to Handle 64 Bits

+

+  Revision 1.5  2006/01/11 22:39:02  drellis

+  Updated to Support Up to OpenGL 2.0

+

+  Revision 1.4  2005/01/05 00:28:40  savage

+  Forgot to wrap a couple of Load_WGL function calls with an IFDEF WIN32. Fixed so now compiles under Linux as well.

+

   Revision 1.3  2004/08/24 19:33:06  savage

   Removed declarations of SDL_GL_GetProcAddress as the correct ones are in sdl.pas.

 

@@ -54,7 +63,7 @@ uses
   gpc,

 {$ENDIF}

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   Windows,

 {$ENDIF}

   moduleloader,

@@ -63,9 +72,8 @@ uses
 // 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;

-

+// Load a Specific Extension

+function glext_LoadExtension(ext: String): Boolean;

 // Some types that were introduced by extensions:

 type

   GLintptrARB = Integer;

@@ -80,6 +88,15 @@ type
   GLhandleARB = Cardinal;

   PGLhandleARB = ^GLhandleARB;

 

+  GLintptr = Integer;

+  PGLintptr = ^GLintptr;

+

+  GLsizeiptr = Integer;

+  PGLsizeiptr = ^GLsizeiptr;

+

+  GLchar = Char;

+  PGLchar = ^GLchar;

+

 //***** GL_version_1_2 *****//

 const

   GL_UNSIGNED_BYTE_3_3_2 = $8032;

@@ -123,10 +140,10 @@ const
   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}

+  glDrawRangeElements: procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF WINDOWS}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 WINDOWS}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 WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_version_1_2: Boolean;

 

@@ -210,40 +227,40 @@ const
   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}

+  glColorTable: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColorTableParameterfv: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColorTableParameteriv: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyColorTable: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetColorTable: procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetColorTableParameterfv: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetColorTableParameteriv: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColorSubTable: procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyColorSubTable: procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionFilter1D: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionFilter2D: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionParameterf: procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionParameterfv: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionParameteri: procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionParameteriv: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyConvolutionFilter1D: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyConvolutionFilter2D: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetConvolutionFilter: procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetConvolutionParameterfv: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetConvolutionParameteriv: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetSeparableFilter: procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetHistogram: procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetHistogramParameterfv: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetHistogramParameteriv: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMinmax: procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMinmaxParameterfv: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMinmaxParameteriv: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glHistogram: procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMinmax: procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glResetHistogram: procedure(target: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glResetMinmax: procedure(target: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBlendEquation: procedure(mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBlendColor: procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_imaging: Boolean;

 

@@ -347,52 +364,52 @@ const
   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}

+  glActiveTexture: procedure(texture: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glClientActiveTexture: procedure(texture: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1d: procedure(target: GLenum; s: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1dv: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1f: procedure(target: GLenum; s: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1fv: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1i: procedure(target: GLenum; s: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1iv: procedure(target: GLenum; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1s: procedure(target: GLenum; s: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1sv: procedure(target: GLenum; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2d: procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2dv: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2f: procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2fv: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2i: procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2iv: procedure(target: GLenum; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2s: procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2sv: procedure(target: GLenum; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3d: procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3dv: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3f: procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3fv: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3i: procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3iv: procedure(target: GLenum; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3s: procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3sv: procedure(target: GLenum; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4d: procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4dv: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4f: procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4fv: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4i: procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4iv: procedure(target: GLenum; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4s: procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4sv: procedure(target: GLenum; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLoadTransposeMatrixf: procedure(const m: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLoadTransposeMatrixd: procedure(const m: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultTransposeMatrixf: procedure(const m: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultTransposeMatrixd: procedure(const m: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSampleCoverage: procedure(value: GLclampf; invert: GLboolean); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCompressedTexImage2D: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCompressedTexImage1D: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WINDOWS}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 WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCompressedTexSubImage1D: procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetCompressedTexImage: procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_version_1_3: Boolean;

 

@@ -434,40 +451,40 @@ const
   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}

+  glActiveTextureARB: procedure(texture: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glClientActiveTextureARB: procedure(texture: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1dARB: procedure(target: GLenum; s: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1dvARB: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1fARB: procedure(target: GLenum; s: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1fvARB: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1iARB: procedure(target: GLenum; s: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1ivARB: procedure(target: GLenum; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1sARB: procedure(target: GLenum; s: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1svARB: procedure(target: GLenum; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2dARB: procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2dvARB: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2fARB: procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2fvARB: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2iARB: procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2ivARB: procedure(target: GLenum; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2sARB: procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2svARB: procedure(target: GLenum; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3dARB: procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3dvARB: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3fARB: procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3fvARB: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3iARB: procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3ivARB: procedure(target: GLenum; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3sARB: procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3svARB: procedure(target: GLenum; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4dARB: procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4dvARB: procedure(target: GLenum; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4fARB: procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4fvARB: procedure(target: GLenum; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4iARB: procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4ivARB: procedure(target: GLenum; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4sARB: procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4svARB: procedure(target: GLenum; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_multitexture: Boolean;

 

@@ -478,10 +495,10 @@ const
   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}

+  glLoadTransposeMatrixfARB: procedure(m: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLoadTransposeMatrixdARB: procedure(m: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultTransposeMatrixfARB: procedure(m: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultTransposeMatrixdARB: procedure(m: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_transpose_matrix: Boolean;

 

@@ -499,7 +516,7 @@ const
   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}

+  glSampleCoverageARB: procedure(value: GLclampf; invert: GLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_multisample: Boolean;

 

@@ -507,10 +524,10 @@ function Load_GL_ARB_multisample: Boolean;
 

 function Load_GL_ARB_texture_env_add: Boolean;

 

-{$IFDEF Win32}

+{$IFDEF WINDOWS}

 //***** WGL_ARB_extensions_string *****//

 var

-  wglGetExtensionsStringARB: function(hdc: HDC): Pchar; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetExtensionsStringARB: function(hdc: HDC): Pchar; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_ARB_extensions_string: Boolean;

 

@@ -521,10 +538,10 @@ const
   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}

+  wglCreateBufferRegionARB: function(hDC: HDC; iLayerPlane: GLint; uType: GLuint): THandle; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglDeleteBufferRegionARB: procedure(hRegion: THandle); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglSaveBufferRegionARB: function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglRestoreBufferRegionARB: function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint; xSrc: GLint; ySrc: GLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_ARB_buffer_region: Boolean;

 {$ENDIF}

@@ -563,8 +580,8 @@ const
   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}

+  glPointParameterfARB: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPointParameterfvARB: procedure(pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_point_parameters: Boolean;

 

@@ -602,13 +619,13 @@ const
   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}

+  glCompressedTexImage3DARB: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCompressedTexImage2DARB: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCompressedTexImage1DARB: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WINDOWS}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 WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCompressedTexSubImage1DARB: procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetCompressedTexImageARB: procedure(target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_texture_compression: Boolean;

 

@@ -701,17 +718,17 @@ const
   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}

+  glWeightbvARB: procedure(size: GLint; weights: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWeightsvARB: procedure(size: GLint; weights: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWeightivARB: procedure(size: GLint; weights: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWeightfvARB: procedure(size: GLint; weights: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWeightdvARB: procedure(size: GLint; weights: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWeightvARB: procedure(size: GLint; weights: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWeightubvARB: procedure(size: GLint; weights: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWeightusvARB: procedure(size: GLint; weights: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWeightuivARB: procedure(size: GLint; weights: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWeightPointerARB: procedure(size: GLint; _type: GLenum; stride: GLsizei; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexBlendARB: procedure(count: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_vertex_blend: Boolean;

 

@@ -797,89 +814,89 @@ const
   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}

+  glVertexAttrib1sARB: procedure(index: GLuint; x: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1fARB: procedure(index: GLuint; x: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1dARB: procedure(index: GLuint; x: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2sARB: procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2fARB: procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2dARB: procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3sARB: procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3fARB: procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3dARB: procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4sARB: procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4fARB: procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4dARB: procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4NubARB: procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1svARB: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1fvARB: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1dvARB: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2svARB: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2fvARB: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2dvARB: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3svARB: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3fvARB: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3dvARB: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4bvARB: procedure(index: GLuint; const v: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4svARB: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4ivARB: procedure(index: GLuint; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4ubvARB: procedure(index: GLuint; const v: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4usvARB: procedure(index: GLuint; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4uivARB: procedure(index: GLuint; const v: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4fvARB: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4dvARB: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4NbvARB: procedure(index: GLuint; const v: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4NsvARB: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4NivARB: procedure(index: GLuint; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4NubvARB: procedure(index: GLuint; const v: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4NusvARB: procedure(index: GLuint; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4NuivARB: procedure(index: GLuint; const v: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribPointerARB: procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEnableVertexAttribArrayARB: procedure(index: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDisableVertexAttribArrayARB: procedure(index: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramStringARB: procedure(target: GLenum; format: GLenum; len: GLsizei; const _string: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindProgramARB: procedure(target: GLenum; _program: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteProgramsARB: procedure(n: GLsizei; const programs: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenProgramsARB: procedure(n: GLsizei; programs: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramEnvParameter4dARB: procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramEnvParameter4dvARB: procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramEnvParameter4fARB: procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramEnvParameter4fvARB: procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramLocalParameter4dARB: procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramLocalParameter4dvARB: procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramLocalParameter4fARB: procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramLocalParameter4fvARB: procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramEnvParameterdvARB: procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramEnvParameterfvARB: procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramLocalParameterdvARB: procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramLocalParameterfvARB: procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramivARB: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramStringARB: procedure(target: GLenum; pname: GLenum; _string: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribdvARB: procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribfvARB: procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribivARB: procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribPointervARB: procedure(index: GLuint; pname: GLenum; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsProgramARB: function(_program: GLuint): GLboolean; {$IFDEF WINDOWS}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}

+  glWindowPos2dARB: procedure(x: GLdouble; y: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2fARB: procedure(x: GLfloat; y: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2iARB: procedure(x: GLint; y: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2sARB: procedure(x: GLshort; y: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2dvARB: procedure(const p: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2fvARB: procedure(const p: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2ivARB: procedure(const p: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2svARB: procedure(const p: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3dARB: procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3fARB: procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3iARB: procedure(x: GLint; y: GLint; z: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3sARB: procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3dvARB: procedure(const p: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3fvARB: procedure(const p: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3ivARB: procedure(const p: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3svARB: procedure(const p: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_window_pos: Boolean;

 

@@ -913,7 +930,7 @@ const
   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}

+  glBlendColorEXT: procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_blend_color: Boolean;

 

@@ -924,7 +941,7 @@ const
   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}

+  glBlendFuncSeparateEXT: procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_blend_func_separate: Boolean;

 

@@ -939,7 +956,7 @@ const
   GL_MAX_EXT = $8008;

   GL_BLEND_EQUATION_EXT = $8009;

 var

-  glBlendEquationEXT: procedure(mode: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBlendEquationEXT: procedure(mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_blend_minmax: Boolean;

 

@@ -958,8 +975,8 @@ 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}

+  glColorSubTableEXT: procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyColorSubTableEXT: procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_color_subtable: Boolean;

 

@@ -968,8 +985,8 @@ 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}

+  glLockArraysEXT: procedure(first: GLint; count: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUnlockArraysEXT: procedure(); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_compiled_vertex_array: Boolean;

 

@@ -996,19 +1013,19 @@ const
   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}

+  glConvolutionFilter1DEXT: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionFilter2DEXT: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyConvolutionFilter1DEXT: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyConvolutionFilter2DEXT: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetConvolutionFilterEXT: procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetSeparableFilterEXT: procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionParameteriEXT: procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionParameterivEXT: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionParameterfEXT: procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glConvolutionParameterfvEXT: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetConvolutionParameterivEXT: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetConvolutionParameterfvEXT: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_convolution: Boolean;

 

@@ -1028,23 +1045,23 @@ const
   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}

+  glHistogramEXT: procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glResetHistogramEXT: procedure(target: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetHistogramEXT: procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetHistogramParameterivEXT: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetHistogramParameterfvEXT: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMinmaxEXT: procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glResetMinmaxEXT: procedure(target: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMinmaxEXT: procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMinmaxParameterivEXT: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMinmaxParameterfvEXT: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}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}

+  glMultiDrawArraysEXT: procedure(mode: GLenum; first: PGLint; count: PGLsizei; primcount: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiDrawElementsEXT: procedure(mode: GLenum; count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_multi_draw_arrays: Boolean;

 

@@ -1088,11 +1105,11 @@ const
   // 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}

+  glColorTableEXT: procedure(target: GLenum; internalFormat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF WINDOWS}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}

+  glGetColorTableEXT: procedure(target: GLenum; format: GLenum; _type: GLenum; data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetColorTableParameterivEXT: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetColorTableParameterfvEXT: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_paletted_texture: Boolean;

 

@@ -1103,8 +1120,8 @@ const
   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}

+  glPointParameterfEXT: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPointParameterfvEXT: procedure(pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_point_parameters: Boolean;

 

@@ -1114,7 +1131,7 @@ const
   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}

+  glPolygonOffsetEXT: procedure(factor: GLfloat; bias: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_polygon_offset: Boolean;

 

@@ -1141,7 +1158,7 @@ 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}

+  glActiveStencilFaceEXT: procedure(face: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_stencil_two_side: Boolean;

 

@@ -1154,9 +1171,9 @@ 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}

+  glTexSubImage1DEXT: procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF WINDOWS}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 WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_subtexture: Boolean;

 

@@ -1172,7 +1189,7 @@ const
   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}

+  glTexImage3DEXT: procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_texture3D: Boolean;

 

@@ -1245,12 +1262,12 @@ const
   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}

+  glGenTexturesEXT: procedure(n: GLsizei; textures: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteTexturesEXT: procedure(n: GLsizei; const textures: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindTextureEXT: procedure(target: GLenum; texture: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPrioritizeTexturesEXT: procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glAreTexturesResidentEXT: function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsTextureEXT: function(texture: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_texture_object: Boolean;

 

@@ -1290,15 +1307,15 @@ const
   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}

+  glArrayElementEXT: procedure(i: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawArraysEXT: procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexPointerEXT: procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalPointerEXT: procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColorPointerEXT: procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIndexPointerEXT: procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoordPointerEXT: procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEdgeFlagPointerEXT: procedure(stride: GLsizei; count: GLsizei; const pointer: PGLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetPointervEXT: procedure(pname: GLenum; params: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_vertex_array: Boolean;

 

@@ -1415,48 +1432,48 @@ const
   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}

+  glBeginVertexShaderEXT: procedure(); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEndVertexShaderEXT: procedure(); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindVertexShaderEXT: procedure(id: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenVertexShadersEXT: function(range: GLuint): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteVertexShaderEXT: procedure(id: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glShaderOp1EXT: procedure(op: GLenum; res: GLuint; arg1: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glShaderOp2EXT: procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glShaderOp3EXT: procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint; arg3: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSwizzleEXT: procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWriteMaskEXT: procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glInsertComponentEXT: procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glExtractComponentEXT: procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenSymbolsEXT: function(datatype: GLenum; storagetype: GLenum; range: GLenum; components: GLuint): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSetInvariantEXT: procedure(id: GLuint; _type: GLenum; addr: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSetLocalConstantEXT: procedure(id: GLuint; _type: GLenum; addr: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVariantbvEXT: procedure(id: GLuint; addr: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVariantsvEXT: procedure(id: GLuint; addr: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVariantivEXT: procedure(id: GLuint; addr: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVariantfvEXT: procedure(id: GLuint; addr: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVariantdvEXT: procedure(id: GLuint; addr: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVariantubvEXT: procedure(id: GLuint; addr: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVariantusvEXT: procedure(id: GLuint; addr: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVariantuivEXT: procedure(id: GLuint; addr: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVariantPointerEXT: procedure(id: GLuint; _type: GLenum; stride: GLuint; addr: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEnableVariantClientStateEXT: procedure(id: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDisableVariantClientStateEXT: procedure(id: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindLightParameterEXT: function(light: GLenum; value: GLenum): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindMaterialParameterEXT: function(face: GLenum; value: GLenum): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindTexGenParameterEXT: function(_unit: GLenum; coord: GLenum; value: GLenum): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindTextureUnitParameterEXT: function(_unit: GLenum; value: GLenum): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindParameterEXT: function(value: GLenum): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsVariantEnabledEXT: function(id: GLuint; cap: GLenum): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVariantBooleanvEXT: procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVariantIntegervEXT: procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVariantFloatvEXT: procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVariantPointervEXT: procedure(id: GLuint; value: GLenum; data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetInvariantBooleanvEXT: procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetInvariantIntegervEXT: procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetInvariantFloatvEXT: procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetLocalConstantBooleanvEXT: procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetLocalConstantIntegervEXT: procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetLocalConstantFloatvEXT: procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_vertex_shader: Boolean;

 

@@ -1476,9 +1493,9 @@ const
   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}

+  glVertexWeightfEXT: procedure(weight: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexWeightfvEXT: procedure(weight: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexWeightPointerEXT: procedure(size: GLint; _type: GLenum; stride: GLsizei; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_vertex_weighting: Boolean;

 

@@ -1533,15 +1550,15 @@ const
   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}

+  glMapControlPointsNV: procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; uorder: GLint; vorder: GLint; _packed: GLboolean; const points: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMapParameterivNV: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMapParameterfvNV: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMapControlPointsNV: procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; _packed: GLboolean; points: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMapParameterivNV: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMapParameterfvNV: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMapAttribParameterivNV: procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetMapAttribParameterfvNV: procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEvalMapsNV: procedure(target: GLenum; mode: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_NV_evaluators: Boolean;

 

@@ -1551,13 +1568,13 @@ const
   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}

+  glGenFencesNV: procedure(n: GLsizei; fences: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteFencesNV: procedure(n: GLsizei; const fences: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSetFenceNV: procedure(fence: GLuint; condition: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTestFenceNV: function(fence: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFinishFenceNV: procedure(fence: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsFenceNV: function(fence: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetFenceivNV: procedure(fence: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_NV_fence: Boolean;

 

@@ -1591,13 +1608,13 @@ const
   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}

+  glGenOcclusionQueriesNV: procedure(n: GLsizei; ids: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteOcclusionQueriesNV: procedure(n: GLsizei; const ids: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsOcclusionQueryNV: function(id: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBeginOcclusionQueryNV: procedure(id: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEndOcclusionQueryNV: procedure(); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetOcclusionQueryivNV: procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetOcclusionQueryuivNV: procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_NV_occlusion_query: Boolean;

 

@@ -1614,8 +1631,8 @@ const
   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}

+  glPointParameteriNV: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPointParameterivNV: procedure(pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_NV_point_sprite: Boolean;

 

@@ -1673,19 +1690,19 @@ const
   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}

+  glCombinerParameterfvNV: procedure(pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCombinerParameterivNV: procedure(pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCombinerParameterfNV: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCombinerParameteriNV: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCombinerInputNV: procedure(stage: GLenum; portion: GLenum; variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFinalCombinerInputNV: procedure(variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetCombinerInputParameterfvNV: procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetCombinerInputParameterivNV: procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetCombinerOutputParameterfvNV: procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetCombinerOutputParameterivNV: procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetFinalCombinerInputParameterfvNV: procedure(variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetFinalCombinerInputParameterivNV: procedure(variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_NV_register_combiners: Boolean;

 

@@ -1693,8 +1710,8 @@ function Load_GL_NV_register_combiners: Boolean;
 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}

+  glCombinerStageParameterfvNV: procedure(stage: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetCombinerStageParameterfvNV: procedure(stage: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_NV_register_combiners2: Boolean;

 

@@ -1878,11 +1895,11 @@ const
   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}

+  glVertexArrayRangeNV: procedure(length: GLsizei; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFlushVertexArrayRangeNV: procedure(); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+{$IFDEF WINDOWS}

+  wglAllocateMemoryNV: function(size: GLsizei; readFrequency: GLfloat; writeFrequency: GLfloat; priority: GLfloat): PGLvoid; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglFreeMemoryNV: procedure(pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 {$ENDIF}

 

 function Load_GL_NV_vertex_array_range: Boolean;

@@ -1979,68 +1996,68 @@ const
   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}

+  glBindProgramNV: procedure(target: GLenum; id: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteProgramsNV: procedure(n: GLsizei; const ids: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glExecuteProgramNV: procedure(target: GLenum; id: GLuint; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenProgramsNV: procedure(n: GLsizei; ids: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glAreProgramsResidentNV: function(n: GLsizei; const ids: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRequestResidentProgramsNV: procedure(n: GLsizei; ids: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramParameterfvNV: procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramParameterdvNV: procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramivNV: procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramStringNV: procedure(id: GLuint; pname: GLenum; _program: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTrackMatrixivNV: procedure(target: GLenum; address: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribdvNV: procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribfvNV: procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribivNV: procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribPointervNV: procedure(index: GLuint; pname: GLenum; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsProgramNV: function(id: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLoadProgramNV: procedure(target: GLenum; id: GLuint; len: GLsizei; const _program: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramParameter4fNV: procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramParameter4fvNV: procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramParameters4dvNV: procedure(target: GLenum; index: GLuint; num: GLuint; const params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramParameters4fvNV: procedure(target: GLenum; index: GLuint; num: GLuint; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTrackMatrixNV: procedure(target: GLenum; address: GLuint; matrix: GLenum; transform: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribPointerNV: procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1sNV: procedure(index: GLuint; x: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1fNV: procedure(index: GLuint; x: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1dNV: procedure(index: GLuint; x: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2sNV: procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2fNV: procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2dNV: procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3sNV: procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3fNV: procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3dNV: procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4sNV: procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4fNV: procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4dNV: procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4ubNV: procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1svNV: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1fvNV: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1dvNV: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2svNV: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2fvNV: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2dvNV: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3svNV: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3fvNV: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3dvNV: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4svNV: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4fvNV: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4dvNV: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4ubvNV: procedure(index: GLuint; const v: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs1svNV: procedure(index: GLuint; n: GLsizei; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs1fvNV: procedure(index: GLuint; n: GLsizei; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs1dvNV: procedure(index: GLuint; n: GLsizei; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs2svNV: procedure(index: GLuint; n: GLsizei; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs2fvNV: procedure(index: GLuint; n: GLsizei; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs2dvNV: procedure(index: GLuint; n: GLsizei; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs3svNV: procedure(index: GLuint; n: GLsizei; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs3fvNV: procedure(index: GLuint; n: GLsizei; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs3dvNV: procedure(index: GLuint; n: GLsizei; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs4svNV: procedure(index: GLuint; n: GLsizei; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs4fvNV: procedure(index: GLuint; n: GLsizei; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs4dvNV: procedure(index: GLuint; n: GLsizei; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs4ubvNV: procedure(index: GLuint; n: GLsizei; const v: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_NV_vertex_program: Boolean;

 

@@ -2054,9 +2071,9 @@ const
   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}

+  glElementPointerATI: procedure(_type: GLenum; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawElementArrayATI: procedure(mode: GLenum; count: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawRangeElementArrayATI: procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ATI_element_array: Boolean;

 

@@ -2071,10 +2088,10 @@ const
   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}

+  glTexBumpParameterivATI: procedure(pname: GLenum; param: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexBumpParameterfvATI: procedure(pname: GLenum; param: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexBumpParameterivATI: procedure(pname: GLenum; param: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetTexBumpParameterfvATI: procedure(pname: GLenum; param: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ATI_envmap_bumpmap: Boolean;

 

@@ -2126,20 +2143,20 @@ const
   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}

+  glGenFragmentShadersATI: function(range: GLuint): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindFragmentShaderATI: procedure(id: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteFragmentShaderATI: procedure(id: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBeginFragmentShaderATI: procedure(); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEndFragmentShaderATI: procedure(); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPassTexCoordATI: procedure(dst: GLuint; coord: GLuint; swizzle: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSampleMapATI: procedure(dst: GLuint; interp: GLuint; swizzle: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColorFragmentOp1ATI: procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF WINDOWS}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 WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glAlphaFragmentOp1ATI: procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF WINDOWS}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 WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSetFragmentShaderConstantATI: procedure(dst: GLuint; const value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ATI_fragment_shader: Boolean;

 

@@ -2155,8 +2172,8 @@ const
   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}

+  glPNTrianglesiATI: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPNTrianglesfATI: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ATI_pn_triangles: Boolean;

 

@@ -2178,18 +2195,18 @@ const
   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}

+  glNewObjectBufferATI: function(size: GLsizei; const pointer: PGLvoid; usage: GLenum): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsObjectBufferATI: function(buffer: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUpdateObjectBufferATI: procedure(buffer: GLuint; offset: GLuint; size: GLsizei; const pointer: PGLvoid; preserve: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetObjectBufferfvATI: procedure(buffer: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetObjectBufferivATI: procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteObjectBufferATI: procedure(buffer: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glArrayObjectATI: procedure(_array: GLenum; size: GLint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetArrayObjectfvATI: procedure(_array: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetArrayObjectivATI: procedure(_array: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVariantArrayObjectATI: procedure(id: GLuint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVariantArrayObjectfvATI: procedure(id: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVariantArrayObjectivATI: procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ATI_vertex_array_object: Boolean;

 

@@ -2206,82 +2223,82 @@ const
   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}

+  glVertexStream1s: procedure(stream: GLenum; coords: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream1i: procedure(stream: GLenum; coords: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream1f: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream1d: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream1sv: procedure(stream: GLenum; coords: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream1iv: procedure(stream: GLenum; coords: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream1fv: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream1dv: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream2s: procedure(stream: GLenum; coords: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream2i: procedure(stream: GLenum; coords: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream2f: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream2d: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream2sv: procedure(stream: GLenum; coords: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream2iv: procedure(stream: GLenum; coords: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream2fv: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream2dv: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream3s: procedure(stream: GLenum; coords: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream3i: procedure(stream: GLenum; coords: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream3f: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream3d: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream3sv: procedure(stream: GLenum; coords: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream3iv: procedure(stream: GLenum; coords: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream3fv: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream3dv: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream4s: procedure(stream: GLenum; coords: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream4i: procedure(stream: GLenum; coords: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream4f: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream4d: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream4sv: procedure(stream: GLenum; coords: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream4iv: procedure(stream: GLenum; coords: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream4fv: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexStream4dv: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalStream3b: procedure(stream: GLenum; coords: GLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalStream3s: procedure(stream: GLenum; coords: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalStream3i: procedure(stream: GLenum; coords: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalStream3f: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalStream3d: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalStream3bv: procedure(stream: GLenum; coords: GLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalStream3sv: procedure(stream: GLenum; coords: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalStream3iv: procedure(stream: GLenum; coords: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalStream3fv: procedure(stream: GLenum; coords: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalStream3dv: procedure(stream: GLenum; coords: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glClientActiveVertexStream: procedure(stream: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexBlendEnvi: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexBlendEnvf: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ATI_vertex_streams: Boolean;

 

-{$IFDEF Win32}

+{$IFDEF WINDOWS}

 //***** 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}

+  wglCreateImageBufferI3D: function(hDC: HDC; dwSize: DWORD; uFlags: UINT): PGLvoid; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglDestroyImageBufferI3D: function(hDC: HDC; pAddress: PGLvoid): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglAssociateImageBufferEventsI3D: function(hdc: HDC; pEvent: PHandle; pAddress: PGLvoid; pSize: PDWORD; count: UINT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglReleaseImageBufferEventsI3D: function(hdc: HDC; pAddress: PGLvoid; count: UINT): BOOL; {$IFDEF WINDOWS}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}

+  wglEnableFrameLockI3D: function(): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglDisableFrameLockI3D: function(): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglIsEnabledFrameLockI3D: function(pFlag: PBOOL): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglQueryFrameLockMasterI3D: function(pFlag: PBOOL): BOOL; {$IFDEF WINDOWS}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}

+  wglGetFrameUsageI3D: function(pUsage: PGLfloat): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglBeginFrameTrackingI3D: function(): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglEndFrameTrackingI3D: function(): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglQueryFrameTrackingI3D: function(pFrameCount: PDWORD; pMissedFrames: PDWORD; pLastMissedUsage: PGLfloat): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_I3D_swap_frame_usage: Boolean;

 {$ENDIF}

@@ -2301,8 +2318,8 @@ 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}

+  glMultiModeDrawArraysIBM: procedure(mode: PGLenum; first: PGLint; count: PGLsizei; primcount: GLsizei; modestride: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiModeDrawElementsIBM: procedure(mode: PGLenum; count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei; modestride: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_IBM_multimode_draw_arrays: Boolean;

 

@@ -2337,48 +2354,48 @@ const
   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}

+  glColorPointerListIBM: procedure(size: GLint; _type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColorPointerListIBM: procedure(size: GLint; _type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEdgeFlagPointerListIBM: procedure(stride: GLint; const pointer: PGLboolean; ptrstride: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoordPointerListIBM: procedure(_type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormalPointerListIBM: procedure(_type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoordPointerListIBM: procedure(size: GLint; _type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexPointerListIBM: procedure(size: GLint; _type: GLenum; stride: GLint; const pointer: PGLvoid; ptrstride: GLint); {$IFDEF WINDOWS}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}

+  glResizeBuffersMESA: procedure(); {$IFDEF WINDOWS}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}

+  glWindowPos2dMESA: procedure(x: GLdouble; y: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2fMESA: procedure(x: GLfloat; y: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2iMESA: procedure(x: GLint; y: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2sMESA: procedure(x: GLshort; y: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2ivMESA: procedure(const p: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2svMESA: procedure(const p: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2fvMESA: procedure(const p: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2dvMESA: procedure(const p: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3iMESA: procedure(x: GLint; y: GLint; z: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3sMESA: procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3fMESA: procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3dMESA: procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3ivMESA: procedure(const p: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3svMESA: procedure(const p: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3fvMESA: procedure(const p: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3dvMESA: procedure(const p: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos4iMESA: procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos4sMESA: procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos4fMESA: procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos4dMESA: procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos4ivMESA: procedure(const p: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos4svMESA: procedure(const p: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos4fvMESA: procedure(const p: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos4dvMESA: procedure(const p: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_MESA_window_pos: Boolean;

 

@@ -2437,8 +2454,8 @@ const
   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}

+  glSampleMaskSGIS: procedure(value: GLclampf; invert: GLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSamplePatternSGIS: procedure(pattern: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_SGIS_multisample: Boolean;

 

@@ -2449,10 +2466,10 @@ const
   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}

+  glPixelTexGenParameteriSGIS: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPixelTexGenParameterfSGIS: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetPixelTexGenParameterivSGIS: procedure(pname: GLenum; params: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetPixelTexGenParameterfvSGIS: procedure(pname: GLenum; params: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_SGIS_pixel_texture: Boolean;

 

@@ -2465,7 +2482,7 @@ function Load_GL_SGIS_texture_border_clamp: Boolean;
 const

   GL_TEXTURE_COLOR_WRITEMASK_SGIS = $81EF;

 var

-  glTextureColorMaskSGIS: procedure(r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTextureColorMaskSGIS: procedure(r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_SGIS_texture_color_mask: Boolean;

 

@@ -2546,13 +2563,13 @@ const
   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}

+  glColorTableSGI: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCopyColorTableSGI: procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColorTableParameterivSGI: procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColorTableParameterfvSGI: procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetColorTableSGI: procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetColorTableParameterivSGI: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetColorTableParameterfvSGI: procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_SGI_color_table: Boolean;

 

@@ -2565,46 +2582,46 @@ 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}

+  glColor4ubVertex2fSUN: procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4ubVertex2fvSUN: procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4ubVertex3fSUN: procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4ubVertex3fvSUN: procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3fVertex3fSUN: procedure(r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3fVertex3fvSUN: procedure(const c: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3fVertex3fSUN: procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3fVertex3fvSUN: procedure(const n: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4fNormal3fVertex3fvSUN: procedure(const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2fVertex3fSUN: procedure(s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2fVertex3fvSUN: procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4fVertex4fSUN: procedure(s: GLfloat; t: GLfloat; p: GLfloat; q: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4fVertex4fvSUN: procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2fColor4ubVertex3fvSUN: procedure(const tc: PGLfloat; const c: PGLubyte; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2fColor3fVertex3fSUN: procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2fColor3fVertex3fvSUN: procedure(const tc: PGLfloat; const c: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2fNormal3fVertex3fSUN: procedure(s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2fNormal3fVertex3fvSUN: procedure(const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2fColor4fNormal3fVertex3fvSUN: procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4fColor4fNormal3fVertex4fvSUN: procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiVertex3fSUN: procedure(rc: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiVertex3fvSUN: procedure(const rc: PGLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiColor4ubVertex3fSUN: procedure(rc: GLuint; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiColor4ubVertex3fvSUN: procedure(const rc: PGLuint; const c: PGLubyte; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiColor3fVertex3fSUN: procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiColor3fVertex3fvSUN: procedure(const rc: PGLuint; const c: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiNormal3fVertex3fSUN: procedure(rc: GLuint; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiNormal3fVertex3fvSUN: procedure(const rc: PGLuint; const n: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiColor4fNormal3fVertex3fvSUN: procedure(const rc: PGLuint; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiTexCoord2fVertex3fSUN: procedure(rc: GLuint; s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiTexCoord2fVertex3fvSUN: procedure(const rc: PGLuint; const tc: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN: procedure(const rc: PGLuint; const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}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 WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN: procedure(const rc: PGLuint; const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_SUN_vertex: Boolean;

 

@@ -2728,11 +2745,11 @@ const
   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}

+  glElementPointerAPPLE: procedure(_type: GLenum; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawElementArrayAPPLE: procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawRangeElementArrayAPPLE: procedure(mode: GLenum; start: GLuint; _end: GLuint; first: GLint; count: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiDrawElementArrayAPPLE: procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiDrawRangeElementArrayAPPLE: procedure(mode: GLenum; start: GLuint; _end: GLuint; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_APPLE_element_array: Boolean;

 

@@ -2741,14 +2758,14 @@ 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}

+  glGenFencesAPPLE: procedure(n: GLsizei; fences: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteFencesAPPLE: procedure(n: GLsizei; const fences: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSetFenceAPPLE: procedure(fence: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsFenceAPPLE: function(fence: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTestFenceAPPLE: function(fence: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFinishFenceAPPLE: procedure(fence: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTestObjectAPPLE: function(_object: GLenum; name: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFinishObjectAPPLE: procedure(_object: GLenum; name: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_APPLE_fence: Boolean;

 

@@ -2756,10 +2773,10 @@ function Load_GL_APPLE_fence: Boolean;
 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}

+  glBindVertexArrayAPPLE: procedure(_array: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteVertexArraysAPPLE: procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenVertexArraysAPPLE: procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsVertexArrayAPPLE: function(_array: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_APPLE_vertex_array_object: Boolean;

 

@@ -2773,13 +2790,13 @@ const
   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}

+  glVertexArrayRangeAPPLE: procedure(length: GLsizei; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFlushVertexArrayRangeAPPLE: procedure(length: GLsizei; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexArrayParameteriAPPLE: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_APPLE_vertex_array_range: Boolean;

 

-{$IFDEF Win32}

+{$IFDEF WINDOWS}

 //***** WGL_ARB_pixel_format *****//

 const

   WGL_NUMBER_PIXEL_FORMATS_ARB = $2000;

@@ -2832,9 +2849,9 @@ const
   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}

+  wglGetPixelFormatAttribivARB: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; piValues: PGLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetPixelFormatAttribfvARB: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; pfValues: PGLfloat): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglChoosePixelFormatARB: function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_ARB_pixel_format: Boolean;

 

@@ -2843,8 +2860,8 @@ 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}

+  wglMakeContextCurrentARB: function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetCurrentReadDCARB: function(): HDC; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_ARB_make_current_read: Boolean;

 

@@ -2860,18 +2877,18 @@ const
   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}

+  wglCreatePbufferARB: function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): THandle; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetPbufferDCARB: function(hPbuffer: THandle): HDC; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglReleasePbufferDCARB: function(hPbuffer: THandle; hDC: HDC): GLint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglDestroyPbufferARB: function(hPbuffer: THandle): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglQueryPbufferARB: function(hPbuffer: THandle; iAttribute: GLint; piValue: PGLint): BOOL; {$IFDEF WINDOWS}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}

+  wglSwapIntervalEXT: function(interval: GLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetSwapIntervalEXT: function(): GLint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_EXT_swap_control: Boolean;

 

@@ -2912,22 +2929,22 @@ const
   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}

+  wglBindTexImageARB: function(hPbuffer: THandle; iBuffer: GLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglReleaseTexImageARB: function(hPbuffer: THandle; iBuffer: GLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglSetPbufferAttribARB: function(hPbuffer: THandle; const piAttribList: PGLint): BOOL; {$IFDEF WINDOWS}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}

+  wglGetExtensionsStringEXT: function(): Pchar; {$IFDEF WINDOWS}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}

+  wglMakeContextCurrentEXT: function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetCurrentReadDCEXT: function(): HDC; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_EXT_make_current_read: Boolean;

 

@@ -2943,11 +2960,11 @@ const
   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}

+  wglCreatePbufferEXT: function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): THandle; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetPbufferDCEXT: function(hPbuffer: THandle): HDC; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglReleasePbufferDCEXT: function(hPbuffer: THandle; hDC: HDC): GLint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglDestroyPbufferEXT: function(hPbuffer: THandle): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglQueryPbufferEXT: function(hPbuffer: THandle; iAttribute: GLint; piValue: PGLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_EXT_pbuffer: Boolean;

 

@@ -2999,9 +3016,9 @@ const
   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}

+  wglGetPixelFormatAttribivEXT: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; piValues: PGLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetPixelFormatAttribfvEXT: function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; pfValues: PGLfloat): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglChoosePixelFormatEXT: function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_EXT_pixel_format: Boolean;

 

@@ -3012,8 +3029,8 @@ const
   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}

+  wglGetDigitalVideoParametersI3D: function(hDC: HDC; iAttribute: GLint; piValue: PGLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglSetDigitalVideoParametersI3D: function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_I3D_digital_video_control: Boolean;

 

@@ -3023,10 +3040,10 @@ const
   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}

+  wglGetGammaTableParametersI3D: function(hDC: HDC; iAttribute: GLint; piValue: PGLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglSetGammaTableParametersI3D: function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetGammaTableI3D: function(hDC: HDC; iEntries: GLint; puRed: PGLUSHORT; puGreen: PGLUSHORT; puBlue: PGLUSHORT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglSetGammaTableI3D: function(hDC: HDC; iEntries: GLint; const puRed: PGLUSHORT; const puGreen: PGLUSHORT; const puBlue: PGLUSHORT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_I3D_gamma: Boolean;

 

@@ -3042,18 +3059,18 @@ const
   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}

+  wglEnableGenlockI3D: function(hDC: HDC): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglDisableGenlockI3D: function(hDC: HDC): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglIsEnabledGenlockI3D: function(hDC: HDC; pFlag: PBOOL): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGenlockSourceI3D: function(hDC: HDC; uSource: GLUINT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetGenlockSourceI3D: function(hDC: HDC; uSource: PGLUINT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGenlockSourceEdgeI3D: function(hDC: HDC; uEdge: GLUINT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetGenlockSourceEdgeI3D: function(hDC: HDC; uEdge: PGLUINT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGenlockSampleRateI3D: function(hDC: HDC; uRate: GLUINT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetGenlockSampleRateI3D: function(hDC: HDC; uRate: PGLUINT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGenlockSourceDelayI3D: function(hDC: HDC; uDelay: GLUINT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglGetGenlockSourceDelayI3D: function(hDC: HDC; uDelay: PGLUINT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  wglQueryGenlockMaxSourceDelayI3D: function(hDC: HDC; uMaxLineDelay: PGLUINT; uMaxPixelDelay: PGLUINT): BOOL; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_WGL_I3D_genlock: Boolean;

 {$ENDIF}

@@ -3071,11 +3088,11 @@ const
   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}

+  glCurrentPaletteMatrixARB: procedure(index: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMatrixIndexubvARB: procedure(size: GLint; indices: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMatrixIndexusvARB: procedure(size: GLint; indices: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMatrixIndexuivARB: procedure(size: GLint; indices: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMatrixIndexPointerARB: procedure(size: GLint; _type: GLenum; stride: GLsizei; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_matrix_palette: Boolean;

 

@@ -3084,11 +3101,11 @@ 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}

+  glElementPointerNV: procedure(_type: GLenum; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawElementArrayNV: procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawRangeElementArrayNV: procedure(mode: GLenum; start: GLuint; _end: GLuint; first: GLint; count: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiDrawElementArrayNV: procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiDrawRangeElementArrayNV: procedure(mode: GLenum; start: GLuint; _end: GLuint; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_NV_element_array: Boolean;

 

@@ -3109,7 +3126,7 @@ const
   GL_TEXTURE_FLOAT_COMPONENTS_NV = $888C;

   GL_FLOAT_CLEAR_COLOR_VALUE_NV = $888D;

   GL_FLOAT_RGBA_MODE_NV = $888E;

-{$IFDEF Win32}

+{$IFDEF WINDOWS}

   WGL_FLOAT_COMPONENTS_NV = $20B0;

   WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = $20B1;

   WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = $20B2;

@@ -3132,10 +3149,10 @@ const
   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}

+  glProgramNamedParameter4fNV: procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glProgramNamedParameter4dNV: procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramNamedParameterfvNV: procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramNamedParameterdvNV: procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

   // glProgramLocalParameter4dARB  { already defined }

   // glProgramLocalParameter4dvARB  { already defined }

   // glProgramLocalParameter4fARB  { already defined }

@@ -3150,8 +3167,8 @@ 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}

+  glPrimitiveRestartNV: procedure(); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPrimitiveRestartIndexNV: procedure(index: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_NV_primitive_restart: Boolean;

 

@@ -3159,6 +3176,7 @@ function Load_GL_NV_primitive_restart: Boolean;
 

 function Load_GL_NV_vertex_program2: Boolean;

 

+{$IFDEF WINDOWS}

 //***** WGL_NV_render_texture_rectangle *****//

 const

   WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = $20A0;

@@ -3166,6 +3184,7 @@ const
   WGL_TEXTURE_RECTANGLE_NV = $20A2;

 

 function Load_WGL_NV_render_texture_rectangle: Boolean;

+{$ENDIF}

 

 //***** GL_NV_pixel_data_range *****//

 const

@@ -3176,8 +3195,8 @@ const
   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}

+  glPixelDataRangeNV: procedure(target: GLenum; length: GLsizei; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFlushPixelDataRangeNV: procedure(target: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

   // wglAllocateMemoryNV  { already defined }

   // wglFreeMemoryNV  { already defined }

 

@@ -3221,10 +3240,11 @@ const
   GL_DRAW_BUFFER14_ATI = $8833;

   GL_DRAW_BUFFER15_ATI = $8834;

 var

-  glDrawBuffersATI: procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawBuffersATI: procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ATI_draw_buffers: Boolean;

 

+{$IFDEF WINDOWS}

 //***** WGL_ATI_pixel_format_float *****//

 const

   WGL_RGBA_FLOAT_MODE_ATI = $8820;

@@ -3232,6 +3252,7 @@ const
   WGL_TYPE_RGBA_FLOAT_ATI = $21A0;

 

 function Load_WGL_ATI_pixel_format_float: Boolean;

+{$ENDIF}

 

 //***** GL_ATI_texture_env_combine3 *****//

 const

@@ -3268,59 +3289,59 @@ function Load_GL_NV_texture_expand_normal: Boolean;
 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}

+  glVertex2hNV: procedure(x: GLushort; y: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex2hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex3hNV: procedure(x: GLushort; y: GLushort; z: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex3hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex4hNV: procedure(x: GLushort; y: GLushort; z: GLushort; w: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertex4hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3hNV: procedure(nx: GLushort; ny: GLushort; nz: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glNormal3hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3hNV: procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor3hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4hNV: procedure(red: GLushort; green: GLushort; blue: GLushort; alpha: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glColor4hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord1hNV: procedure(s: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord1hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2hNV: procedure(s: GLushort; t: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord2hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord3hNV: procedure(s: GLushort; t: GLushort; r: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord3hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4hNV: procedure(s: GLushort; t: GLushort; r: GLushort; q: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glTexCoord4hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1hNV: procedure(target: GLenum; s: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord1hvNV: procedure(target: GLenum; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2hNV: procedure(target: GLenum; s: GLushort; t: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord2hvNV: procedure(target: GLenum; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3hNV: procedure(target: GLenum; s: GLushort; t: GLushort; r: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord3hvNV: procedure(target: GLenum; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4hNV: procedure(target: GLenum; s: GLushort; t: GLushort; r: GLushort; q: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiTexCoord4hvNV: procedure(target: GLenum; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoordhNV: procedure(fog: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoordhvNV: procedure(const fog: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3hNV: procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3hvNV: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexWeighthNV: procedure(weight: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexWeighthvNV: procedure(const weight: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1hNV: procedure(index: GLuint; x: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1hvNV: procedure(index: GLuint; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2hNV: procedure(index: GLuint; x: GLushort; y: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2hvNV: procedure(index: GLuint; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3hNV: procedure(index: GLuint; x: GLushort; y: GLushort; z: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3hvNV: procedure(index: GLuint; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4hNV: procedure(index: GLuint; x: GLushort; y: GLushort; z: GLushort; w: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4hvNV: procedure(index: GLuint; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs1hvNV: procedure(index: GLuint; n: GLsizei; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs2hvNV: procedure(index: GLuint; n: GLsizei; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs3hvNV: procedure(index: GLuint; n: GLsizei; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribs4hvNV: procedure(index: GLuint; n: GLsizei; const v: PGLushort); {$IFDEF WINDOWS}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}

+  glMapObjectBufferATI: function(buffer: GLuint): PGLvoid; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUnmapObjectBufferATI: procedure(buffer: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ATI_map_object_buffer: Boolean;

 

@@ -3348,16 +3369,16 @@ const
   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}

+  glStencilOpSeparateATI: procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glStencilFuncSeparateATI: procedure(frontfunc: GLenum; backfunc: GLenum; ref: GLint; mask: GLuint); {$IFDEF WINDOWS}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}

+  glVertexAttribArrayObjectATI: procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribArrayObjectfvATI: procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribArrayObjectivATI: procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ATI_vertex_attrib_array_object: Boolean;

 

@@ -3395,17 +3416,17 @@ const
   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}

+  glBindBufferARB: procedure(target: GLenum; buffer: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteBuffersARB: procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenBuffersARB: procedure(n: GLsizei; buffers: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsBufferARB: function(buffer: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBufferDataARB: procedure(target: GLenum; size: GLsizeiptrARB; const data: PGLvoid; usage: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBufferSubDataARB: procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; const data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetBufferSubDataARB: procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMapBufferARB: function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUnmapBufferARB: function(target: GLenum): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetBufferParameterivARB: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetBufferPointervARB: procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_vertex_buffer_object: Boolean;

 

@@ -3417,14 +3438,14 @@ const
   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}

+  glGenQueriesARB: procedure(n: GLsizei; ids: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteQueriesARB: procedure(n: GLsizei; const ids: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsQueryARB: function(id: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBeginQueryARB: procedure(target: GLenum; id: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEndQueryARB: procedure(target: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetQueryivARB: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetQueryObjectivARB: procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetQueryObjectuivARB: procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_occlusion_query: Boolean;

 

@@ -3459,45 +3480,45 @@ const
   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}

+  glDeleteObjectARB: procedure(obj: GLhandleARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetHandleARB: function(pname: GLenum): GLhandleARB; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDetachObjectARB: procedure(containerObj: GLhandleARB; attachedObj: GLhandleARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCreateShaderObjectARB: function(shaderType: GLenum): GLhandleARB; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glShaderSourceARB: procedure(shaderObj: GLhandleARB; count: GLsizei; const _string: PGLvoid; const length: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCompileShaderARB: procedure(shaderObj: GLhandleARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCreateProgramObjectARB: function(): GLhandleARB; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glAttachObjectARB: procedure(containerObj: GLhandleARB; obj: GLhandleARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLinkProgramARB: procedure(programObj: GLhandleARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUseProgramObjectARB: procedure(programObj: GLhandleARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glValidateProgramARB: procedure(programObj: GLhandleARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform1fARB: procedure(location: GLint; v0: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform2fARB: procedure(location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform3fARB: procedure(location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform4fARB: procedure(location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform1iARB: procedure(location: GLint; v0: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform2iARB: procedure(location: GLint; v0: GLint; v1: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform3iARB: procedure(location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform4iARB: procedure(location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform1fvARB: procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform2fvARB: procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform3fvARB: procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform4fvARB: procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform1ivARB: procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform2ivARB: procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform3ivARB: procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform4ivARB: procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniformMatrix2fvARB: procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniformMatrix3fvARB: procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniformMatrix4fvARB: procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetObjectParameterfvARB: procedure(obj: GLhandleARB; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetObjectParameterivARB: procedure(obj: GLhandleARB; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetInfoLogARB: procedure(obj: GLhandleARB; maxLength: GLsizei; length: PGLsizei; infoLog: PGLcharARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetAttachedObjectsARB: procedure(containerObj: GLhandleARB; maxCount: GLsizei; count: PGLsizei; obj: PGLhandleARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetUniformLocationARB: function(programObj: GLhandleARB; const name: PGLcharARB): GLint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetActiveUniformARB: procedure(programObj: GLhandleARB; index: GLuint; maxLength: GLsizei; length: PGLsizei; size: PGLint; _type: PGLenum; name: PGLcharARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetUniformfvARB: procedure(programObj: GLhandleARB; location: GLint; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetUniformivARB: procedure(programObj: GLhandleARB; location: GLint; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetShaderSourceARB: procedure(obj: GLhandleARB; maxLength: GLsizei; length: PGLsizei; source: PGLcharARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_ARB_shader_objects: Boolean;

 

@@ -3572,9 +3593,9 @@ const
   // 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}

+  glBindAttribLocationARB: procedure(programObj: GLhandleARB; index: GLuint; const name: PGLcharARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetActiveAttribARB: procedure(programObj: GLhandleARB; index: GLuint; maxLength: GLsizei; length: PGLsizei; size: PGLint; _type: PGLenum; name: PGLcharARB); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetAttribLocationARB: function(programObj: GLhandleARB; const name: PGLcharARB): GLint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

   // glGetVertexAttribdvARB  { already defined }

   // glGetVertexAttribfvARB  { already defined }

   // glGetVertexAttribivARB  { already defined }

@@ -3614,7 +3635,7 @@ 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}

+  glDepthBoundsEXT: procedure(zmin: GLclampd; zmax: GLclampd); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_depth_bounds_test: Boolean;

 

@@ -3628,23 +3649,23 @@ const
   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}

+  glSecondaryColor3bEXT: procedure(r: GLbyte; g: GLbyte; b: GLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3sEXT: procedure(r: GLshort; g: GLshort; b: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3iEXT: procedure(r: GLint; g: GLint; b: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3fEXT: procedure(r: GLfloat; g: GLfloat; b: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3dEXT: procedure(r: GLdouble; g: GLdouble; b: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3ubEXT: procedure(r: GLubyte; g: GLubyte; b: GLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3usEXT: procedure(r: GLushort; g: GLushort; b: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3uiEXT: procedure(r: GLuint; g: GLuint; b: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3bvEXT: procedure(components: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3svEXT: procedure(components: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3ivEXT: procedure(components: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3fvEXT: procedure(components: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3dvEXT: procedure(components: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3ubvEXT: procedure(components: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3usvEXT: procedure(components: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3uivEXT: procedure(components: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColorPointerEXT: procedure(size: GLint; _type: GLenum; stride: GLsizei; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_secondary_color: Boolean;

 

@@ -3661,7 +3682,7 @@ 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}

+  glBlendEquationSeparateEXT: procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_blend_equation_separate: Boolean;

 

@@ -3694,11 +3715,11 @@ const
   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}

+  glFogCoordfEXT: procedure(coord: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoorddEXT: procedure(coord: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoordfvEXT: procedure(coord: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoorddvEXT: procedure(coord: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoordPointerEXT: procedure(_type: GLenum; stride: GLsizei; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 function Load_GL_EXT_fog_coord: Boolean;

 

@@ -3736,6 +3757,517 @@ function Load_GL_NV_vertex_program2_option: Boolean;
 

 function Load_GL_NV_vertex_program3: Boolean;

 

+//***** GL_ARB_draw_buffers *****//

+const

+  GL_MAX_DRAW_BUFFERS_ARB = $8824;

+  GL_DRAW_BUFFER0_ARB = $8825;

+  GL_DRAW_BUFFER1_ARB = $8826;

+  GL_DRAW_BUFFER2_ARB = $8827;

+  GL_DRAW_BUFFER3_ARB = $8828;

+  GL_DRAW_BUFFER4_ARB = $8829;

+  GL_DRAW_BUFFER5_ARB = $882A;

+  GL_DRAW_BUFFER6_ARB = $882B;

+  GL_DRAW_BUFFER7_ARB = $882C;

+  GL_DRAW_BUFFER8_ARB = $882D;

+  GL_DRAW_BUFFER9_ARB = $882E;

+  GL_DRAW_BUFFER10_ARB = $882F;

+  GL_DRAW_BUFFER11_ARB = $8830;

+  GL_DRAW_BUFFER12_ARB = $8831;

+  GL_DRAW_BUFFER13_ARB = $8832;

+  GL_DRAW_BUFFER14_ARB = $8833;

+  GL_DRAW_BUFFER15_ARB = $8834;

+var

+  glDrawBuffersARB: procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+function Load_GL_ARB_draw_buffers: Boolean;

+

+//***** GL_ARB_texture_rectangle *****//

+const

+  GL_TEXTURE_RECTANGLE_ARB = $84F5;

+  GL_TEXTURE_BINDING_RECTANGLE_ARB = $84F6;

+  GL_PROXY_TEXTURE_RECTANGLE_ARB = $84F7;

+  GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = $84F8;

+

+function Load_GL_ARB_texture_rectangle: Boolean;

+

+//***** GL_ARB_color_buffer_float *****//

+const

+  GL_RGBA_FLOAT_MODE_ARB = $8820;

+  GL_CLAMP_VERTEX_COLOR_ARB = $891A;

+  GL_CLAMP_FRAGMENT_COLOR_ARB = $891B;

+  GL_CLAMP_READ_COLOR_ARB = $891C;

+  GL_FIXED_ONLY_ARB = $891D;

+  WGL_TYPE_RGBA_FLOAT_ARB = $21A0;

+var

+  glClampColorARB: procedure(target: GLenum; clamp: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+function Load_GL_ARB_color_buffer_float: Boolean;

+

+//***** GL_ARB_half_float_pixel *****//

+const

+  GL_HALF_FLOAT_ARB = $140B;

+

+function Load_GL_ARB_half_float_pixel: Boolean;

+

+//***** GL_ARB_texture_float *****//

+const

+  GL_TEXTURE_RED_TYPE_ARB = $8C10;

+  GL_TEXTURE_GREEN_TYPE_ARB = $8C11;

+  GL_TEXTURE_BLUE_TYPE_ARB = $8C12;

+  GL_TEXTURE_ALPHA_TYPE_ARB = $8C13;

+  GL_TEXTURE_LUMINANCE_TYPE_ARB = $8C14;

+  GL_TEXTURE_INTENSITY_TYPE_ARB = $8C15;

+  GL_TEXTURE_DEPTH_TYPE_ARB = $8C16;

+  GL_UNSIGNED_NORMALIZED_ARB = $8C17;

+  GL_RGBA32F_ARB = $8814;

+  GL_RGB32F_ARB = $8815;

+  GL_ALPHA32F_ARB = $8816;

+  GL_INTENSITY32F_ARB = $8817;

+  GL_LUMINANCE32F_ARB = $8818;

+  GL_LUMINANCE_ALPHA32F_ARB = $8819;

+  GL_RGBA16F_ARB = $881A;

+  GL_RGB16F_ARB = $881B;

+  GL_ALPHA16F_ARB = $881C;

+  GL_INTENSITY16F_ARB = $881D;

+  GL_LUMINANCE16F_ARB = $881E;

+  GL_LUMINANCE_ALPHA16F_ARB = $881F;

+

+function Load_GL_ARB_texture_float: Boolean;

+

+//***** GL_EXT_texture_compression_dxt1 *****//

+  // GL_COMPRESSED_RGB_S3TC_DXT1_EXT  { already defined }

+  // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT  { already defined }

+

+function Load_GL_EXT_texture_compression_dxt1: Boolean;

+

+//***** GL_ARB_pixel_buffer_object *****//

+const

+  GL_PIXEL_PACK_BUFFER_ARB = $88EB;

+  GL_PIXEL_UNPACK_BUFFER_ARB = $88EC;

+  GL_PIXEL_PACK_BUFFER_BINDING_ARB = $88ED;

+  GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = $88EF;

+

+function Load_GL_ARB_pixel_buffer_object: Boolean;

+

+//***** GL_EXT_framebuffer_object *****//

+const

+  GL_FRAMEBUFFER_EXT = $8D40;

+  GL_RENDERBUFFER_EXT = $8D41;

+  GL_STENCIL_INDEX_EXT = $8D45;

+  GL_STENCIL_INDEX1_EXT = $8D46;

+  GL_STENCIL_INDEX4_EXT = $8D47;

+  GL_STENCIL_INDEX8_EXT = $8D48;

+  GL_STENCIL_INDEX16_EXT = $8D49;

+  GL_RENDERBUFFER_WIDTH_EXT = $8D42;

+  GL_RENDERBUFFER_HEIGHT_EXT = $8D43;

+  GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = $8D44;

+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = $8CD0;

+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = $8CD1;

+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = $8CD2;

+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = $8CD3;

+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = $8CD4;

+  GL_COLOR_ATTACHMENT0_EXT = $8CE0;

+  GL_COLOR_ATTACHMENT1_EXT = $8CE1;

+  GL_COLOR_ATTACHMENT2_EXT = $8CE2;

+  GL_COLOR_ATTACHMENT3_EXT = $8CE3;

+  GL_COLOR_ATTACHMENT4_EXT = $8CE4;

+  GL_COLOR_ATTACHMENT5_EXT = $8CE5;

+  GL_COLOR_ATTACHMENT6_EXT = $8CE6;

+  GL_COLOR_ATTACHMENT7_EXT = $8CE7;

+  GL_COLOR_ATTACHMENT8_EXT = $8CE8;

+  GL_COLOR_ATTACHMENT9_EXT = $8CE9;

+  GL_COLOR_ATTACHMENT10_EXT = $8CEA;

+  GL_COLOR_ATTACHMENT11_EXT = $8CEB;

+  GL_COLOR_ATTACHMENT12_EXT = $8CEC;

+  GL_COLOR_ATTACHMENT13_EXT = $8CED;

+  GL_COLOR_ATTACHMENT14_EXT = $8CEE;

+  GL_COLOR_ATTACHMENT15_EXT = $8CEF;

+  GL_DEPTH_ATTACHMENT_EXT = $8D00;

+  GL_STENCIL_ATTACHMENT_EXT = $8D20;

+  GL_FRAMEBUFFER_COMPLETE_EXT = $8CD5;

+  GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = $8CD6;

+  GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = $8CD7;

+  GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = $8CD8;

+  GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = $8CD9;

+  GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = $8CDA;

+  GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = $8CDB;

+  GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = $8CDC;

+  GL_FRAMEBUFFER_UNSUPPORTED_EXT = $8CDD;

+  GL_FRAMEBUFFER_STATUS_ERROR_EXT = $8CDE;

+  GL_FRAMEBUFFER_BINDING_EXT = $8CA6;

+  GL_RENDERBUFFER_BINDING_EXT = $8CA7;

+  GL_MAX_COLOR_ATTACHMENTS_EXT = $8CDF;

+  GL_MAX_RENDERBUFFER_SIZE_EXT = $84E8;

+  GL_INVALID_FRAMEBUFFER_OPERATION_EXT = $0506;

+var

+  glIsRenderbufferEXT: function(renderbuffer: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindRenderbufferEXT: procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteRenderbuffersEXT: procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenRenderbuffersEXT: procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glRenderbufferStorageEXT: procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetRenderbufferParameterivEXT: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsFramebufferEXT: function(framebuffer: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindFramebufferEXT: procedure(target: GLenum; framebuffer: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteFramebuffersEXT: procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenFramebuffersEXT: procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCheckFramebufferStatusEXT: function(target: GLenum): GLenum; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFramebufferTexture1DEXT: procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFramebufferTexture2DEXT: procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFramebufferTexture3DEXT: procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFramebufferRenderbufferEXT: procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetFramebufferAttachmentParameterivEXT: procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenerateMipmapEXT: procedure(target: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+function Load_GL_EXT_framebuffer_object: Boolean;

+

+//***** GL_version_1_4 *****//

+const

+  GL_BLEND_DST_RGB = $80C8;

+  GL_BLEND_SRC_RGB = $80C9;

+  GL_BLEND_DST_ALPHA = $80CA;

+  GL_BLEND_SRC_ALPHA = $80CB;

+  GL_POINT_SIZE_MIN = $8126;

+  GL_POINT_SIZE_MAX = $8127;

+  GL_POINT_FADE_THRESHOLD_SIZE = $8128;

+  GL_POINT_DISTANCE_ATTENUATION = $8129;

+  GL_GENERATE_MIPMAP = $8191;

+  GL_GENERATE_MIPMAP_HINT = $8192;

+  GL_DEPTH_COMPONENT16 = $81A5;

+  GL_DEPTH_COMPONENT24 = $81A6;

+  GL_DEPTH_COMPONENT32 = $81A7;

+  GL_MIRRORED_REPEAT = $8370;

+  GL_FOG_COORDINATE_SOURCE = $8450;

+  GL_FOG_COORDINATE = $8451;

+  GL_FRAGMENT_DEPTH = $8452;

+  GL_CURRENT_FOG_COORDINATE = $8453;

+  GL_FOG_COORDINATE_ARRAY_TYPE = $8454;

+  GL_FOG_COORDINATE_ARRAY_STRIDE = $8455;

+  GL_FOG_COORDINATE_ARRAY_POINTER = $8456;

+  GL_FOG_COORDINATE_ARRAY = $8457;

+  GL_COLOR_SUM = $8458;

+  GL_CURRENT_SECONDARY_COLOR = $8459;

+  GL_SECONDARY_COLOR_ARRAY_SIZE = $845A;

+  GL_SECONDARY_COLOR_ARRAY_TYPE = $845B;

+  GL_SECONDARY_COLOR_ARRAY_STRIDE = $845C;

+  GL_SECONDARY_COLOR_ARRAY_POINTER = $845D;

+  GL_SECONDARY_COLOR_ARRAY = $845E;

+  GL_MAX_TEXTURE_LOD_BIAS = $84FD;

+  GL_TEXTURE_FILTER_CONTROL = $8500;

+  GL_TEXTURE_LOD_BIAS = $8501;

+  GL_INCR_WRAP = $8507;

+  GL_DECR_WRAP = $8508;

+  GL_TEXTURE_DEPTH_SIZE = $884A;

+  GL_DEPTH_TEXTURE_MODE = $884B;

+  GL_TEXTURE_COMPARE_MODE = $884C;

+  GL_TEXTURE_COMPARE_FUNC = $884D;

+  GL_COMPARE_R_TO_TEXTURE = $884E;

+var

+  glBlendFuncSeparate: procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoordf: procedure(coord: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoordfv: procedure(const coord: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoordd: procedure(coord: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoorddv: procedure(const coord: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glFogCoordPointer: procedure(_type: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiDrawArrays: procedure(mode: GLenum; first: PGLint; count: PGLsizei; primcount: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMultiDrawElements: procedure(mode: GLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPointParameterf: procedure(pname: GLenum; param: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPointParameterfv: procedure(pname: GLenum; const params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPointParameteri: procedure(pname: GLenum; param: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glPointParameteriv: procedure(pname: GLenum; const params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3b: procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3bv: procedure(const v: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3d: procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3f: procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3i: procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3s: procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3ub: procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3ubv: procedure(const v: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3ui: procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3uiv: procedure(const v: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3us: procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColor3usv: procedure(const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glSecondaryColorPointer: procedure(size: GLint; _type: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2d: procedure(x: GLdouble; y: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2f: procedure(x: GLfloat; y: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2i: procedure(x: GLint; y: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2s: procedure(x: GLshort; y: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos2sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3d: procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3dv: procedure(const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3f: procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3fv: procedure(const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3i: procedure(x: GLint; y: GLint; z: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3iv: procedure(const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3s: procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glWindowPos3sv: procedure(const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+function Load_GL_version_1_4: Boolean;

+

+//***** GL_version_1_5 *****//

+const

+  GL_BUFFER_SIZE = $8764;

+  GL_BUFFER_USAGE = $8765;

+  GL_QUERY_COUNTER_BITS = $8864;

+  GL_CURRENT_QUERY = $8865;

+  GL_QUERY_RESULT = $8866;

+  GL_QUERY_RESULT_AVAILABLE = $8867;

+  GL_ARRAY_BUFFER = $8892;

+  GL_ELEMENT_ARRAY_BUFFER = $8893;

+  GL_ARRAY_BUFFER_BINDING = $8894;

+  GL_ELEMENT_ARRAY_BUFFER_BINDING = $8895;

+  GL_VERTEX_ARRAY_BUFFER_BINDING = $8896;

+  GL_NORMAL_ARRAY_BUFFER_BINDING = $8897;

+  GL_COLOR_ARRAY_BUFFER_BINDING = $8898;

+  GL_INDEX_ARRAY_BUFFER_BINDING = $8899;

+  GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = $889A;

+  GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = $889B;

+  GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = $889C;

+  GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = $889D;

+  GL_WEIGHT_ARRAY_BUFFER_BINDING = $889E;

+  GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = $889F;

+  GL_READ_ONLY = $88B8;

+  GL_WRITE_ONLY = $88B9;

+  GL_READ_WRITE = $88BA;

+  GL_BUFFER_ACCESS = $88BB;

+  GL_BUFFER_MAPPED = $88BC;

+  GL_BUFFER_MAP_POINTER = $88BD;

+  GL_STREAM_DRAW = $88E0;

+  GL_STREAM_READ = $88E1;

+  GL_STREAM_COPY = $88E2;

+  GL_STATIC_DRAW = $88E4;

+  GL_STATIC_READ = $88E5;

+  GL_STATIC_COPY = $88E6;

+  GL_DYNAMIC_DRAW = $88E8;

+  GL_DYNAMIC_READ = $88E9;

+  GL_DYNAMIC_COPY = $88EA;

+  GL_SAMPLES_PASSED = $8914;

+  GL_FOG_COORD_SRC = $8450;

+  GL_FOG_COORD = $8451;

+  GL_CURRENT_FOG_COORD = $8453;

+  GL_FOG_COORD_ARRAY_TYPE = $8454;

+  GL_FOG_COORD_ARRAY_STRIDE = $8455;

+  GL_FOG_COORD_ARRAY_POINTER = $8456;

+  GL_FOG_COORD_ARRAY = $8457;

+  GL_FOG_COORD_ARRAY_BUFFER_BINDING = $889D;

+  GL_SRC0_RGB = $8580;

+  GL_SRC1_RGB = $8581;

+  GL_SRC2_RGB = $8582;

+  GL_SRC0_ALPHA = $8588;

+  GL_SRC1_ALPHA = $8589;

+  GL_SRC2_ALPHA = $858A;

+var

+  glGenQueries: procedure(n: GLsizei; ids: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteQueries: procedure(n: GLsizei; const ids: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsQuery: function(id: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBeginQuery: procedure(target: GLenum; id: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEndQuery: procedure(target: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetQueryiv: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetQueryObjectiv: procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetQueryObjectuiv: procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindBuffer: procedure(target: GLenum; buffer: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteBuffers: procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGenBuffers: procedure(n: GLsizei; buffers: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsBuffer: function(buffer: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBufferData: procedure(target: GLenum; size: GLsizeiptr; const data: PGLvoid; usage: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBufferSubData: procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; const data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetBufferSubData: procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; data: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glMapBuffer: function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUnmapBuffer: function(target: GLenum): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetBufferParameteriv: procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetBufferPointerv: procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+function Load_GL_version_1_5: Boolean;

+

+//***** GL_version_2_0 *****//

+const

+  GL_BLEND_EQUATION_RGB = $8009;

+  GL_VERTEX_ATTRIB_ARRAY_ENABLED = $8622;

+  GL_VERTEX_ATTRIB_ARRAY_SIZE = $8623;

+  GL_VERTEX_ATTRIB_ARRAY_STRIDE = $8624;

+  GL_VERTEX_ATTRIB_ARRAY_TYPE = $8625;

+  GL_CURRENT_VERTEX_ATTRIB = $8626;

+  GL_VERTEX_PROGRAM_POINT_SIZE = $8642;

+  GL_VERTEX_PROGRAM_TWO_SIDE = $8643;

+  GL_VERTEX_ATTRIB_ARRAY_POINTER = $8645;

+  GL_STENCIL_BACK_FUNC = $8800;

+  GL_STENCIL_BACK_FAIL = $8801;

+  GL_STENCIL_BACK_PASS_DEPTH_FAIL = $8802;

+  GL_STENCIL_BACK_PASS_DEPTH_PASS = $8803;

+  GL_MAX_DRAW_BUFFERS = $8824;

+  GL_DRAW_BUFFER0 = $8825;

+  GL_DRAW_BUFFER1 = $8826;

+  GL_DRAW_BUFFER2 = $8827;

+  GL_DRAW_BUFFER3 = $8828;

+  GL_DRAW_BUFFER4 = $8829;

+  GL_DRAW_BUFFER5 = $882A;

+  GL_DRAW_BUFFER6 = $882B;

+  GL_DRAW_BUFFER7 = $882C;

+  GL_DRAW_BUFFER8 = $882D;

+  GL_DRAW_BUFFER9 = $882E;

+  GL_DRAW_BUFFER10 = $882F;

+  GL_DRAW_BUFFER11 = $8830;

+  GL_DRAW_BUFFER12 = $8831;

+  GL_DRAW_BUFFER13 = $8832;

+  GL_DRAW_BUFFER14 = $8833;

+  GL_DRAW_BUFFER15 = $8834;

+  GL_BLEND_EQUATION_ALPHA = $883D;

+  GL_POINT_SPRITE = $8861;

+  GL_COORD_REPLACE = $8862;

+  GL_MAX_VERTEX_ATTRIBS = $8869;

+  GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = $886A;

+  GL_MAX_TEXTURE_COORDS = $8871;

+  GL_MAX_TEXTURE_IMAGE_UNITS = $8872;

+  GL_FRAGMENT_SHADER = $8B30;

+  GL_VERTEX_SHADER = $8B31;

+  GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = $8B49;

+  GL_MAX_VERTEX_UNIFORM_COMPONENTS = $8B4A;

+  GL_MAX_VARYING_FLOATS = $8B4B;

+  GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = $8B4C;

+  GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = $8B4D;

+  GL_SHADER_TYPE = $8B4F;

+  GL_FLOAT_VEC2 = $8B50;

+  GL_FLOAT_VEC3 = $8B51;

+  GL_FLOAT_VEC4 = $8B52;

+  GL_INT_VEC2 = $8B53;

+  GL_INT_VEC3 = $8B54;

+  GL_INT_VEC4 = $8B55;

+  GL_BOOL = $8B56;

+  GL_BOOL_VEC2 = $8B57;

+  GL_BOOL_VEC3 = $8B58;

+  GL_BOOL_VEC4 = $8B59;

+  GL_FLOAT_MAT2 = $8B5A;

+  GL_FLOAT_MAT3 = $8B5B;

+  GL_FLOAT_MAT4 = $8B5C;

+  GL_SAMPLER_1D = $8B5D;

+  GL_SAMPLER_2D = $8B5E;

+  GL_SAMPLER_3D = $8B5F;

+  GL_SAMPLER_CUBE = $8B60;

+  GL_SAMPLER_1D_SHADOW = $8B61;

+  GL_SAMPLER_2D_SHADOW = $8B62;

+  GL_DELETE_STATUS = $8B80;

+  GL_COMPILE_STATUS = $8B81;

+  GL_LINK_STATUS = $8B82;

+  GL_VALIDATE_STATUS = $8B83;

+  GL_INFO_LOG_LENGTH = $8B84;

+  GL_ATTACHED_SHADERS = $8B85;

+  GL_ACTIVE_UNIFORMS = $8B86;

+  GL_ACTIVE_UNIFORM_MAX_LENGTH = $8B87;

+  GL_SHADER_SOURCE_LENGTH = $8B88;

+  GL_ACTIVE_ATTRIBUTES = $8B89;

+  GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = $8B8A;

+  GL_FRAGMENT_SHADER_DERIVATIVE_HINT = $8B8B;

+  GL_SHADING_LANGUAGE_VERSION = $8B8C;

+  GL_CURRENT_PROGRAM = $8B8D;

+  GL_POINT_SPRITE_COORD_ORIGIN = $8CA0;

+  GL_LOWER_LEFT = $8CA1;

+  GL_UPPER_LEFT = $8CA2;

+  GL_STENCIL_BACK_REF = $8CA3;

+  GL_STENCIL_BACK_VALUE_MASK = $8CA4;

+  GL_STENCIL_BACK_WRITEMASK = $8CA5;

+var

+  glBlendEquationSeparate: procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDrawBuffers: procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glStencilOpSeparate: procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glStencilFuncSeparate: procedure(frontfunc: GLenum; backfunc: GLenum; ref: GLint; mask: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glStencilMaskSeparate: procedure(face: GLenum; mask: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glAttachShader: procedure(_program: GLuint; shader: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glBindAttribLocation: procedure(_program: GLuint; index: GLuint; const name: PGLchar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCompileShader: procedure(shader: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCreateProgram: function(): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glCreateShader: function(_type: GLenum): GLuint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteProgram: procedure(_program: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDeleteShader: procedure(shader: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDetachShader: procedure(_program: GLuint; shader: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glDisableVertexAttribArray: procedure(index: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glEnableVertexAttribArray: procedure(index: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetActiveAttrib: procedure(_program: GLuint; index: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLint; _type: PGLenum; name: PGLchar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetActiveUniform: procedure(_program: GLuint; index: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLint; _type: PGLenum; name: PGLchar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetAttachedShaders: procedure(_program: GLuint; maxCount: GLsizei; count: PGLsizei; obj: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetAttribLocation: function(_program: GLuint; const name: PGLchar): GLint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramiv: procedure(_program: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetProgramInfoLog: procedure(_program: GLuint; bufSize: GLsizei; length: PGLsizei; infoLog: PGLchar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetShaderiv: procedure(shader: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetShaderInfoLog: procedure(shader: GLuint; bufSize: GLsizei; length: PGLsizei; infoLog: PGLchar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetShaderSource: procedure(shader: GLuint; bufSize: GLsizei; length: PGLsizei; source: PGLchar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetUniformLocation: function(_program: GLuint; const name: PGLchar): GLint; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetUniformfv: procedure(_program: GLuint; location: GLint; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetUniformiv: procedure(_program: GLuint; location: GLint; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribdv: procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribfv: procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribiv: procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glGetVertexAttribPointerv: procedure(index: GLuint; pname: GLenum; pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsProgram: function(_program: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glIsShader: function(shader: GLuint): GLboolean; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glLinkProgram: procedure(_program: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glShaderSource: procedure(shader: GLuint; count: GLsizei; const _string: PGLchar; const length: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUseProgram: procedure(_program: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform1f: procedure(location: GLint; v0: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform2f: procedure(location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform3f: procedure(location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform4f: procedure(location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform1i: procedure(location: GLint; v0: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform2i: procedure(location: GLint; v0: GLint; v1: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform3i: procedure(location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform4i: procedure(location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform1fv: procedure(location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform2fv: procedure(location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform3fv: procedure(location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform4fv: procedure(location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform1iv: procedure(location: GLint; count: GLsizei; const value: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform2iv: procedure(location: GLint; count: GLsizei; const value: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform3iv: procedure(location: GLint; count: GLsizei; const value: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniform4iv: procedure(location: GLint; count: GLsizei; const value: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniformMatrix2fv: procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniformMatrix3fv: procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glUniformMatrix4fv: procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glValidateProgram: procedure(_program: GLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1d: procedure(index: GLuint; x: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1dv: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1f: procedure(index: GLuint; x: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1fv: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1s: procedure(index: GLuint; x: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib1sv: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2d: procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2dv: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2f: procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2fv: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2s: procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib2sv: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3d: procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3dv: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3f: procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3fv: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3s: procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib3sv: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4Nbv: procedure(index: GLuint; const v: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4Niv: procedure(index: GLuint; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4Nsv: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4Nub: procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4Nubv: procedure(index: GLuint; const v: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4Nuiv: procedure(index: GLuint; const v: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4Nusv: procedure(index: GLuint; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4bv: procedure(index: GLuint; const v: PGLbyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4d: procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4dv: procedure(index: GLuint; const v: PGLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4f: procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4fv: procedure(index: GLuint; const v: PGLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4iv: procedure(index: GLuint; const v: PGLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4s: procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4sv: procedure(index: GLuint; const v: PGLshort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4ubv: procedure(index: GLuint; const v: PGLubyte); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4uiv: procedure(index: GLuint; const v: PGLuint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttrib4usv: procedure(index: GLuint; const v: PGLushort); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glVertexAttribPointer: procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const pointer: PGLvoid); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+function Load_GL_version_2_0: Boolean;

+

 implementation

 

 uses

@@ -4125,7 +4657,7 @@ begin
 

 end;

 

-{$IFDEF Win32}

+{$IFDEF WINDOWS}

 function Load_WGL_ARB_extensions_string: Boolean;

 var

   extstring : PChar;

@@ -5736,7 +6268,7 @@ begin
     if not Assigned(glVertexArrayRangeNV) then Exit;

     @glFlushVertexArrayRangeNV := SDL_GL_GetProcAddress('glFlushVertexArrayRangeNV');

     if not Assigned(glFlushVertexArrayRangeNV) then Exit;

-    {$IFDEF WIN32}

+    {$IFDEF WINDOWS}

     @wglAllocateMemoryNV := SDL_GL_GetProcAddress('wglAllocateMemoryNV');

     if not Assigned(wglAllocateMemoryNV) then Exit;

     @wglFreeMemoryNV := SDL_GL_GetProcAddress('wglFreeMemoryNV');

@@ -6181,7 +6713,7 @@ begin
 

 end;

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

 function Load_WGL_I3D_image_buffer: Boolean;

 var

   extstring : PChar;

@@ -7007,7 +7539,7 @@ begin
 

 end;

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

 function Load_WGL_ARB_pixel_format: Boolean;

 var

   extstring : PChar;

@@ -7435,7 +7967,7 @@ begin
 

 end;

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

 function Load_WGL_NV_render_texture_rectangle: Boolean;

 var

   extstring : PChar;

@@ -7468,7 +8000,7 @@ begin
     if not Assigned(glPixelDataRangeNV) then Exit;

     @glFlushPixelDataRangeNV := SDL_GL_GetProcAddress('glFlushPixelDataRangeNV');

     if not Assigned(glFlushPixelDataRangeNV) then Exit;

-    {$IFDEF WIN32}

+    {$IFDEF WINDOWS}

     @wglAllocateMemoryNV := SDL_GL_GetProcAddress('wglAllocateMemoryNV');

     if not Assigned(wglAllocateMemoryNV) then Exit;

     @wglFreeMemoryNV := SDL_GL_GetProcAddress('wglFreeMemoryNV');

@@ -7526,7 +8058,7 @@ begin
 

 end;

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

 function Load_WGL_ATI_pixel_format_float: Boolean;

 var

   extstring : PChar;

@@ -8327,7 +8859,515 @@ begin
 

 end;

 

-function glext_LoadExtension(ext: PChar): Boolean;

+function Load_GL_ARB_draw_buffers: Boolean;

+var

+  extstring: PChar;

+begin

+

+  Result := FALSE;

+  extstring := glGetString(GL_EXTENSIONS);

+

+  if glext_ExtensionSupported('GL_ARB_draw_buffers', extstring) then

+  begin

+    glDrawBuffersARB := SDL_GL_GetProcAddress('glDrawBuffersARB');

+    if not Assigned(glDrawBuffersARB) then Exit;

+    Result := TRUE;

+  end;

+

+end;

+

+function Load_GL_ARB_texture_rectangle: Boolean;

+var

+  extstring: PChar;

+begin

+

+  Result := FALSE;

+  extstring := glGetString(GL_EXTENSIONS);

+

+  if glext_ExtensionSupported('GL_ARB_texture_rectangle', extstring) then

+  begin

+    Result := TRUE;

+  end;

+

+end;

+

+function Load_GL_ARB_color_buffer_float: Boolean;

+var

+  extstring: PChar;

+begin

+

+  Result := FALSE;

+  extstring := glGetString(GL_EXTENSIONS);

+

+  if glext_ExtensionSupported('GL_ARB_color_buffer_float', extstring) then

+  begin

+    glClampColorARB := SDL_GL_GetProcAddress('glClampColorARB');

+    if not Assigned(glClampColorARB) then Exit;

+    Result := TRUE;

+  end;

+

+end;

+

+function Load_GL_ARB_half_float_pixel: Boolean;

+var

+  extstring: PChar;

+begin

+

+  Result := FALSE;

+  extstring := glGetString(GL_EXTENSIONS);

+

+  if glext_ExtensionSupported('GL_ARB_half_float_pixel', extstring) then

+  begin

+    Result := TRUE;

+  end;

+

+end;

+

+function Load_GL_ARB_texture_float: Boolean;

+var

+  extstring: PChar;

+begin

+

+  Result := FALSE;

+  extstring := glGetString(GL_EXTENSIONS);

+

+  if glext_ExtensionSupported('GL_ARB_texture_float', extstring) then

+  begin

+    Result := TRUE;

+  end;

+

+end;

+

+function Load_GL_EXT_texture_compression_dxt1: Boolean;

+var

+  extstring: PChar;

+begin

+

+  Result := FALSE;

+  extstring := glGetString(GL_EXTENSIONS);

+

+  if glext_ExtensionSupported('GL_EXT_texture_compression_dxt1', extstring) then

+  begin

+    Result := TRUE;

+  end;

+

+end;

+

+function Load_GL_ARB_pixel_buffer_object: Boolean;

+var

+  extstring: PChar;

+begin

+

+  Result := FALSE;

+  extstring := glGetString(GL_EXTENSIONS);

+

+  if glext_ExtensionSupported('GL_ARB_pixel_buffer_object', extstring) then

+  begin

+    Result := TRUE;

+  end;

+

+end;

+

+function Load_GL_EXT_framebuffer_object: Boolean;

+var

+  extstring: PChar;

+begin

+

+  Result := FALSE;

+  extstring := glGetString(GL_EXTENSIONS);

+

+  if glext_ExtensionSupported('GL_EXT_framebuffer_object', extstring) then

+  begin

+    glIsRenderbufferEXT := SDL_GL_GetProcAddress('glIsRenderbufferEXT');

+    if not Assigned(glIsRenderbufferEXT) then Exit;

+    glBindRenderbufferEXT := SDL_GL_GetProcAddress('glBindRenderbufferEXT');

+    if not Assigned(glBindRenderbufferEXT) then Exit;

+    glDeleteRenderbuffersEXT := SDL_GL_GetProcAddress('glDeleteRenderbuffersEXT');

+    if not Assigned(glDeleteRenderbuffersEXT) then Exit;

+    glGenRenderbuffersEXT := SDL_GL_GetProcAddress('glGenRenderbuffersEXT');

+    if not Assigned(glGenRenderbuffersEXT) then Exit;

+    glRenderbufferStorageEXT := SDL_GL_GetProcAddress('glRenderbufferStorageEXT');

+    if not Assigned(glRenderbufferStorageEXT) then Exit;

+    glGetRenderbufferParameterivEXT := SDL_GL_GetProcAddress('glGetRenderbufferParameterivEXT');

+    if not Assigned(glGetRenderbufferParameterivEXT) then Exit;

+    glIsFramebufferEXT := SDL_GL_GetProcAddress('glIsFramebufferEXT');

+    if not Assigned(glIsFramebufferEXT) then Exit;

+    glBindFramebufferEXT := SDL_GL_GetProcAddress('glBindFramebufferEXT');

+    if not Assigned(glBindFramebufferEXT) then Exit;

+    glDeleteFramebuffersEXT := SDL_GL_GetProcAddress('glDeleteFramebuffersEXT');

+    if not Assigned(glDeleteFramebuffersEXT) then Exit;

+    glGenFramebuffersEXT := SDL_GL_GetProcAddress('glGenFramebuffersEXT');

+    if not Assigned(glGenFramebuffersEXT) then Exit;

+    glCheckFramebufferStatusEXT := SDL_GL_GetProcAddress('glCheckFramebufferStatusEXT');

+    if not Assigned(glCheckFramebufferStatusEXT) then Exit;

+    glFramebufferTexture1DEXT := SDL_GL_GetProcAddress('glFramebufferTexture1DEXT');

+    if not Assigned(glFramebufferTexture1DEXT) then Exit;

+    glFramebufferTexture2DEXT := SDL_GL_GetProcAddress('glFramebufferTexture2DEXT');

+    if not Assigned(glFramebufferTexture2DEXT) then Exit;

+    glFramebufferTexture3DEXT := SDL_GL_GetProcAddress('glFramebufferTexture3DEXT');

+    if not Assigned(glFramebufferTexture3DEXT) then Exit;

+    glFramebufferRenderbufferEXT := SDL_GL_GetProcAddress('glFramebufferRenderbufferEXT');

+    if not Assigned(glFramebufferRenderbufferEXT) then Exit;

+    glGetFramebufferAttachmentParameterivEXT := SDL_GL_GetProcAddress('glGetFramebufferAttachmentParameterivEXT');

+    if not Assigned(glGetFramebufferAttachmentParameterivEXT) then Exit;

+    glGenerateMipmapEXT := SDL_GL_GetProcAddress('glGenerateMipmapEXT');

+    if not Assigned(glGenerateMipmapEXT) then Exit;

+    Result := TRUE;

+  end;

+

+end;

+

+function Load_GL_version_1_4: Boolean;

+var

+  extstring: String;

+begin

+

+  Result := FALSE;

+  extstring := String(PChar(glGetString(GL_EXTENSIONS)));

+

+    glBlendFuncSeparate := SDL_GL_GetProcAddress('glBlendFuncSeparate');

+    if not Assigned(glBlendFuncSeparate) then Exit;

+    glFogCoordf := SDL_GL_GetProcAddress('glFogCoordf');

+    if not Assigned(glFogCoordf) then Exit;

+    glFogCoordfv := SDL_GL_GetProcAddress('glFogCoordfv');

+    if not Assigned(glFogCoordfv) then Exit;

+    glFogCoordd := SDL_GL_GetProcAddress('glFogCoordd');

+    if not Assigned(glFogCoordd) then Exit;

+    glFogCoorddv := SDL_GL_GetProcAddress('glFogCoorddv');

+    if not Assigned(glFogCoorddv) then Exit;

+    glFogCoordPointer := SDL_GL_GetProcAddress('glFogCoordPointer');

+    if not Assigned(glFogCoordPointer) then Exit;

+    glMultiDrawArrays := SDL_GL_GetProcAddress('glMultiDrawArrays');

+    if not Assigned(glMultiDrawArrays) then Exit;

+    glMultiDrawElements := SDL_GL_GetProcAddress('glMultiDrawElements');

+    if not Assigned(glMultiDrawElements) then Exit;

+    glPointParameterf := SDL_GL_GetProcAddress('glPointParameterf');

+    if not Assigned(glPointParameterf) then Exit;

+    glPointParameterfv := SDL_GL_GetProcAddress('glPointParameterfv');

+    if not Assigned(glPointParameterfv) then Exit;

+    glPointParameteri := SDL_GL_GetProcAddress('glPointParameteri');

+    if not Assigned(glPointParameteri) then Exit;

+    glPointParameteriv := SDL_GL_GetProcAddress('glPointParameteriv');

+    if not Assigned(glPointParameteriv) then Exit;

+    glSecondaryColor3b := SDL_GL_GetProcAddress('glSecondaryColor3b');

+    if not Assigned(glSecondaryColor3b) then Exit;

+    glSecondaryColor3bv := SDL_GL_GetProcAddress('glSecondaryColor3bv');

+    if not Assigned(glSecondaryColor3bv) then Exit;

+    glSecondaryColor3d := SDL_GL_GetProcAddress('glSecondaryColor3d');

+    if not Assigned(glSecondaryColor3d) then Exit;

+    glSecondaryColor3dv := SDL_GL_GetProcAddress('glSecondaryColor3dv');

+    if not Assigned(glSecondaryColor3dv) then Exit;

+    glSecondaryColor3f := SDL_GL_GetProcAddress('glSecondaryColor3f');

+    if not Assigned(glSecondaryColor3f) then Exit;

+    glSecondaryColor3fv := SDL_GL_GetProcAddress('glSecondaryColor3fv');

+    if not Assigned(glSecondaryColor3fv) then Exit;

+    glSecondaryColor3i := SDL_GL_GetProcAddress('glSecondaryColor3i');

+    if not Assigned(glSecondaryColor3i) then Exit;

+    glSecondaryColor3iv := SDL_GL_GetProcAddress('glSecondaryColor3iv');

+    if not Assigned(glSecondaryColor3iv) then Exit;

+    glSecondaryColor3s := SDL_GL_GetProcAddress('glSecondaryColor3s');

+    if not Assigned(glSecondaryColor3s) then Exit;

+    glSecondaryColor3sv := SDL_GL_GetProcAddress('glSecondaryColor3sv');

+    if not Assigned(glSecondaryColor3sv) then Exit;

+    glSecondaryColor3ub := SDL_GL_GetProcAddress('glSecondaryColor3ub');

+    if not Assigned(glSecondaryColor3ub) then Exit;

+    glSecondaryColor3ubv := SDL_GL_GetProcAddress('glSecondaryColor3ubv');

+    if not Assigned(glSecondaryColor3ubv) then Exit;

+    glSecondaryColor3ui := SDL_GL_GetProcAddress('glSecondaryColor3ui');

+    if not Assigned(glSecondaryColor3ui) then Exit;

+    glSecondaryColor3uiv := SDL_GL_GetProcAddress('glSecondaryColor3uiv');

+    if not Assigned(glSecondaryColor3uiv) then Exit;

+    glSecondaryColor3us := SDL_GL_GetProcAddress('glSecondaryColor3us');

+    if not Assigned(glSecondaryColor3us) then Exit;

+    glSecondaryColor3usv := SDL_GL_GetProcAddress('glSecondaryColor3usv');

+    if not Assigned(glSecondaryColor3usv) then Exit;

+    glSecondaryColorPointer := SDL_GL_GetProcAddress('glSecondaryColorPointer');

+    if not Assigned(glSecondaryColorPointer) then Exit;

+    glWindowPos2d := SDL_GL_GetProcAddress('glWindowPos2d');

+    if not Assigned(glWindowPos2d) then Exit;

+    glWindowPos2dv := SDL_GL_GetProcAddress('glWindowPos2dv');

+    if not Assigned(glWindowPos2dv) then Exit;

+    glWindowPos2f := SDL_GL_GetProcAddress('glWindowPos2f');

+    if not Assigned(glWindowPos2f) then Exit;

+    glWindowPos2fv := SDL_GL_GetProcAddress('glWindowPos2fv');

+    if not Assigned(glWindowPos2fv) then Exit;

+    glWindowPos2i := SDL_GL_GetProcAddress('glWindowPos2i');

+    if not Assigned(glWindowPos2i) then Exit;

+    glWindowPos2iv := SDL_GL_GetProcAddress('glWindowPos2iv');

+    if not Assigned(glWindowPos2iv) then Exit;

+    glWindowPos2s := SDL_GL_GetProcAddress('glWindowPos2s');

+    if not Assigned(glWindowPos2s) then Exit;

+    glWindowPos2sv := SDL_GL_GetProcAddress('glWindowPos2sv');

+    if not Assigned(glWindowPos2sv) then Exit;

+    glWindowPos3d := SDL_GL_GetProcAddress('glWindowPos3d');

+    if not Assigned(glWindowPos3d) then Exit;

+    glWindowPos3dv := SDL_GL_GetProcAddress('glWindowPos3dv');

+    if not Assigned(glWindowPos3dv) then Exit;

+    glWindowPos3f := SDL_GL_GetProcAddress('glWindowPos3f');

+    if not Assigned(glWindowPos3f) then Exit;

+    glWindowPos3fv := SDL_GL_GetProcAddress('glWindowPos3fv');

+    if not Assigned(glWindowPos3fv) then Exit;

+    glWindowPos3i := SDL_GL_GetProcAddress('glWindowPos3i');

+    if not Assigned(glWindowPos3i) then Exit;

+    glWindowPos3iv := SDL_GL_GetProcAddress('glWindowPos3iv');

+    if not Assigned(glWindowPos3iv) then Exit;

+    glWindowPos3s := SDL_GL_GetProcAddress('glWindowPos3s');

+    if not Assigned(glWindowPos3s) then Exit;

+    glWindowPos3sv := SDL_GL_GetProcAddress('glWindowPos3sv');

+    if not Assigned(glWindowPos3sv) then Exit;

+    Result := TRUE;

+

+end;

+

+function Load_GL_version_1_5: Boolean;

+var

+  extstring: String;

+begin

+

+  Result := FALSE;

+  extstring := String(PChar(glGetString(GL_EXTENSIONS)));

+

+    glGenQueries := SDL_GL_GetProcAddress('glGenQueries');

+    if not Assigned(glGenQueries) then Exit;

+    glDeleteQueries := SDL_GL_GetProcAddress('glDeleteQueries');

+    if not Assigned(glDeleteQueries) then Exit;

+    glIsQuery := SDL_GL_GetProcAddress('glIsQuery');

+    if not Assigned(glIsQuery) then Exit;

+    glBeginQuery := SDL_GL_GetProcAddress('glBeginQuery');

+    if not Assigned(glBeginQuery) then Exit;

+    glEndQuery := SDL_GL_GetProcAddress('glEndQuery');

+    if not Assigned(glEndQuery) then Exit;

+    glGetQueryiv := SDL_GL_GetProcAddress('glGetQueryiv');

+    if not Assigned(glGetQueryiv) then Exit;

+    glGetQueryObjectiv := SDL_GL_GetProcAddress('glGetQueryObjectiv');

+    if not Assigned(glGetQueryObjectiv) then Exit;

+    glGetQueryObjectuiv := SDL_GL_GetProcAddress('glGetQueryObjectuiv');

+    if not Assigned(glGetQueryObjectuiv) then Exit;

+    glBindBuffer := SDL_GL_GetProcAddress('glBindBuffer');

+    if not Assigned(glBindBuffer) then Exit;

+    glDeleteBuffers := SDL_GL_GetProcAddress('glDeleteBuffers');

+    if not Assigned(glDeleteBuffers) then Exit;

+    glGenBuffers := SDL_GL_GetProcAddress('glGenBuffers');

+    if not Assigned(glGenBuffers) then Exit;

+    glIsBuffer := SDL_GL_GetProcAddress('glIsBuffer');

+    if not Assigned(glIsBuffer) then Exit;

+    glBufferData := SDL_GL_GetProcAddress('glBufferData');

+    if not Assigned(glBufferData) then Exit;

+    glBufferSubData := SDL_GL_GetProcAddress('glBufferSubData');

+    if not Assigned(glBufferSubData) then Exit;

+    glGetBufferSubData := SDL_GL_GetProcAddress('glGetBufferSubData');

+    if not Assigned(glGetBufferSubData) then Exit;

+    glMapBuffer := SDL_GL_GetProcAddress('glMapBuffer');

+    if not Assigned(glMapBuffer) then Exit;

+    glUnmapBuffer := SDL_GL_GetProcAddress('glUnmapBuffer');

+    if not Assigned(glUnmapBuffer) then Exit;

+    glGetBufferParameteriv := SDL_GL_GetProcAddress('glGetBufferParameteriv');

+    if not Assigned(glGetBufferParameteriv) then Exit;

+    glGetBufferPointerv := SDL_GL_GetProcAddress('glGetBufferPointerv');

+    if not Assigned(glGetBufferPointerv) then Exit;

+    Result := TRUE;

+

+end;

+

+function Load_GL_version_2_0: Boolean;

+var

+  extstring: String;

+begin

+

+  Result := FALSE;

+  extstring := String(PChar(glGetString(GL_EXTENSIONS)));

+

+    glBlendEquationSeparate := SDL_GL_GetProcAddress('glBlendEquationSeparate');

+    if not Assigned(glBlendEquationSeparate) then Exit;

+    glDrawBuffers := SDL_GL_GetProcAddress('glDrawBuffers');

+    if not Assigned(glDrawBuffers) then Exit;

+    glStencilOpSeparate := SDL_GL_GetProcAddress('glStencilOpSeparate');

+    if not Assigned(glStencilOpSeparate) then Exit;

+    glStencilFuncSeparate := SDL_GL_GetProcAddress('glStencilFuncSeparate');

+    if not Assigned(glStencilFuncSeparate) then Exit;

+    glStencilMaskSeparate := SDL_GL_GetProcAddress('glStencilMaskSeparate');

+    if not Assigned(glStencilMaskSeparate) then Exit;

+    glAttachShader := SDL_GL_GetProcAddress('glAttachShader');

+    if not Assigned(glAttachShader) then Exit;

+    glBindAttribLocation := SDL_GL_GetProcAddress('glBindAttribLocation');

+    if not Assigned(glBindAttribLocation) then Exit;

+    glCompileShader := SDL_GL_GetProcAddress('glCompileShader');

+    if not Assigned(glCompileShader) then Exit;

+    glCreateProgram := SDL_GL_GetProcAddress('glCreateProgram');

+    if not Assigned(glCreateProgram) then Exit;

+    glCreateShader := SDL_GL_GetProcAddress('glCreateShader');

+    if not Assigned(glCreateShader) then Exit;

+    glDeleteProgram := SDL_GL_GetProcAddress('glDeleteProgram');

+    if not Assigned(glDeleteProgram) then Exit;

+    glDeleteShader := SDL_GL_GetProcAddress('glDeleteShader');

+    if not Assigned(glDeleteShader) then Exit;

+    glDetachShader := SDL_GL_GetProcAddress('glDetachShader');

+    if not Assigned(glDetachShader) then Exit;

+    glDisableVertexAttribArray := SDL_GL_GetProcAddress('glDisableVertexAttribArray');

+    if not Assigned(glDisableVertexAttribArray) then Exit;

+    glEnableVertexAttribArray := SDL_GL_GetProcAddress('glEnableVertexAttribArray');

+    if not Assigned(glEnableVertexAttribArray) then Exit;

+    glGetActiveAttrib := SDL_GL_GetProcAddress('glGetActiveAttrib');

+    if not Assigned(glGetActiveAttrib) then Exit;

+    glGetActiveUniform := SDL_GL_GetProcAddress('glGetActiveUniform');

+    if not Assigned(glGetActiveUniform) then Exit;

+    glGetAttachedShaders := SDL_GL_GetProcAddress('glGetAttachedShaders');

+    if not Assigned(glGetAttachedShaders) then Exit;

+    glGetAttribLocation := SDL_GL_GetProcAddress('glGetAttribLocation');

+    if not Assigned(glGetAttribLocation) then Exit;

+    glGetProgramiv := SDL_GL_GetProcAddress('glGetProgramiv');

+    if not Assigned(glGetProgramiv) then Exit;

+    glGetProgramInfoLog := SDL_GL_GetProcAddress('glGetProgramInfoLog');

+    if not Assigned(glGetProgramInfoLog) then Exit;

+    glGetShaderiv := SDL_GL_GetProcAddress('glGetShaderiv');

+    if not Assigned(glGetShaderiv) then Exit;

+    glGetShaderInfoLog := SDL_GL_GetProcAddress('glGetShaderInfoLog');

+    if not Assigned(glGetShaderInfoLog) then Exit;

+    glGetShaderSource := SDL_GL_GetProcAddress('glGetShaderSource');

+    if not Assigned(glGetShaderSource) then Exit;

+    glGetUniformLocation := SDL_GL_GetProcAddress('glGetUniformLocation');

+    if not Assigned(glGetUniformLocation) then Exit;

+    glGetUniformfv := SDL_GL_GetProcAddress('glGetUniformfv');

+    if not Assigned(glGetUniformfv) then Exit;

+    glGetUniformiv := SDL_GL_GetProcAddress('glGetUniformiv');

+    if not Assigned(glGetUniformiv) then Exit;

+    glGetVertexAttribdv := SDL_GL_GetProcAddress('glGetVertexAttribdv');

+    if not Assigned(glGetVertexAttribdv) then Exit;

+    glGetVertexAttribfv := SDL_GL_GetProcAddress('glGetVertexAttribfv');

+    if not Assigned(glGetVertexAttribfv) then Exit;

+    glGetVertexAttribiv := SDL_GL_GetProcAddress('glGetVertexAttribiv');

+    if not Assigned(glGetVertexAttribiv) then Exit;

+    glGetVertexAttribPointerv := SDL_GL_GetProcAddress('glGetVertexAttribPointerv');

+    if not Assigned(glGetVertexAttribPointerv) then Exit;

+    glIsProgram := SDL_GL_GetProcAddress('glIsProgram');

+    if not Assigned(glIsProgram) then Exit;

+    glIsShader := SDL_GL_GetProcAddress('glIsShader');

+    if not Assigned(glIsShader) then Exit;

+    glLinkProgram := SDL_GL_GetProcAddress('glLinkProgram');

+    if not Assigned(glLinkProgram) then Exit;

+    glShaderSource := SDL_GL_GetProcAddress('glShaderSource');

+    if not Assigned(glShaderSource) then Exit;

+    glUseProgram := SDL_GL_GetProcAddress('glUseProgram');

+    if not Assigned(glUseProgram) then Exit;

+    glUniform1f := SDL_GL_GetProcAddress('glUniform1f');

+    if not Assigned(glUniform1f) then Exit;

+    glUniform2f := SDL_GL_GetProcAddress('glUniform2f');

+    if not Assigned(glUniform2f) then Exit;

+    glUniform3f := SDL_GL_GetProcAddress('glUniform3f');

+    if not Assigned(glUniform3f) then Exit;

+    glUniform4f := SDL_GL_GetProcAddress('glUniform4f');

+    if not Assigned(glUniform4f) then Exit;

+    glUniform1i := SDL_GL_GetProcAddress('glUniform1i');

+    if not Assigned(glUniform1i) then Exit;

+    glUniform2i := SDL_GL_GetProcAddress('glUniform2i');

+    if not Assigned(glUniform2i) then Exit;

+    glUniform3i := SDL_GL_GetProcAddress('glUniform3i');

+    if not Assigned(glUniform3i) then Exit;

+    glUniform4i := SDL_GL_GetProcAddress('glUniform4i');

+    if not Assigned(glUniform4i) then Exit;

+    glUniform1fv := SDL_GL_GetProcAddress('glUniform1fv');

+    if not Assigned(glUniform1fv) then Exit;

+    glUniform2fv := SDL_GL_GetProcAddress('glUniform2fv');

+    if not Assigned(glUniform2fv) then Exit;

+    glUniform3fv := SDL_GL_GetProcAddress('glUniform3fv');

+    if not Assigned(glUniform3fv) then Exit;

+    glUniform4fv := SDL_GL_GetProcAddress('glUniform4fv');

+    if not Assigned(glUniform4fv) then Exit;

+    glUniform1iv := SDL_GL_GetProcAddress('glUniform1iv');

+    if not Assigned(glUniform1iv) then Exit;

+    glUniform2iv := SDL_GL_GetProcAddress('glUniform2iv');

+    if not Assigned(glUniform2iv) then Exit;

+    glUniform3iv := SDL_GL_GetProcAddress('glUniform3iv');

+    if not Assigned(glUniform3iv) then Exit;

+    glUniform4iv := SDL_GL_GetProcAddress('glUniform4iv');

+    if not Assigned(glUniform4iv) then Exit;

+    glUniformMatrix2fv := SDL_GL_GetProcAddress('glUniformMatrix2fv');

+    if not Assigned(glUniformMatrix2fv) then Exit;

+    glUniformMatrix3fv := SDL_GL_GetProcAddress('glUniformMatrix3fv');

+    if not Assigned(glUniformMatrix3fv) then Exit;

+    glUniformMatrix4fv := SDL_GL_GetProcAddress('glUniformMatrix4fv');

+    if not Assigned(glUniformMatrix4fv) then Exit;

+    glValidateProgram := SDL_GL_GetProcAddress('glValidateProgram');

+    if not Assigned(glValidateProgram) then Exit;

+    glVertexAttrib1d := SDL_GL_GetProcAddress('glVertexAttrib1d');

+    if not Assigned(glVertexAttrib1d) then Exit;

+    glVertexAttrib1dv := SDL_GL_GetProcAddress('glVertexAttrib1dv');

+    if not Assigned(glVertexAttrib1dv) then Exit;

+    glVertexAttrib1f := SDL_GL_GetProcAddress('glVertexAttrib1f');

+    if not Assigned(glVertexAttrib1f) then Exit;

+    glVertexAttrib1fv := SDL_GL_GetProcAddress('glVertexAttrib1fv');

+    if not Assigned(glVertexAttrib1fv) then Exit;

+    glVertexAttrib1s := SDL_GL_GetProcAddress('glVertexAttrib1s');

+    if not Assigned(glVertexAttrib1s) then Exit;

+    glVertexAttrib1sv := SDL_GL_GetProcAddress('glVertexAttrib1sv');

+    if not Assigned(glVertexAttrib1sv) then Exit;

+    glVertexAttrib2d := SDL_GL_GetProcAddress('glVertexAttrib2d');

+    if not Assigned(glVertexAttrib2d) then Exit;

+    glVertexAttrib2dv := SDL_GL_GetProcAddress('glVertexAttrib2dv');

+    if not Assigned(glVertexAttrib2dv) then Exit;

+    glVertexAttrib2f := SDL_GL_GetProcAddress('glVertexAttrib2f');

+    if not Assigned(glVertexAttrib2f) then Exit;

+    glVertexAttrib2fv := SDL_GL_GetProcAddress('glVertexAttrib2fv');

+    if not Assigned(glVertexAttrib2fv) then Exit;

+    glVertexAttrib2s := SDL_GL_GetProcAddress('glVertexAttrib2s');

+    if not Assigned(glVertexAttrib2s) then Exit;

+    glVertexAttrib2sv := SDL_GL_GetProcAddress('glVertexAttrib2sv');

+    if not Assigned(glVertexAttrib2sv) then Exit;

+    glVertexAttrib3d := SDL_GL_GetProcAddress('glVertexAttrib3d');

+    if not Assigned(glVertexAttrib3d) then Exit;

+    glVertexAttrib3dv := SDL_GL_GetProcAddress('glVertexAttrib3dv');

+    if not Assigned(glVertexAttrib3dv) then Exit;

+    glVertexAttrib3f := SDL_GL_GetProcAddress('glVertexAttrib3f');

+    if not Assigned(glVertexAttrib3f) then Exit;

+    glVertexAttrib3fv := SDL_GL_GetProcAddress('glVertexAttrib3fv');

+    if not Assigned(glVertexAttrib3fv) then Exit;

+    glVertexAttrib3s := SDL_GL_GetProcAddress('glVertexAttrib3s');

+    if not Assigned(glVertexAttrib3s) then Exit;

+    glVertexAttrib3sv := SDL_GL_GetProcAddress('glVertexAttrib3sv');

+    if not Assigned(glVertexAttrib3sv) then Exit;

+    glVertexAttrib4Nbv := SDL_GL_GetProcAddress('glVertexAttrib4Nbv');

+    if not Assigned(glVertexAttrib4Nbv) then Exit;

+    glVertexAttrib4Niv := SDL_GL_GetProcAddress('glVertexAttrib4Niv');

+    if not Assigned(glVertexAttrib4Niv) then Exit;

+    glVertexAttrib4Nsv := SDL_GL_GetProcAddress('glVertexAttrib4Nsv');

+    if not Assigned(glVertexAttrib4Nsv) then Exit;

+    glVertexAttrib4Nub := SDL_GL_GetProcAddress('glVertexAttrib4Nub');

+    if not Assigned(glVertexAttrib4Nub) then Exit;

+    glVertexAttrib4Nubv := SDL_GL_GetProcAddress('glVertexAttrib4Nubv');

+    if not Assigned(glVertexAttrib4Nubv) then Exit;

+    glVertexAttrib4Nuiv := SDL_GL_GetProcAddress('glVertexAttrib4Nuiv');

+    if not Assigned(glVertexAttrib4Nuiv) then Exit;

+    glVertexAttrib4Nusv := SDL_GL_GetProcAddress('glVertexAttrib4Nusv');

+    if not Assigned(glVertexAttrib4Nusv) then Exit;

+    glVertexAttrib4bv := SDL_GL_GetProcAddress('glVertexAttrib4bv');

+    if not Assigned(glVertexAttrib4bv) then Exit;

+    glVertexAttrib4d := SDL_GL_GetProcAddress('glVertexAttrib4d');

+    if not Assigned(glVertexAttrib4d) then Exit;

+    glVertexAttrib4dv := SDL_GL_GetProcAddress('glVertexAttrib4dv');

+    if not Assigned(glVertexAttrib4dv) then Exit;

+    glVertexAttrib4f := SDL_GL_GetProcAddress('glVertexAttrib4f');

+    if not Assigned(glVertexAttrib4f) then Exit;

+    glVertexAttrib4fv := SDL_GL_GetProcAddress('glVertexAttrib4fv');

+    if not Assigned(glVertexAttrib4fv) then Exit;

+    glVertexAttrib4iv := SDL_GL_GetProcAddress('glVertexAttrib4iv');

+    if not Assigned(glVertexAttrib4iv) then Exit;

+    glVertexAttrib4s := SDL_GL_GetProcAddress('glVertexAttrib4s');

+    if not Assigned(glVertexAttrib4s) then Exit;

+    glVertexAttrib4sv := SDL_GL_GetProcAddress('glVertexAttrib4sv');

+    if not Assigned(glVertexAttrib4sv) then Exit;

+    glVertexAttrib4ubv := SDL_GL_GetProcAddress('glVertexAttrib4ubv');

+    if not Assigned(glVertexAttrib4ubv) then Exit;

+    glVertexAttrib4uiv := SDL_GL_GetProcAddress('glVertexAttrib4uiv');

+    if not Assigned(glVertexAttrib4uiv) then Exit;

+    glVertexAttrib4usv := SDL_GL_GetProcAddress('glVertexAttrib4usv');

+    if not Assigned(glVertexAttrib4usv) then Exit;

+    glVertexAttribPointer := SDL_GL_GetProcAddress('glVertexAttribPointer');

+    if not Assigned(glVertexAttribPointer) then Exit;

+    Result := TRUE;

+

+end;

+

+function glext_LoadExtension(ext: String): Boolean;

 begin

 

   Result := FALSE;

@@ -8339,7 +9379,7 @@ begin
   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}

+  {$IFDEF WINDOWS}

   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}

@@ -8425,7 +9465,7 @@ begin
   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}

+  {$IFDEF WINDOWS}

   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

@@ -8463,7 +9503,7 @@ begin
   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}

+  {$IFDEF WINDOWS}

   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

@@ -8483,14 +9523,14 @@ begin
   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}

+  {$IFDEF WINDOWS}

   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}

+  {$IFDEF WINDOWS}

   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

@@ -8521,6 +9561,17 @@ begin
   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

+  else if ext = 'GL_ARB_draw_buffers' then Result := Load_GL_ARB_draw_buffers

+  else if ext = 'GL_ARB_texture_rectangle' then Result := Load_GL_ARB_texture_rectangle

+  else if ext = 'GL_ARB_color_buffer_float' then Result := Load_GL_ARB_color_buffer_float

+  else if ext = 'GL_ARB_half_float_pixel' then Result := Load_GL_ARB_half_float_pixel

+  else if ext = 'GL_ARB_texture_float' then Result := Load_GL_ARB_texture_float

+  else if ext = 'GL_EXT_texture_compression_dxt1' then Result := Load_GL_EXT_texture_compression_dxt1

+  else if ext = 'GL_ARB_pixel_buffer_object' then Result := Load_GL_ARB_pixel_buffer_object

+  else if ext = 'GL_EXT_framebuffer_object' then Result := Load_GL_EXT_framebuffer_object

+  else if ext = 'GL_version_1_4' then Result := Load_GL_version_1_4

+  else if ext = 'GL_version_1_5' then Result := Load_GL_version_1_5

+  else if ext = 'GL_version_2_0' then Result := Load_GL_version_2_0

 

 end;

 

diff --git a/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glu.pas b/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glu.pas
index fb48f65d..371ccdda 100644
--- a/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glu.pas
+++ b/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glu.pas
@@ -1,6 +1,6 @@
 unit glu;

 {

-  $Id: glu.pas,v 1.3 2004/10/07 21:01:29 savage Exp $

+  $Id: glu.pas,v 1.8 2007/05/20 20:28:31 savage Exp $

 

   Adaption of the delphi3d.net OpenGL units to FreePascal

   Sebastian Guenther (sg@freepascal.org) in 2002

@@ -62,6 +62,21 @@ Abstract:
 

 {

   $Log: glu.pas,v $

+  Revision 1.8  2007/05/20 20:28:31  savage

+  Initial Changes to Handle 64 Bits

+

+  Revision 1.7  2006/11/26 16:35:49  savage

+  Messed up the last change to GLUtessCombineDataProc, had to reapply it. Thanks Michalis.

+

+  Revision 1.6  2006/11/25 23:38:02  savage

+  Changes as proposed by Michalis Kamburelis for better FPC support

+

+  Revision 1.5  2006/11/20 21:20:59  savage

+  Updated to work in MacOS X

+

+  Revision 1.4  2005/05/22 18:52:09  savage

+  Changes as suggested by Michalis Kamburelis. Thanks again.

+

   Revision 1.3  2004/10/07 21:01:29  savage

   Fix for FPC

 

@@ -117,156 +132,159 @@ uses
   gl;

 

 const

-{$IFDEF WIN32}

-  GLuLibName = 'glu32.dll';

+{$IFDEF WINDOWS}

+  GLuLibName   = 'glu32.dll';

 {$ENDIF}

 

 {$IFDEF UNIX}

 {$IFDEF DARWIN}

-  GLuLibName = 'libGLU.dylib';

+  GLuLibName   = '/System/Library/Frameworks/OpenGL.framework/Libraries/libGLU.dylib';

 {$ELSE}

-  GLuLibName = 'libGLU.so';

+  GLuLibName   = 'libGLU.so';

 {$ENDIF}

 {$ENDIF}

 

 type

-  TViewPortArray = array [0..3] of GLint;

-  T16dArray = array [0..15] of GLdouble;

+  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__}

+  T3dArray = array[ 0..2 ] of GLdouble;

+  T4pArray = array[ 0..3 ] of Pointer;

+  T4fArray = array[ 0..3 ] of GLfloat;

+{$IFNDEF __GPC__}

   PPointer = ^Pointer;

-  {$ENDIF}

+{$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}

+  gluErrorString : function( errCode : GLenum ) : PChar; {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluErrorUnicodeStringEXT : function( errCode : GLenum ) : PWideChar; {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluGetString : function( name : GLenum ) : PChar; {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluOrtho2D   : procedure( left, right, bottom, top : GLdouble ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluPerspective : procedure( fovy, aspect, zNear, zFar : GLdouble ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluPickMatrix : procedure( x, y, width, height : GLdouble; var viewport : TViewPortArray ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluLookAt    : procedure( eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz : GLdouble ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluProject   : function( objx, objy, objz : GLdouble; var modelMatrix, projMatrix : T16dArray; var viewport : TViewPortArray; winx, winy, winz : PGLdouble ) : Integer; {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluUnProject : function( winx, winy, winz : GLdouble; var modelMatrix, projMatrix : T16dArray; var viewport : TViewPortArray; objx, objy, objz : PGLdouble ) : Integer; {$IFDEF WINDOWS}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 WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluBuild1DMipmaps : function( target : GLenum; components, width : GLint; format, atype : GLenum; const data : Pointer ) : Integer; {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluBuild2DMipmaps : function( target : GLenum; components, width, height : GLint; format, atype : GLenum; const data : Pointer ) : Integer; {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

 

 type

-  GLUnurbs = record end;                PGLUnurbs = ^GLUnurbs;

-  GLUquadric = record end;              PGLUquadric = ^GLUquadric;

-  GLUtesselator = record end;           PGLUtesselator = ^GLUtesselator;

+  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;

+  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}

+  gluNewQuadric : function : PGLUquadric; {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluDeleteQuadric : procedure( state : PGLUquadric ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluQuadricNormals : procedure( quadObject : PGLUquadric; normals : GLenum ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluQuadricTexture : procedure( quadObject : PGLUquadric; textureCoords : GLboolean ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluQuadricOrientation : procedure( quadObject : PGLUquadric; orientation : GLenum ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluQuadricDrawStyle : procedure( quadObject : PGLUquadric; drawStyle : GLenum ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluCylinder  : procedure( qobj : PGLUquadric; baseRadius, topRadius, height : GLdouble; slices, stacks : GLint ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluDisk      : procedure( qobj : PGLUquadric; innerRadius, outerRadius : GLdouble; slices, loops : GLint ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluPartialDisk : procedure( qobj : PGLUquadric; innerRadius, outerRadius : GLdouble; slices, loops : GLint; startAngle, sweepAngle : GLdouble ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluSphere    : procedure( qobj : PGLuquadric; radius : GLdouble; slices, stacks : GLint ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluQuadricCallback : procedure( qobj : PGLUquadric; which : GLenum; fn : TCallBack ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluNewTess   : function : PGLUtesselator; {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluDeleteTess : procedure( tess : PGLUtesselator ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluTessBeginPolygon : procedure( tess : PGLUtesselator; polygon_data : Pointer ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluTessBeginContour : procedure( tess : PGLUtesselator ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluTessVertex : procedure( tess : PGLUtesselator; var coords : T3dArray; data : Pointer ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluTessEndContour : procedure( tess : PGLUtesselator ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluTessEndPolygon : procedure( tess : PGLUtesselator ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluTessProperty : procedure( tess : PGLUtesselator; which : GLenum; value : GLdouble ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluTessNormal : procedure( tess : PGLUtesselator; x, y, z : GLdouble ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluTessCallback : procedure( tess : PGLUtesselator; which : GLenum; fn : TCallBack ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluGetTessProperty : procedure( tess : PGLUtesselator; which : GLenum; value : PGLdouble ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluNewNurbsRenderer : function : PGLUnurbs; {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluDeleteNurbsRenderer : procedure( nobj : PGLUnurbs ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluBeginSurface : procedure( nobj : PGLUnurbs ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluBeginCurve : procedure( nobj : PGLUnurbs ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluEndCurve  : procedure( nobj : PGLUnurbs ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluEndSurface : procedure( nobj : PGLUnurbs ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluBeginTrim : procedure( nobj : PGLUnurbs ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluEndTrim   : procedure( nobj : PGLUnurbs ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluPwlCurve  : procedure( nobj : PGLUnurbs; count : GLint; aarray : PGLfloat; stride : GLint; atype : GLenum ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluNurbsCurve : procedure( nobj : PGLUnurbs; nknots : GLint; knot : PGLfloat; stride : GLint; ctlarray : PGLfloat; order : GLint; atype : GLenum ); {$IFDEF WINDOWS}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 WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluLoadSamplingMatrices : procedure( nobj : PGLUnurbs; var modelMatrix, projMatrix : T16dArray; var viewport : TViewPortArray ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluNurbsProperty : procedure( nobj : PGLUnurbs; aproperty : GLenum; value : GLfloat ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluGetNurbsProperty : procedure( nobj : PGLUnurbs; aproperty : GLenum; value : PGLfloat ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluNurbsCallback : procedure( nobj : PGLUnurbs; which : GLenum; fn : TCallBack ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

 

 (**** Callback function prototypes ****)

 

 type

   // gluQuadricCallback

-  GLUquadricErrorProc = procedure(p: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUquadricErrorProc = procedure( p : GLenum ); {$IFDEF WINDOWS}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}

+  GLUtessBeginProc = procedure( p : GLenum ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessEdgeFlagProc = procedure( p : GLboolean ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessVertexProc = procedure( p : Pointer ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessEndProc = procedure; {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessErrorProc = procedure( p : GLenum ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessCombineProc = procedure( var p1 : T3dArray; p2 : T4pArray; p3 : T4fArray; p4 : PPointer ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessBeginDataProc = procedure( p1 : GLenum; p2 : Pointer ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessEdgeFlagDataProc = procedure( p1 : GLboolean; p2 : Pointer ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessVertexDataProc = procedure( p1, p2 : Pointer ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessEndDataProc = procedure( p : Pointer ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessErrorDataProc = procedure( p1 : GLenum; p2 : Pointer ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  GLUtessCombineDataProc = procedure( var p1 : T3dArray; var p2 : T4pArray; var p3 : T4fArray;

+    p4 : PPointer; p5 : Pointer ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

 

   // gluNurbsCallback

-  GLUnurbsErrorProc = procedure(p: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUnurbsErrorProc = procedure( p : GLenum ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

 

 

 //***           Generic constants               ****/

 

 const

   // Version

-  GLU_VERSION_1_1                 = 1;

-  GLU_VERSION_1_2                 = 1;

+  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;

+  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;

+  GLU_VERSION  = 100800;

+  GLU_EXTENSIONS = 100801;

 

   // Boolean

-  GLU_TRUE                        = GL_TRUE;

-  GLU_FALSE                       = GL_FALSE;

+  GLU_TRUE     = GL_TRUE;

+  GLU_FALSE    = GL_FALSE;

 

 

   //***           Quadric constants               ****/

 

   // QuadricNormal

-  GLU_SMOOTH              = 100000;

-  GLU_FLAT                = 100001;

-  GLU_NONE                = 100002;

+  GLU_SMOOTH   = 100000;

+  GLU_FLAT     = 100001;

+  GLU_NONE     = 100002;

 

   // QuadricDrawStyle

-  GLU_POINT               = 100010;

-  GLU_LINE                = 100011;

-  GLU_FILL                = 100012;

-  GLU_SILHOUETTE          = 100013;

+  GLU_POINT    = 100010;

+  GLU_LINE     = 100011;

+  GLU_FILL     = 100012;

+  GLU_SILHOUETTE = 100013;

 

   // QuadricOrientation

-  GLU_OUTSIDE             = 100020;

-  GLU_INSIDE              = 100021;

+  GLU_OUTSIDE  = 100020;

+  GLU_INSIDE   = 100021;

 

   // Callback types:

   //      GLU_ERROR       = 100103;

@@ -274,161 +292,161 @@ const
 

   //***           Tesselation constants           ****/

 

-  GLU_TESS_MAX_COORD              = 1.0e150;

+  GLU_TESS_MAX_COORD = 1.0E150;

 

   // TessProperty

-  GLU_TESS_WINDING_RULE           = 100140;

-  GLU_TESS_BOUNDARY_ONLY          = 100141;

-  GLU_TESS_TOLERANCE              = 100142;

+  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;

+  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],

+  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,

+  GLU_TESS_BEGIN_DATA = 100106; { void (CALLBACK*)(GLenum    type,

                                                             void      *polygon_data) }

-  GLU_TESS_VERTEX_DATA    = 100107;    { void (CALLBACK*)(void      *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,

+  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,

+  GLU_TESS_EDGE_FLAG_DATA = 100110; { void (CALLBACK*)(GLboolean boundaryEdge,

                                                             void      *polygon_data) }

-  GLU_TESS_COMBINE_DATA   = 100111;    { void (CALLBACK*)(GLdouble  coords[3],

+  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;

+  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;

+  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;

+  GLU_PATH_LENGTH = 100215;

+  GLU_PARAMETRIC_ERROR = 100216;

+  GLU_DOMAIN_DISTANCE = 100217;

 

 

   // NurbsTrim

-  GLU_MAP1_TRIM_2                 = 100210;

-  GLU_MAP1_TRIM_3                 = 100211;

+  GLU_MAP1_TRIM_2 = 100210;

+  GLU_MAP1_TRIM_3 = 100211;

 

   // NurbsDisplay

   //      GLU_FILL                = 100012;

-  GLU_OUTLINE_POLYGON             = 100240;

-  GLU_OUTLINE_PATCH               = 100241;

+  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;

+  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}

+  gluBeginPolygon : procedure( tess : PGLUtesselator ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluNextContour : procedure( tess : PGLUtesselator; atype : GLenum ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

+  gluEndPolygon : procedure( tess : PGLUtesselator ); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}

 

 const

   // Contours types -- obsolete!

-  GLU_CW          = 100120;

-  GLU_CCW         = 100121;

-  GLU_INTERIOR    = 100122;

-  GLU_EXTERIOR    = 100123;

-  GLU_UNKNOWN     = 100124;

+  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;

+  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 LoadGLu( const dll : PChar );

 procedure FreeGLu;

 

 implementation

 

 var

-  LibGlu: TModuleHandle;

-  

+  LibGlu       : TModuleHandle;

+

 procedure FreeGLu;

 begin

 

@@ -485,70 +503,70 @@ begin
   @gluNextContour := nil;

   @gluEndPolygon := nil;

 

-  UnLoadModule(LibGlu);

+  UnLoadModule( LibGlu );

 

 end;

 

-procedure LoadGLu(const dll: PChar);

+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');

+    @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;

 

@@ -561,3 +579,4 @@ finalization
   FreeGLu;

 

 end.

+

diff --git a/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glut.pas b/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glut.pas
index 2a882a20..3bea3499 100644
--- a/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glut.pas
+++ b/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glut.pas
@@ -1,6 +1,6 @@
 unit glut;

 {

-  $Id: glut.pas,v 1.2 2004/08/14 22:54:30 savage Exp $

+  $Id: glut.pas,v 1.4 2007/05/20 20:28:31 savage Exp $

 

   Adaption of the delphi3d.net OpenGL units to FreePascal

   Sebastian Guenther (sg@freepascal.org) in 2002

@@ -26,6 +26,12 @@ unit glut;
 

 {

   $Log: glut.pas,v $

+  Revision 1.4  2007/05/20 20:28:31  savage

+  Initial Changes to Handle 64 Bits

+

+  Revision 1.3  2006/11/20 21:20:59  savage

+  Updated to work in MacOS X

+

   Revision 1.2  2004/08/14 22:54:30  savage

   Updated so that Library name defines are correctly defined for MacOS X.

 

@@ -63,7 +69,7 @@ uses
   gpc,

 {$ENDIF}

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   Windows,

 {$ENDIF}

   moduleloader,

@@ -74,21 +80,21 @@ type
   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}

+  TGlutVoidCallback = procedure; {$IFNDEF __GPC__}{$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}

+  TGlut1IntCallback = procedure(value: Integer); {$IFNDEF __GPC__}{$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}

+  TGlut2IntCallback = procedure(v1, v2: Integer); {$IFNDEF __GPC__}{$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}

+  TGlut3IntCallback = procedure(v1, v2, v3: Integer); {$IFNDEF __GPC__}{$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}

+  TGlut4IntCallback = procedure(v1, v2, v3, v4: Integer); {$IFNDEF __GPC__}{$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}

+  TGlut1Char2IntCallback = procedure(c: Byte; v1, v2: Integer); {$IFNDEF __GPC__}{$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}{$ENDIF}

 

 const

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   GlutLibName = 'glut32.dll';

 {$ENDIF}

 

 {$IFDEF UNIX}

 {$IFDEF DARWIN}

-  GlutLibName = 'libglut.dylib';

+  GlutLibName = '/System/Library/Frameworks/GLUT.framework/Libraries/libglut.dylib';

 {$ELSE}

   GlutLibName = 'libglut.so';

 {$ENDIF}

@@ -301,139 +307,139 @@ const
 

 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}

+  glutInit: procedure(argcp: PInteger; argv: PPChar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutInitDisplayMode: procedure(mode: Word); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutInitDisplayString: procedure(const str: PChar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutInitWindowPosition: procedure(x, y: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutInitWindowSize: procedure(width, height: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutMainLoop: procedure; {$IFDEF WINDOWS}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}

+  glutCreateWindow: function(const title: PChar): Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutCreateSubWindow: function(win, x, y, width, height: Integer): Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutDestroyWindow: procedure(win: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutPostRedisplay: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutPostWindowRedisplay: procedure(win: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSwapBuffers: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutGetWindow: function: Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSetWindow: procedure(win: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSetWindowTitle: procedure(const title: PChar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSetIconTitle: procedure(const title: PChar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutPositionWindow: procedure(x, y: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutReshapeWindow: procedure(width, height: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutPopWindow: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutPushWindow: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutIconifyWindow: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutShowWindow: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutHideWindow: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutFullScreen: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSetCursor: procedure(cursor: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutWarpPointer: procedure(x, y: Integer); {$IFDEF WINDOWS}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}

+  glutEstablishOverlay: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutRemoveOverlay: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutUseLayer: procedure(layer: GLenum); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutPostOverlayRedisplay: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutPostWindowOverlayRedisplay: procedure(win: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutShowOverlay: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutHideOverlay: procedure; {$IFDEF WINDOWS}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}

+  glutCreateMenu: function(callback: TGlut1IntCallback): Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutDestroyMenu: procedure(menu: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutGetMenu: function: Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSetMenu: procedure(menu: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutAddMenuEntry: procedure(const caption: PChar; value: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutAddSubMenu: procedure(const caption: PChar; submenu: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutChangeToMenuEntry: procedure(item: Integer; const caption: PChar; value: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutChangeToSubMenu: procedure(item: Integer; const caption: PChar; submenu: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutRemoveMenuItem: procedure(item: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutAttachMenu: procedure(button: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutDetachMenu: procedure(button: Integer); {$IFDEF WINDOWS}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}

+  glutDisplayFunc: procedure(f: TGlutVoidCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutReshapeFunc: procedure(f: TGlut2IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutKeyboardFunc: procedure(f: TGlut1Char2IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutMouseFunc: procedure(f: TGlut4IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutMotionFunc: procedure(f: TGlut2IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutPassiveMotionFunc: procedure(f: TGlut2IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutEntryFunc: procedure(f: TGlut1IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutVisibilityFunc: procedure(f: TGlut1IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutIdleFunc: procedure(f: TGlutVoidCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutTimerFunc: procedure(millis: Word; f: TGlut1IntCallback; value: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutMenuStateFunc: procedure(f: TGlut1IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSpecialFunc: procedure(f: TGlut3IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSpaceballMotionFunc: procedure(f: TGlut3IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSpaceballRotateFunc: procedure(f: TGlut3IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSpaceballButtonFunc: procedure(f: TGlut2IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutButtonBoxFunc: procedure(f: TGlut2IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutDialsFunc: procedure(f: TGlut2IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutTabletMotionFunc: procedure(f: TGlut2IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutTabletButtonFunc: procedure(f: TGlut4IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutMenuStatusFunc: procedure(f: TGlut3IntCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutOverlayDisplayFunc: procedure(f:TGlutVoidCallback); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutWindowStatusFunc: procedure(f: TGlut1IntCallback); {$IFDEF WINDOWS}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}

+  glutSetColor: procedure(cell: Integer; red, green, blue: GLfloat); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutGetColor: function(ndx, component: Integer): GLfloat; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutCopyColormap: procedure(win: Integer); {$IFDEF WINDOWS}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}

+  glutGet: function(t: GLenum): Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutDeviceGet: function(t: GLenum): Integer; {$IFDEF WINDOWS}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}

+  glutExtensionSupported: function(const name: PChar): Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutGetModifiers: function: Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutLayerGet: function(t: GLenum): Integer; {$IFDEF WINDOWS}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}

+  glutBitmapCharacter: procedure(font : pointer; character: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutBitmapWidth: function(font : pointer; character: Integer): Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutStrokeCharacter: procedure(font : pointer; character: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutStrokeWidth: function(font : pointer; character: Integer): Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutBitmapLength: function(font: pointer; const str: PChar): Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutStrokeLength: function(font: pointer; const str: PChar): Integer; {$IFDEF WINDOWS}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}

+  glutWireSphere: procedure(radius: GLdouble; slices, stacks: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSolidSphere: procedure(radius: GLdouble; slices, stacks: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutWireCone: procedure(base, height: GLdouble; slices, stacks: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSolidCone: procedure(base, height: GLdouble; slices, stacks: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutWireCube: procedure(size: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSolidCube: procedure(size: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutWireTorus: procedure(innerRadius, outerRadius: GLdouble; sides, rings: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSolidTorus: procedure(innerRadius, outerRadius: GLdouble; sides, rings: GLint); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutWireDodecahedron: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSolidDodecahedron: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutWireTeapot: procedure(size: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSolidTeapot: procedure(size: GLdouble); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutWireOctahedron: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSolidOctahedron: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutWireTetrahedron: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSolidTetrahedron: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutWireIcosahedron: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSolidIcosahedron: procedure; {$IFDEF WINDOWS}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}

+  glutVideoResizeGet: function(param: GLenum): Integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutSetupVideoResizing: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutStopVideoResizing: procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutVideoResize: procedure(x, y, width, height: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutVideoPan: procedure(x, y, width, height: Integer); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

 

 // GLUT debugging sub-API.

-  glutReportErrors: procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutReportErrors: procedure; {$IFDEF WINDOWS}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} 

+  glutGameModeString : procedure (const AString : PChar); {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutEnterGameMode : function : integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutLeaveGameMode : procedure; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF}

+  glutGameModeGet : function (mode : GLenum) : integer; {$IFDEF WINDOWS}stdcall;{$ELSE}cdecl;{$ENDIF} 

 

 procedure LoadGlut(const dll: PChar);

 procedure FreeGlut;

diff --git a/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glx.pas b/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glx.pas
index e478758f..125e3e39 100644
--- a/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glx.pas
+++ b/Game/Code/lib/JEDI-SDL/OpenGL/Pas/glx.pas
@@ -1,6 +1,6 @@
 unit glx;

 {

-  $Id: glx.pas,v 1.1 2004/03/30 21:53:55 savage Exp $

+  $Id: glx.pas,v 1.3 2006/11/20 21:20:59 savage Exp $

 

   Translation of the Mesa GLX headers for FreePascal

   Copyright (C) 1999 Sebastian Guenther

@@ -33,6 +33,12 @@ unit glx;
 

 {

   $Log: glx.pas,v $

+  Revision 1.3  2006/11/20 21:20:59  savage

+  Updated to work in MacOS X

+

+  Revision 1.2  2006/04/18 18:38:33  savage

+  fixed boolean test - thanks grudzio

+

   Revision 1.1  2004/03/30 21:53:55  savage

   Moved to it's own folder.

 

@@ -66,8 +72,6 @@ interface
 

 {$I jedi-sdl.inc}

 

-//{$MACRO ON}

-

 {$IFDEF UNIX}

   uses

     {$IFDEF FPC}

@@ -225,7 +229,7 @@ function InitGLXFromLibrary( dll : PChar ): Boolean;
 begin

   Result := False;

 

-  if LoadModule( libGLX, dll ) then

+  if not LoadModule( libGLX, dll ) then

     exit;

 

   glXChooseVisual := GetModuleSymbol(libglx, 'glXChooseVisual');

diff --git a/Game/Code/lib/JEDI-SDL/SDL/Pas/jedi-sdl.inc b/Game/Code/lib/JEDI-SDL/SDL/Pas/jedi-sdl.inc
index 48a789fd..31283d40 100644
--- a/Game/Code/lib/JEDI-SDL/SDL/Pas/jedi-sdl.inc
+++ b/Game/Code/lib/JEDI-SDL/SDL/Pas/jedi-sdl.inc
@@ -1,5 +1,5 @@
 {

-  $Id: jedi-sdl.inc,v 1.9 2004/12/23 23:42:17 savage Exp $

+  $Id: jedi-sdl.inc,v 1.15 2007/05/29 21:30:48 savage Exp $

 }

 {******************************************************************************}

 {                                                                              }

@@ -74,6 +74,24 @@
 {                                                                              }

 (*

   $Log: jedi-sdl.inc,v $

+  Revision 1.15  2007/05/29 21:30:48  savage

+  Changes as suggested by Almindor for 64bit compatibility.

+

+  Revision 1.14  2007/05/20 20:29:11  savage

+  Initial Changes to Handle 64 Bits

+

+  Revision 1.13  2007/01/21 15:51:45  savage

+  Added Delphi 2006 support

+

+  Revision 1.12  2006/11/19 18:41:01  savage

+  removed THREADING ON flag as it is no longer needed in latest versions of FPC.

+

+  Revision 1.11  2006/01/04 00:52:41  drellis

+  Updated to include defined for ENDIAN values, SDL_BYTEORDER should now be correctly defined depending onthe platform. Code taken from sdl_mixer

+

+  Revision 1.10  2005/05/22 18:42:31  savage

+  Changes as suggested by Michalis Kamburelis. Thanks again.

+

   Revision 1.9  2004/12/23 23:42:17  savage

   Applied Patches supplied by Michalis Kamburelis ( THANKS! ), for greater FreePascal compatability.

 

@@ -148,73 +166,138 @@
 {$IFDEF ver90}

    {$DEFINE Delphi}      {Delphi 2.x}

    {$DEFINE Delphi32}

+   {$DEFINE WIN32}

+   {$DEFINE WINDOWS}

 {$ENDIF ver90}

 

 {$IFDEF ver100}

    {$DEFINE Delphi}      {Delphi 3.x}

    {$DEFINE Delphi32}

    {$DEFINE WIN32}

+   {$DEFINE WINDOWS}

 {$ENDIF ver100}

 

 {$IFDEF ver93}

    {$DEFINE Delphi}      {C++ Builder 1.x}

    {$DEFINE Delphi32}

+   {$DEFINE WINDOWS}

 {$ENDIF ver93}

 

 {$IFDEF ver110}

    {$DEFINE Delphi}      {C++ Builder 3.x}

    {$DEFINE Delphi32}

+   {$DEFINE WINDOWS}

 {$ENDIF ver110}

 

 {$IFDEF ver120}

    {$DEFINE Delphi}      {Delphi 4.x}

    {$DEFINE Delphi32}

+   {$DEFINE Delphi4UP}

    {$DEFINE Has_Int64}

+   {$DEFINE WINDOWS}

 {$ENDIF ver120}

 

 {$IFDEF ver130}

    {$DEFINE Delphi}      {Delphi 5.x}

    {$DEFINE Delphi32}

+   {$DEFINE Delphi4UP}

+   {$DEFINE Delphi5UP}

    {$DEFINE Has_Int64}

+   {$DEFINE WINDOWS}

 {$ENDIF ver130}

 

 {$IFDEF ver140}

    {$DEFINE Delphi}      {Delphi 6.x}

    {$DEFINE Delphi32}

+   {$DEFINE Delphi4UP}

+   {$DEFINE Delphi5UP}

+   {$DEFINE Delphi6UP}

    {$DEFINE Has_Int64}

+   {$DEFINE HAS_TYPES}

 {$ENDIF ver140}

 

 {$IFDEF ver150}

    {$DEFINE Delphi}      {Delphi 7.x}

    {$DEFINE Delphi32}

+   {$DEFINE Delphi4UP}

+   {$DEFINE Delphi5UP}

+   {$DEFINE Delphi6UP}

+   {$DEFINE Delphi7UP}

    {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types in Delphi 7}

    {$DEFINE Has_Int64}

+   {$DEFINE HAS_TYPES}

 {$ENDIF ver150}

 

 {$IFDEF ver160}

-   {$DEFINE Delphi}      {Delphi 8??}

+   {$DEFINE Delphi}      {Delphi 8}

    {$DEFINE Delphi32}

+   {$DEFINE Delphi4UP}

+   {$DEFINE Delphi5UP}

+   {$DEFINE Delphi6UP}

+   {$DEFINE Delphi7UP}

+   {$DEFINE Delphi8UP}

    {$DEFINE Has_Int64}

+   {$DEFINE HAS_TYPES}

 {$ENDIF ver160}

 

 {$IFDEF ver170}

-   {$DEFINE Delphi}      {Delphi 9??}

+   {$DEFINE Delphi}      {Delphi 2005}

    {$DEFINE Delphi32}

+   {$DEFINE Delphi4UP}

+   {$DEFINE Delphi5UP}

+   {$DEFINE Delphi6UP}

+   {$DEFINE Delphi7UP}

+   {$DEFINE Delphi8UP}

+   {$DEFINE Delphi9UP}

    {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types in Delphi 7}

    {$DEFINE Has_Int64}

+   {$DEFINE HAS_TYPES}

 {$ENDIF ver170}

 

-{$IFDEF UNIX}

-  {$ifdef VER150}

-    {$define KYLIX}

-  {$endif}

+{$IFDEF ver180}

+   {$DEFINE Delphi}      {Delphi 2006}

+   {$DEFINE Delphi32}

+   {$DEFINE Delphi4UP}

+   {$DEFINE Delphi5UP}

+   {$DEFINE Delphi6UP}

+   {$DEFINE Delphi7UP}

+   {$DEFINE Delphi8UP}

+   {$DEFINE Delphi9UP}

+   {$DEFINE Delphi10UP}

+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types in Delphi 7}

+   {$DEFINE Has_Int64}

+   {$DEFINE HAS_TYPES}

+{$ENDIF ver180}

+

+{$IFDEF ver185}

+   {$DEFINE Delphi}      {Delphi 2007}

+   {$DEFINE Delphi32}

+   {$DEFINE Delphi4UP}

+   {$DEFINE Delphi5UP}

+   {$DEFINE Delphi6UP}

+   {$DEFINE Delphi7UP}

+   {$DEFINE Delphi8UP}

+   {$DEFINE Delphi9UP}

+   {$DEFINE Delphi10UP}

+   {$WARN UNSAFE_TYPE OFF} {Disable warning for unsafe types in Delphi 7}

+   {$DEFINE Has_Int64}

+   {$DEFINE HAS_TYPES}

+{$ENDIF ver180}

 

-  {$ifdef VER140}

-    {$define KYLIX}

+{$IFDEF UNIX}

+  {$ifdef VER140}    // Kylix 1 & 2

+    {$DEFINE KYLIX}

+    {$DEFINE KYLIX1UP}

+    {$DEFINE KYLIX2UP}

+    {$DEFINE HAS_TYPES}

   {$endif}

 

-  {$ifdef VER140}

-    {$define KYLIX}

+  {$ifdef VER150}   // Kylix 3

+    {$DEFINE KYLIX}

+    {$DEFINE KYLIX1UP}

+    {$DEFINE KYLIX2UP}

+    {$DEFINE KYLIX3UP}

+    {$DEFINE HAS_TYPES}

   {$endif}

 {$ENDIF UNIX}

 

@@ -227,14 +310,14 @@
 {$IFDEF Delphi}

   {$DEFINE Windows}

   {$DEFINE USE_STDCALL}

+  //{$ALIGN ON}

 {$ENDIF Delphi}

 

 {$IFDEF FPC}

   {$MODE Delphi}          { use Delphi compatibility mode }

   {$H+}

-  {$PACKRECORDS 4}        // Added for record

+  {$PACKRECORDS C}        // Added for record

   {$MACRO ON}             // Added For OpenGL

-  {$THREADING on}

   {$DEFINE Delphi}

   {$DEFINE UseAT}

   {$UNDEF USE_STDCALL}

@@ -242,7 +325,7 @@
   {$DEFINE NO_EXPORTS}

   {$DEFINE Has_Int64}

   {$DEFINE NOCRT}

-  {$IFDEF unix}

+  {$IFDEF UNIX}

      {$DEFINE fpc_unix}

   {$ELSE}

      {$DEFINE __OS_DOS__}

@@ -250,6 +333,7 @@
   {$IFDEF WIN32}

    {$DEFINE UseWin}

   {$ENDIF}

+  {$DEFINE HAS_TYPES}

 {$ENDIF FPC}

 

 {$IFDEF Win16}

@@ -335,3 +419,20 @@
 {$IFNDEF ver70}

   {$UNDEF assembler}

 {$ENDIF}

+

+{*************** define LITTLE ENDIAN platforms ********************}

+

+

+{$IFDEF Delphi}

+{$DEFINE IA32}

+{$ENDIF}

+

+{$IFDEF KYLIX}

+{$DEFINE IA32}

+{$ENDIF}

+

+{$IFDEF FPC}

+{$IFDEF FPC_LITTLE_ENDIAN}

+{$DEFINE IA32}

+{$ENDIF}

+{$ENDIF}

diff --git a/Game/Code/lib/JEDI-SDL/SDL/Pas/libxmlparser.pas b/Game/Code/lib/JEDI-SDL/SDL/Pas/libxmlparser.pas
index 54841840..0cdf44c7 100644
--- a/Game/Code/lib/JEDI-SDL/SDL/Pas/libxmlparser.pas
+++ b/Game/Code/lib/JEDI-SDL/SDL/Pas/libxmlparser.pas
@@ -194,8 +194,6 @@ UNIT libxmlparser;
 

 {$I jedi-sdl.inc}

 

-{$ALIGN ON}

-

 INTERFACE

 

 USES

diff --git a/Game/Code/lib/JEDI-SDL/SDL/Pas/logger.pas b/Game/Code/lib/JEDI-SDL/SDL/Pas/logger.pas
index 88bb1698..461fa261 100644
--- a/Game/Code/lib/JEDI-SDL/SDL/Pas/logger.pas
+++ b/Game/Code/lib/JEDI-SDL/SDL/Pas/logger.pas
@@ -1,6 +1,6 @@
 unit logger;

 {

-  $Id: logger.pas,v 1.1 2004/02/05 00:08:20 savage Exp $

+  $Id: logger.pas,v 1.2 2006/11/26 16:58:04 savage Exp $

 

 }

 {******************************************************************************}

@@ -63,6 +63,9 @@ unit logger;
 {******************************************************************************}

 {

   $Log: logger.pas,v $

+  Revision 1.2  2006/11/26 16:58:04  savage

+  Modifed to create separate log files. Therefore each instance running from the same directory will have their own individual log file, prepended with a number.

+

   Revision 1.1  2004/02/05 00:08:20  savage

   Module 1.0 release

 

@@ -107,10 +110,20 @@ implementation
 

 { TLogger }

 constructor TLogger.Create;

+var

+  FileName : string;

+  FileNo : integer;

 begin

   FApplicationName := ExtractFileName( ParamStr(0) );

   FApplicationPath := ExtractFilePath( ParamStr(0) );

-  AssignFile( FFileHandle, FApplicationPath + ChangeFileExt( FApplicationName, '.log' ) );

+  FileName := FApplicationPath + ChangeFileExt( FApplicationName, '.log' );

+  FileNo := 0;

+  while FileExists( FileName ) do

+  begin

+    inc( FileNo );

+    FileName := FApplicationPath + IntToStr( FileNo ) + ChangeFileExt( FApplicationName, '.log' )

+  end;

+  AssignFile( FFileHandle, FileName );

   ReWrite( FFileHandle );

   (*inherited Create( FApplicationPath + ChangeFileExt( FApplicationName, '.log' ),

                     fmCreate {$IFNDEF FPC}or fmShareExclusive{$ENDIF} );*)

diff --git a/Game/Code/lib/JEDI-SDL/SDL/Pas/sdl.pas b/Game/Code/lib/JEDI-SDL/SDL/Pas/sdl.pas
index ad5d783a..29bc7123 100644
--- a/Game/Code/lib/JEDI-SDL/SDL/Pas/sdl.pas
+++ b/Game/Code/lib/JEDI-SDL/SDL/Pas/sdl.pas
@@ -1,6 +1,6 @@
 unit sdl;

 {

-  $Id: sdl.pas,v 1.17 2005/01/03 18:40:59 savage Exp $

+  $Id: sdl.pas,v 1.38 2008/01/26 10:09:32 savage Exp $

 

 }

 {******************************************************************************}

@@ -36,10 +36,10 @@ unit sdl;
 {                          SDL_loadso.h                                        }

 {                                                                              }

 { The initial developer of this Pascal code was :                              }

-{ Dominqiue Louis <Dominique@SavageSoftware.com.au>                            }

+{ Dominique Louis <Dominique@SavageSoftware.com.au>                            }

 {                                                                              }

-{ Portions created by Dominqiue Louis are                                      }

-{ Copyright (C) 2000 - 2004 Dominqiue Louis.                                   }

+{ Portions created by Dominique Louis are                                      }

+{ Copyright (C) 2000 - 2004 Dominique Louis.                                   }

 {                                                                              }

 {                                                                              }

 { Contributor(s)                                                               }

@@ -168,6 +168,63 @@ unit sdl;
 {                                                                              }

 {

   $Log: sdl.pas,v $

+  Revision 1.38  2008/01/26 10:09:32  savage

+  Added SDL_BUTTON_X1 and SDL_BUTTON_X2 constants for extended mouse buttons. Now makes SDL v1.2.13 compliant.

+

+  Revision 1.37  2007/12/20 22:36:56  savage

+  Added SKYOS support, thanks to Sebastian-Torsten Tillmann

+

+  Revision 1.36  2007/12/05 22:52:04  savage

+  Better Mac OS X support for Frameworks.

+

+  Revision 1.35  2007/12/02 22:41:13  savage

+  Change for Mac OS X to link to SDL Framework

+

+  Revision 1.34  2007/08/26 23:50:53  savage

+  Jonas supplied another fix.

+

+  Revision 1.33  2007/08/26 15:59:46  savage

+  Mac OS changes as suggested by Jonas Maebe

+

+  Revision 1.32  2007/08/22 21:18:43  savage

+  Thanks to Dean for his MouseDelta patch.

+

+  Revision 1.31  2007/05/29 21:30:48  savage

+  Changes as suggested by Almindor for 64bit compatibility.

+

+  Revision 1.30  2007/05/29 19:31:03  savage

+  Fix to TSDL_Overlay structure - thanks David Pethes (aka imcold)

+

+  Revision 1.29  2007/05/20 20:29:11  savage

+  Initial Changes to Handle 64 Bits

+

+  Revision 1.26  2007/02/11 13:38:04  savage

+  Added Nintendo DS support - Thanks Dean.

+

+  Revision 1.25  2006/12/02 00:12:52  savage

+  Updated to latest version

+

+  Revision 1.24  2006/05/18 21:10:04  savage

+  Added 1.2.10 Changes

+

+  Revision 1.23  2005/12/04 23:17:52  drellis

+  Added declaration of SInt8 and PSInt8

+

+  Revision 1.22  2005/05/24 21:59:03  savage

+  Re-arranged uses clause to work on Win32 and Linux, Thanks again Michalis.

+

+  Revision 1.21  2005/05/22 18:42:31  savage

+  Changes as suggested by Michalis Kamburelis. Thanks again.

+

+  Revision 1.20  2005/04/10 11:48:33  savage

+  Changes as suggested by Michalis, thanks.

+

+  Revision 1.19  2005/01/05 01:47:06  savage

+  Changed LibName to reflect what MacOS X should have. ie libSDL*-1.2.0.dylib respectively.

+

+  Revision 1.18  2005/01/04 23:14:41  savage

+  Changed LibName to reflect what most Linux distros will have. ie libSDL*-1.2.so.0 respectively.

+

   Revision 1.17  2005/01/03 18:40:59  savage

   Updated Version number to reflect latest one

 

@@ -241,35 +298,54 @@ unit sdl;
 

 {$I jedi-sdl.inc}

 

-{$ALIGN ON}

-

 interface

 

 uses

 {$IFDEF __GPC__}

   system,

+  {$IFDEF WINDOWS}

+  wintypes,

+  {$ELSE}

+  {$ENDIF}

   gpc;

 {$ENDIF}

 

-{$IFDEF WIN32}

-  {$IFNDEF __GPC__}

+{$IFDEF HAS_TYPES}

+  Types{$IFNDEF NDS},{$ELSE};{$ENDIF}

+{$ENDIF}

+

+{$IFDEF WINDOWS}

   Windows;

-  {$ENDIF}

 {$ENDIF}

 

 {$IFDEF UNIX}

   {$IFDEF FPC}

-    {$IFDEF Ver1_0}

-    linux,

-    {$ELSE}

-    pthreads,

-    baseunix,

-    unix,

-    {$ENDIF}

-    x,

-    xlib;

+  {$IFNDEF SKYOS}

+  pthreads,

+  {$ENDIF}

+  baseunix,

+  {$IFNDEF GP2X}

+  {$IFNDEF DARWIN}

+  {$IFNDEF SKYOS}

+  unix,

+  {$ELSE}

+  unix;

+  {$ENDIF}

+  {$ELSE}

+  unix;

+  {$ENDIF}

+  {$ELSE}

+  unix;

+  {$ENDIF}

+  {$IFNDEF GP2X}

+  {$IFNDEF DARWIN}

+  {$IFNDEF SKYOS}

+  x,

+  xlib;

+  {$ENDIF}

+  {$ENDIF}

+  {$ENDIF}

   {$ELSE}

-  Types,

   Libc,

   Xlib;

   {$ENDIF}

@@ -280,22 +356,45 @@ uses
 {$ENDIF}

 

 const

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   SDLLibName = 'SDL.dll';

 {$ENDIF}

 

 {$IFDEF UNIX}

 {$IFDEF DARWIN}

-  SDLLibName = 'libSDL.dylib';

+  SDLLibName = 'libSDL-1.2.0.dylib';

 {$ELSE}

+  {$IFDEF FPC}

   SDLLibName = 'libSDL.so';

+  {$ELSE}

+  SDLLibName = 'libSDL-1.2.so.0';

+  {$ENDIF}

 {$ENDIF}

 {$ENDIF}

 

 {$IFDEF MACOS}

   SDLLibName = 'SDL';

+  {$linklib libSDL}

+{$ENDIF}

+

+{$IFDEF NDS}

+  SDLLibName = 'libSDL.a';

+  {$linklib libSDL.a}

+  {$linklib libnds9.a}

+  {$linklib libc.a}

+  {$linklib libgcc.a}

+  {$linklib libsysbase.a}

 {$ENDIF}

 

+  // SDL_verion.h constants

+  // Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL

+  SDL_MAJOR_VERSION = 1;

+{$EXTERNALSYM SDL_MAJOR_VERSION}

+  SDL_MINOR_VERSION = 2;

+{$EXTERNALSYM SDL_MINOR_VERSION}

+  SDL_PATCHLEVEL    = 13;

+{$EXTERNALSYM SDL_PATCHLEVEL}

+

   // SDL.h constants

   SDL_INIT_TIMER = $00000001;

 {$EXTERNALSYM SDL_INIT_TIMER}

@@ -438,15 +537,6 @@ const
   SDL_HAT_LEFTDOWN = SDL_HAT_LEFT or SDL_HAT_DOWN;

 {$EXTERNALSYM SDL_HAT_LEFTDOWN}

 

-  // SDL_verion.h constants

-  // Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL

-  SDL_MAJOR_VERSION = 1;

-{$EXTERNALSYM SDL_MAJOR_VERSION}

-  SDL_MINOR_VERSION = 2;

-{$EXTERNALSYM SDL_MINOR_VERSION}

-  SDL_PATCHLEVEL    = 8;

-{$EXTERNALSYM SDL_PATCHLEVEL}

-

   // SDL_events.h constants

   SDL_NOEVENT = 0; // Unused (do not remove)

 {$EXTERNALSYM SDL_NOEVENT}

@@ -1059,6 +1149,47 @@ const
   SDLK_EURO = 321; // Some european keyboards

 {$EXTERNALSYM SDLK_EURO}

 

+{$IFDEF GP2X}

+SDLK_GP2X_UP = 0;

+{$EXTERNALSYM SDLK_GP2X_UP}

+SDLK_GP2X_UPLEFT = 1;

+{$EXTERNALSYM SDLK_GP2X_UPLEFT}

+SDLK_GP2X_LEFT = 2;

+{$EXTERNALSYM SDLK_GP2X_LEFT}

+SDLK_GP2X_DOWNLEFT = 3;

+{$EXTERNALSYM SDLK_GP2X_DOWNLEFT}

+SDLK_GP2X_DOWN = 4;

+{$EXTERNALSYM SDLK_GP2X_DOWN}

+SDLK_GP2X_DOWNRIGHT = 5;

+{$EXTERNALSYM SDLK_GP2X_DOWNRIGHT}

+SDLK_GP2X_RIGHT = 6;

+{$EXTERNALSYM SDLK_GP2X_RIGHT}

+SDLK_GP2X_UPRIGHT = 7;

+{$EXTERNALSYM SDLK_GP2X_UPRIGHT}

+SDLK_GP2X_START = 8;

+{$EXTERNALSYM SDLK_GP2X_START}

+SDLK_GP2X_SELECT = 9;

+{$EXTERNALSYM SDLK_GP2X_SELECT}

+SDLK_GP2X_L = 10;

+{$EXTERNALSYM SDLK_GP2X_L}

+SDLK_GP2X_R = 11;

+{$EXTERNALSYM SDLK_GP2X_R}

+SDLK_GP2X_A = 12;

+{$EXTERNALSYM SDLK_GP2X_A}

+SDLK_GP2X_B = 13;

+{$EXTERNALSYM SDLK_GP2X_B}

+SDLK_GP2X_Y = 14;

+{$EXTERNALSYM SDLK_GP2X_Y}

+SDLK_GP2X_X = 15;

+{$EXTERNALSYM SDLK_GP2X_X}

+SDLK_GP2X_VOLUP = 16;

+{$EXTERNALSYM SDLK_GP2X_VOLUP}

+SDLK_GP2X_VOLDOWN = 17;

+{$EXTERNALSYM SDLK_GP2X_VOLDOWN}

+SDLK_GP2X_CLICK = 18;

+{$EXTERNALSYM SDLK_GP2X_CLICK}

+{$ENDIF}

+

   // Enumeration of valid key mods (possibly OR'd together)

   KMOD_NONE = $0000;

 {$EXTERNALSYM KMOD_NONE}

@@ -1173,25 +1304,36 @@ const
     Button 1:	Left mouse button

     Button 2:	Middle mouse button

     Button 3:	Right mouse button

-    Button 4:	Mouse Wheel Up

-    Button 5:	Mouse Wheel Down

+    Button 4:	Mouse Wheel Up (may also be a real button)

+    Button 5:	Mouse Wheel Down (may also be a real button)

+    Button 6:	Mouse X1 (may also be a real button)

+    Button 7:	Mouse X2 (may also be a real button)

   }

-  SDL_BUTTON_LEFT = 1;

+  SDL_BUTTON_LEFT      = 1;

 {$EXTERNALSYM SDL_BUTTON_LEFT}

-  SDL_BUTTON_MIDDLE = 2;

+  SDL_BUTTON_MIDDLE    = 2;

 {$EXTERNALSYM SDL_BUTTON_MIDDLE}

-  SDL_BUTTON_RIGHT = 3;

+  SDL_BUTTON_RIGHT     = 3;

 {$EXTERNALSYM SDL_BUTTON_RIGHT}

-  SDL_BUTTON_WHEELUP = 4;

+  SDL_BUTTON_WHEELUP   = 4;

 {$EXTERNALSYM SDL_BUTTON_WHEELUP}

   SDL_BUTTON_WHEELDOWN = 5;

 {$EXTERNALSYM SDL_BUTTON_WHEELDOWN}

+  SDL_BUTTON_X1        = 6;

+{$EXTERNALSYM SDL_BUTTON_X1}

+  SDL_BUTTON_X2        = 7;

+{$EXTERNALSYM SDL_BUTTON_X2}

+

   SDL_BUTTON_LMASK = SDL_PRESSED shl (SDL_BUTTON_LEFT - 1);

 {$EXTERNALSYM SDL_BUTTON_LMASK}

   SDL_BUTTON_MMASK = SDL_PRESSED shl (SDL_BUTTON_MIDDLE - 1);

 {$EXTERNALSYM SDL_BUTTON_MMASK}

-  SDL_BUTTON_RMask = SDL_PRESSED shl (SDL_BUTTON_RIGHT - 1);

-{$EXTERNALSYM SDL_BUTTON_RMask}

+  SDL_BUTTON_RMASK = SDL_PRESSED shl (SDL_BUTTON_RIGHT - 1);

+{$EXTERNALSYM SDL_BUTTON_RMASK}

+  SDL_BUTTON_X1MASK = SDL_PRESSED shl (SDL_BUTTON_X1 - 1);

+{$EXTERNALSYM SDL_BUTTON_X1MASK}

+  SDL_BUTTON_X2MASK = SDL_PRESSED shl (SDL_BUTTON_X2 - 1);

+{$EXTERNALSYM SDL_BUTTON_X2MASK}

 

   // SDL_active.h constants

   // The available application states

@@ -1233,6 +1375,7 @@ type
 

   PUInt8Array = ^TUInt8Array;

   PUInt8 = ^UInt8;

+  PPUInt8 = ^PUInt8;

   UInt8 = Byte;

 {$EXTERNALSYM UInt8}

   TUInt8Array = array [0..MAXINT shr 1] of UInt8;

@@ -1241,6 +1384,10 @@ type
   UInt16 = word;

 {$EXTERNALSYM UInt16}

 

+  PSInt8 = ^SInt8;

+  SInt8 = Shortint;

+{$EXTERNALSYM SInt8}

+

   PSInt16 = ^SInt16;

   SInt16 = smallint;

 {$EXTERNALSYM SInt16}

@@ -1675,7 +1822,7 @@ type
  {$ENDIF}

 

 // The windows custom event structure

-{$IFDEF Win32}

+{$IFDEF WINDOWS}

   PSDL_SysWMmsg = ^TSDL_SysWMmsg;

   TSDL_SysWMmsg = record

     version: TSDL_version;

@@ -1693,7 +1840,13 @@ type
     version : TSDL_version;

     subsystem : TSDL_SysWm;

     {$IFDEF FPC}

+    {$IFNDEF GP2X}

+    {$IFNDEF DARWIN}

+    {$IFNDEF SKYOS}

     event : TXEvent;

+    {$ENDIF}

+    {$ENDIF}

+    {$ENDIF}

     {$ELSE}

     event : XEvent;

     {$ENDIF}

@@ -1710,7 +1863,7 @@ type
 {$ENDIF}

 

 // The Windows custom window manager information structure

-{$IFDEF Win32}

+{$IFDEF WINDOWS}

   PSDL_SysWMinfo = ^TSDL_SysWMinfo;

   TSDL_SysWMinfo = record

     version : TSDL_version;

@@ -1720,6 +1873,9 @@ type
 

 // The Linux custom window manager information structure

 {$IFDEF Unix}

+  {$IFNDEF GP2X}

+  {$IFNDEF DARWIN}

+  {$IFNDEF SKYOS}

   TX11 = record

     display : PDisplay;	// The X11 display

     window : TWindow ;		// The X11 display window */

@@ -1735,12 +1891,21 @@ type
     fswindow : TWindow ;	// The X11 fullscreen window */

     wmwindow : TWindow ;	// The X11 managed input window */

   end;

-

+  {$ENDIF}

+  {$ENDIF}

+  {$ENDIF}

+  

   PSDL_SysWMinfo = ^TSDL_SysWMinfo;

   TSDL_SysWMinfo = record

      version : TSDL_version ;

      subsystem : TSDL_SysWm;

+     {$IFNDEF GP2X}

+     {$IFNDEF DARWIN}

+     {$IFNDEF SKYOS}

      X11 : TX11;

+     {$ENDIF}

+     {$ENDIF}

+     {$ENDIF}

   end;

 {$ELSE}

   // The generic custom window manager information structure

@@ -1839,7 +2004,7 @@ type
     alpha: UInt8; // Alpha value information (per-surface alpha)

   end;

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   {PPrivate_hwdata = ^TPrivate_hwdata;

   TPrivate_hwdata = record

     dd_surface : IDIRECTDRAWSURFACE3;

@@ -1939,6 +2104,8 @@ type
     UnusedBits3: UInt8; // Unused at this point

     video_mem: UInt32; // The total amount of video memory (in K)

     vfmt: PSDL_PixelFormat; // Value: The format of the video surface

+    current_w : SInt32;	// Value: The current video mode width

+	  current_h : SInt32;	// Value: The current video mode height

   end;

 

   // The YUV hardware video overlay

@@ -1949,8 +2116,8 @@ type
     planes: Integer; // Number of planes in the overlay. Usually either 1 or 3

     pitches: PUInt16;

       // An array of pitches, one for each plane. Pitch is the length of a row in bytes.

-    pixels: PUInt8;

-      // An array of pointers to teh data of each plane. The overlay should be locked before these pointers are used.

+    pixels: PPUInt8;

+      // An array of pointers to the data of each plane. The overlay should be locked before these pointers are used.

     hw_overlay: UInt32;

       // This will be set to 1 if the overlay is hardware accelerated.

   end;

@@ -1971,7 +2138,9 @@ type
     SDL_GL_ACCUM_ALPHA_SIZE,

     SDL_GL_STEREO,

     SDL_GL_MULTISAMPLEBUFFERS,

-    SDL_GL_MULTISAMPLESAMPLES);

+    SDL_GL_MULTISAMPLESAMPLES,

+    SDL_GL_ACCELERATED_VISUAL,

+    SDL_GL_SWAP_CONTROL);

 

 

 

@@ -1987,7 +2156,7 @@ type
 

 // SDL_mutex.h types

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   PSDL_Mutex = ^TSDL_Mutex;

   TSDL_Mutex = record

     id: THANDLE;

@@ -2005,6 +2174,15 @@ type
   end;

 {$ENDIF}

 

+{$IFDEF NDS}

+  PSDL_mutex = ^TSDL_Mutex;

+  TSDL_Mutex = record

+    recursive: Integer;

+    Owner: UInt32;

+    sem: PSDL_sem;

+  end;

+{$ENDIF}

+

 {$IFDEF __MACH__}

   {$define USE_NAMED_SEMAPHORES}

   // Broken sem_getvalue() in MacOS X Public Beta */

@@ -2012,8 +2190,8 @@ type
 {$ENDIF}

 

 PSDL_semaphore = ^TSDL_semaphore;

-{$IFDEF WIN32}

-  // Win32 or Machintosh

+{$IFDEF WINDOWS}

+  // WINDOWS or Machintosh

   TSDL_semaphore = record

     id: THANDLE;

     count: UInt32;

@@ -2065,7 +2243,7 @@ PSDL_semaphore = ^TSDL_semaphore;
   end;

 

   // SDL_thread.h types

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   TSYS_ThreadHandle = THandle;

 {$ENDIF}

 

@@ -2073,6 +2251,10 @@ PSDL_semaphore = ^TSDL_semaphore;
   TSYS_ThreadHandle = pthread_t;

 {$ENDIF}

 

+{$IFDEF NDS}

+  TSYS_ThreadHandle = Integer;

+{$ENDIF}

+

   { This is the system-independent thread info structure }

   PSDL_Thread = ^TSDL_Thread;

   TSDL_Thread = record

@@ -2103,17 +2285,34 @@ PSDL_semaphore = ^TSDL_semaphore;
   TWordArray = array[0..16383] of Word;

 

   PPoint = ^TPoint;

-  TPoint = record

-    x: Longint;

-    y: Longint;

-  end;

+  {$IFDEF HAS_TYPES}

+  TPoint = Types.TPoint;

+  {$ELSE}

+    {$IFDEF WINDOWS}

+      {$IFDEF __GPC__}

+      TPoint = wintypes.TPoint;

+      {$ELSE}

+      TPoint = Windows.TPoint;

+      {$ENDIF}

+    {$ELSE}

+      //Can't define TPoint : neither Types nor Windows unit available.

+    {$ENDIF}

+  {$ENDIF}

 

   PRect = ^TRect;

-  TRect = record

-    case Integer of

-      0: (Left, Top, Right, Bottom: Integer);

-      1: (TopLeft, BottomRight: TPoint);

-  end;

+  {$IFDEF HAS_TYPES}

+  TRect = Types.TRect;

+  {$ELSE}

+    {$IFDEF WINDOWS}

+      {$IFDEF __GPC__}

+      TRect = wintypes.TRect;

+      {$ELSE}

+      TRect = Windows.TRect;

+      {$ENDIF}

+    {$ELSE}

+      //Can't define TRect: neither Types nor Windows unit available.

+    {$ENDIF}

+  {$ENDIF}

 

   { Generic procedure pointer }

   TProcedure = procedure;

@@ -2128,17 +2327,17 @@ PSDL_semaphore = ^TSDL_semaphore;
   signal handlers for some commonly ignored fatal signals (like SIGSEGV) }

 

 function SDL_Init( flags : UInt32 ) : Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_Init}

 

 // This function initializes specific SDL subsystems

 function SDL_InitSubSystem( flags : UInt32 ) : Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_InitSubSystem'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_InitSubSystem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_InitSubSystem}

 

 // This function cleans up specific SDL subsystems

 procedure SDL_QuitSubSystem( flags : UInt32 );

-cdecl; external {$IFDEF __GPC__}name 'SDL_QuitSubSystem'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_QuitSubSystem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_QuitSubSystem}

 

 { This function returns mask of the specified subsystems which have

@@ -2146,26 +2345,26 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_QuitSubSystem'{$ELSE} SDLLibName{$ENDI
   If 'flags' is 0, it returns a mask of all initialized subsystems. }

 

 function SDL_WasInit( flags : UInt32 ): UInt32;

-cdecl; external {$IFDEF __GPC__}name 'SDL_WasInit'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WasInit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_WasInit}

 

 { This function cleans up all initialized subsystems and unloads the

   dynamically linked library.  You should call it upon all exit conditions. }

 procedure SDL_Quit;

-cdecl; external {$IFDEF __GPC__}name 'SDL_Quit'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Quit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_Quit}

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

 // This should be called from your WinMain() function, if any

 function SDL_RegisterApp(name: PChar; style: UInt32; h_Inst: Pointer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_RegisterApp'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RegisterApp'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_RegisterApp}

 {$ENDIF}

 

 {$IFDEF __MACH__}

 // This should be called from your main() function, if any

 procedure SDL_InitQuickDraw( the_qd: QDGlobals );

-cdecl; external {$IFDEF __GPC__}name 'SDL_InitQuickDraw'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_InitQuickDraw'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_InitQuickDraw}

 {$ENDIF}

 

@@ -2183,18 +2382,18 @@ function SDL_TableSize( table: PChar ): Integer;
 {------------------------------------------------------------------------------}

 // Public functions

 function SDL_GetError: PChar;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetError'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetError'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetError}

 procedure SDL_SetError(fmt: PChar);

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetError'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetError'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetError}

 procedure SDL_ClearError;

-cdecl; external {$IFDEF __GPC__}name 'SDL_ClearError'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ClearError'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_ClearError}

 

-{$IFNDEF WIN32}

+{$IFNDEF WINDOWS}

 procedure SDL_Error(Code: TSDL_errorcode);

-cdecl; external {$IFDEF __GPC__}name 'SDL_Error'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Error'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_Error}

 {$ENDIF}

 

@@ -2207,24 +2406,24 @@ procedure SDL_OutOfMemory;
 // Functions to create SDL_RWops structures from various data sources

 

 function SDL_RWFromFile(filename, mode: PChar): PSDL_RWops;

-cdecl; external {$IFDEF __GPC__}name 'SDL_RWFromFile'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromFile'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_RWFromFile}

 procedure SDL_FreeRW(area: PSDL_RWops);

-cdecl; external {$IFDEF __GPC__}name 'SDL_FreeRW'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeRW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_FreeRW}

 

 //fp is FILE *fp ???

 function SDL_RWFromFP(fp: Pointer; autoclose: Integer): PSDL_RWops;

-cdecl; external {$IFDEF __GPC__}name 'SDL_RWFromFP'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromFP'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_RWFromFP}

 function SDL_RWFromMem(mem: Pointer; size: Integer): PSDL_RWops;

-cdecl; external {$IFDEF __GPC__}name 'SDL_RWFromMem'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromMem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_RWFromMem}

 function SDL_RWFromConstMem(const mem: Pointer; size: Integer) : PSDL_RWops;

-cdecl; external {$IFDEF __GPC__}name 'SDL_RWFromConstMem'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromConstMem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_RWFromConstMem}

 function SDL_AllocRW: PSDL_RWops;

-cdecl; external {$IFDEF __GPC__}name 'SDL_AllocRW'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AllocRW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_AllocRW}

 

 function SDL_RWSeek(context: PSDL_RWops; offset: Integer; whence: Integer) : Integer;

@@ -2245,28 +2444,28 @@ function SDL_RWClose(context: PSDL_RWops): Integer;
 { Get the number of milliseconds since the SDL library initialization. }

 { Note that this value wraps if the program runs for more than ~49 days. }

 function SDL_GetTicks: UInt32;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetTicks'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetTicks'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetTicks}

 

 // Wait a specified number of milliseconds before returning

 procedure SDL_Delay(msec: UInt32);

-cdecl; external {$IFDEF __GPC__}name 'SDL_Delay'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Delay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_Delay}

 

 { Add a new timer to the pool of timers already running. }

 { Returns a timer ID, or NULL when an error occurs.      }

 function SDL_AddTimer(interval: UInt32; callback: TSDL_NewTimerCallback; param : Pointer): PSDL_TimerID;

-cdecl; external {$IFDEF __GPC__}name 'SDL_AddTimer'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AddTimer'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_AddTimer}

 

 { Remove one of the multiple timers knowing its ID. }

 { Returns a boolean value indicating success. }

 function SDL_RemoveTimer(t: PSDL_TimerID): TSDL_Bool;

-cdecl; external {$IFDEF __GPC__}name 'SDL_RemoveTimer'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RemoveTimer'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_RemoveTimer}

 

 function SDL_SetTimer(interval: UInt32; callback: TSDL_TimerCallback): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetTimer'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetTimer'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetTimer}

 

 {------------------------------------------------------------------------------}

@@ -2278,10 +2477,10 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_SetTimer'{$ELSE} SDLLibName{$ENDIF __G
   You should normally use SDL_Init() or SDL_InitSubSystem(). }

 

 function SDL_AudioInit(driver_name: PChar): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_AudioInit'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AudioInit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_AudioInit}

 procedure SDL_AudioQuit;

-cdecl; external {$IFDEF __GPC__}name 'SDL_AudioQuit'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AudioQuit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_AudioQuit}

 

 { This function fills the given character buffer with the name of the

@@ -2289,7 +2488,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_AudioQuit'{$ELSE} SDLLibName{$ENDIF __
   been initialized.  It returns NULL if no driver has been initialized. }

 

 function SDL_AudioDriverName(namebuf: PChar; maxlen: Integer): PChar;

-cdecl; external {$IFDEF __GPC__}name 'SDL_AudioDriverName'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AudioDriverName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_AudioDriverName}

 

 { This function opens the audio device with the desired parameters, and

@@ -2333,12 +2532,12 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_AudioDriverName'{$ELSE} SDLLibName{$EN
   any local mixing buffers after you open the audio device. }

 

 function SDL_OpenAudio(desired, obtained: PSDL_AudioSpec): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_OpenAudio'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_OpenAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_OpenAudio}

 

 { Get the current audio state: }

 function SDL_GetAudioStatus: TSDL_Audiostatus;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetAudioStatus'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetAudioStatus'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetAudioStatus}

 

 { This function pauses and unpauses the audio callback processing.

@@ -2348,7 +2547,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GetAudioStatus'{$ELSE} SDLLibName{$END
   Silence will be written to the audio device during the pause. }

 

 procedure SDL_PauseAudio(pause_on: Integer);

-cdecl; external {$IFDEF __GPC__}name 'SDL_PauseAudio'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PauseAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_PauseAudio}

 

 { This function loads a WAVE from the data source, automatically freeing

@@ -2369,7 +2568,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_PauseAudio'{$ELSE} SDLLibName{$ENDIF _
 

 function SDL_LoadWAV_RW(src: PSDL_RWops; freesrc: Integer; spec:

   PSDL_AudioSpec; audio_buf: PUInt8; audiolen: PUInt32): PSDL_AudioSpec;

-cdecl; external {$IFDEF __GPC__}name 'SDL_LoadWAV_RW'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadWAV_RW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_LoadWAV_RW}

 

 // Compatibility convenience function -- loads a WAV from a file

@@ -2380,7 +2579,7 @@ function SDL_LoadWAV(filename: PChar; spec: PSDL_AudioSpec; audio_buf:
 { This function frees data previously allocated with SDL_LoadWAV_RW() }

 

 procedure SDL_FreeWAV(audio_buf: PUInt8);

-cdecl; external {$IFDEF __GPC__}name 'SDL_FreeWAV'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeWAV'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_FreeWAV}

 

 { This function takes a source format and rate and a destination format

@@ -2391,7 +2590,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_FreeWAV'{$ELSE} SDLLibName{$ENDIF __GP
 function SDL_BuildAudioCVT(cvt: PSDL_AudioCVT; src_format: UInt16;

   src_channels: UInt8; src_rate: Integer; dst_format: UInt16; dst_channels: UInt8;

   dst_rate: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_BuildAudioCVT'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_BuildAudioCVT'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_BuildAudioCVT}

 

 { Once you have initialized the 'cvt' structure using SDL_BuildAudioCVT(),

@@ -2402,7 +2601,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_BuildAudioCVT'{$ELSE} SDLLibName{$ENDI
   cvt->buf should be allocated after the cvt structure is initialized by

   SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long. }

 function SDL_ConvertAudio(cvt: PSDL_AudioCVT): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_ConvertAudio'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ConvertAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_ConvertAudio}

 

 { This takes two audio buffers of the playing audio format and mixes

@@ -2412,7 +2611,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_ConvertAudio'{$ELSE} SDLLibName{$ENDIF
   This is provided for convenience -- you can mix your own audio data. }

 

 procedure SDL_MixAudio(dst, src: PUInt8; len: UInt32; volume: Integer);

-cdecl; external {$IFDEF __GPC__}name 'SDL_MixAudio'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_MixAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_MixAudio}

 

 { The lock manipulated by these functions protects the callback function.

@@ -2420,16 +2619,16 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_MixAudio'{$ELSE} SDLLibName{$ENDIF __G
   callback function is not running.  Do not call these from the callback

   function or you will cause deadlock. }

 procedure SDL_LockAudio;

-cdecl; external {$IFDEF __GPC__}name 'SDL_LockAudio'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LockAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_LockAudio}

 procedure SDL_UnlockAudio;

-cdecl; external {$IFDEF __GPC__}name 'SDL_UnlockAudio'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnlockAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_UnlockAudio}

 

 { This function shuts down audio processing and closes the audio device. }

 

 procedure SDL_CloseAudio;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CloseAudio'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CloseAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CloseAudio}

 

 {------------------------------------------------------------------------------}

@@ -2440,7 +2639,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_CloseAudio'{$ELSE} SDLLibName{$ENDIF _
   SDL_Init() has not been called with the SDL_INIT_CDROM flag. }

 

 function SDL_CDNumDrives: Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDNumDrives'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDNumDrives'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDNumDrives}

 

 { Returns a human-readable, system-dependent identifier for the CD-ROM.

@@ -2450,7 +2649,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_CDNumDrives'{$ELSE} SDLLibName{$ENDIF
    "/dev/disk/ide/1/master" }

 

 function SDL_CDName(drive: Integer): PChar;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDName'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDName}

 

 { Opens a CD-ROM drive for access.  It returns a drive handle on success,

@@ -2460,7 +2659,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_CDName'{$ELSE} SDLLibName{$ENDIF __GPC
   Drives are numbered starting with 0.  Drive 0 is the system default CD-ROM. }

 

 function SDL_CDOpen(drive: Integer): PSDL_CD;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDOpen'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDOpen'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDOpen}

 

 { This function returns the current status of the given drive.

@@ -2468,7 +2667,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_CDOpen'{$ELSE} SDLLibName{$ENDIF __GPC
   play position of the CD will be stored in the SDL_CD structure. }

 

 function SDL_CDStatus(cdrom: PSDL_CD): TSDL_CDStatus;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDStatus'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDStatus'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDStatus}

 

 {  Play the given CD starting at 'start_track' and 'start_frame' for 'ntracks'

@@ -2495,7 +2694,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_CDStatus'{$ELSE} SDLLibName{$ENDIF __G
 

 function SDL_CDPlayTracks(cdrom: PSDL_CD; start_track: Integer; start_frame:

   Integer; ntracks: Integer; nframes: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDPlayTracks'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDPlayTracks'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDPlayTracks}

 

 

@@ -2503,32 +2702,32 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_CDPlayTracks'{$ELSE} SDLLibName{$ENDIF
    It returns 0, or -1 if there was an error. }

 

 function SDL_CDPlay(cdrom: PSDL_CD; start: Integer; length: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDPlay'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDPlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDPlay}

 

 // Pause play -- returns 0, or -1 on error

 function SDL_CDPause(cdrom: PSDL_CD): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDPause'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDPause'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDPause}

 

 // Resume play -- returns 0, or -1 on error

 function SDL_CDResume(cdrom: PSDL_CD): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDResume'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDResume'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDResume}

 

 // Stop play -- returns 0, or -1 on error

 function SDL_CDStop(cdrom: PSDL_CD): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDStop'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDStop'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDStop}

 

 // Eject CD-ROM -- returns 0, or -1 on error

 function SDL_CDEject(cdrom: PSDL_CD): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDEject'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDEject'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDEject}

 

 // Closes the handle for the CD-ROM drive

 procedure SDL_CDClose(cdrom: PSDL_CD);

-cdecl; external {$IFDEF __GPC__}name 'SDL_CDClose'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDClose'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CDClose}

 

 // Given a status, returns true if there's a disk in the drive

@@ -2548,14 +2747,14 @@ function MSF_TO_FRAMES(M: Integer; S: Integer; F: Integer): Integer;
 

 { Count the number of joysticks attached to the system }

 function SDL_NumJoysticks: Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_NumJoysticks'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_NumJoysticks'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_NumJoysticks}

 

 { Get the implementation dependent name of a joystick.

   This can be called before any joysticks are opened.

   If no name can be found, this function returns NULL. }

 function SDL_JoystickName(index: Integer): PChar;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickName'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickName}

 

 { Open a joystick for use - the index passed as an argument refers to

@@ -2564,40 +2763,40 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickName'{$ELSE} SDLLibName{$ENDIF
 

   This function returns a joystick identifier, or NULL if an error occurred. }

 function SDL_JoystickOpen(index: Integer): PSDL_Joystick;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickOpen'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickOpen'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickOpen}

 

 { Returns 1 if the joystick has been opened, or 0 if it has not. }

 function SDL_JoystickOpened(index: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickOpened'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickOpened'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickOpened}

 

 { Get the device index of an opened joystick. }

 function SDL_JoystickIndex(joystick: PSDL_Joystick): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickIndex'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickIndex'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickIndex}

 

 { Get the number of general axis controls on a joystick }

 function SDL_JoystickNumAxes(joystick: PSDL_Joystick): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickNumAxes'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumAxes'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickNumAxes}

 

 { Get the number of trackballs on a joystick

   Joystick trackballs have only relative motion events associated

   with them and their state cannot be polled. }

 function SDL_JoystickNumBalls(joystick: PSDL_Joystick): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickNumBalls'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumBalls'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickNumBalls}

 

 

 { Get the number of POV hats on a joystick }

 function SDL_JoystickNumHats(joystick: PSDL_Joystick): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickNumHats'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumHats'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickNumHats}

 

 { Get the number of buttons on a joystick }

 function SDL_JoystickNumButtons(joystick: PSDL_Joystick): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickNumButtons'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumButtons'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickNumButtons}

 

 { Update the current state of the open joysticks.

@@ -2605,7 +2804,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickNumButtons'{$ELSE} SDLLibName{
   events are enabled. }

 

 procedure SDL_JoystickUpdate;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickUpdate'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickUpdate'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickUpdate;}

 

 { Enable/disable joystick event polling.

@@ -2615,7 +2814,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickUpdate'{$ELSE} SDLLibName{$END
   The state can be one of SDL_QUERY, SDL_ENABLE or SDL_IGNORE. }

 

 function SDL_JoystickEventState(state: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickEventState'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickEventState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickEventState}

 

 { Get the current state of an axis control on a joystick

@@ -2623,13 +2822,13 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickEventState'{$ELSE} SDLLibName{
   The axis indices start at index 0. }

 

 function SDL_JoystickGetAxis(joystick: PSDL_Joystick; axis: Integer) : SInt16;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickGetAxis'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetAxis'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickGetAxis}

 

 { The hat indices start at index 0. }

 

 function SDL_JoystickGetHat(joystick: PSDL_Joystick; hat: Integer): UInt8;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickGetHat'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetHat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickGetHat}

 

 { Get the ball axis change since the last poll

@@ -2637,18 +2836,18 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickGetHat'{$ELSE} SDLLibName{$END
   The ball indices start at index 0. }

 

 function SDL_JoystickGetBall(joystick: PSDL_Joystick; ball: Integer; var dx: Integer; var dy: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickGetBall'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetBall'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickGetBall}

 

 { Get the current state of a button on a joystick

   The button indices start at index 0. }

 function SDL_JoystickGetButton( joystick: PSDL_Joystick; Button: Integer): UInt8;

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickGetButton'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetButton'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickGetButton}

 

 { Close a joystick previously opened with SDL_JoystickOpen() }

 procedure SDL_JoystickClose(joystick: PSDL_Joystick);

-cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickClose'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickClose'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_JoystickClose}

 

 {------------------------------------------------------------------------------}

@@ -2660,7 +2859,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_JoystickClose'{$ELSE} SDLLibName{$ENDI
   This should only be run in the thread that sets the video mode. }

 

 procedure SDL_PumpEvents;

-cdecl; external {$IFDEF __GPC__}name 'SDL_PumpEvents'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PumpEvents'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_PumpEvents;}

 

 { Checks the event queue for messages and optionally returns them.

@@ -2676,7 +2875,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_PumpEvents'{$ELSE} SDLLibName{$ENDIF _
   if there was an error.  This function is thread-safe. }

 

 function SDL_PeepEvents(events: PSDL_Event; numevents: Integer; action: TSDL_eventaction; mask: UInt32): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_PeepEvents'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PeepEvents'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_PeepEvents}

 

 { Polls for currently pending events, and returns 1 if there are any pending

@@ -2684,7 +2883,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_PeepEvents'{$ELSE} SDLLibName{$ENDIF _
    event is removed from the queue and stored in that area. }

 

 function SDL_PollEvent(event: PSDL_Event): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_PollEvent'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PollEvent'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_PollEvent}

 

 {  Waits indefinitely for the next available event, returning 1, or 0 if there

@@ -2692,11 +2891,11 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_PollEvent'{$ELSE} SDLLibName{$ENDIF __
    event is removed from the queue and stored in that area. }

 

 function SDL_WaitEvent(event: PSDL_Event): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_WaitEvent'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WaitEvent'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_WaitEvent}

 

 function SDL_PushEvent( event : PSDL_Event ) : Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_PushEvent'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PushEvent'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_PushEvent}

 

 { If the filter returns 1, then the event will be added to the internal queue.

@@ -2714,14 +2913,14 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_PushEvent'{$ELSE} SDLLibName{$ENDIF __
   If the quit event is generated by an interrupt signal, it will bypass the

   internal queue and be delivered to the application at the next event poll. }

 procedure SDL_SetEventFilter( filter : TSDL_EventFilter );

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetEventFilter'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetEventFilter'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetEventFilter}

 

 { Return the current event filter - can be used to "chain" filters.

   If there is no event filter set, this function returns NULL. }

 

 function SDL_GetEventFilter: TSDL_EventFilter;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetEventFilter'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetEventFilter'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetEventFilter}

 

 { This function allows you to set the state of processing certain events.

@@ -2732,7 +2931,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GetEventFilter'{$ELSE} SDLLibName{$END
   current processing state of the specified event. }

 

 function SDL_EventState(type_: UInt8; state: Integer): UInt8;

-cdecl; external {$IFDEF __GPC__}name 'SDL_EventState'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_EventState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_EventState}

 

 {------------------------------------------------------------------------------}

@@ -2764,7 +2963,7 @@ function SDL_VERSION_ATLEAST(X: Integer; Y: Integer; Z: Integer) : LongBool;
   use the SDL_Version() macro. }

 

 function SDL_Linked_Version: PSDL_version;

-cdecl; external {$IFDEF __GPC__}name 'SDL_Linked_Version'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Linked_Version'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_Linked_Version}

 

 {------------------------------------------------------------------------------}

@@ -2785,10 +2984,10 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_Linked_Version'{$ELSE} SDLLibName{$END
   you won't be able to set full-screen display modes. }

 

 function SDL_VideoInit(driver_name: PChar; flags: UInt32): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_VideoInit'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoInit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_VideoInit}

 procedure SDL_VideoQuit;

-cdecl; external {$IFDEF __GPC__}name 'SDL_VideoQuit'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoQuit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_VideoQuit}

 

 { This function fills the given character buffer with the name of the

@@ -2796,7 +2995,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_VideoQuit'{$ELSE} SDLLibName{$ENDIF __
   been initialized.  It returns NULL if no driver has been initialized. }

 

 function SDL_VideoDriverName(namebuf: PChar; maxlen: Integer): PChar;

-cdecl; external {$IFDEF __GPC__}name 'SDL_VideoDriverName'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoDriverName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_VideoDriverName}

 

 { This function returns a pointer to the current display surface.

@@ -2805,7 +3004,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_VideoDriverName'{$ELSE} SDLLibName{$EN
   surface. }

 

 function SDL_GetVideoSurface: PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetVideoSurface'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetVideoSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetVideoSurface}

 

 { This function returns a read-only pointer to information about the

@@ -2813,7 +3012,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GetVideoSurface'{$ELSE} SDLLibName{$EN
   member of the returned structure will contain the pixel format of the

   "best" video mode. }

 function SDL_GetVideoInfo: PSDL_VideoInfo;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetVideoInfo'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetVideoInfo'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetVideoInfo}

 

 { Check to see if a particular video mode is supported.

@@ -2827,7 +3026,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GetVideoInfo'{$ELSE} SDLLibName{$ENDIF
   SDL_SetVideoMode() }

 

 function SDL_VideoModeOK(width, height, bpp: Integer; flags: UInt32): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_VideoModeOK'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoModeOK'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_VideoModeOK}

 

 { Return a pointer to an array of available screen dimensions for the

@@ -2839,7 +3038,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_VideoModeOK'{$ELSE} SDLLibName{$ENDIF
   by SDL_GetVideoInfo( ) - > vfmt }

 

 function SDL_ListModes(format: PSDL_PixelFormat; flags: UInt32): PPSDL_Rect;

-cdecl; external {$IFDEF __GPC__}name 'SDL_ListModes'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ListModes'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_ListModes}

 

 

@@ -2886,7 +3085,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_ListModes'{$ELSE} SDLLibName{$ENDIF __
   This function returns the video framebuffer surface, or NULL if it fails. }

 

 function SDL_SetVideoMode(width, height, bpp: Integer; flags: UInt32): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetVideoMode'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetVideoMode'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetVideoMode}

 

 

@@ -2896,10 +3095,10 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_SetVideoMode'{$ELSE} SDLLibName{$ENDIF
   These functions should not be called while 'screen' is locked. }

 

 procedure SDL_UpdateRects(screen: PSDL_Surface; numrects: Integer; rects: PSDL_Rect);

-cdecl; external {$IFDEF __GPC__}name 'SDL_UpdateRects'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UpdateRects'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_UpdateRects}

 procedure SDL_UpdateRect(screen: PSDL_Surface; x, y: SInt32; w, h: UInt32);

-cdecl; external {$IFDEF __GPC__}name 'SDL_UpdateRect'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UpdateRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_UpdateRect}

 

 

@@ -2913,7 +3112,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_UpdateRect'{$ELSE} SDLLibName{$ENDIF _
   This function returns 0 if successful, or -1 if there was an error.}

 

 function SDL_Flip(screen: PSDL_Surface): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_Flip'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Flip'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_Flip}

 

 { Set the gamma correction for each of the color channels.

@@ -2924,7 +3123,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_Flip'{$ELSE} SDLLibName{$ENDIF __GPC__
   function returns 0, otherwise it returns -1. }

 

 function SDL_SetGamma(redgamma: single; greengamma: single; bluegamma: single ): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetGamma'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetGamma'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetGamma}

 

 { Set the gamma translation table for the red, green, and blue channels

@@ -2939,7 +3138,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_SetGamma'{$ELSE} SDLLibName{$ENDIF __G
   this function will return -1. }

 

 function SDL_SetGammaRamp( redtable: PUInt16; greentable: PUInt16; bluetable: PUInt16): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetGammaRamp'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetGammaRamp'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetGammaRamp}

 

 { Retrieve the current values of the gamma translation tables.

@@ -2951,7 +3150,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_SetGammaRamp'{$ELSE} SDLLibName{$ENDIF
   this function will return -1. }

 

 function SDL_GetGammaRamp( redtable: PUInt16; greentable: PUInt16; bluetable: PUInt16): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetGammaRamp'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetGammaRamp'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetGammaRamp}

 

 { Sets a portion of the colormap for the given 8-bit surface.  If 'surface'

@@ -2970,7 +3169,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GetGammaRamp'{$ELSE} SDLLibName{$ENDIF
 

 

 function SDL_SetColors(surface: PSDL_Surface; colors: PSDL_Color; firstcolor : Integer; ncolors: Integer) : Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetColors'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetColors'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetColors}

 

 { Sets a portion of the colormap for a given 8-bit surface.

@@ -2989,27 +3188,27 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_SetColors'{$ELSE} SDLLibName{$ENDIF __
   flags = (SDL_LOGPAL or SDL_PHYSPAL). }

 

 function SDL_SetPalette(surface: PSDL_Surface; flags: Integer; colors: PSDL_Color; firstcolor: Integer; ncolors: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetPalette'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetPalette'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetPalette}

 

 { Maps an RGB triple to an opaque pixel value for a given pixel format }

 function SDL_MapRGB(format: PSDL_PixelFormat; r: UInt8; g: UInt8; b: UInt8) : UInt32;

-cdecl; external {$IFDEF __GPC__}name 'SDL_MapRGB'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_MapRGB'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_MapRGB}

 

 { Maps an RGBA quadruple to a pixel value for a given pixel format }

 function SDL_MapRGBA(format: PSDL_PixelFormat; r: UInt8; g: UInt8; b: UInt8; a: UInt8): UInt32;

-cdecl; external {$IFDEF __GPC__}name 'SDL_MapRGBA'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_MapRGBA'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_MapRGBA}

 

 { Maps a pixel value into the RGB components for a given pixel format }

 procedure SDL_GetRGB(pixel: UInt32; fmt: PSDL_PixelFormat; r: PUInt8; g: PUInt8; b: PUInt8);

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetRGB'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetRGB'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetRGB}

 

 { Maps a pixel value into the RGBA components for a given pixel format }

 procedure SDL_GetRGBA(pixel: UInt32; fmt: PSDL_PixelFormat; r: PUInt8; g: PUInt8; b: PUInt8; a: PUInt8);

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetRGBA'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetRGBA'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetRGBA}

 

 { Allocate and free an RGB surface (must be called after SDL_SetVideoMode)

@@ -3050,16 +3249,16 @@ function SDL_AllocSurface(flags: UInt32; width, height, depth: Integer;
 {$EXTERNALSYM SDL_AllocSurface}

 

 function SDL_CreateRGBSurface(flags: UInt32; width, height, depth: Integer; RMask, GMask, BMask, AMask: UInt32): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CreateRGBSurface'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateRGBSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CreateRGBSurface}

 

 function SDL_CreateRGBSurfaceFrom(pixels: Pointer; width, height, depth, pitch

   : Integer; RMask, GMask, BMask, AMask: UInt32): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CreateRGBSurfaceFrom'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateRGBSurfaceFrom'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CreateRGBSurfaceFrom}

 

 procedure SDL_FreeSurface(surface: PSDL_Surface);

-cdecl; external {$IFDEF __GPC__}name 'SDL_FreeSurface'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_FreeSurface}

 

 function SDL_MustLock(Surface: PSDL_Surface): Boolean;

@@ -3081,11 +3280,11 @@ function SDL_MustLock(Surface: PSDL_Surface): Boolean;
 

   SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked. }

 function SDL_LockSurface(surface: PSDL_Surface): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_LockSurface'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LockSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_LockSurface}

 

 procedure SDL_UnlockSurface(surface: PSDL_Surface);

-cdecl; external {$IFDEF __GPC__}name 'SDL_UnlockSurface'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnlockSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_UnlockSurface}

 

 { Load a surface from a seekable SDL data source (memory or file.)

@@ -3093,7 +3292,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_UnlockSurface'{$ELSE} SDLLibName{$ENDI
   Returns the new surface, or NULL if there was an error.

   The new surface should be freed with SDL_FreeSurface(). }

 function SDL_LoadBMP_RW(src: PSDL_RWops; freesrc: Integer): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'SDL_LoadBMP_RW'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadBMP_RW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_LoadBMP_RW}

 

 // Convenience macro -- load a surface from a file

@@ -3105,7 +3304,7 @@ function SDL_LoadBMP(filename: PChar): PSDL_Surface;
   Returns 0 if successful or -1 if there was an error. }

 

 function SDL_SaveBMP_RW(surface: PSDL_Surface; dst: PSDL_RWops; freedst: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SaveBMP_RW'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SaveBMP_RW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SaveBMP_RW}

 

 // Convenience macro -- save a surface to a file

@@ -3121,7 +3320,7 @@ function SDL_SaveBMP(surface: PSDL_Surface; filename: PChar): Integer;
   This function returns 0, or -1 if there was an error. }

 

 function SDL_SetColorKey(surface: PSDL_Surface; flag, key: UInt32) : Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetColorKey'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetColorKey'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetColorKey}

 

 { This function sets the alpha value for the entire surface, as opposed to

@@ -3138,7 +3337,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_SetColorKey'{$ELSE} SDLLibName{$ENDIF
 

 

 function SDL_SetAlpha(surface: PSDL_Surface; flag: UInt32; alpha: UInt8): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetAlpha'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetAlpha'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetAlpha}

 

 { Sets the clipping rectangle for the destination surface in a blit.

@@ -3152,14 +3351,14 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_SetAlpha'{$ELSE} SDLLibName{$ENDIF __G
   Note that blits are automatically clipped to the edges of the source

   and destination surfaces. }

 procedure SDL_SetClipRect(surface: PSDL_Surface; rect: PSDL_Rect); cdecl;

-external {$IFDEF __GPC__}name 'SDL_SetClipRect'{$ELSE} SDLLibName{$ENDIF __GPC__};

+external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetClipRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetClipRect}

 

 { Gets the clipping rectangle for the destination surface in a blit.

   'rect' must be a pointer to a valid rectangle which will be filled

   with the correct values. }

 procedure SDL_GetClipRect(surface: PSDL_Surface; rect: PSDL_Rect); cdecl;

-external {$IFDEF __GPC__}name 'SDL_GetClipRect'{$ELSE} SDLLibName{$ENDIF __GPC__};

+external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetClipRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetClipRect}

 

 { Creates a new surface of the specified format, and then copies and maps

@@ -3174,7 +3373,7 @@ external {$IFDEF __GPC__}name 'SDL_GetClipRect'{$ELSE} SDLLibName{$ENDIF __GPC__
   This function is used internally by SDL_DisplayFormat(). }

 

 function SDL_ConvertSurface(src: PSDL_Surface; fmt: PSDL_PixelFormat; flags: UInt32): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'SDL_ConvertSurface'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ConvertSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_ConvertSurface}

 

 {

@@ -3254,13 +3453,13 @@ function SDL_BlitSurface(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surfac
 {  This is the public blit function, SDL_BlitSurface(), and it performs

    rectangle validation and clipping before passing it to SDL_LowerBlit() }

 function SDL_UpperBlit(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_UpperBlit'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UpperBlit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_UpperBlit}

 

 { This is a semi-private blit function and it performs low-level surface

   blitting only. }

 function SDL_LowerBlit(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_LowerBlit'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LowerBlit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_LowerBlit}

 

 { This function performs a fast fill of the given rectangle with 'color'

@@ -3272,7 +3471,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_LowerBlit'{$ELSE} SDLLibName{$ENDIF __
   This function returns 0 on success, or -1 on error. }

 

 function SDL_FillRect(dst: PSDL_Surface; dstrect: PSDL_Rect; color: UInt32) : Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_FillRect'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FillRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_FillRect}

 

 { This function takes a surface and copies it to a new surface of the

@@ -3286,7 +3485,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_FillRect'{$ELSE} SDLLibName{$ENDIF __G
   If the conversion fails or runs out of memory, it returns NULL }

 

 function SDL_DisplayFormat(surface: PSDL_Surface): PSDL_Surface; cdecl;

-external {$IFDEF __GPC__}name 'SDL_DisplayFormat'{$ELSE} SDLLibName{$ENDIF __GPC__};

+external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DisplayFormat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_DisplayFormat}

 

 { This function takes a surface and copies it to a new surface of the

@@ -3302,7 +3501,7 @@ external {$IFDEF __GPC__}name 'SDL_DisplayFormat'{$ELSE} SDLLibName{$ENDIF __GPC
 

 

 function SDL_DisplayFormatAlpha(surface: PSDL_Surface): PSDL_Surface; cdecl;

-external {$IFDEF __GPC__}name 'SDL_DisplayFormatAlpha'{$ELSE} SDLLibName{$ENDIF __GPC__};

+external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DisplayFormatAlpha'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_DisplayFormatAlpha}

 

 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

@@ -3315,16 +3514,16 @@ external {$IFDEF __GPC__}name 'SDL_DisplayFormatAlpha'{$ELSE} SDLLibName{$ENDIF
   is shown is undefined - it may be overwritten with the converted YUV data. }

 

 function SDL_CreateYUVOverlay(width: Integer; height: Integer; format: UInt32; display: PSDL_Surface): PSDL_Overlay;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CreateYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CreateYUVOverlay}

 

 // Lock an overlay for direct access, and unlock it when you are done

 function SDL_LockYUVOverlay(Overlay: PSDL_Overlay): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_LockYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LockYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_LockYUVOverlay}

 

 procedure SDL_UnlockYUVOverlay(Overlay: PSDL_Overlay); cdecl;

-external {$IFDEF __GPC__}name 'SDL_UnlockYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__};

+external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnlockYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_UnlockYUVOverlay}

 

 

@@ -3335,12 +3534,12 @@ external {$IFDEF __GPC__}name 'SDL_UnlockYUVOverlay'{$ELSE} SDLLibName{$ENDIF __
   that of the overlay, but currently only 2x scaling is supported. }

 

 function SDL_DisplayYUVOverlay(Overlay: PSDL_Overlay; dstrect: PSDL_Rect) : Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_DisplayYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DisplayYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_DisplayYUVOverlay}

 

 // Free a video overlay

 procedure SDL_FreeYUVOverlay(Overlay: PSDL_Overlay);

-cdecl; external {$IFDEF __GPC__}name 'SDL_FreeYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_FreeYUVOverlay}

 

 {------------------------------------------------------------------------------}

@@ -3358,17 +3557,17 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_FreeYUVOverlay'{$ELSE} SDLLibName{$END
 

 

 function SDL_GL_LoadLibrary(filename: PChar): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GL_LoadLibrary'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_LoadLibrary'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GL_LoadLibrary}

 

 { Get the address of a GL function (for extension functions) }

 function SDL_GL_GetProcAddress(procname: PChar) : Pointer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GL_GetProcAddress'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_GetProcAddress'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GL_GetProcAddress}

 

 { Set an attribute of the OpenGL subsystem before intialization. }

 function SDL_GL_SetAttribute(attr: TSDL_GLAttr; value: Integer) : Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GL_SetAttribute'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_SetAttribute'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GL_SetAttribute}

 

 { Get an attribute of the OpenGL subsystem from the windowing

@@ -3380,26 +3579,26 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GL_SetAttribute'{$ELSE} SDLLibName{$EN
   themselves if they want to retrieve these values. }

 

 function SDL_GL_GetAttribute(attr: TSDL_GLAttr; var value: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GL_GetAttribute'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_GetAttribute'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GL_GetAttribute}

 

 { Swap the OpenGL buffers, if double-buffering is supported. }

 

 procedure SDL_GL_SwapBuffers;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GL_SwapBuffers'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_SwapBuffers'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GL_SwapBuffers;}

 

 { Internal functions that should not be called unless you have read

   and understood the source code for these functions. }

 

 procedure SDL_GL_UpdateRects(numrects: Integer; rects: PSDL_Rect);

-cdecl; external {$IFDEF __GPC__}name 'SDL_GL_UpdateRects'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_UpdateRects'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GL_UpdateRects}

 procedure SDL_GL_Lock;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GL_Lock'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_Lock'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GL_Lock;}

 procedure SDL_GL_Unlock;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GL_Unlock'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_Unlock'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GL_Unlock;}

 

 {* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}

@@ -3408,10 +3607,10 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GL_Unlock'{$ELSE} SDLLibName{$ENDIF __
 

 { Sets/Gets the title and icon text of the display window }

 procedure SDL_WM_GetCaption(var title : PChar; var icon : PChar);

-cdecl; external {$IFDEF __GPC__}name 'SDL_WM_GetCaption'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_GetCaption'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_WM_GetCaption}

 procedure SDL_WM_SetCaption( const title : PChar; const icon : PChar);

-cdecl; external {$IFDEF __GPC__}name 'SDL_WM_SetCaption'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_SetCaption'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_WM_SetCaption}

 

 { Sets the icon for the display window.

@@ -3419,7 +3618,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_WM_SetCaption'{$ELSE} SDLLibName{$ENDI
   It takes an icon surface, and a mask in MSB format.

   If 'mask' is NULL, the entire icon surface will be used as the icon. }

 procedure SDL_WM_SetIcon(icon: PSDL_Surface; mask: UInt8);

-cdecl; external {$IFDEF __GPC__}name 'SDL_WM_SetIcon'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_SetIcon'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_WM_SetIcon}

 

 { This function iconifies the window, and returns 1 if it succeeded.

@@ -3427,7 +3626,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_WM_SetIcon'{$ELSE} SDLLibName{$ENDIF _
   This function is a noop and returns 0 in non-windowed environments. }

 

 function SDL_WM_IconifyWindow: Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_WM_IconifyWindow'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_IconifyWindow'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_WM_IconifyWindow}

 

 { Toggle fullscreen mode without changing the contents of the screen.

@@ -3445,7 +3644,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_WM_IconifyWindow'{$ELSE} SDLLibName{$E
   This is currently only implemented in the X11 video driver. }

 

 function SDL_WM_ToggleFullScreen(surface: PSDL_Surface): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_WM_ToggleFullScreen'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_ToggleFullScreen'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_WM_ToggleFullScreen}

 

 { Grabbing means that the mouse is confined to the application window,

@@ -3453,7 +3652,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_WM_ToggleFullScreen'{$ELSE} SDLLibName
   and not interpreted by a window manager, if any. }

 

 function SDL_WM_GrabInput(mode: TSDL_GrabMode): TSDL_GrabMode;

-cdecl; external {$IFDEF __GPC__}name 'SDL_WM_GrabInput'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_GrabInput'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_WM_GrabInput}

 

 {------------------------------------------------------------------------------}

@@ -3466,7 +3665,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_WM_GrabInput'{$ELSE} SDLLibName{$ENDIF
   current mouse cursor position.  You can pass NULL for either x or y. }

 

 function SDL_GetMouseState(var x: Integer; var y: Integer): UInt8;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetMouseState'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetMouseState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetMouseState}

 

 { Retrieve the current state of the mouse.

@@ -3474,12 +3673,12 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GetMouseState'{$ELSE} SDLLibName{$ENDI
   be tested using the SDL_BUTTON(X) macros, and x and y are set to the

   mouse deltas since the last call to SDL_GetRelativeMouseState(). }

 function SDL_GetRelativeMouseState(var x: Integer; var y: Integer): UInt8;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetRelativeMouseState'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetRelativeMouseState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetRelativeMouseState}

 

 { Set the position of the mouse cursor (generates a mouse motion event) }

 procedure SDL_WarpMouse(x, y: UInt16);

-cdecl; external {$IFDEF __GPC__}name 'SDL_WarpMouse'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WarpMouse'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_WarpMouse}

 

 { Create a cursor using the specified data and mask (in MSB format).

@@ -3494,24 +3693,24 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_WarpMouse'{$ELSE} SDLLibName{$ENDIF __
 

   Cursors created with this function must be freed with SDL_FreeCursor(). }

 function SDL_CreateCursor(data, mask: PUInt8; w, h, hot_x, hot_y: Integer): PSDL_Cursor;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CreateCursor'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CreateCursor}

 

 { Set the currently active cursor to the specified one.

   If the cursor is currently visible, the change will be immediately

   represented on the display. }

 procedure SDL_SetCursor(cursor: PSDL_Cursor);

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetCursor'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetCursor}

 

 { Returns the currently active cursor. }

 function SDL_GetCursor: PSDL_Cursor;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetCursor'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetCursor}

 

 { Deallocates a cursor created with SDL_CreateCursor(). }

 procedure SDL_FreeCursor(cursor: PSDL_Cursor);

-cdecl; external {$IFDEF __GPC__}name 'SDL_FreeCursor'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_FreeCursor}

 

 { Toggle whether or not the cursor is shown on the screen.

@@ -3520,7 +3719,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_FreeCursor'{$ELSE} SDLLibName{$ENDIF _
   before the call, or 0 if it was not.  You can query the current

   state by passing a 'toggle' value of -1. }

 function SDL_ShowCursor(toggle: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_ShowCursor'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ShowCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_ShowCursor}

 

 function SDL_BUTTON( Button : Integer ) : Integer;

@@ -3536,14 +3735,18 @@ function SDL_BUTTON( Button : Integer ) : Integer;
   If 'enable' is -1, the translation state is not changed.

   It returns the previous state of keyboard translation. }

 function SDL_EnableUNICODE(enable: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_EnableUNICODE'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_EnableUNICODE'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_EnableUNICODE}

 

 { If 'delay' is set to 0, keyboard repeat is disabled. }

 function SDL_EnableKeyRepeat(delay: Integer; interval: Integer): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_EnableKeyRepeat'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_EnableKeyRepeat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_EnableKeyRepeat}

 

+procedure SDL_GetKeyRepeat(delay : PInteger; interval: PInteger);

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetKeyRepeat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

+{$EXTERNALSYM SDL_GetKeyRepeat}

+

 { Get a snapshot of the current state of the keyboard.

   Returns an array of keystates, indexed by the SDLK_* syms.

   Used:

@@ -3552,23 +3755,23 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_EnableKeyRepeat'{$ELSE} SDLLibName{$EN
   if ( keystate[SDLK_RETURN] ) ... <RETURN> is pressed }

 

 function SDL_GetKeyState(numkeys: PInt): PUInt8;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetKeyState'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetKeyState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetKeyState}

 

 { Get the current key modifier state }

 function SDL_GetModState: TSDLMod;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetModState'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetModState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetModState}

 

 { Set the current key modifier state

   This does not change the keyboard state, only the key modifier flags. }

 procedure SDL_SetModState(modstate: TSDLMod);

-cdecl; external {$IFDEF __GPC__}name 'SDL_SetModState'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetModState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SetModState}

 

 { Get the name of an SDL virtual keysym }

 function SDL_GetKeyName(key: TSDLKey): PChar;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetKeyName'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetKeyName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetKeyName}

 

 {------------------------------------------------------------------------------}

@@ -3581,7 +3784,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GetKeyName'{$ELSE} SDLLibName{$ENDIF _
   see your application, otherwise it has been iconified or disabled. }

 

 function SDL_GetAppState: UInt8;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetAppState'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetAppState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetAppState}

 

 

@@ -3590,13 +3793,13 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GetAppState'{$ELSE} SDLLibName{$ENDIF
 { Create a mutex, initialized unlocked }

 

 function SDL_CreateMutex: PSDL_Mutex;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CreateMutex'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateMutex'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CreateMutex}

 

 { Lock the mutex  (Returns 0, or -1 on error) }

 

  function SDL_mutexP(mutex: PSDL_mutex): Integer;

- cdecl; external {$IFDEF __GPC__}name 'SDL_mutexP'{$ELSE} SDLLibName{$ENDIF __GPC__};

+ cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_mutexP'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 { $ EXTERNALSYM SDL_mutexP}

 

 function SDL_LockMutex(mutex: PSDL_mutex): Integer;

@@ -3604,7 +3807,7 @@ function SDL_LockMutex(mutex: PSDL_mutex): Integer;
 

 { Unlock the mutex  (Returns 0, or -1 on error) }

 function SDL_mutexV(mutex: PSDL_mutex): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_mutexV'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_mutexV'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_mutexV}

 

 function SDL_UnlockMutex(mutex: PSDL_mutex): Integer;

@@ -3612,7 +3815,7 @@ function SDL_UnlockMutex(mutex: PSDL_mutex): Integer;
 

 { Destroy a mutex }

 procedure SDL_DestroyMutex(mutex: PSDL_mutex);

-cdecl; external {$IFDEF __GPC__}name 'SDL_DestroyMutex'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DestroyMutex'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_DestroyMutex}

 

 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }

@@ -3620,13 +3823,13 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_DestroyMutex'{$ELSE} SDLLibName{$ENDIF
 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }

 { Create a semaphore, initialized with value, returns NULL on failure. }

 function SDL_CreateSemaphore(initial_value: UInt32): PSDL_Sem;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CreateSemaphore'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateSemaphore'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CreateSemaphore}

 

 

 { Destroy a semaphore }

 procedure SDL_DestroySemaphore(sem: PSDL_sem);

-cdecl; external {$IFDEF __GPC__}name 'SDL_DestroySemaphore'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DestroySemaphore'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_DestroySemaphore}

 

 { This function suspends the calling thread until the semaphore pointed

@@ -3634,14 +3837,14 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_DestroySemaphore'{$ELSE} SDLLibName{$E
   count. }

 

 function SDL_SemWait(sem: PSDL_sem): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SemWait'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemWait'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SemWait}

 

 { Non-blocking variant of SDL_SemWait(), returns 0 if the wait succeeds,

    SDL_MUTEX_TIMEDOUT if the wait would block, and -1 on error. }

 

 function SDL_SemTryWait(sem: PSDL_sem): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SemTryWait'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemTryWait'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SemTryWait}

 

 { Variant of SDL_SemWait() with a timeout in milliseconds, returns 0 if

@@ -3651,20 +3854,20 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_SemTryWait'{$ELSE} SDLLibName{$ENDIF _
    of 1 ms, and so should be avoided if possible. }

 

 function SDL_SemWaitTimeout(sem: PSDL_sem; ms: UInt32): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SemWaitTimeout'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemWaitTimeout'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SemTryWait}

 

 { Atomically increases the semaphore's count (not blocking), returns 0,

    or -1 on error. }

 

 function SDL_SemPost(sem: PSDL_sem): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SemPost'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemPost'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SemTryWait}

 

 { Returns the current count of the semaphore }

 

 function SDL_SemValue(sem: PSDL_sem): UInt32;

-cdecl; external {$IFDEF __GPC__}name 'SDL_SemValue'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemValue'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_SemValue}

 

 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }

@@ -3672,26 +3875,26 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_SemValue'{$ELSE} SDLLibName{$ENDIF __G
 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }

 { Create a condition variable }

 function SDL_CreateCond: PSDL_Cond;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CreateCond'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateCond'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CreateCond}

 

 { Destroy a condition variable }

 procedure SDL_DestroyCond(cond: PSDL_Cond);

-cdecl; external {$IFDEF __GPC__}name 'SDL_DestroyCond'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DestroyCond'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_DestroyCond}

 

 { Restart one of the threads that are waiting on the condition variable,

    returns 0 or -1 on error. }

 

 function SDL_CondSignal(cond: PSDL_cond): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CondSignal'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondSignal'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CondSignal}

 

 { Restart all threads that are waiting on the condition variable,

   returns 0 or -1 on error. }

 

 function SDL_CondBroadcast(cond: PSDL_cond): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CondBroadcast'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondBroadcast'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CondBroadcast}

 

 

@@ -3700,7 +3903,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_CondBroadcast'{$ELSE} SDLLibName{$ENDI
   Returns 0 when it is signaled, or -1 on error. }

 

 function SDL_CondWait(cond: PSDL_cond; mut: PSDL_mutex): Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CondWait'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondWait'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CondWait}

 

 { Waits for at most 'ms' milliseconds, and returns 0 if the condition

@@ -3710,7 +3913,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_CondWait'{$ELSE} SDLLibName{$ENDIF __G
   of 1 ms, and so should be avoided if possible. }

 

 function SDL_CondWaitTimeout(cond: PSDL_cond; mut: PSDL_mutex; ms: UInt32) : Integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CondWaitTimeout'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondWaitTimeout'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CondWaitTimeout}

 

 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }

@@ -3719,18 +3922,18 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_CondWaitTimeout'{$ELSE} SDLLibName{$EN
 

 { Create a thread }

 function SDL_CreateThread(fn: PInt; data: Pointer): PSDL_Thread;

-cdecl; external {$IFDEF __GPC__}name 'SDL_CreateThread'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateThread'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_CreateThread}

 

 { Get the 32-bit thread identifier for the current thread }

 function SDL_ThreadID: UInt32;

-cdecl; external {$IFDEF __GPC__}name 'SDL_ThreadID'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ThreadID'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_ThreadID}

 

 { Get the 32-bit thread identifier for the specified thread,

   equivalent to SDL_ThreadID() if the specified thread is NULL. }

 function SDL_GetThreadID(thread: PSDL_Thread): UInt32;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetThreadID'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetThreadID'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetThreadID}

 

 { Wait for a thread to finish.

@@ -3738,18 +3941,18 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GetThreadID'{$ELSE} SDLLibName{$ENDIF
   pointed to by 'status', if 'status' is not NULL. }

 

 procedure SDL_WaitThread(thread: PSDL_Thread; var status: Integer);

-cdecl; external {$IFDEF __GPC__}name 'SDL_WaitThread'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WaitThread'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_WaitThread}

 

 { Forcefully kill a thread without worrying about its state }

 procedure SDL_KillThread(thread: PSDL_Thread);

-cdecl; external {$IFDEF __GPC__}name 'SDL_KillThread'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_KillThread'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_KillThread}

 

 {------------------------------------------------------------------------------}

 { Get Environment Routines                                                     }

 {------------------------------------------------------------------------------}

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

 function _putenv( const variable : Pchar ): integer;

 cdecl;

 {$ENDIF}

@@ -3762,7 +3965,7 @@ cdecl; external 'libc.so' name 'putenv';
 {$ENDIF}

 

 { Put a variable of the form "name=value" into the environment }

-//function SDL_putenv(const variable: PChar): integer; cdecl; external {$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}SDLLibName name '';

+//function SDL_putenv(const variable: PChar): integer; cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}SDLLibName name '';

 function SDL_putenv(const variable: PChar): integer;

 {$EXTERNALSYM SDL_putenv}

 

@@ -3771,14 +3974,14 @@ function SDL_putenv(const variable: PChar): integer;
 //function putenv(const variable: PChar): integer;

 //{$EXTERNALSYM putenv}

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

 {$IFNDEF __GPC__}

 function getenv( const name : Pchar ): PChar; cdecl;

 {$ENDIF}

 {$ENDIF}

 

 {* Retrieve a variable named "name" from the environment }

-//function SDL_getenv(const name: PChar): PChar; cdecl; external {$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}SDLLibName name '';

+//function SDL_getenv(const name: PChar): PChar; cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}SDLLibName name '';

 function SDL_getenv(const name: PChar): PChar;

 {$EXTERNALSYM SDL_getenv}

 

@@ -3794,7 +3997,7 @@ function SDL_getenv(const name: PChar): PChar;
  * the version member of the 'info' structure is invalid, it returns 0.

  *}

 function SDL_GetWMInfo(info : PSDL_SysWMinfo) : integer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_GetWMInfo'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetWMInfo'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_GetWMInfo}

 

 {------------------------------------------------------------------------------}

@@ -3805,7 +4008,7 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_GetWMInfo'{$ELSE} SDLLibName{$ENDIF __
  * The 'sofile' parameter is a system dependent name of the object file.

  *}

 function SDL_LoadObject( const sofile : PChar ) : Pointer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_LoadObject'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadObject'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_LoadObject}

 

 {* Given an object handle, this function looks up the address of the

@@ -3813,12 +4016,12 @@ cdecl; external {$IFDEF __GPC__}name 'SDL_LoadObject'{$ELSE} SDLLibName{$ENDIF _
  * is no longer valid after calling SDL_UnloadObject().

  *}

 function SDL_LoadFunction( handle : Pointer; const name : PChar ) : Pointer;

-cdecl; external {$IFDEF __GPC__}name 'SDL_LoadFunction'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadFunction'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_LoadFunction}

 

 {* Unload a shared object from memory *}

 procedure SDL_UnloadObject( handle : Pointer );

-cdecl; external {$IFDEF __GPC__}name 'SDL_UnloadObject'{$ELSE} SDLLibName{$ENDIF __GPC__};

+cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnloadObject'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};

 {$EXTERNALSYM SDL_UnloadObject}

 

 

@@ -3860,7 +4063,7 @@ end;
 

 procedure SDL_OutOfMemory;

 begin

-  {$IFNDEF WIN32}

+  {$IFNDEF WINDOWS}

   SDL_Error(SDL_ENOMEM);

   {$ENDIF}

 end;

@@ -3981,7 +4184,7 @@ begin
   Result := SDL_mutexV(mutex);

 end;

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

 function _putenv( const variable : Pchar ): Integer;

 cdecl; external {$IFDEF __GPC__}name '_putenv'{$ELSE} 'MSVCRT.DLL'{$ENDIF __GPC__};

 {$ENDIF}

@@ -3989,7 +4192,7 @@ cdecl; external {$IFDEF __GPC__}name '_putenv'{$ELSE} 'MSVCRT.DLL'{$ENDIF __GPC_
 

 function SDL_putenv(const variable: PChar): Integer;

 begin

-  {$IFDEF WIN32}

+  {$IFDEF WINDOWS}

   Result := _putenv(variable);

   {$ENDIF}

 

@@ -4002,7 +4205,7 @@ begin
   {$ENDIF}

 end;

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

 {$IFNDEF __GPC__}

 function getenv( const name : Pchar ): PChar;

 cdecl; external {$IFDEF __GPC__}name 'getenv'{$ELSE} 'MSVCRT.DLL'{$ENDIF};

@@ -4011,7 +4214,7 @@ cdecl; external {$IFDEF __GPC__}name 'getenv'{$ELSE} 'MSVCRT.DLL'{$ENDIF};
 

 function SDL_getenv(const name: PChar): PChar;

 begin

-  {$IFDEF WIN32}

+  {$IFDEF WINDOWS}

 

   {$IFDEF __GPC__}

   Result := getenv( string( name ) );

diff --git a/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlgameinterface.pas b/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlgameinterface.pas
index f8bf902c..cc95751d 100644
--- a/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlgameinterface.pas
+++ b/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlgameinterface.pas
@@ -1,6 +1,6 @@
 unit sdlgameinterface;

 {

-  $Id: sdlgameinterface.pas,v 1.3 2004/10/17 18:41:49 savage Exp $

+  $Id: sdlgameinterface.pas,v 1.4 2005/08/03 18:57:31 savage Exp $

   

 }

 {******************************************************************************}

@@ -62,6 +62,9 @@ unit sdlgameinterface;
 {   September   23 2004 - DL : Initial Creation                                }

 {

   $Log: sdlgameinterface.pas,v $

+  Revision 1.4  2005/08/03 18:57:31  savage

+  Various updates and additions. Mainly to handle OpenGL 3D Window support and better cursor support for the mouse class

+

   Revision 1.3  2004/10/17 18:41:49  savage

   Slight Change to allow Reseting of Input Event handlers

 

@@ -97,11 +100,11 @@ type
     procedure MouseWheelScroll( WheelDelta : Integer; Shift: TSDLMod; MousePos : TPoint ); virtual;

     procedure KeyDown( var Key: TSDLKey; Shift: TSDLMod; unicode : UInt16 ); virtual;

   public

-    MainWindow : TSDL2DWindow;

+    MainWindow : TSDLCustomWindow;

     procedure ResetInputManager;

     procedure LoadSurfaces; virtual;

     function PointIsInRect( Point : TPoint; x, y, x1, y1 : integer ) : Boolean;

-    constructor Create( const aMainWindow : TSDL2DWindow );

+    constructor Create( const aMainWindow : TSDLCustomWindow );

     destructor Destroy; override;

     property NextGameInterface : TGameInterfaceClass read FNextGameInterface write FNextGameInterface;

   end;

@@ -114,7 +117,7 @@ begin
   FNextGameInterface := nil;

 end;

 

-constructor TGameInterface.Create( const aMainWindow : TSDL2DWindow );

+constructor TGameInterface.Create( const aMainWindow : TSDLCustomWindow );

 begin

   inherited Create;

   MainWindow := aMainWindow;

@@ -176,14 +179,18 @@ begin
 end;

 

 procedure TGameInterface.ResetInputManager;

+var

+  temp : TSDLNotifyEvent;

 begin

   MainWindow.InputManager.Mouse.OnMouseDown := MouseDown;

   MainWindow.InputManager.Mouse.OnMouseMove := MouseMove;

   MainWindow.InputManager.Mouse.OnMouseUp := MouseUp;

   MainWindow.InputManager.Mouse.OnMouseWheel := MouseWheelScroll;

   MainWindow.InputManager.KeyBoard.OnKeyDown := KeyDown;

-  MainWindow.OnRender := Render;

-  MainWindow.OnClose := Close;

+  temp := Render;

+  MainWindow.OnRender := temp;

+  temp := Close;

+  MainWindow.OnClose := temp;

   MainWindow.OnUpdate := Update;

 end;

 

diff --git a/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlticks.pas b/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlticks.pas
index 4e91ecb8..8e00dd6f 100644
--- a/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlticks.pas
+++ b/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlticks.pas
@@ -1,7 +1,7 @@
 unit sdlticks;

 {

-  $Id: sdlticks.pas,v 1.1 2004/09/30 22:35:47 savage Exp $

-  

+  $Id: sdlticks.pas,v 1.2 2006/11/08 08:22:48 savage Exp $

+

 }

 {******************************************************************************}

 {                                                                              }

@@ -59,10 +59,12 @@ unit sdlticks;
 {   September   23 2004 - DL : Initial Creation                                }

 {

   $Log: sdlticks.pas,v $

+  Revision 1.2  2006/11/08 08:22:48  savage

+  updates tp sdlgameinterface and sdlticks functions.

+

   Revision 1.1  2004/09/30 22:35:47  savage

   Changes, enhancements and additions as required to get SoAoS working.

 

-

 }

 {******************************************************************************}

 

@@ -71,49 +73,50 @@ interface
 uses

   sdl;

 

-

 type

   TSDLTicks = class

   private

-    m_startTime : Int64;

-    m_ticksPerSecond : Int64;

-    s_lastTime : Int64;

-

+    FStartTime : UInt32;

+    FTicksPerSecond : UInt32;

+    FElapsedLastTime : UInt32;

+    FFPSLastTime : UInt32;

+    FLockFPSLastTime : UInt32;

   public

     constructor Create;

-    destructor Destroy; override;          // destructor

+    destructor Destroy; override; // destructor

 

     {*****************************************************************************

      Init

-

      If the hi-res timer is present, the tick rate is stored and the function

      returns true. Otherwise, the function returns false, and the timer should

      not be used.

     *****************************************************************************}

     function Init : boolean;

 

-    function GetElapsedSeconds( elapsedFrames : Cardinal = 1 ) : single;

+    {***************************************************************************

+     GetGetElapsedSeconds

+     Returns the Elapsed time, since the function was last called.

+    ***************************************************************************}

+    function GetElapsedSeconds : Single;

 

     {***************************************************************************

      GetFPS

-

-     Returns the average frames per second over elapsedFrames, which defaults to

-     one. If this is not called every frame, the client should track the number

+     Returns the average frames per second.

+     If this is not called every frame, the client should track the number

      of frames itself, and reset the value after this is called.

     ***************************************************************************}

-    function GetFPS( elapsedFrames : Cardinal  = 1 )  : single;

+    function GetFPS : single;

 

     {***************************************************************************

      LockFPS

-

      Used to lock the frame rate to a set amount. This will block until enough

      time has passed to ensure that the fps won't go over the requested amount.

      Note that this can only keep the fps from going above the specified level;

      it can still drop below it. It is assumed that if used, this function will

      be called every frame. The value returned is the instantaneous fps, which

-     will be <= targetFPS.

+     will be less than or equal to the targetFPS.

     ***************************************************************************}

-    function LockFPS( targetFPS : Byte ) : single;

+    procedure LockFPS( targetFPS : Byte );

   end;

 

 implementation

@@ -121,76 +124,74 @@ implementation
 { TSDLTicks }

 constructor TSDLTicks.Create;

 begin

-

+  inherited;

+  FTicksPerSecond := 1000;

 end;

 

 destructor TSDLTicks.Destroy;

 begin

-

   inherited;

 end;

 

-function TSDLTicks.GetElapsedSeconds( elapsedFrames: Cardinal ): single;

+function TSDLTicks.GetElapsedSeconds : Single;

 var

-  currentTime : Int64;

+  currentTime       : Cardinal;

 begin

-  // s_lastTime := m_startTime;

-

   currentTime := SDL_GetTicks;

-  //QueryPerformanceCounter( currentTime );

 

-  result :=  (currentTime - s_lastTime) / m_ticksPerSecond;

+  result := ( currentTime - FElapsedLastTime ) / FTicksPerSecond;

 

   // reset the timer

-  s_lastTime := currentTime;

+  FElapsedLastTime := currentTime;

 end;

 

-function TSDLTicks.GetFPS( elapsedFrames: Cardinal ): single;

+function TSDLTicks.GetFPS : Single;

 var

-  currentTime : integer;

-  fps : single;

+  currentTime, FrameTime : UInt32;

+  fps               : single;

 begin

-  // s_lastTime := m_startTime;

-

   currentTime := SDL_GetTicks;

 

-  fps := elapsedFrames * m_ticksPerSecond / ( currentTime - s_lastTime);

+  FrameTime := ( currentTime - FFPSLastTime );

 

-  // reset the timer

-  s_lastTime := currentTime;

+  if FrameTime = 0 then

+    FrameTime := 1;

 

+  fps := FTicksPerSecond / FrameTime;

+

+  // reset the timer

+  FFPSLastTime := currentTime;

   result := fps;

 end;

 

-function TSDLTicks.Init: boolean;

+function TSDLTicks.Init : boolean;

 begin

-  m_startTime := SDL_GetTicks;

-  s_lastTime := m_startTime;

-  m_ticksPerSecond := 1000;

+  FStartTime := SDL_GetTicks;

+  FElapsedLastTime := FStartTime;

+  FFPSLastTime := FStartTime;

+  FLockFPSLastTime := FStartTime;

   result := true;

 end;

 

-function TSDLTicks.LockFPS(targetFPS: Byte): single;

+procedure TSDLTicks.LockFPS( targetFPS : Byte );

 var

-  currentTime : integer;

-  fps : single;

+  currentTime       : UInt32;

+  targetTime        : single;

 begin

-  if (targetFPS = 0) then

+  if ( targetFPS = 0 ) then

     targetFPS := 1;

 

-  s_lastTime := m_startTime;

+  targetTime := FTicksPerSecond / targetFPS;

 

   // delay to maintain a constant frame rate

   repeat

     currentTime := SDL_GetTicks;

-    fps := m_ticksPerSecond / (currentTime - s_lastTime);

-  until (fps > targetFPS);

+  until ( ( currentTime - FLockFPSLastTime ) > targetTime );

 

   // reset the timer

-  s_lastTime := m_startTime;

-

-  result := fps;

+  FLockFPSLastTime := currentTime;

 end;

 

 end.

+

  
\ No newline at end of file
diff --git a/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlutils.pas b/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlutils.pas
index bef83cbc..b15fa9ba 100644
--- a/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlutils.pas
+++ b/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlutils.pas
@@ -1,7 +1,7 @@
 unit sdlutils;

 {

-  $Id: sdlutils.pas,v 1.4 2004/06/02 19:38:53 savage Exp $

-  

+  $Id: sdlutils.pas,v 1.5 2006/11/19 18:56:44 savage Exp $

+

 }

 {******************************************************************************}

 {                                                                              }

@@ -105,6 +105,9 @@ unit sdlutils;
 {******************************************************************************}

 {

   $Log: sdlutils.pas,v $

+  Revision 1.5  2006/11/19 18:56:44  savage

+  Removed Hints and Warnings.

+

   Revision 1.4  2004/06/02 19:38:53  savage

   Changes to SDL_GradientFillRect as suggested by

   Ángel Eduardo García Hernández.  Many thanks.

@@ -119,12 +122,12 @@ unit sdlutils;
   Revision 1.1  2004/02/05 00:08:20  savage

   Module 1.0 release

 

-  

+

 }

 

 interface

 

-{$i jedi-sdl.inc}

+{$I jedi-sdl.inc}

 

 uses

 {$IFDEF UNIX}

@@ -157,7 +160,7 @@ procedure SDL_DrawLine( DstSurface : PSDL_Surface; x1, y1, x2, y2 : integer; Col
   cardinal ); overload;

 

 procedure SDL_DrawLine( DstSurface : PSDL_Surface; x1, y1, x2, y2 : integer; Color :

-  cardinal ; DashLength, DashSpace : byte );  overload;  

+  cardinal; DashLength, DashSpace : byte ); overload;

 

 procedure SDL_AddLine( DstSurface : PSDL_Surface; x1, y1, x2, y2 : integer; Color :

   cardinal );

@@ -217,16 +220,16 @@ procedure SDL_FillRectSub( DstSurface : PSDL_Surface; dstrect : PSDL_Rect; color
 procedure SDL_GradientFillRect( DstSurface : PSDL_Surface; const Rect : PSDL_Rect; const StartColor, EndColor : TSDL_Color; const Style : TGradientStyle );

 

 // NOTE for All SDL_2xblit... function : the dest surface must be 2x of the source surface!

-procedure SDL_2xBlit(Src, Dest: PSDL_Surface);

+procedure SDL_2xBlit( Src, Dest : PSDL_Surface );

 

-procedure SDL_Scanline2xBlit(Src, Dest: PSDL_Surface);

+procedure SDL_Scanline2xBlit( Src, Dest : PSDL_Surface );

 

-procedure SDL_50Scanline2xBlit(Src, Dest: PSDL_Surface);

+procedure SDL_50Scanline2xBlit( Src, Dest : PSDL_Surface );

 

 //

 function SDL_PixelTestSurfaceVsRect( SrcSurface1 : PSDL_Surface; SrcRect1 :

-PSDL_Rect; SrcRect2 : PSDL_Rect; Left1, Top1, Left2, Top2 : integer ) :

-boolean;

+  PSDL_Rect; SrcRect2 : PSDL_Rect; Left1, Top1, Left2, Top2 : integer ) :

+  boolean;

 

 // Jason's boolean Surface functions

 procedure SDL_ORSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;

@@ -242,7 +245,7 @@ procedure SDL_GTSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;
 procedure SDL_LTSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;

   DestSurface : PSDL_Surface; DestRect : PSDL_Rect );

 

-function SDL_ClipLine(var x1,y1,x2,y2: Integer; ClipRect: PSDL_Rect) : boolean;

+function SDL_ClipLine( var x1, y1, x2, y2 : Integer; ClipRect : PSDL_Rect ) : boolean;

 

 implementation

 

@@ -256,13 +259,13 @@ var
   right1, bottom1 : integer;

   right2, bottom2 : integer;

   Scan1Start, Scan2Start, ScanWidth, ScanHeight : cardinal;

-  Mod1, Mod2 : cardinal;

+  Mod1, Mod2   : cardinal;

   Addr1, Addr2 : cardinal;

-  BPP : cardinal;

+  BPP          : cardinal;

   Pitch1, Pitch2 : cardinal;

   TransparentColor1, TransparentColor2 : cardinal;

-  tx, ty : cardinal;

-  StartTick : cardinal;

+  tx, ty       : cardinal;

+  StartTick    : cardinal;

   Color1, Color2 : cardinal;

 begin

   Result := false;

@@ -438,9 +441,9 @@ end;
 procedure SDL_AddPixel( DstSurface : PSDL_Surface; x : cardinal; y : cardinal; Color :

   cardinal );

 var

-  SrcColor : cardinal;

-  Addr : cardinal;

-  R, G, B : cardinal;

+  SrcColor     : cardinal;

+  Addr         : cardinal;

+  R, G, B      : cardinal;

 begin

   if Color = 0 then

     exit;

@@ -521,9 +524,9 @@ end;
 procedure SDL_SubPixel( DstSurface : PSDL_Surface; x : cardinal; y : cardinal; Color :

   cardinal );

 var

-  SrcColor : cardinal;

-  Addr : cardinal;

-  R, G, B : cardinal;

+  SrcColor     : cardinal;

+  Addr         : cardinal;

+  R, G, B      : cardinal;

 begin

   if Color = 0 then

     exit;

@@ -608,12 +611,12 @@ procedure SDL_AddSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;
   DestSurface : PSDL_Surface; DestRect : PSDL_Rect );

 var

   R, G, B, Pixel1, Pixel2, TransparentColor : cardinal;

-  Src, Dest : TSDL_Rect;

-  Diff : integer;

+  Src, Dest    : TSDL_Rect;

+  Diff         : integer;

   SrcAddr, DestAddr : cardinal;

   WorkX, WorkY : word;

   SrcMod, DestMod : cardinal;

-  Bits : cardinal;

+  Bits         : cardinal;

 begin

   if ( SrcSurface = nil ) or ( DestSurface = nil ) then

     exit; // Remove this to make it faster

@@ -878,13 +881,13 @@ procedure SDL_SubSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;
   DestSurface : PSDL_Surface; DestRect : PSDL_Rect );

 var

   R, G, B, Pixel1, Pixel2, TransparentColor : cardinal;

-  Src, Dest : TSDL_Rect;

-  Diff : integer;

+  Src, Dest    : TSDL_Rect;

+  Diff         : integer;

   SrcAddr, DestAddr : cardinal;

   _ebx, _esi, _edi, _esp : cardinal;

   WorkX, WorkY : word;

   SrcMod, DestMod : cardinal;

-  Bits : cardinal;

+  Bits         : cardinal;

 begin

   if ( SrcSurface = nil ) or ( DestSurface = nil ) then

     exit; // Remove this to make it faster

@@ -1140,14 +1143,14 @@ end;
 procedure SDL_MonoSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;

   DestSurface : PSDL_Surface; DestRect : PSDL_Rect; Color : cardinal );

 var

-  Src, Dest : TSDL_Rect;

-  Diff : integer;

+  Src, Dest    : TSDL_Rect;

+  Diff         : integer;

   SrcAddr, DestAddr : cardinal;

   _ebx, _esi, _edi, _esp : cardinal;

   WorkX, WorkY : word;

   SrcMod, DestMod : cardinal;

   TransparentColor, SrcColor : cardinal;

-  BPP : cardinal;

+  BPP          : cardinal;

 begin

   if ( SrcSurface = nil ) or ( DestSurface = nil ) then

     exit; // Remove this to make it faster

@@ -1312,14 +1315,14 @@ procedure SDL_TexturedSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;
   DestSurface : PSDL_Surface; DestRect : PSDL_Rect; Texture : PSDL_Surface;

   TextureRect : PSDL_Rect );

 var

-  Src, Dest : TSDL_Rect;

-  Diff : integer;

+  Src, Dest    : TSDL_Rect;

+  Diff         : integer;

   SrcAddr, DestAddr, TextAddr : cardinal;

   _ebx, _esi, _edi, _esp : cardinal;

   WorkX, WorkY : word;

   SrcMod, DestMod, TextMod : cardinal;

   SrcColor, TransparentColor, TextureColor : cardinal;

-  BPP : cardinal;

+  BPP          : cardinal;

 begin

   if ( SrcSurface = nil ) or ( DestSurface = nil ) then

     exit; // Remove this to make it faster

@@ -1496,10 +1499,10 @@ end;
 

 procedure SDL_ZoomSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect; DstSurface : PSDL_Surface; DstRect : PSDL_Rect );

 var

-  xc, yc : cardinal;

+  xc, yc       : cardinal;

   rx, wx, ry, wy, ry16 : cardinal;

-  color : cardinal;

-  modx, mody : cardinal;

+  color        : cardinal;

+  modx, mody   : cardinal;

 begin

   // Warning! No checks for surface pointers!!!

   if srcrect = nil then

@@ -1540,13 +1543,13 @@ end;
 

 procedure SDL_WarpSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect; DstSurface : PSDL_Surface; UL, UR, LR, LL : PPoint );

 const

-  SHIFTS = 15; // Extend ints to limit round-off error (try 2 - 20)

-  THRESH = 1 shl SHIFTS; // Threshold for pixel size value

+  SHIFTS       = 15; // Extend ints to limit round-off error (try 2 - 20)

+  THRESH       = 1 shl SHIFTS; // Threshold for pixel size value

   procedure CopySourceToDest( UL, UR, LR, LL : TPoint; x1, y1, x2, y2 : cardinal );

   var

     tm, lm, rm, bm, m : TPoint;

-    mx, my : cardinal;

-    cr : cardinal;

+    mx, my     : cardinal;

+    cr         : cardinal;

   begin

     // Does the destination area specify a single pixel?

     if ( ( abs( ul.x - ur.x ) < THRESH ) and

@@ -1620,6 +1623,7 @@ end;
 

 // Draw a line between x1,y1 and x2,y2 to the given surface

 // NOTE: The surface must be locked before calling this!

+

 procedure SDL_DrawLine( DstSurface : PSDL_Surface; x1, y1, x2, y2 : integer; Color :

   cardinal );

 var

@@ -1673,8 +1677,9 @@ end;
 

 // Draw a dashed line between x1,y1 and x2,y2 to the given surface

 // NOTE: The surface must be locked before calling this!

+

 procedure SDL_DrawLine( DstSurface : PSDL_Surface; x1, y1, x2, y2 : integer; Color :

-  cardinal ; DashLength, DashSpace : byte );  overload;

+  cardinal; DashLength, DashSpace : byte ); overload;

 var

   dx, dy, sdx, sdy, x, y, px, py, counter : integer; drawdash : boolean;

 begin

@@ -1682,10 +1687,12 @@ begin
   drawdash := true; //begin line drawing with dash

 

   //Avoid invalid user-passed dash parameters

-  if (DashLength < 1)

-  then DashLength := 1;

-  if (DashSpace < 1)

-  then DashSpace := 0;

+  if ( DashLength < 1 )

+    then

+    DashLength := 1;

+  if ( DashSpace < 1 )

+    then

+    DashSpace := 0;

 

   dx := x2 - x1;

   dy := y2 - y1;

@@ -1706,28 +1713,28 @@ begin
   if dx >= dy then

   begin

     for x := 0 to dx - 1 do

-      begin

+    begin

 

       //Alternate drawing dashes, or leaving spaces

       if drawdash then

+      begin

+        SDL_PutPixel( DstSurface, px, py, Color );

+        inc( counter );

+        if ( counter > DashLength - 1 ) and ( DashSpace > 0 ) then

         begin

-          SDL_PutPixel( DstSurface, px, py, Color );

-          inc(counter);

-          if (counter > DashLength-1) and (DashSpace > 0) then

-            begin

-              drawdash := false;

-              counter := 0;

-            end;

-        end

+          drawdash := false;

+          counter := 0;

+        end;

+      end

       else //space

+      begin

+        inc( counter );

+        if counter > DashSpace - 1 then

         begin

-          inc(counter);

-          if counter > DashSpace-1 then

-            begin

-              drawdash := true;

-              counter := 0;

-            end;

+          drawdash := true;

+          counter := 0;

         end;

+      end;

 

       y := y + dy;

       if y >= dx then

@@ -1745,24 +1752,24 @@ begin
 

       //Alternate drawing dashes, or leaving spaces

       if drawdash then

+      begin

+        SDL_PutPixel( DstSurface, px, py, Color );

+        inc( counter );

+        if ( counter > DashLength - 1 ) and ( DashSpace > 0 ) then

         begin

-          SDL_PutPixel( DstSurface, px, py, Color );

-          inc(counter);

-          if (counter > DashLength-1) and (DashSpace > 0) then

-            begin

-              drawdash := false;

-              counter := 0;

-            end;

-        end

+          drawdash := false;

+          counter := 0;

+        end;

+      end

       else //space

+      begin

+        inc( counter );

+        if counter > DashSpace - 1 then

         begin

-          inc(counter);

-          if counter > DashSpace-1 then

-            begin

-              drawdash := true;

-              counter := 0;

-            end;

+          drawdash := true;

+          counter := 0;

         end;

+      end;

 

       x := x + dx;

       if x >= dy then

@@ -1878,13 +1885,14 @@ begin
 end;

 

 // flips a rectangle vertically on given surface

+

 procedure SDL_FlipRectV( DstSurface : PSDL_Surface; Rect : PSDL_Rect );

 var

-  TmpRect : TSDL_Rect;

-  Locked : boolean;

+  TmpRect      : TSDL_Rect;

+  Locked       : boolean;

   y, FlipLength, RowLength : integer;

-  Row1, Row2 : Pointer;

-  OneRow : TByteArray; // Optimize it if you wish

+  Row1, Row2   : Pointer;

+  OneRow       : TByteArray; // Optimize it if you wish

 begin

   if DstSurface <> nil then

   begin

@@ -1920,6 +1928,7 @@ begin
 end;

 

 // flips a rectangle horizontally on given surface

+

 procedure SDL_FlipRectH( DstSurface : PSDL_Surface; Rect : PSDL_Rect );

 type

   T24bit = packed array[ 0..2 ] of byte;

@@ -1928,15 +1937,15 @@ type
   TLongWordArray = array[ 0..8191 ] of LongWord;

   PLongWordArray = ^TLongWordArray;

 var

-  TmpRect : TSDL_Rect;

-  Row8bit : PByteArray;

-  Row16bit : PWordArray;

-  Row24bit : P24bitArray;

-  Row32bit : PLongWordArray;

+  TmpRect      : TSDL_Rect;

+  Row8bit      : PByteArray;

+  Row16bit     : PWordArray;

+  Row24bit     : P24bitArray;

+  Row32bit     : PLongWordArray;

   y, x, RightSide, FlipLength : integer;

-  Pixel : cardinal;

-  Pixel24 : T24bit;

-  Locked : boolean;

+  Pixel        : cardinal;

+  Pixel24      : T24bit;

+  Locked       : boolean;

 begin

   if DstSurface <> nil then

   begin

@@ -2030,9 +2039,10 @@ end;
 

 // Use with caution! The procedure allocates memory for TSDL_Rect and return with its pointer.

 // But you MUST free it after you don't need it anymore!!!

+

 function PSDLRect( aLeft, aTop, aWidth, aHeight : integer ) : PSDL_Rect;

 var

-  Rect : PSDL_Rect;

+  Rect         : PSDL_Rect;

 begin

   New( Rect );

   with Rect^ do

@@ -2103,10 +2113,11 @@ begin
 end;

 

 // Stretches a part of a surface

+

 function SDL_ScaleSurfaceRect( SrcSurface : PSDL_Surface; SrcX1, SrcY1, SrcW, SrcH,

   Width, Height : integer ) : PSDL_Surface;

 var

-  dst_surface : PSDL_Surface;

+  dst_surface  : PSDL_Surface;

   dx, dy, e, d, dx2, srcx2, srcy2 : integer;

   destx1, desty1 : integer;

 begin

@@ -2153,7 +2164,7 @@ end;
 procedure SDL_MoveLine( Surface : PSDL_Surface; x1, x2, y1, xofs, depth : integer );

 var

   src_pixels, dst_pixels : PUint8;

-  i : integer;

+  i            : integer;

 begin

   src_pixels := PUint8( integer( Surface^.pixels ) + Surface^.w * y1 * depth + x2 *

     depth );

@@ -2171,8 +2182,8 @@ NOTE: The surface must be locked before calling this! }
 

 function SDL_GetPixel( SrcSurface : PSDL_Surface; x : integer; y : integer ) : Uint32;

 var

-  bpp : UInt32;

-  p : PInteger;

+  bpp          : UInt32;

+  p            : PInteger;

 begin

   bpp := SrcSurface.format.BytesPerPixel;

   // Here p is the address to the pixel we want to retrieve

@@ -2199,8 +2210,8 @@ end;
 procedure SDL_PutPixel( DstSurface : PSDL_Surface; x : integer; y : integer; pixel :

   Uint32 );

 var

-  bpp : UInt32;

-  p : PInteger;

+  bpp          : UInt32;

+  p            : PInteger;

 begin

   bpp := DstSurface.format.BytesPerPixel;

   p := Pointer( Uint32( DstSurface.pixels ) + UInt32( y ) * DstSurface.pitch + UInt32( x )

@@ -2228,9 +2239,9 @@ end;
 

 procedure SDL_ScrollY( DstSurface : PSDL_Surface; DifY : integer );

 var

-  r1, r2 : TSDL_Rect;

+  r1, r2       : TSDL_Rect;

   //buffer: PSDL_Surface;

-  YPos : Integer;

+  YPos         : Integer;

 begin

   if ( DstSurface <> nil ) and ( DifY <> 0 ) then

   begin

@@ -2282,8 +2293,8 @@ end;}
 

 procedure SDL_ScrollX( DstSurface : PSDL_Surface; DifX : integer );

 var

-  r1, r2 : TSDL_Rect;

-  buffer : PSDL_Surface;

+  r1, r2       : TSDL_Rect;

+  buffer       : PSDL_Surface;

 begin

   if ( DstSurface <> nil ) and ( DifX <> 0 ) then

   begin

@@ -2310,14 +2321,14 @@ end;
 procedure SDL_RotateRad( DstSurface, SrcSurface : PSDL_Surface; SrcRect :

   PSDL_Rect; DestX, DestY, OffsetX, OffsetY : Integer; Angle : Single );

 var

-  aSin, aCos : Single;

+  aSin, aCos   : Single;

   MX, MY, DX, DY, NX, NY, SX, SY, OX, OY, Width, Height, TX, TY, RX, RY, ROX, ROY : Integer;

   Colour, TempTransparentColour : UInt32;

-  MAXX, MAXY : Integer;

+  MAXX, MAXY   : Integer;

 begin

   // Rotate the surface to the target surface.

   TempTransparentColour := SrcSurface.format.colorkey;

-  if srcRect.w > srcRect.h then

+  {if srcRect.w > srcRect.h then

   begin

     Width := srcRect.w;

     Height := srcRect.w;

@@ -2326,7 +2337,7 @@ begin
   begin

     Width := srcRect.h;

     Height := srcRect.h;

-  end;

+  end; }

 

   maxx := DstSurface.w;

   maxy := DstSurface.h;

@@ -2384,8 +2395,8 @@ end;
 

 function ValidateSurfaceRect( DstSurface : PSDL_Surface; dstrect : PSDL_Rect ) : TSDL_Rect;

 var

-  RealRect : TSDL_Rect;

-  OutOfRange : Boolean;

+  RealRect     : TSDL_Rect;

+  OutOfRange   : Boolean;

 begin

   OutOfRange := false;

   if dstrect = nil then

@@ -2457,9 +2468,9 @@ end;
 

 procedure SDL_FillRectAdd( DstSurface : PSDL_Surface; dstrect : PSDL_Rect; color : UInt32 );

 var

-  RealRect : TSDL_Rect;

-  Addr : pointer;

-  ModX, BPP : cardinal;

+  RealRect     : TSDL_Rect;

+  Addr         : pointer;

+  ModX, BPP    : cardinal;

   x, y, R, G, B, SrcColor : cardinal;

 begin

   RealRect := ValidateSurfaceRect( DstSurface, DstRect );

@@ -2590,9 +2601,9 @@ end;
 

 procedure SDL_FillRectSub( DstSurface : PSDL_Surface; dstrect : PSDL_Rect; color : UInt32 );

 var

-  RealRect : TSDL_Rect;

-  Addr : pointer;

-  ModX, BPP : cardinal;

+  RealRect     : TSDL_Rect;

+  Addr         : pointer;

+  ModX, BPP    : cardinal;

   x, y, R, G, B, SrcColor : cardinal;

 begin

   RealRect := ValidateSurfaceRect( DstSurface, DstRect );

@@ -2723,13 +2734,13 @@ end;
 

 procedure SDL_GradientFillRect( DstSurface : PSDL_Surface; const Rect : PSDL_Rect; const StartColor, EndColor : TSDL_Color; const Style : TGradientStyle );

 var

-  FBC : array[ 0..255 ] of Cardinal;

+  FBC          : array[ 0..255 ] of Cardinal;

   // temp vars

   i, YR, YG, YB, SR, SG, SB, DR, DG, DB : Integer;

 

   TempStepV, TempStepH : Single;

   TempLeft, TempTop, TempHeight, TempWidth : integer;

-  TempRect : TSDL_Rect;

+  TempRect     : TSDL_Rect;

 

 begin

   // calc FBC

@@ -2787,328 +2798,328 @@ begin
   end;

 end;

 

-procedure SDL_2xBlit(Src, Dest: PSDL_Surface);

+procedure SDL_2xBlit( Src, Dest : PSDL_Surface );

 var

-  ReadAddr, WriteAddr, ReadRow, WriteRow: UInt32;

-  SrcPitch, DestPitch, x, y: UInt32;

+  ReadAddr, WriteAddr, ReadRow, WriteRow : UInt32;

+  SrcPitch, DestPitch, x, y : UInt32;

 begin

-  if (Src = nil) or (Dest = nil) then

+  if ( Src = nil ) or ( Dest = nil ) then

     exit;

-  if (Src.w shl 1) < Dest.w then

+  if ( Src.w shl 1 ) < Dest.w then

     exit;

-  if (Src.h shl 1) < Dest.h then

+  if ( Src.h shl 1 ) < Dest.h then

     exit;

 

-  if SDL_MustLock(Src) then

-    SDL_LockSurface(Src);

-  if SDL_MustLock(Dest) then

-    SDL_LockSurface(Dest);

+  if SDL_MustLock( Src ) then

+    SDL_LockSurface( Src );

+  if SDL_MustLock( Dest ) then

+    SDL_LockSurface( Dest );

 

-  ReadRow := UInt32(Src.Pixels);

-  WriteRow := UInt32(Dest.Pixels);

+  ReadRow := UInt32( Src.Pixels );

+  WriteRow := UInt32( Dest.Pixels );

 

   SrcPitch := Src.pitch;

   DestPitch := Dest.pitch;

 

   case Src.format.BytesPerPixel of

-    1: for y := 1 to Src.h do

-       begin

-         ReadAddr := ReadRow;

-         WriteAddr := WriteRow;

-         for x := 1 to Src.w do

-         begin

-           PUInt8(WriteAddr)^ := PUInt8(ReadAddr)^;

-           PUInt8(WriteAddr + 1)^ := PUInt8(ReadAddr)^;

-           PUInt8(WriteAddr + DestPitch)^ := PUInt8(ReadAddr)^;

-           PUInt8(WriteAddr + DestPitch + 1)^ := PUInt8(ReadAddr)^;

-           inc(ReadAddr);

-           inc(WriteAddr, 2);

-         end;

-         inc(UInt32(ReadRow), SrcPitch);

-         inc(UInt32(WriteRow), DestPitch * 2);

-       end;

-    2: for y := 1 to Src.h do

-       begin

-         ReadAddr := ReadRow;

-         WriteAddr := WriteRow;

-         for x := 1 to Src.w do

-         begin

-           PUInt16(WriteAddr)^ := PUInt16(ReadAddr)^;

-           PUInt16(WriteAddr + 2)^ := PUInt16(ReadAddr)^;

-           PUInt16(WriteAddr + DestPitch)^ := PUInt16(ReadAddr)^;

-           PUInt16(WriteAddr + DestPitch + 2)^ := PUInt16(ReadAddr)^;

-           inc(ReadAddr, 2);

-           inc(WriteAddr, 4);

-         end;

-         inc(UInt32(ReadRow), SrcPitch);

-         inc(UInt32(WriteRow), DestPitch * 2);

-       end;

-    3: for y := 1 to Src.h do

-       begin

-         ReadAddr := ReadRow;

-         WriteAddr := WriteRow;

-         for x := 1 to Src.w do

-         begin

-           PUInt32(WriteAddr)^ := (PUInt32(WriteAddr)^ and $ff000000) or (PUInt32(ReadAddr)^ and $00ffffff);

-           PUInt32(WriteAddr + 3)^ := (PUInt32(WriteAddr + 3)^ and $ff000000) or (PUInt32(ReadAddr)^ and $00ffffff);

-           PUInt32(WriteAddr + DestPitch)^ := (PUInt32(WriteAddr + DestPitch)^ and $ff000000) or (PUInt32(ReadAddr)^ and $00ffffff);

-           PUInt32(WriteAddr + DestPitch + 3)^ := (PUInt32(WriteAddr + DestPitch + 3)^ and $ff000000) or (PUInt32(ReadAddr)^ and $00ffffff);

-           inc(ReadAddr, 3);

-           inc(WriteAddr, 6);

-         end;

-         inc(UInt32(ReadRow), SrcPitch);

-         inc(UInt32(WriteRow), DestPitch * 2);

-       end;

-    4: for y := 1 to Src.h do

-       begin

-         ReadAddr := ReadRow;

-         WriteAddr := WriteRow;

-         for x := 1 to Src.w do

-         begin

-           PUInt32(WriteAddr)^ := PUInt32(ReadAddr)^;

-           PUInt32(WriteAddr + 4)^ := PUInt32(ReadAddr)^;

-           PUInt32(WriteAddr + DestPitch)^ := PUInt32(ReadAddr)^;

-           PUInt32(WriteAddr + DestPitch + 4)^ := PUInt32(ReadAddr)^;

-           inc(ReadAddr, 4);

-           inc(WriteAddr, 8);

-         end;

-         inc(UInt32(ReadRow), SrcPitch);

-         inc(UInt32(WriteRow), DestPitch * 2);

-       end;  

+    1 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

+        begin

+          PUInt8( WriteAddr )^ := PUInt8( ReadAddr )^;

+          PUInt8( WriteAddr + 1 )^ := PUInt8( ReadAddr )^;

+          PUInt8( WriteAddr + DestPitch )^ := PUInt8( ReadAddr )^;

+          PUInt8( WriteAddr + DestPitch + 1 )^ := PUInt8( ReadAddr )^;

+          inc( ReadAddr );

+          inc( WriteAddr, 2 );

+        end;

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

+    2 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

+        begin

+          PUInt16( WriteAddr )^ := PUInt16( ReadAddr )^;

+          PUInt16( WriteAddr + 2 )^ := PUInt16( ReadAddr )^;

+          PUInt16( WriteAddr + DestPitch )^ := PUInt16( ReadAddr )^;

+          PUInt16( WriteAddr + DestPitch + 2 )^ := PUInt16( ReadAddr )^;

+          inc( ReadAddr, 2 );

+          inc( WriteAddr, 4 );

+        end;

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

+    3 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

+        begin

+          PUInt32( WriteAddr )^ := ( PUInt32( WriteAddr )^ and $FF000000 ) or ( PUInt32( ReadAddr )^ and $00FFFFFF );

+          PUInt32( WriteAddr + 3 )^ := ( PUInt32( WriteAddr + 3 )^ and $FF000000 ) or ( PUInt32( ReadAddr )^ and $00FFFFFF );

+          PUInt32( WriteAddr + DestPitch )^ := ( PUInt32( WriteAddr + DestPitch )^ and $FF000000 ) or ( PUInt32( ReadAddr )^ and $00FFFFFF );

+          PUInt32( WriteAddr + DestPitch + 3 )^ := ( PUInt32( WriteAddr + DestPitch + 3 )^ and $FF000000 ) or ( PUInt32( ReadAddr )^ and $00FFFFFF );

+          inc( ReadAddr, 3 );

+          inc( WriteAddr, 6 );

+        end;

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

+    4 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

+        begin

+          PUInt32( WriteAddr )^ := PUInt32( ReadAddr )^;

+          PUInt32( WriteAddr + 4 )^ := PUInt32( ReadAddr )^;

+          PUInt32( WriteAddr + DestPitch )^ := PUInt32( ReadAddr )^;

+          PUInt32( WriteAddr + DestPitch + 4 )^ := PUInt32( ReadAddr )^;

+          inc( ReadAddr, 4 );

+          inc( WriteAddr, 8 );

+        end;

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

   end;

 

-  if SDL_MustLock(Src) then

-    SDL_UnlockSurface(Src);

-  if SDL_MustLock(Dest) then

-    SDL_UnlockSurface(Dest);

+  if SDL_MustLock( Src ) then

+    SDL_UnlockSurface( Src );

+  if SDL_MustLock( Dest ) then

+    SDL_UnlockSurface( Dest );

 end;

 

-procedure SDL_Scanline2xBlit(Src, Dest: PSDL_Surface);

+procedure SDL_Scanline2xBlit( Src, Dest : PSDL_Surface );

 var

-  ReadAddr, WriteAddr, ReadRow, WriteRow: UInt32;

-  SrcPitch, DestPitch, x, y: UInt32;

+  ReadAddr, WriteAddr, ReadRow, WriteRow : UInt32;

+  SrcPitch, DestPitch, x, y : UInt32;

 begin

-  if (Src = nil) or (Dest = nil) then

+  if ( Src = nil ) or ( Dest = nil ) then

     exit;

-  if (Src.w shl 1) < Dest.w then

+  if ( Src.w shl 1 ) < Dest.w then

     exit;

-  if (Src.h shl 1) < Dest.h then

+  if ( Src.h shl 1 ) < Dest.h then

     exit;

 

-  if SDL_MustLock(Src) then

-    SDL_LockSurface(Src);

-  if SDL_MustLock(Dest) then

-    SDL_LockSurface(Dest);

+  if SDL_MustLock( Src ) then

+    SDL_LockSurface( Src );

+  if SDL_MustLock( Dest ) then

+    SDL_LockSurface( Dest );

 

-  ReadRow := UInt32(Src.Pixels);

-  WriteRow := UInt32(Dest.Pixels);

+  ReadRow := UInt32( Src.Pixels );

+  WriteRow := UInt32( Dest.Pixels );

 

   SrcPitch := Src.pitch;

   DestPitch := Dest.pitch;

 

   case Src.format.BytesPerPixel of

-    1: for y := 1 to Src.h do

-       begin

-         ReadAddr := ReadRow;

-         WriteAddr := WriteRow;

-         for x := 1 to Src.w do

-         begin

-           PUInt8(WriteAddr)^ := PUInt8(ReadAddr)^;

-           PUInt8(WriteAddr + 1)^ := PUInt8(ReadAddr)^;

-           inc(ReadAddr);

-           inc(WriteAddr, 2);

-         end;

-         inc(UInt32(ReadRow), SrcPitch);

-         inc(UInt32(WriteRow), DestPitch * 2);

-       end;

-    2: for y := 1 to Src.h do

-       begin

-         ReadAddr := ReadRow;

-         WriteAddr := WriteRow;

-         for x := 1 to Src.w do

-         begin

-           PUInt16(WriteAddr)^ := PUInt16(ReadAddr)^;

-           PUInt16(WriteAddr + 2)^ := PUInt16(ReadAddr)^;

-           inc(ReadAddr, 2);

-           inc(WriteAddr, 4);

-         end;

-         inc(UInt32(ReadRow), SrcPitch);

-         inc(UInt32(WriteRow), DestPitch * 2);

-       end;

-    3: for y := 1 to Src.h do

-       begin

-         ReadAddr := ReadRow;

-         WriteAddr := WriteRow;

-         for x := 1 to Src.w do

-         begin

-           PUInt32(WriteAddr)^ := (PUInt32(WriteAddr)^ and $ff000000) or (PUInt32(ReadAddr)^ and $00ffffff);

-           PUInt32(WriteAddr + 3)^ := (PUInt32(WriteAddr + 3)^ and $ff000000) or (PUInt32(ReadAddr)^ and $00ffffff);

-           inc(ReadAddr, 3);

-           inc(WriteAddr, 6);

-         end;

-         inc(UInt32(ReadRow), SrcPitch);

-         inc(UInt32(WriteRow), DestPitch * 2);

-       end;

-    4: for y := 1 to Src.h do

-       begin

-         ReadAddr := ReadRow;

-         WriteAddr := WriteRow;

-         for x := 1 to Src.w do

-         begin

-           PUInt32(WriteAddr)^ := PUInt32(ReadAddr)^;

-           PUInt32(WriteAddr + 4)^ := PUInt32(ReadAddr)^;

-           inc(ReadAddr, 4);

-           inc(WriteAddr, 8);

-         end;

-         inc(UInt32(ReadRow), SrcPitch);

-         inc(UInt32(WriteRow), DestPitch * 2);

-       end;  

+    1 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

+        begin

+          PUInt8( WriteAddr )^ := PUInt8( ReadAddr )^;

+          PUInt8( WriteAddr + 1 )^ := PUInt8( ReadAddr )^;

+          inc( ReadAddr );

+          inc( WriteAddr, 2 );

+        end;

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

+    2 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

+        begin

+          PUInt16( WriteAddr )^ := PUInt16( ReadAddr )^;

+          PUInt16( WriteAddr + 2 )^ := PUInt16( ReadAddr )^;

+          inc( ReadAddr, 2 );

+          inc( WriteAddr, 4 );

+        end;

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

+    3 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

+        begin

+          PUInt32( WriteAddr )^ := ( PUInt32( WriteAddr )^ and $FF000000 ) or ( PUInt32( ReadAddr )^ and $00FFFFFF );

+          PUInt32( WriteAddr + 3 )^ := ( PUInt32( WriteAddr + 3 )^ and $FF000000 ) or ( PUInt32( ReadAddr )^ and $00FFFFFF );

+          inc( ReadAddr, 3 );

+          inc( WriteAddr, 6 );

+        end;

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

+    4 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

+        begin

+          PUInt32( WriteAddr )^ := PUInt32( ReadAddr )^;

+          PUInt32( WriteAddr + 4 )^ := PUInt32( ReadAddr )^;

+          inc( ReadAddr, 4 );

+          inc( WriteAddr, 8 );

+        end;

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

   end;

 

-  if SDL_MustLock(Src) then

-    SDL_UnlockSurface(Src);

-  if SDL_MustLock(Dest) then

-    SDL_UnlockSurface(Dest);

+  if SDL_MustLock( Src ) then

+    SDL_UnlockSurface( Src );

+  if SDL_MustLock( Dest ) then

+    SDL_UnlockSurface( Dest );

 end;

 

-procedure SDL_50Scanline2xBlit(Src, Dest: PSDL_Surface);

+procedure SDL_50Scanline2xBlit( Src, Dest : PSDL_Surface );

 var

-  ReadAddr, WriteAddr, ReadRow, WriteRow: UInt32;

-  SrcPitch, DestPitch, x, y, Color: UInt32;

+  ReadAddr, WriteAddr, ReadRow, WriteRow : UInt32;

+  SrcPitch, DestPitch, x, y, Color : UInt32;

 begin

-  if (Src = nil) or (Dest = nil) then

+  if ( Src = nil ) or ( Dest = nil ) then

     exit;

-  if (Src.w shl 1) < Dest.w then

+  if ( Src.w shl 1 ) < Dest.w then

     exit;

-  if (Src.h shl 1) < Dest.h then

+  if ( Src.h shl 1 ) < Dest.h then

     exit;

 

-  if SDL_MustLock(Src) then

-    SDL_LockSurface(Src);

-  if SDL_MustLock(Dest) then

-    SDL_LockSurface(Dest);

+  if SDL_MustLock( Src ) then

+    SDL_LockSurface( Src );

+  if SDL_MustLock( Dest ) then

+    SDL_LockSurface( Dest );

 

-  ReadRow := UInt32(Src.Pixels);

-  WriteRow := UInt32(Dest.Pixels);

+  ReadRow := UInt32( Src.Pixels );

+  WriteRow := UInt32( Dest.Pixels );

 

   SrcPitch := Src.pitch;

   DestPitch := Dest.pitch;

 

   case Src.format.BitsPerPixel of

-    8: for y := 1 to Src.h do

-       begin

-         ReadAddr := ReadRow;

-         WriteAddr := WriteRow;

-         for x := 1 to Src.w do

-         begin

-           Color := PUInt8(ReadAddr)^;

-           PUInt8(WriteAddr)^ := Color;

-           PUInt8(WriteAddr + 1)^ := Color;

-           Color := (Color shr 1) and $6d; {%01101101}

-           PUInt8(WriteAddr + DestPitch)^ := Color;

-           PUInt8(WriteAddr + DestPitch + 1)^ := Color;

-           inc(ReadAddr);

-           inc(WriteAddr, 2);

-         end;

-         inc(UInt32(ReadRow), SrcPitch);

-         inc(UInt32(WriteRow), DestPitch * 2);

-       end;

-    15: for y := 1 to Src.h do

+    8 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

         begin

-          ReadAddr := ReadRow;

-          WriteAddr := WriteRow;

-          for x := 1 to Src.w do

-          begin

-            Color := PUInt16(ReadAddr)^;

-            PUInt16(WriteAddr)^ := Color;

-            PUInt16(WriteAddr + 2)^ := Color;

-            Color := (Color shr 1) and $3def; {%0011110111101111}

-            PUInt16(WriteAddr + DestPitch)^ := Color;

-            PUInt16(WriteAddr + DestPitch + 2)^ := Color;

-            inc(ReadAddr, 2);

-            inc(WriteAddr, 4);

-          end;

-          inc(UInt32(ReadRow), SrcPitch);

-          inc(UInt32(WriteRow), DestPitch * 2);

+          Color := PUInt8( ReadAddr )^;

+          PUInt8( WriteAddr )^ := Color;

+          PUInt8( WriteAddr + 1 )^ := Color;

+          Color := ( Color shr 1 ) and $6D; {%01101101}

+          PUInt8( WriteAddr + DestPitch )^ := Color;

+          PUInt8( WriteAddr + DestPitch + 1 )^ := Color;

+          inc( ReadAddr );

+          inc( WriteAddr, 2 );

         end;

-    16: for y := 1 to Src.h do

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

+    15 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

         begin

-          ReadAddr := ReadRow;

-          WriteAddr := WriteRow;

-          for x := 1 to Src.w do

-          begin

-            Color := PUInt16(ReadAddr)^;

-            PUInt16(WriteAddr)^ := Color;

-            PUInt16(WriteAddr + 2)^ := Color;

-            Color := (Color shr 1) and $7bef; {%0111101111101111}

-            PUInt16(WriteAddr + DestPitch)^ := Color;

-            PUInt16(WriteAddr + DestPitch + 2)^ := Color;

-            inc(ReadAddr, 2);

-            inc(WriteAddr, 4);

-          end;

-          inc(UInt32(ReadRow), SrcPitch);

-          inc(UInt32(WriteRow), DestPitch * 2);

+          Color := PUInt16( ReadAddr )^;

+          PUInt16( WriteAddr )^ := Color;

+          PUInt16( WriteAddr + 2 )^ := Color;

+          Color := ( Color shr 1 ) and $3DEF; {%0011110111101111}

+          PUInt16( WriteAddr + DestPitch )^ := Color;

+          PUInt16( WriteAddr + DestPitch + 2 )^ := Color;

+          inc( ReadAddr, 2 );

+          inc( WriteAddr, 4 );

+        end;

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

+    16 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

+        begin

+          Color := PUInt16( ReadAddr )^;

+          PUInt16( WriteAddr )^ := Color;

+          PUInt16( WriteAddr + 2 )^ := Color;

+          Color := ( Color shr 1 ) and $7BEF; {%0111101111101111}

+          PUInt16( WriteAddr + DestPitch )^ := Color;

+          PUInt16( WriteAddr + DestPitch + 2 )^ := Color;

+          inc( ReadAddr, 2 );

+          inc( WriteAddr, 4 );

         end;

-    24: for y := 1 to Src.h do

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

+    24 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

         begin

-          ReadAddr := ReadRow;

-          WriteAddr := WriteRow;

-          for x := 1 to Src.w do

-          begin

-            Color := (PUInt32(WriteAddr)^ and $ff000000) or (PUInt32(ReadAddr)^ and $00ffffff);

-            PUInt32(WriteAddr)^ := Color;

-            PUInt32(WriteAddr + 3)^ := Color;

-            Color := (Color shr 1) and $007f7f7f; {%011111110111111101111111}

-            PUInt32(WriteAddr + DestPitch)^ := Color;

-            PUInt32(WriteAddr + DestPitch + 3)^ := Color;

-            inc(ReadAddr, 3);

-            inc(WriteAddr, 6);

-          end;

-          inc(UInt32(ReadRow), SrcPitch);

-          inc(UInt32(WriteRow), DestPitch * 2);

+          Color := ( PUInt32( WriteAddr )^ and $FF000000 ) or ( PUInt32( ReadAddr )^ and $00FFFFFF );

+          PUInt32( WriteAddr )^ := Color;

+          PUInt32( WriteAddr + 3 )^ := Color;

+          Color := ( Color shr 1 ) and $007F7F7F; {%011111110111111101111111}

+          PUInt32( WriteAddr + DestPitch )^ := Color;

+          PUInt32( WriteAddr + DestPitch + 3 )^ := Color;

+          inc( ReadAddr, 3 );

+          inc( WriteAddr, 6 );

         end;

-    32: for y := 1 to Src.h do

-       begin

-         ReadAddr := ReadRow;

-         WriteAddr := WriteRow;

-         for x := 1 to Src.w do

-         begin

-           Color := PUInt32(ReadAddr)^;

-           PUInt32(WriteAddr)^ := Color;

-           PUInt32(WriteAddr + 4)^ := Color;

-           Color := (Color shr 1) and $7f7f7f7f;

-           PUInt32(WriteAddr + DestPitch)^ := Color;

-           PUInt32(WriteAddr + DestPitch + 4)^ := Color;

-           inc(ReadAddr, 4);

-           inc(WriteAddr, 8);

-         end;

-         inc(UInt32(ReadRow), SrcPitch);

-         inc(UInt32(WriteRow), DestPitch * 2);

-       end;  

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

+    32 : for y := 1 to Src.h do

+      begin

+        ReadAddr := ReadRow;

+        WriteAddr := WriteRow;

+        for x := 1 to Src.w do

+        begin

+          Color := PUInt32( ReadAddr )^;

+          PUInt32( WriteAddr )^ := Color;

+          PUInt32( WriteAddr + 4 )^ := Color;

+          Color := ( Color shr 1 ) and $7F7F7F7F;

+          PUInt32( WriteAddr + DestPitch )^ := Color;

+          PUInt32( WriteAddr + DestPitch + 4 )^ := Color;

+          inc( ReadAddr, 4 );

+          inc( WriteAddr, 8 );

+        end;

+        inc( UInt32( ReadRow ), SrcPitch );

+        inc( UInt32( WriteRow ), DestPitch * 2 );

+      end;

   end;

 

-  if SDL_MustLock(Src) then

-    SDL_UnlockSurface(Src);

-  if SDL_MustLock(Dest) then

-    SDL_UnlockSurface(Dest);

+  if SDL_MustLock( Src ) then

+    SDL_UnlockSurface( Src );

+  if SDL_MustLock( Dest ) then

+    SDL_UnlockSurface( Dest );

 end;

 

 function SDL_PixelTestSurfaceVsRect( SrcSurface1 : PSDL_Surface; SrcRect1 :

-PSDL_Rect; SrcRect2 : PSDL_Rect; Left1, Top1, Left2, Top2 : integer ) :

-boolean;

+  PSDL_Rect; SrcRect2 : PSDL_Rect; Left1, Top1, Left2, Top2 : integer ) :

+  boolean;

 var

   Src_Rect1, Src_Rect2 : TSDL_Rect;

   right1, bottom1 : integer;

   right2, bottom2 : integer;

-  Scan1Start, Scan2Start, ScanWidth, ScanHeight : cardinal;

-  Mod1: cardinal;

-  Addr1 : cardinal;

-  BPP : cardinal;

-  Pitch1 : cardinal;

+  Scan1Start, {Scan2Start,} ScanWidth, ScanHeight : cardinal;

+  Mod1         : cardinal;

+  Addr1        : cardinal;

+  BPP          : cardinal;

+  Pitch1       : cardinal;

   TransparentColor1 : cardinal;

-  tx, ty : cardinal;

-  StartTick : cardinal;

-  Color1 : cardinal;

+  tx, ty       : cardinal;

+  StartTick    : cardinal;

+  Color1       : cardinal;

 begin

   Result := false;

   if SrcRect1 = nil then

@@ -3124,7 +3135,7 @@ begin
   else

     Src_Rect1 := SrcRect1^;

 

-    Src_Rect2 := SrcRect2^;

+  Src_Rect2 := SrcRect2^;

   with Src_Rect1 do

   begin

     Right1 := Left1 + w;

@@ -3135,15 +3146,13 @@ begin
     Right2 := Left2 + w;

     Bottom2 := Top2 + h;

   end;

-  if ( Left1 >= Right2 ) or ( Right1 <= Left2 ) or ( Top1 >= Bottom2 ) or ( 

-Bottom1 <=

-    Top2 ) then

+  if ( Left1 >= Right2 ) or ( Right1 <= Left2 ) or ( Top1 >= Bottom2 ) or ( Bottom1 <= Top2 ) then

     exit;

   if Left1 <= Left2 then

   begin

     // 1. left, 2. right

     Scan1Start := Src_Rect1.x + Left2 - Left1;

-    Scan2Start := Src_Rect2.x;

+    //Scan2Start := Src_Rect2.x;

     ScanWidth := Right1 - Left2;

     with Src_Rect2 do

       if ScanWidth > w then

@@ -3153,7 +3162,7 @@ Bottom1 <=
   begin

     // 1. right, 2. left

     Scan1Start := Src_Rect1.x;

-    Scan2Start := Src_Rect2.x + Left1 - Left2;

+    //Scan2Start := Src_Rect2.x + Left1 - Left2;

     ScanWidth := Right2 - Left1;

     with Src_Rect1 do

       if ScanWidth > w then

@@ -3213,7 +3222,7 @@ Bottom1 <=
       begin

         for tx := 1 to ScanWidth do

         begin

-          if ( PWord( Addr1 )^ <> TransparentColor1 )  then

+          if ( PWord( Addr1 )^ <> TransparentColor1 ) then

           begin

             Result := true;

             exit;

@@ -3248,7 +3257,7 @@ Bottom1 <=
       begin

         for tx := 1 to ScanWidth do

         begin

-          if ( PLongWord( Addr1 )^ <> TransparentColor1 )  then

+          if ( PLongWord( Addr1 )^ <> TransparentColor1 ) then

           begin

             Result := true;

             exit;

@@ -3266,12 +3275,12 @@ procedure SDL_ORSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;
   DestSurface : PSDL_Surface; DestRect : PSDL_Rect );

 var

   R, G, B, Pixel1, Pixel2, TransparentColor : cardinal;

-  Src, Dest : TSDL_Rect;

-  Diff : integer;

+  Src, Dest    : TSDL_Rect;

+  Diff         : integer;

   SrcAddr, DestAddr : cardinal;

   WorkX, WorkY : word;

   SrcMod, DestMod : cardinal;

-  Bits : cardinal;

+  Bits         : cardinal;

 begin

   if ( SrcSurface = nil ) or ( DestSurface = nil ) then

     exit; // Remove this to make it faster

@@ -3366,7 +3375,7 @@ begin
             if ( Pixel1 <> TransparentColor ) and ( Pixel1 <> 0 ) then

             begin

               Pixel2 := PUInt8( DestAddr )^;

-              PUInt8( DestAddr )^ := Pixel2 OR Pixel1;

+              PUInt8( DestAddr )^ := Pixel2 or Pixel1;

             end;

             inc( SrcAddr );

             inc( DestAddr );

@@ -3387,7 +3396,7 @@ begin
             begin

               Pixel2 := PUInt16( DestAddr )^;

 

-              PUInt16( DestAddr )^ := Pixel2 OR Pixel1;

+              PUInt16( DestAddr )^ := Pixel2 or Pixel1;

 

             end;

             inc( SrcAddr, 2 );

@@ -3409,7 +3418,7 @@ begin
             begin

               Pixel2 := PUInt16( DestAddr )^;

 

-                PUInt16( DestAddr )^ := Pixel2 OR Pixel1;

+              PUInt16( DestAddr )^ := Pixel2 or Pixel1;

 

             end;

             inc( SrcAddr, 2 );

@@ -3452,7 +3461,7 @@ begin
             begin

               Pixel2 := PUInt32( DestAddr )^;

 

-                PUInt32( DestAddr )^ := Pixel2 or Pixel1;

+              PUInt32( DestAddr )^ := Pixel2 or Pixel1;

             end;

             inc( SrcAddr, 4 );

             inc( DestAddr, 4 );

@@ -3472,12 +3481,12 @@ procedure SDL_ANDSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;
   DestSurface : PSDL_Surface; DestRect : PSDL_Rect );

 var

   R, G, B, Pixel1, Pixel2, TransparentColor : cardinal;

-  Src, Dest : TSDL_Rect;

-  Diff : integer;

+  Src, Dest    : TSDL_Rect;

+  Diff         : integer;

   SrcAddr, DestAddr : cardinal;

   WorkX, WorkY : word;

   SrcMod, DestMod : cardinal;

-  Bits : cardinal;

+  Bits         : cardinal;

 begin

   if ( SrcSurface = nil ) or ( DestSurface = nil ) then

     exit; // Remove this to make it faster

@@ -3615,7 +3624,7 @@ begin
             begin

               Pixel2 := PUInt16( DestAddr )^;

 

-                PUInt16( DestAddr )^ := Pixel2 and Pixel1;

+              PUInt16( DestAddr )^ := Pixel2 and Pixel1;

 

             end;

             inc( SrcAddr, 2 );

@@ -3658,7 +3667,7 @@ begin
             begin

               Pixel2 := PUInt32( DestAddr )^;

 

-                PUInt32( DestAddr )^ := Pixel2 and Pixel1;

+              PUInt32( DestAddr )^ := Pixel2 and Pixel1;

             end;

             inc( SrcAddr, 4 );

             inc( DestAddr, 4 );

@@ -3680,12 +3689,12 @@ procedure SDL_GTSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;
   DestSurface : PSDL_Surface; DestRect : PSDL_Rect );

 var

   R, G, B, Pixel1, Pixel2, TransparentColor : cardinal;

-  Src, Dest : TSDL_Rect;

-  Diff : integer;

+  Src, Dest    : TSDL_Rect;

+  Diff         : integer;

   SrcAddr, DestAddr : cardinal;

   WorkX, WorkY : word;

   SrcMod, DestMod : cardinal;

-  Bits : cardinal;

+  Bits         : cardinal;

 begin

   if ( SrcSurface = nil ) or ( DestSurface = nil ) then

     exit; // Remove this to make it faster

@@ -3782,9 +3791,18 @@ begin
               Pixel2 := PUInt8( DestAddr )^;

               if Pixel2 > 0 then

               begin

-                if Pixel2 and $E0 > Pixel1 and $E0 then R := Pixel2 and $E0 else R := Pixel1 and $E0;

-                if Pixel2 and $1C > Pixel1 and $1C then G := Pixel2 and $1C else G := Pixel1 and $1C;

-                if Pixel2 and $03 > Pixel1 and $03 then B := Pixel2 and $03 else B := Pixel1 and $03;

+                if Pixel2 and $E0 > Pixel1 and $E0 then

+                  R := Pixel2 and $E0

+                else

+                  R := Pixel1 and $E0;

+                if Pixel2 and $1C > Pixel1 and $1C then

+                  G := Pixel2 and $1C

+                else

+                  G := Pixel1 and $1C;

+                if Pixel2 and $03 > Pixel1 and $03 then

+                  B := Pixel2 and $03

+                else

+                  B := Pixel1 and $03;

 

                 if R > $E0 then

                   R := $E0;

@@ -3818,9 +3836,18 @@ begin
               if Pixel2 > 0 then

               begin

 

-              if Pixel2 and $7C00 > Pixel1 and $7C00 then R := Pixel2 and $7C00 else R := Pixel1 and $7C00;

-              if Pixel2 and $03E0 > Pixel1 and $03E0 then G := Pixel2 and $03E0 else G := Pixel1 and $03E0;

-              if Pixel2 and $001F > Pixel1 and $001F then B := Pixel2 and $001F else B := Pixel1 and $001F;

+                if Pixel2 and $7C00 > Pixel1 and $7C00 then

+                  R := Pixel2 and $7C00

+                else

+                  R := Pixel1 and $7C00;

+                if Pixel2 and $03E0 > Pixel1 and $03E0 then

+                  G := Pixel2 and $03E0

+                else

+                  G := Pixel1 and $03E0;

+                if Pixel2 and $001F > Pixel1 and $001F then

+                  B := Pixel2 and $001F

+                else

+                  B := Pixel1 and $001F;

 

                 PUInt16( DestAddr )^ := R or G or B;

               end

@@ -3848,9 +3875,18 @@ begin
               if Pixel2 > 0 then

               begin

 

-              if Pixel2 and $F800 > Pixel1 and $F800 then R := Pixel2 and $F800 else R := Pixel1 and $F800;

-              if Pixel2 and $07E0 > Pixel1 and $07E0 then G := Pixel2 and $07E0 else G := Pixel1 and $07E0;

-              if Pixel2 and $001F > Pixel1 and $001F then B := Pixel2 and $001F else B := Pixel1 and $001F;

+                if Pixel2 and $F800 > Pixel1 and $F800 then

+                  R := Pixel2 and $F800

+                else

+                  R := Pixel1 and $F800;

+                if Pixel2 and $07E0 > Pixel1 and $07E0 then

+                  G := Pixel2 and $07E0

+                else

+                  G := Pixel1 and $07E0;

+                if Pixel2 and $001F > Pixel1 and $001F then

+                  B := Pixel2 and $001F

+                else

+                  B := Pixel1 and $001F;

 

                 PUInt16( DestAddr )^ := R or G or B;

               end

@@ -3878,9 +3914,18 @@ begin
               if Pixel2 > 0 then

               begin

 

-              if Pixel2 and $FF0000 > Pixel1 and $FF0000 then R := Pixel2 and $FF0000 else R := Pixel1 and $FF0000;

-              if Pixel2 and $00FF00 > Pixel1 and $00FF00 then G := Pixel2 and $00FF00 else G := Pixel1 and $00FF00;

-              if Pixel2 and $0000FF > Pixel1 and $0000FF then B := Pixel2 and $0000FF else B := Pixel1 and $0000FF;

+                if Pixel2 and $FF0000 > Pixel1 and $FF0000 then

+                  R := Pixel2 and $FF0000

+                else

+                  R := Pixel1 and $FF0000;

+                if Pixel2 and $00FF00 > Pixel1 and $00FF00 then

+                  G := Pixel2 and $00FF00

+                else

+                  G := Pixel1 and $00FF00;

+                if Pixel2 and $0000FF > Pixel1 and $0000FF then

+                  B := Pixel2 and $0000FF

+                else

+                  B := Pixel1 and $0000FF;

 

                 PUInt32( DestAddr )^ := PUInt32( DestAddr )^ and $FF000000 or ( R or G or B );

               end

@@ -3908,9 +3953,18 @@ begin
               if Pixel2 > 0 then

               begin

 

-              if Pixel2 and $FF0000 > Pixel1 and $FF0000 then R := Pixel2 and $FF0000 else R := Pixel1 and $FF0000;

-              if Pixel2 and $00FF00 > Pixel1 and $00FF00 then G := Pixel2 and $00FF00 else G := Pixel1 and $00FF00;

-              if Pixel2 and $0000FF > Pixel1 and $0000FF then B := Pixel2 and $0000FF else B := Pixel1 and $0000FF;

+                if Pixel2 and $FF0000 > Pixel1 and $FF0000 then

+                  R := Pixel2 and $FF0000

+                else

+                  R := Pixel1 and $FF0000;

+                if Pixel2 and $00FF00 > Pixel1 and $00FF00 then

+                  G := Pixel2 and $00FF00

+                else

+                  G := Pixel1 and $00FF00;

+                if Pixel2 and $0000FF > Pixel1 and $0000FF then

+                  B := Pixel2 and $0000FF

+                else

+                  B := Pixel1 and $0000FF;

 

                 PUInt32( DestAddr )^ := R or G or B;

               end

@@ -3936,12 +3990,12 @@ procedure SDL_LTSurface( SrcSurface : PSDL_Surface; SrcRect : PSDL_Rect;
   DestSurface : PSDL_Surface; DestRect : PSDL_Rect );

 var

   R, G, B, Pixel1, Pixel2, TransparentColor : cardinal;

-  Src, Dest : TSDL_Rect;

-  Diff : integer;

+  Src, Dest    : TSDL_Rect;

+  Diff         : integer;

   SrcAddr, DestAddr : cardinal;

   WorkX, WorkY : word;

   SrcMod, DestMod : cardinal;

-  Bits : cardinal;

+  Bits         : cardinal;

 begin

   if ( SrcSurface = nil ) or ( DestSurface = nil ) then

     exit; // Remove this to make it faster

@@ -4038,9 +4092,18 @@ begin
               Pixel2 := PUInt8( DestAddr )^;

               if Pixel2 > 0 then

               begin

-                if Pixel2 and $E0 < Pixel1 and $E0 then R := Pixel2 and $E0 else R := Pixel1 and $E0;

-                if Pixel2 and $1C < Pixel1 and $1C then G := Pixel2 and $1C else G := Pixel1 and $1C;

-                if Pixel2 and $03 < Pixel1 and $03 then B := Pixel2 and $03 else B := Pixel1 and $03;

+                if Pixel2 and $E0 < Pixel1 and $E0 then

+                  R := Pixel2 and $E0

+                else

+                  R := Pixel1 and $E0;

+                if Pixel2 and $1C < Pixel1 and $1C then

+                  G := Pixel2 and $1C

+                else

+                  G := Pixel1 and $1C;

+                if Pixel2 and $03 < Pixel1 and $03 then

+                  B := Pixel2 and $03

+                else

+                  B := Pixel1 and $03;

 

                 if R > $E0 then

                   R := $E0;

@@ -4074,9 +4137,18 @@ begin
               if Pixel2 > 0 then

               begin

 

-              if Pixel2 and $7C00 < Pixel1 and $7C00 then R := Pixel2 and $7C00 else R := Pixel1 and $7C00;

-              if Pixel2 and $03E0 < Pixel1 and $03E0 then G := Pixel2 and $03E0 else G := Pixel1 and $03E0;

-              if Pixel2 and $001F < Pixel1 and $001F then B := Pixel2 and $001F else B := Pixel1 and $001F;

+                if Pixel2 and $7C00 < Pixel1 and $7C00 then

+                  R := Pixel2 and $7C00

+                else

+                  R := Pixel1 and $7C00;

+                if Pixel2 and $03E0 < Pixel1 and $03E0 then

+                  G := Pixel2 and $03E0

+                else

+                  G := Pixel1 and $03E0;

+                if Pixel2 and $001F < Pixel1 and $001F then

+                  B := Pixel2 and $001F

+                else

+                  B := Pixel1 and $001F;

 

                 PUInt16( DestAddr )^ := R or G or B;

               end

@@ -4104,9 +4176,18 @@ begin
               if Pixel2 > 0 then

               begin

 

-              if Pixel2 and $F800 < Pixel1 and $F800 then R := Pixel2 and $F800 else R := Pixel1 and $F800;

-              if Pixel2 and $07E0 < Pixel1 and $07E0 then G := Pixel2 and $07E0 else G := Pixel1 and $07E0;

-              if Pixel2 and $001F < Pixel1 and $001F then B := Pixel2 and $001F else B := Pixel1 and $001F;

+                if Pixel2 and $F800 < Pixel1 and $F800 then

+                  R := Pixel2 and $F800

+                else

+                  R := Pixel1 and $F800;

+                if Pixel2 and $07E0 < Pixel1 and $07E0 then

+                  G := Pixel2 and $07E0

+                else

+                  G := Pixel1 and $07E0;

+                if Pixel2 and $001F < Pixel1 and $001F then

+                  B := Pixel2 and $001F

+                else

+                  B := Pixel1 and $001F;

 

                 PUInt16( DestAddr )^ := R or G or B;

               end

@@ -4134,9 +4215,18 @@ begin
               if Pixel2 > 0 then

               begin

 

-              if Pixel2 and $FF0000 < Pixel1 and $FF0000 then R := Pixel2 and $FF0000 else R := Pixel1 and $FF0000;

-              if Pixel2 and $00FF00 < Pixel1 and $00FF00 then G := Pixel2 and $00FF00 else G := Pixel1 and $00FF00;

-              if Pixel2 and $0000FF < Pixel1 and $0000FF then B := Pixel2 and $0000FF else B := Pixel1 and $0000FF;

+                if Pixel2 and $FF0000 < Pixel1 and $FF0000 then

+                  R := Pixel2 and $FF0000

+                else

+                  R := Pixel1 and $FF0000;

+                if Pixel2 and $00FF00 < Pixel1 and $00FF00 then

+                  G := Pixel2 and $00FF00

+                else

+                  G := Pixel1 and $00FF00;

+                if Pixel2 and $0000FF < Pixel1 and $0000FF then

+                  B := Pixel2 and $0000FF

+                else

+                  B := Pixel1 and $0000FF;

 

                 PUInt32( DestAddr )^ := PUInt32( DestAddr )^ and $FF000000 or ( R or G or B );

               end

@@ -4164,9 +4254,18 @@ begin
               if Pixel2 > 0 then

               begin

 

-              if Pixel2 and $FF0000 < Pixel1 and $FF0000 then R := Pixel2 and $FF0000 else R := Pixel1 and $FF0000;

-              if Pixel2 and $00FF00 < Pixel1 and $00FF00 then G := Pixel2 and $00FF00 else G := Pixel1 and $00FF00;

-              if Pixel2 and $0000FF < Pixel1 and $0000FF then B := Pixel2 and $0000FF else B := Pixel1 and $0000FF;

+                if Pixel2 and $FF0000 < Pixel1 and $FF0000 then

+                  R := Pixel2 and $FF0000

+                else

+                  R := Pixel1 and $FF0000;

+                if Pixel2 and $00FF00 < Pixel1 and $00FF00 then

+                  G := Pixel2 and $00FF00

+                else

+                  G := Pixel1 and $00FF00;

+                if Pixel2 and $0000FF < Pixel1 and $0000FF then

+                  B := Pixel2 and $0000FF

+                else

+                  B := Pixel1 and $0000FF;

 

                 PUInt32( DestAddr )^ := R or G or B;

               end

@@ -4188,69 +4287,75 @@ begin
 end;

 

 // Will clip the x1,x2,y1,x2 params to the ClipRect provided

-function SDL_ClipLine(var x1,y1,x2,y2: Integer; ClipRect: PSDL_Rect) : boolean;

-  var tflag, flag1, flag2: word;

-    txy, xedge, yedge: Integer;

-    slope: single;

 

-  function ClipCode(x,y: Integer): word;

+function SDL_ClipLine( var x1, y1, x2, y2 : Integer; ClipRect : PSDL_Rect ) : boolean;

+var

+  tflag, flag1, flag2 : word;

+  txy, xedge, yedge : Integer;

+  slope        : single;

+

+  function ClipCode( x, y : Integer ) : word;

   begin

     Result := 0;

-    if x < ClipRect.x then Result := 1;

-    if x >= ClipRect.w + ClipRect.x then Result := Result or 2;

-    if y < ClipRect.y then Result := Result or 4;

-    if y >= ClipRect.h + ClipRect.y then Result := Result or 8;

+    if x < ClipRect.x then

+      Result := 1;

+    if x >= ClipRect.w + ClipRect.x then

+      Result := Result or 2;

+    if y < ClipRect.y then

+      Result := Result or 4;

+    if y >= ClipRect.h + ClipRect.y then

+      Result := Result or 8;

   end;

 

 begin

-  flag1 := ClipCode(x1,y1);

-  flag2 := ClipCode(x2,y2);

+  flag1 := ClipCode( x1, y1 );

+  flag2 := ClipCode( x2, y2 );

   result := true;

 

   while true do

   begin

-    if (flag1 or flag2) = 0 then Exit; // all in

+    if ( flag1 or flag2 ) = 0 then

+      Exit; // all in

 

-    if (flag1 and flag2) <> 0 then

-      begin

-        result := false;

-        Exit; // all out

-      end;

+    if ( flag1 and flag2 ) <> 0 then

+    begin

+      result := false;

+      Exit; // all out

+    end;

 

     if flag2 = 0 then

-      begin

-        txy := x1; x1 := x2; x2 := txy;

-        txy := y1; y1 := y2; y2 := txy;

-        tflag := flag1; flag1 := flag2; flag2 := tflag;

-      end;

+    begin

+      txy := x1; x1 := x2; x2 := txy;

+      txy := y1; y1 := y2; y2 := txy;

+      tflag := flag1; flag1 := flag2; flag2 := tflag;

+    end;

 

-    if (flag2 and 3) <> 0 then

-      begin

-        if (flag2 and 1) <> 0 then

-          xedge := ClipRect.x

-        else

-          xedge := ClipRect.w + ClipRect.x -1; // back 1 pixel otherwise we end up in a loop

-

-        slope := (y2 - y1) / (x2 - x1);

-        y2 := y1 + Round(slope * (xedge - x1));

-        x2 := xedge;

-      end

+    if ( flag2 and 3 ) <> 0 then

+    begin

+      if ( flag2 and 1 ) <> 0 then

+        xedge := ClipRect.x

+      else

+        xedge := ClipRect.w + ClipRect.x - 1; // back 1 pixel otherwise we end up in a loop

+

+      slope := ( y2 - y1 ) / ( x2 - x1 );

+      y2 := y1 + Round( slope * ( xedge - x1 ) );

+      x2 := xedge;

+    end

     else

-      begin

-        if (flag2 and 4) <> 0 then

-          yedge := ClipRect.y

-        else

-          yedge := ClipRect.h + ClipRect.y -1; // up 1 pixel otherwise we end up in a loop

-

-        slope := (x2 - x1) / (y2 - y1);

-        x2 := x1 + Round(slope * (yedge - y1));

-        y2 := yedge;

-      end;

+    begin

+      if ( flag2 and 4 ) <> 0 then

+        yedge := ClipRect.y

+      else

+        yedge := ClipRect.h + ClipRect.y - 1; // up 1 pixel otherwise we end up in a loop

 

-    flag2 := ClipCode(x2, y2);

+      slope := ( x2 - x1 ) / ( y2 - y1 );

+      x2 := x1 + Round( slope * ( yedge - y1 ) );

+      y2 := yedge;

+    end;

+

+    flag2 := ClipCode( x2, y2 );

   end;

 end;

 

 end.

 

-

diff --git a/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlwindow.pas b/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlwindow.pas
index ef290071..ba60714b 100644
--- a/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlwindow.pas
+++ b/Game/Code/lib/JEDI-SDL/SDL/Pas/sdlwindow.pas
@@ -1,6 +1,6 @@
 unit sdlwindow;

 {

-  $Id: sdlwindow.pas,v 1.7 2004/09/30 22:35:47 savage Exp $

+  $Id: sdlwindow.pas,v 1.9 2006/10/22 18:55:25 savage Exp $

   

 }

 {******************************************************************************}

@@ -59,6 +59,12 @@ unit sdlwindow;
 {                                                                              }

 {

   $Log: sdlwindow.pas,v $

+  Revision 1.9  2006/10/22 18:55:25  savage

+  Slight Change to handle OpenGL context

+

+  Revision 1.8  2005/08/03 18:57:32  savage

+  Various updates and additions. Mainly to handle OpenGL 3D Window support and better cursor support for the mouse class

+

   Revision 1.7  2004/09/30 22:35:47  savage

   Changes, enhancements and additions as required to get SoAoS working.

 

@@ -171,15 +177,8 @@ type
     function Show : Boolean; virtual;

   end;

 

-  TSDL2DWindow = class( TSDLBaseWindow )

+  TSDLCustomWindow = class( TSDLBaseWindow )

   public

-    constructor Create( aWidth : integer; aHeight : integer; aBitDepth : integer; aVideoFlags : Uint32 = SDL_DOUBLEBUF or SDL_SWSURFACE); override;

-    procedure Render; override;

-    procedure Update( aElapsedTime : single ); override;

-    procedure InitialiseObjects; override;

-    procedure RestoreObjects; override;

-    procedure DeleteObjects; override;

-    function Flip : integer; override;

     property OnCreate;

     property OnDestroy;

     property OnClose;

@@ -190,7 +189,18 @@ type
     property DisplaySurface;

   end;

 

-  TSDL3DWindow = class( TSDLBaseWindow )

+  TSDL2DWindow = class( TSDLCustomWindow )

+  public

+    constructor Create( aWidth : integer; aHeight : integer; aBitDepth : integer; aVideoFlags : Uint32 = SDL_DOUBLEBUF or SDL_SWSURFACE); override;

+    procedure Render; override;

+    procedure Update( aElapsedTime : single ); override;

+    procedure InitialiseObjects; override;

+    procedure RestoreObjects; override;

+    procedure DeleteObjects; override;

+    function Flip : integer; override;

+  end;

+

+  TSDL3DWindow = class( TSDLCustomWindow )

   public

     constructor Create( aWidth : integer; aHeight : integer; aBitDepth : integer; aVideoFlags : Uint32 = SDL_OPENGL or SDL_DOUBLEBUF); override;

     function Flip : integer; override;

@@ -199,14 +209,6 @@ type
     procedure InitialiseObjects; override;

     procedure RestoreObjects; override;

     procedure DeleteObjects; override;

-    property OnCreate;

-    property OnDestroy;

-    property OnClose;

-    property OnShow;

-    property OnResize;

-    property OnRender;

-    property OnUpdate;

-    property DisplaySurface;

   end;

 

 

@@ -226,7 +228,7 @@ begin
     Log.LogError( Format('Could not set video mode: %s', [SDL_GetError]), 'Main');

     exit;

   end;

-  

+

   SetCaption( 'Made with JEDI-SDL', 'JEDI-SDL Icon' );

 end;

 

@@ -552,7 +554,7 @@ end;
 procedure TSDL3DWindow.Render;

 begin

   inherited;

-

+  

 end;

 

 procedure TSDL3DWindow.RestoreObjects;

diff --git a/Game/Code/lib/JEDI-SDL/SDL_Image/Pas/sdl_image.pas b/Game/Code/lib/JEDI-SDL/SDL_Image/Pas/sdl_image.pas
index fecc0dbc..d0699761 100644
--- a/Game/Code/lib/JEDI-SDL/SDL_Image/Pas/sdl_image.pas
+++ b/Game/Code/lib/JEDI-SDL/SDL_Image/Pas/sdl_image.pas
@@ -1,6 +1,6 @@
 unit sdl_image;

 {

-  $Id: sdl_image.pas,v 1.7 2005/01/01 02:03:12 savage Exp $

+  $Id: sdl_image.pas,v 1.15 2007/12/05 22:52:23 savage Exp $

   

 }

 {******************************************************************************}

@@ -83,6 +83,30 @@ unit sdl_image;
 {                                                                              }

 {

   $Log: sdl_image.pas,v $

+  Revision 1.15  2007/12/05 22:52:23  savage

+  Better Mac OS X support for Frameworks.

+

+  Revision 1.14  2007/05/29 21:31:13  savage

+  Changes as suggested by Almindor for 64bit compatibility.

+

+  Revision 1.13  2007/05/20 20:30:54  savage

+  Initial Changes to Handle 64 Bits

+

+  Revision 1.12  2006/12/02 00:14:40  savage

+  Updated to latest version

+

+  Revision 1.11  2005/04/10 18:22:59  savage

+  Changes as suggested by Michalis, thanks.

+

+  Revision 1.10  2005/04/10 11:48:33  savage

+  Changes as suggested by Michalis, thanks.

+

+  Revision 1.9  2005/01/05 01:47:07  savage

+  Changed LibName to reflect what MacOS X should have. ie libSDL*-1.2.0.dylib respectively.

+

+  Revision 1.8  2005/01/04 23:14:44  savage

+  Changed LibName to reflect what most Linux distros will have. ie libSDL*-1.2.so.0 respectively.

+

   Revision 1.7  2005/01/01 02:03:12  savage

   Updated to v1.2.4

 

@@ -110,8 +134,6 @@ unit sdl_image;
 

 {$I jedi-sdl.inc}

 

-{$ALIGN ON}

-

 interface

 

 uses

@@ -121,20 +143,25 @@ uses
   sdl;

 

 const

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   SDL_ImageLibName =  'SDL_Image.dll';

 {$ENDIF}

 

 {$IFDEF UNIX}

 {$IFDEF DARWIN}

-  SDL_ImageLibName = 'libSDL_image.dylib';

+  SDL_ImageLibName = 'libSDL_image-1.2.0.dylib';

 {$ELSE}

-  SDL_ImageLibName =  'libSDL_image.so';

+  {$IFDEF FPC}

+    SDL_ImageLibName = 'libSDL_image.so';

+  {$ELSE}

+    SDL_ImageLibName = 'libSDL_image-1.2.so.0';

+  {$ENDIF}

 {$ENDIF}

 {$ENDIF}

 

 {$IFDEF MACOS}

   SDL_ImageLibName = 'SDL_image';

+  {$linklib libSDL_image}

 {$ENDIF}

 

   // Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL

@@ -142,7 +169,7 @@ const
 {$EXTERNALSYM SDL_IMAGE_MAJOR_VERSION}

   SDL_IMAGE_MINOR_VERSION = 2;

 {$EXTERNALSYM SDL_IMAGE_MINOR_VERSION}

-  SDL_IMAGE_PATCHLEVEL    = 4;

+  SDL_IMAGE_PATCHLEVEL    = 6;

 {$EXTERNALSYM SDL_IMAGE_PATCHLEVEL}

 

 { This macro can be used to fill a version structure with the compile-time

@@ -187,68 +214,103 @@ cdecl; external {$IFDEF __GPC__}name 'IMG_InvertAlpha'{$ELSE} SDL_ImageLibName{$
 function IMG_isBMP(src: PSDL_RWops): Integer;

 cdecl; external {$IFDEF __GPC__}name 'IMG_isBMP'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

 {$EXTERNALSYM IMG_isBMP}

-function IMG_isPNM(src: PSDL_RWops): Integer;

-cdecl; external {$IFDEF __GPC__}name 'IMG_isPNM'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_isPNM}

-function IMG_isXPM(src: PSDL_RWops): Integer;

-cdecl; external {$IFDEF __GPC__}name 'IMG_isXPM'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_isXPM}

-function IMG_isXCF(src: PSDL_RWops): Integer;

-cdecl; external {$IFDEF __GPC__}name 'IMG_isXCF'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_isXCF}

-function IMG_isPCX(src: PSDL_RWops): Integer;

-cdecl; external {$IFDEF __GPC__}name 'IMG_isPCX'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_isPCX}

+

 function IMG_isGIF(src: PSDL_RWops): Integer;

 cdecl; external {$IFDEF __GPC__}name 'IMG_isGIF'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

 {$EXTERNALSYM IMG_isGIF}

+

 function IMG_isJPG(src: PSDL_RWops): Integer;

 cdecl; external {$IFDEF __GPC__}name 'IMG_isJPG'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

 {$EXTERNALSYM IMG_isJPG}

-function IMG_isTIF(src: PSDL_RWops): Integer;

-cdecl; external {$IFDEF __GPC__}name 'IMG_isTIF'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_isTIF}

-function IMG_isPNG(src: PSDL_RWops): Integer;

-cdecl; external {$IFDEF __GPC__}name 'IMG_isPNG'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_isPNG}

+

 function IMG_isLBM(src: PSDL_RWops): Integer;

 cdecl; external {$IFDEF __GPC__}name 'IMG_isLBM'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

 {$EXTERNALSYM IMG_isLBM}

 

+function IMG_isPCX(src: PSDL_RWops): Integer;

+cdecl; external {$IFDEF __GPC__}name 'IMG_isPCX'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_isPCX}

+

+function IMG_isPNG(src: PSDL_RWops): Integer;

+cdecl; external {$IFDEF __GPC__}name 'IMG_isPNG'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_isPNG}

+

+function IMG_isPNM(src: PSDL_RWops): Integer;

+cdecl; external {$IFDEF __GPC__}name 'IMG_isPNM'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_isPNM}

+

+function IMG_isTIF(src: PSDL_RWops): Integer;

+cdecl; external {$IFDEF __GPC__}name 'IMG_isTIF'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_isTIF}

+

+function IMG_isXCF(src: PSDL_RWops): Integer;

+cdecl; external {$IFDEF __GPC__}name 'IMG_isXCF'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_isXCF}

+

+function IMG_isXPM(src: PSDL_RWops): Integer;

+cdecl; external {$IFDEF __GPC__}name 'IMG_isXPM'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_isXPM}

+

+function IMG_isXV(src: PSDL_RWops): Integer;

+cdecl; external {$IFDEF __GPC__}name 'IMG_isXV'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_isXV}

+

+

 { Individual loading functions }

 function IMG_LoadBMP_RW(src: PSDL_RWops): PSDL_Surface;

 cdecl; external {$IFDEF __GPC__}name 'IMG_LoadBMP_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

 {$EXTERNALSYM IMG_LoadBMP_RW}

-function IMG_LoadPNM_RW(src: PSDL_RWops): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'IMG_LoadPNM_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_LoadPNM_RW}

-function IMG_LoadXPM_RW(src: PSDL_RWops): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'IMG_LoadXPM_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_LoadXPM_RW}

-function IMG_LoadXCF_RW(src: PSDL_RWops): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'IMG_LoadXCF_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_LoadXCF_RW}

-function IMG_LoadPCX_RW(src: PSDL_RWops): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'IMG_LoadPCX_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_LoadPCX_RW}

+

 function IMG_LoadGIF_RW(src: PSDL_RWops): PSDL_Surface;

 cdecl; external {$IFDEF __GPC__}name 'IMG_LoadGIF_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

 {$EXTERNALSYM IMG_LoadGIF_RW}

+

 function IMG_LoadJPG_RW(src: PSDL_RWops): PSDL_Surface;

 cdecl; external {$IFDEF __GPC__}name 'IMG_LoadJPG_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

 {$EXTERNALSYM IMG_LoadJPG_RW}

-function IMG_LoadTIF_RW(src: PSDL_RWops): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'IMG_LoadTIF_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_LoadTIF_RW}

+

+function IMG_LoadLBM_RW(src: PSDL_RWops): PSDL_Surface;

+cdecl; external {$IFDEF __GPC__}name 'IMG_LoadLBM_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_LoadLBM_RW}

+

+function IMG_LoadPCX_RW(src: PSDL_RWops): PSDL_Surface;

+cdecl; external {$IFDEF __GPC__}name 'IMG_LoadPCX_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_LoadPCX_RW}

+

+function IMG_LoadPNM_RW(src: PSDL_RWops): PSDL_Surface;

+cdecl; external {$IFDEF __GPC__}name 'IMG_LoadPNM_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_LoadPNM_RW}

+

 function IMG_LoadPNG_RW(src: PSDL_RWops): PSDL_Surface;

 cdecl; external {$IFDEF __GPC__}name 'IMG_LoadPNG_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

 {$EXTERNALSYM IMG_LoadPNG_RW}

+

 function IMG_LoadTGA_RW(src: PSDL_RWops): PSDL_Surface;

 cdecl; external {$IFDEF __GPC__}name 'IMG_LoadTGA_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

 {$EXTERNALSYM IMG_LoadTGA_RW}

-function IMG_LoadLBM_RW(src: PSDL_RWops): PSDL_Surface;

-cdecl; external {$IFDEF __GPC__}name 'IMG_LoadLBM_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

-{$EXTERNALSYM IMG_LoadLBM_RW}

+

+function IMG_LoadTIF_RW(src: PSDL_RWops): PSDL_Surface;

+cdecl; external {$IFDEF __GPC__}name 'IMG_LoadTIF_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_LoadTIF_RW}

+

+function IMG_LoadXCF_RW(src: PSDL_RWops): PSDL_Surface;

+cdecl; external {$IFDEF __GPC__}name 'IMG_LoadXCF_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_LoadXCF_RW}

+

+function IMG_LoadXPM_RW(src: PSDL_RWops): PSDL_Surface;

+cdecl; external {$IFDEF __GPC__}name 'IMG_LoadXPM_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_LoadXPM_RW}

+

+function IMG_LoadXV_RW(src: PSDL_RWops): PSDL_Surface;

+cdecl; external {$IFDEF __GPC__}name 'IMG_LoadXV_RW'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_LoadXV_RW}

+

+function IMG_ReadXPMFromArray( xpm : PPChar ): PSDL_Surface;

+cdecl; external {$IFDEF __GPC__}name 'IMG_ReadXPMFromArray'{$ELSE} SDL_ImageLibName{$ENDIF __GPC__};

+{$EXTERNALSYM IMG_ReadXPMFromArray}

+

+

+

 

 { used internally, NOT an exported function }

 //function IMG_string_equals( const str1 : PChar; const str2 : PChar ) : integer;

diff --git a/Game/Code/lib/JEDI-SDL/SDL_ttf/Pas/sdl_ttf.pas b/Game/Code/lib/JEDI-SDL/SDL_ttf/Pas/sdl_ttf.pas
index eea69719..88966f82 100644
--- a/Game/Code/lib/JEDI-SDL/SDL_ttf/Pas/sdl_ttf.pas
+++ b/Game/Code/lib/JEDI-SDL/SDL_ttf/Pas/sdl_ttf.pas
@@ -1,6 +1,6 @@
 unit sdl_ttf;

 {

-  $Id: sdl_ttf.pas,v 1.10 2005/01/02 19:07:32 savage Exp $

+  $Id: sdl_ttf.pas,v 1.19 2007/12/05 22:54:20 savage Exp $

 

 }

 {******************************************************************************}

@@ -87,6 +87,33 @@ unit sdl_ttf;
 {                                                                              }

 {

   $Log: sdl_ttf.pas,v $

+  Revision 1.19  2007/12/05 22:54:20  savage

+  Better Mac OS X support for Frameworks.

+

+  Revision 1.18  2007/06/01 11:16:33  savage

+  Added IFDEF UNIX for Workaround.

+

+  Revision 1.17  2007/06/01 08:38:21  savage

+  Added TTF_RenderText_Solid workaround as suggested by Michalis Kamburelis

+

+  Revision 1.16  2007/05/29 21:32:14  savage

+  Changes as suggested by Almindor for 64bit compatibility.

+

+  Revision 1.15  2007/05/20 20:32:45  savage

+  Initial Changes to Handle 64 Bits

+

+  Revision 1.14  2006/12/02 00:19:01  savage

+  Updated to latest version

+

+  Revision 1.13  2005/04/10 11:48:33  savage

+  Changes as suggested by Michalis, thanks.

+

+  Revision 1.12  2005/01/05 01:47:14  savage

+  Changed LibName to reflect what MacOS X should have. ie libSDL*-1.2.0.dylib respectively.

+

+  Revision 1.11  2005/01/04 23:14:57  savage

+  Changed LibName to reflect what most Linux distros will have. ie libSDL*-1.2.so.0 respectively.

+

   Revision 1.10  2005/01/02 19:07:32  savage

   Slight bug fix to use LongInt instead of Long ( Thanks Michalis Kamburelis )

 

@@ -124,7 +151,17 @@ unit sdl_ttf;
 

 {$I jedi-sdl.inc}

 

-{$ALIGN ON}

+{

+  Define this to workaround a known bug in some freetype versions.

+  The error manifests as TTF_RenderGlyph_Solid returning nil (error)

+  and error message (in SDL_Error) is

+  "Failed loading DPMSDisable: /usr/lib/libX11.so.6: undefined symbol: DPMSDisable"

+  See [http://lists.libsdl.org/pipermail/sdl-libsdl.org/2007-March/060459.html]

+}

+{$IFDEF UNIX}

+{$DEFINE Workaround_TTF_RenderText_Solid}

+{$ENDIF}

+

 

 interface

 

@@ -133,7 +170,7 @@ uses
   gpc,

 {$ENDIF}

 

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   {$IFNDEF __GPC__}

   Windows,

   {$ENDIF}

@@ -141,20 +178,25 @@ uses
   sdl;

 

 const

-{$IFDEF WIN32}

+{$IFDEF WINDOWS}

   SDLttfLibName = 'SDL_ttf.dll';

 {$ENDIF}

 

 {$IFDEF UNIX}

 {$IFDEF DARWIN}

-  SDLttfLibName = 'libSDL_ttf.dylib';

+  SDLttfLibName = 'libSDL_ttf-2.0.0.dylib';

 {$ELSE}

-  SDLttfLibName = 'libSDL_ttf.so';

+  {$IFDEF FPC}

+    SDLttfLibName = 'libSDL_ttf.so';

+  {$ELSE}

+    SDLttfLibName = 'libSDL_ttf-2.0.so.0';

+  {$ENDIF}

 {$ENDIF}

 {$ENDIF}

 

 {$IFDEF MACOS}

   SDLttfLibName = 'SDL_ttf';

+  {$linklib libSDL_ttf}

 {$ENDIF}

 

   {* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL *}

@@ -162,7 +204,7 @@ const
 {$EXTERNALSYM SDL_TTF_MAJOR_VERSION}

   SDL_TTF_MINOR_VERSION = 0;

 {$EXTERNALSYM SDL_TTF_MINOR_VERSION}

-  SDL_TTF_PATCHLEVEL = 7;

+  SDL_TTF_PATCHLEVEL = 9;

 {$EXTERNALSYM SDL_TTF_PATCHLEVEL}

 

   // Backwards compatibility

@@ -314,8 +356,10 @@ cdecl; external {$IFDEF __GPC__}name 'TTF_SizeUNICODE'{$ELSE} SDLttfLibName{$END
 }

 function TTF_RenderText_Solid( font : PTTF_Font;

 				const text : PChar; fg : TSDL_Color ): PSDL_Surface;

+{$IFNDEF Workaround_TTF_RenderText_Solid}

 cdecl; external {$IFDEF __GPC__}name 'TTF_RenderText_Solid'{$ELSE} SDLttfLibName{$ENDIF __GPC__};

 {$EXTERNALSYM TTF_RenderText_Solid}

+{$ENDIF}

 

 function TTF_RenderUTF8_Solid( font : PTTF_Font;

 				const text : PChar; fg : TSDL_Color ): PSDL_Surface;

@@ -448,4 +492,14 @@ begin
   result := SDL_GetError;

 end;

 

+{$IFDEF Workaround_TTF_RenderText_Solid}

+function TTF_RenderText_Solid( font : PTTF_Font;

+  const text : PChar; fg : TSDL_Color ): PSDL_Surface;

+const

+  Black: TSDL_Color = (r: 0; g: 0; b: 0; unused: 0);

+begin

+  Result := TTF_RenderText_Shaded(font, text, fg, Black);

+end;

+{$ENDIF Workaround_TTF_RenderText_Solid}

+

 end.

diff --git a/Game/Code/lib/JEDI-SDL/SDL_ttf/Pas/sdltruetypefont.pas b/Game/Code/lib/JEDI-SDL/SDL_ttf/Pas/sdltruetypefont.pas
index 4b53ddd9..a0f25e12 100644
--- a/Game/Code/lib/JEDI-SDL/SDL_ttf/Pas/sdltruetypefont.pas
+++ b/Game/Code/lib/JEDI-SDL/SDL_ttf/Pas/sdltruetypefont.pas
@@ -1,6 +1,6 @@
 unit sdltruetypefont;

 {

-  $Id: sdltruetypefont.pas,v 1.1 2004/09/30 22:39:50 savage Exp $

+  $Id: sdltruetypefont.pas,v 1.5 2005/05/26 21:22:28 savage Exp $

 

 }

 {******************************************************************************}

@@ -62,6 +62,21 @@ unit sdltruetypefont;
 {   September   23 2004 - DL : Initial Creation                                }

 {

   $Log: sdltruetypefont.pas,v $

+  Revision 1.5  2005/05/26 21:22:28  savage

+  Update to Input code.

+

+  Revision 1.1  2005/05/25 23:15:42  savage

+  Latest Changes

+

+  Revision 1.4  2005/05/25 22:55:01  savage

+  Added InputRect support.

+

+  Revision 1.3  2005/05/13 14:02:49  savage

+  Made it use UniCode rendering by default.

+

+  Revision 1.2  2005/05/13 11:37:52  savage

+  Improved wordwrapping algorithm

+

   Revision 1.1  2004/09/30 22:39:50  savage

   Added a true type font class which contains a wrap text function.

   Changed the sdl_ttf.pas header to reflect the future of jedi-sdl.

@@ -93,6 +108,7 @@ type
     FFontFile : string;

     FFontSize : integer;

     procedure PrepareFont;

+

   protected

 

   public

@@ -100,6 +116,7 @@ type
     destructor Destroy; override;

     function DrawText( aText : WideString ) : PSDL_Surface; overload;

     function DrawText( aText : WideString; aWidth, aHeight : Integer ) : PSDL_Surface; overload;

+    function Input(aDestination: PSDL_Surface; aX, aY, aWidth, aHeight: integer; var aText: string; aMaxChars: integer = 10 ): PSDL_Surface;

     property BackGroundColour : TSDL_Color read FBackGroundColour write FBackGroundColour;

     property ForeGroundColour : TSDL_Color read FForeGroundColour write FForeGroundColour;

     property FontFile : string read FFontFile write FFontFile;

@@ -131,7 +148,7 @@ begin
     FForeGroundColour.r := 0;

     FForeGroundColour.g := 0;

     FForeGroundColour.b := 0;

-    FRenderType := rtUTF8;

+    FRenderType := rtUnicode;

     if ( TTF_Init >= 0 ) then

     begin

       FFontFile := aFontFile;

@@ -265,26 +282,31 @@ begin
         else

         begin

           dec( i );

-          strChopped := Copy( strChopped, 0, i );

-          if TTF_SizeText( FFont, PChar( string( strChopped ) ), textw, texth ) = 0 then

+          if TTF_SizeText( FFont, PChar( string( Copy( strChopped, 0, i ) ) ), textw, texth ) = 0 then

           begin

             if ( textw < aWidth )

-              and ( texth < aHeight ) then

+            and ( texth < aHeight ) then

             begin

               SetLength( strlist, Length( strlist ) + 1 );

-              strlist[ Length( strlist ) - 1 ] := strChopped;

-              strChopped := Copy( aText, i + 2, Length( aText ) - ( i - 1 ) );

+              strlist[ Length( strlist ) - 1 ] := Copy( strChopped, 0, i );

+              strChopped := Copy( strChopped, i + 2, Length( strChopped ) - ( i - 1 ) );

               i := Length( strChopped );

               if TTF_SizeText( FFont, PChar( string( strChopped ) ), textw, texth ) = 0 then

               begin

-                SetLength( strlist, Length( strlist ) + 1 );

-                strlist[ Length( strlist ) - 1 ] := strChopped;

-                break;

+                if ( textw < aWidth )

+                and ( texth < aHeight ) then

+                begin

+                  SetLength( strlist, Length( strlist ) + 1 );

+                  strlist[ Length( strlist ) - 1 ] := Copy( strChopped, 0, i );

+                  strChopped := Copy( strChopped, i + 2, Length( strChopped ) - ( i - 1 ) );

+                  i := Length( strChopped );

+                end;

               end;

             end;

           end;

         end;

       end;

+      

       SetLength( SurfaceList, Length( strlist ) );

       for i := Low( strlist ) to High( strlist ) do

       begin

@@ -310,26 +332,31 @@ begin
         else

         begin

           dec( i );

-          strChopped := Copy( strChopped, 0, i );

-          if TTF_SizeUTF8( FFont, PChar( string( strChopped ) ), textw, texth ) = 0 then

+          if TTF_SizeUTF8( FFont, PChar( string( Copy( strChopped, 0, i ) ) ), textw, texth ) = 0 then

           begin

             if ( textw < aWidth )

-              and ( texth < aHeight ) then

+            and ( texth < aHeight ) then

             begin

               SetLength( strlist, Length( strlist ) + 1 );

-              strlist[ Length( strlist ) - 1 ] := strChopped;

-              strChopped := Copy( aText, i + 2, Length( aText ) - ( i - 1 ) );

+              strlist[ Length( strlist ) - 1 ] := Copy( strChopped, 0, i );

+              strChopped := Copy( strChopped, i + 2, Length( strChopped ) - ( i - 1 ) );

               i := Length( strChopped );

               if TTF_SizeUTF8( FFont, PChar( string( strChopped ) ), textw, texth ) = 0 then

               begin

-                SetLength( strlist, Length( strlist ) + 1 );

-                strlist[ Length( strlist ) - 1 ] := strChopped;

-                break;

+                if ( textw < aWidth )

+                and ( texth < aHeight ) then

+                begin

+                  SetLength( strlist, Length( strlist ) + 1 );

+                  strlist[ Length( strlist ) - 1 ] := Copy( strChopped, 0, i );

+                  strChopped := Copy( strChopped, i + 2, Length( strChopped ) - ( i - 1 ) );

+                  i := Length( strChopped );

+                end;

               end;

             end;

           end;

         end;

       end;

+

       SetLength( SurfaceList, Length( strlist ) );

       for i := Low( strlist ) to High( strlist ) do

       begin

@@ -355,21 +382,25 @@ begin
         else

         begin

           dec( i );

-          strChopped := Copy( strChopped, 0, i );

-          if TTF_SizeUNICODE( FFont, PUInt16( strChopped ), textw, texth ) = 0 then

+          if TTF_SizeUNICODE( FFont, PUInt16( Copy( strChopped, 0, i ) ), textw, texth ) = 0 then

           begin

             if ( textw < aWidth )

-              and ( texth < aHeight ) then

+            and ( texth < aHeight ) then

             begin

               SetLength( strlist, Length( strlist ) + 1 );

-              strlist[ Length( strlist ) - 1 ] := strChopped;

-              strChopped := Copy( aText, i + 2, Length( aText ) - ( i - 1 ) );

+              strlist[ Length( strlist ) - 1 ] := Copy( strChopped, 0, i );

+              strChopped := Copy( strChopped, i + 2, Length( strChopped ) - ( i - 1 ) );

               i := Length( strChopped );

               if TTF_SizeUNICODE( FFont, PUInt16( strChopped ), textw, texth ) = 0 then

               begin

-                SetLength( strlist, Length( strlist ) + 1 );

-                strlist[ Length( strlist ) - 1 ] := strChopped;

-                break;

+                if ( textw < aWidth )

+                and ( texth < aHeight ) then

+                begin

+                  SetLength( strlist, Length( strlist ) + 1 );

+                  strlist[ Length( strlist ) - 1 ] := Copy( strChopped, 0, i );

+                  strChopped := Copy( strChopped, i + 2, Length( strChopped ) - ( i - 1 ) );

+                  i := Length( strChopped );

+                end;

               end;

             end;

           end;

@@ -411,6 +442,103 @@ begin
   SetLength( strlist, 0 );

 end;

 

+function TTrueTypeFont.Input(aDestination: PSDL_Surface; aX, aY, aWidth: integer; aHeight : integer; var aText : string; aMaxChars: integer): PSDL_Surface;

+var

+  event : TSDL_Event;

+  ch : integer;

+

+  BackSurface, TextSurface : PSDL_Surface;

+  rect : SDL_Rect;

+  textw, texth : integer;

+  Done : boolean;

+  PassedInText : string; 

+begin

+  PassedInText := aText;

+

+  BackSurface := SDL_AllocSurface( aDestination.flags,

+    aDestination.w,

+    aDestination.h,

+    aDestination.format.BitsPerPixel,

+    aDestination.format.Rmask,

+    aDestination.format.Gmask,

+    aDestination.format.Bmask, 0 );

+

+  rect.x := aX;

+  rect.y := aY;

+  rect.w := aWidth;

+  rect.h := aHeight;

+

+  SDL_BlitSurface( aDestination, nil, BackSurface, nil );

+  SDL_FillRect( BackSurface, @rect, SDL_MapRGB( aDestination.format, 0, 0, 0 ) );

+

+  TextSurface := DrawText( aText + '|' );

+

+  // start input

+  SDL_EnableUNICODE( 1 );

+  Done := false;

+  while ( not Done ) and ( SDL_WaitEvent( @event ) > 0 ) do

+  begin

+    if event.type_ = SDL_KEYDOWN then

+    begin

+      ch := event.key.keysym.unicode;

+      case ch of

+        SDLK_RETURN :

+        begin

+          Done := true;

+        end;

+

+        SDLK_ESCAPE :

+        begin

+          aText := PassedInText;

+          Done := true;

+        end;

+

+        SDLK_BACKSPACE :

+        begin

+          if ( Length( aText ) > 0 ) then

+          begin

+            aText := Copy( aText, 0, Length( aText ) - 1 );

+            if TextSurface <> nil then

+                SDL_FreeSurface( TextSurface );

+            TextSurface := DrawText( aText + '|' );

+          end;

+        end;

+      else

+        begin

+          if Length( aText ) < aMaxChars then

+          begin

+            if ( chr( ch ) <> '' ) then

+            begin

+              aText := aText + chr( ch );

+

+              if ( aText <> '' )

+              and ( TTF_SizeUNICODE( FFont, PUInt16( aText ), textw, texth ) = 0 ) then

+              begin

+                if ( textw > aWidth ) then

+                  aText := Copy( aText, 0, Length( aText ) - 1 );

+              end;

+

+              if TextSurface <> nil then

+                SDL_FreeSurface( TextSurface );

+              TextSurface := DrawText( aText + '|' );

+            end;

+          end;

+        end;

+      end;

+    end;

+    SDL_BlitSurface( BackSurface, nil, aDestination, nil );

+    SDL_BlitSurface( TextSurface, nil, aDestination, @rect );

+    SDL_Flip( aDestination );

+  end;

+  

+  if TextSurface <> nil then

+    SDL_FreeSurface( TextSurface );

+  if aText <> '' then

+    TextSurface := DrawText( aText );

+  SDL_FreeSurface( BackSurface );

+  result := TextSurface;

+end;

+

 procedure TTrueTypeFont.PrepareFont;

 var

   renderstyle : integer;