added Jedi-SDL to our SVN tree..

simplifies SVN checkout and build, and now that this version is well and truly 
deprecated, we should keep it here in case its removed.

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

1 files changed, 563 insertions, 0 deletions

diff --git a/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glu.pas b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glu.pas
new file mode 100644
index 00000000..fb48f65d
--- /dev/null
+++ b/Game/Code/lib/JEDI-SDLv1.0/OpenGL/Pas/glu.pas
@@ -0,0 +1,563 @@
+unit glu;

+{

+  $Id: glu.pas,v 1.3 2004/10/07 21:01:29 savage Exp $

+

+  Adaption of the delphi3d.net OpenGL units to FreePascal

+  Sebastian Guenther (sg@freepascal.org) in 2002

+  These units are free to use

+}

+

+(*++ BUILD Version: 0004    // Increment this if a change has global effects

+

+Copyright (c) 1985-95, Microsoft Corporation

+

+Module Name:

+

+    glu.h

+

+Abstract:

+

+    Procedure declarations, constant definitions and macros for the OpenGL

+    Utility Library.

+

+--*)

+

+(*

+** Copyright 1991-1993, Silicon Graphics, Inc.

+** All Rights Reserved.

+**

+** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;

+** the contents of this file may not be disclosed to third parties, copied or

+** duplicated in any form, in whole or in part, without the prior written

+** permission of Silicon Graphics, Inc.

+**

+** RESTRICTED RIGHTS LEGEND:

+** Use, duplication or disclosure by the Government is subject to restrictions

+** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data

+** and Computer Software clause at DFARS 252.227-7013, and/or in similar or

+** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -

+** rights reserved under the Copyright Laws of the United States.

+*)

+

+(*

+** Return the error string associated with a particular error code.

+** This will return 0 for an invalid error code.

+**

+** The generic function prototype that can be compiled for ANSI or Unicode

+** is defined as follows:

+**

+** LPCTSTR APIENTRY gluErrorStringWIN (GLenum errCode);

+*)

+

+{******************************************************************************}

+{                                                                              }

+{ Converted to Delphi by Tom Nuydens (tom@delphi3d.net)                        }

+{ For the latest updates, visit Delphi3D: http://www.delphi3d.net              }

+{                                                                              }

+{ Modified for Delphi/Kylix and FreePascal                                     }

+{    by Dominique Louis ( Dominique@Savagesoftware.com.au)                     }

+{ For the latest updates, visit JEDI-SDL : http://www.sf.net/projects/jedi-sdl }

+{                                                                              }

+{******************************************************************************}

+

+{

+  $Log: glu.pas,v $

+  Revision 1.3  2004/10/07 21:01:29  savage

+  Fix for FPC

+

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

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

+

+  Revision 1.1  2004/03/30 21:53:54  savage

+  Moved to it's own folder.

+

+  Revision 1.4  2004/02/20 17:09:55  savage

+  Code tidied up in gl, glu and glut, while extensions in glext.pas are now loaded using SDL_GL_GetProcAddress, thus making it more cross-platform compatible, but now more tied to SDL.

+

+  Revision 1.3  2004/02/14 00:23:39  savage

+  As UNIX is defined in jedi-sdl.inc this will be used to check linux compatability as well. Units have been changed to reflect this change.

+

+  Revision 1.2  2004/02/14 00:09:19  savage

+  Changed uses to now make use of moduleloader.pas rather than dllfuncs.pas

+

+  Revision 1.1  2004/02/05 00:08:19  savage

+  Module 1.0 release

+

+  Revision 1.4  2003/06/02 12:32:13  savage

+  Modified Sources to avoid warnings with Delphi by moving CVS Logging to the top of the header files. Hopefully CVS Logging still works.

+

+  Revision 1.3  2003/05/29 22:55:00  savage

+  Make use of new DLLFunctions

+

+  Revision 1.2  2003/05/27 09:39:53  savage

+  Added better Gnu Pascal support.

+

+  Revision 1.1  2003/05/11 13:18:03  savage

+  Newest OpenGL Headers For Delphi, Kylix and FPC

+

+  Revision 1.2  2002/10/13 14:36:47  sg

+  * Win32 fix: The OS symbol is called "Win32", not "Windows"

+

+  Revision 1.1  2002/10/13 13:57:31  sg

+  * Finally, the new units are available: Match the C headers more closely;

+    support for OpenGL extensions, and much more. Based on the Delphi units

+    by Tom Nuydens of delphi3d.net

+

+}

+

+interface

+

+{$I jedi-sdl.inc}

+

+uses

+{$IFDEF __GPC__}

+  gpc,

+{$ENDIF}

+  moduleloader,

+  gl;

+

+const

+{$IFDEF WIN32}

+  GLuLibName = 'glu32.dll';

+{$ENDIF}

+

+{$IFDEF UNIX}

+{$IFDEF DARWIN}

+  GLuLibName = 'libGLU.dylib';

+{$ELSE}

+  GLuLibName = 'libGLU.so';

+{$ENDIF}

+{$ENDIF}

+

+type

+  TViewPortArray = array [0..3] of GLint;

+  T16dArray = array [0..15] of GLdouble;

+  TCallBack = procedure;

+  T3dArray = array [0..2] of GLdouble;

+  T4pArray = array [0..3] of Pointer;

+  T4fArray = array [0..3] of GLfloat;

+  {$IFNDEF __GPC__}

+  PPointer = ^Pointer;

+  {$ENDIF}

+

+var

+  gluErrorString: function(errCode: GLenum): PGLubyte; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluErrorUnicodeStringEXT: function(errCode: GLenum): PWideChar; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluGetString: function(name: GLenum): PGLubyte; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluOrtho2D: procedure(left,right, bottom, top: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluPerspective: procedure(fovy, aspect, zNear, zFar: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluPickMatrix: procedure(x, y, width, height: GLdouble; viewport: TViewPortArray); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluLookAt: procedure(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluProject: function(objx, objy, objz: GLdouble; const modelMatrix, projMatrix: T16dArray; viewport: TViewPortArray; winx, winy, winz: PGLdouble): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluUnProject: function(winx, winy, winz: GLdouble; const modelMatrix, projMatrix: T16dArray; viewport: TViewPortArray; objx, objy, objz: PGLdouble): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluScaleImage: function(format: GLenum; widthin, heightin: GLint; typein: GLenum; const datain: Pointer; widthout, heightout: GLint; typeout: GLenum; dataout: Pointer): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluBuild1DMipmaps: function(target: GLenum; components, width: GLint; format, atype: GLenum; const data: Pointer): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluBuild2DMipmaps: function(target: GLenum; components, width, height: GLint; format, atype: GLenum; const data: Pointer): Integer; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+type

+  GLUnurbs = record end;                PGLUnurbs = ^GLUnurbs;

+  GLUquadric = record end;              PGLUquadric = ^GLUquadric;

+  GLUtesselator = record end;           PGLUtesselator = ^GLUtesselator;

+

+  // backwards compatibility:

+  GLUnurbsObj = GLUnurbs;               PGLUnurbsObj = PGLUnurbs;

+  GLUquadricObj = GLUquadric;           PGLUquadricObj = PGLUquadric;

+  GLUtesselatorObj = GLUtesselator;     PGLUtesselatorObj = PGLUtesselator;

+  GLUtriangulatorObj = GLUtesselator;   PGLUtriangulatorObj = PGLUtesselator;

+

+var

+  gluNewQuadric: function: PGLUquadric; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluDeleteQuadric: procedure(state: PGLUquadric); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluQuadricNormals: procedure(quadObject: PGLUquadric; normals: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluQuadricTexture: procedure(quadObject: PGLUquadric; textureCoords: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluQuadricOrientation: procedure(quadObject: PGLUquadric; orientation: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluQuadricDrawStyle: procedure(quadObject: PGLUquadric; drawStyle: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluCylinder: procedure(qobj: PGLUquadric; baseRadius, topRadius, height: GLdouble; slices, stacks: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluDisk: procedure(qobj: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluPartialDisk: procedure(qobj: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint; startAngle, sweepAngle: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluSphere: procedure(qobj: PGLuquadric; radius: GLdouble; slices, stacks: GLint); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluQuadricCallback: procedure(qobj: PGLUquadric; which: GLenum; fn: TCallBack); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluNewTess: function: PGLUtesselator; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluDeleteTess: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluTessBeginPolygon: procedure(tess: PGLUtesselator; polygon_data: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluTessBeginContour: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluTessVertex: procedure(tess: PGLUtesselator; coords: T3dArray; data: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluTessEndContour: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluTessEndPolygon: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluTessProperty: procedure(tess: PGLUtesselator; which: GLenum; value: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluTessNormal: procedure(tess: PGLUtesselator; x, y, z: GLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluTessCallback: procedure(tess: PGLUtesselator; which: GLenum;fn: TCallBack); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluGetTessProperty: procedure(tess: PGLUtesselator; which: GLenum; value: PGLdouble); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluNewNurbsRenderer: function: PGLUnurbs; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluDeleteNurbsRenderer: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluBeginSurface: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluBeginCurve: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluEndCurve: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluEndSurface: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluBeginTrim: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluEndTrim: procedure(nobj: PGLUnurbs); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluPwlCurve: procedure(nobj: PGLUnurbs; count: GLint; aarray: PGLfloat; stride: GLint; atype: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluNurbsCurve: procedure(nobj: PGLUnurbs; nknots: GLint; knot: PGLfloat; stride: GLint; ctlarray: PGLfloat; order: GLint; atype: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluNurbsSurface: procedure(nobj: PGLUnurbs; sknot_count: GLint; sknot: PGLfloat; tknot_count: GLint; tknot: PGLfloat; s_stride, t_stride: GLint; ctlarray: PGLfloat; sorder, torder: GLint; atype: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluLoadSamplingMatrices: procedure(nobj: PGLUnurbs; const modelMatrix, projMatrix: T16dArray; viewport: TViewPortArray); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluNurbsProperty: procedure(nobj: PGLUnurbs; aproperty: GLenum; value: GLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluGetNurbsProperty: procedure(nobj: PGLUnurbs; aproperty: GLenum; value: PGLfloat); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluNurbsCallback: procedure(nobj: PGLUnurbs; which: GLenum; fn: TCallBack); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+(**** Callback function prototypes ****)

+

+type

+  // gluQuadricCallback

+  GLUquadricErrorProc = procedure(p: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+  // gluTessCallback

+  GLUtessBeginProc = procedure(p: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessEdgeFlagProc = procedure(p: GLboolean); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessVertexProc = procedure(p: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessEndProc = procedure; {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessErrorProc = procedure(p: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessCombineProc = procedure(p1: T3dArray; p2: T4pArray; p3: T4fArray; p4: PPointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessBeginDataProc = procedure(p1: GLenum; p2: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessEdgeFlagDataProc = procedure(p1: GLboolean; p2: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessVertexDataProc = procedure(p1, p2: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessEndDataProc = procedure(p: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessErrorDataProc = procedure(p1: GLenum; p2: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  GLUtessCombineDataProc = procedure(p1: T3dArray; p2: T4pArray; p3: T4fArray;

+                                     p4: PPointer; p5: Pointer); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+  // gluNurbsCallback

+  GLUnurbsErrorProc = procedure(p: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+

+//***           Generic constants               ****/

+

+const

+  // Version

+  GLU_VERSION_1_1                 = 1;

+  GLU_VERSION_1_2                 = 1;

+

+  // Errors: (return value 0 = no error)

+  GLU_INVALID_ENUM                = 100900;

+  GLU_INVALID_VALUE               = 100901;

+  GLU_OUT_OF_MEMORY               = 100902;

+  GLU_INCOMPATIBLE_GL_VERSION     = 100903;

+

+  // StringName

+  GLU_VERSION                     = 100800;

+  GLU_EXTENSIONS                  = 100801;

+

+  // Boolean

+  GLU_TRUE                        = GL_TRUE;

+  GLU_FALSE                       = GL_FALSE;

+

+

+  //***           Quadric constants               ****/

+

+  // QuadricNormal

+  GLU_SMOOTH              = 100000;

+  GLU_FLAT                = 100001;

+  GLU_NONE                = 100002;

+

+  // QuadricDrawStyle

+  GLU_POINT               = 100010;

+  GLU_LINE                = 100011;

+  GLU_FILL                = 100012;

+  GLU_SILHOUETTE          = 100013;

+

+  // QuadricOrientation

+  GLU_OUTSIDE             = 100020;

+  GLU_INSIDE              = 100021;

+

+  // Callback types:

+  //      GLU_ERROR       = 100103;

+

+

+  //***           Tesselation constants           ****/

+

+  GLU_TESS_MAX_COORD              = 1.0e150;

+

+  // TessProperty

+  GLU_TESS_WINDING_RULE           = 100140;

+  GLU_TESS_BOUNDARY_ONLY          = 100141;

+  GLU_TESS_TOLERANCE              = 100142;

+

+  // TessWinding

+  GLU_TESS_WINDING_ODD            = 100130;

+  GLU_TESS_WINDING_NONZERO        = 100131;

+  GLU_TESS_WINDING_POSITIVE       = 100132;

+  GLU_TESS_WINDING_NEGATIVE       = 100133;

+  GLU_TESS_WINDING_ABS_GEQ_TWO    = 100134;

+

+  // TessCallback

+  GLU_TESS_BEGIN          = 100100;    // void (CALLBACK*)(GLenum    type)

+  GLU_TESS_VERTEX         = 100101;    // void (CALLBACK*)(void      *data)

+  GLU_TESS_END            = 100102;    // void (CALLBACK*)(void)

+  GLU_TESS_ERROR          = 100103;    // void (CALLBACK*)(GLenum    errno)

+  GLU_TESS_EDGE_FLAG      = 100104;    // void (CALLBACK*)(GLboolean boundaryEdge)

+  GLU_TESS_COMBINE        = 100105;    { void (CALLBACK*)(GLdouble  coords[3],

+                                                            void      *data[4],

+                                                            GLfloat   weight[4],

+                                                            void      **dataOut) }

+  GLU_TESS_BEGIN_DATA     = 100106;    { void (CALLBACK*)(GLenum    type,

+                                                            void      *polygon_data) }

+  GLU_TESS_VERTEX_DATA    = 100107;    { void (CALLBACK*)(void      *data,

+                                                            void      *polygon_data) }

+  GLU_TESS_END_DATA       = 100108;    // void (CALLBACK*)(void      *polygon_data)

+  GLU_TESS_ERROR_DATA     = 100109;    { void (CALLBACK*)(GLenum    errno,

+                                                            void      *polygon_data) }

+  GLU_TESS_EDGE_FLAG_DATA = 100110;    { void (CALLBACK*)(GLboolean boundaryEdge,

+                                                            void      *polygon_data) }

+  GLU_TESS_COMBINE_DATA   = 100111;    { void (CALLBACK*)(GLdouble  coords[3],

+                                                            void      *data[4],

+                                                            GLfloat   weight[4],

+                                                            void      **dataOut,

+                                                            void      *polygon_data) }

+

+  // TessError

+  GLU_TESS_ERROR1     = 100151;

+  GLU_TESS_ERROR2     = 100152;

+  GLU_TESS_ERROR3     = 100153;

+  GLU_TESS_ERROR4     = 100154;

+  GLU_TESS_ERROR5     = 100155;

+  GLU_TESS_ERROR6     = 100156;

+  GLU_TESS_ERROR7     = 100157;

+  GLU_TESS_ERROR8     = 100158;

+

+  GLU_TESS_MISSING_BEGIN_POLYGON  = GLU_TESS_ERROR1;

+  GLU_TESS_MISSING_BEGIN_CONTOUR  = GLU_TESS_ERROR2;

+  GLU_TESS_MISSING_END_POLYGON    = GLU_TESS_ERROR3;

+  GLU_TESS_MISSING_END_CONTOUR    = GLU_TESS_ERROR4;

+  GLU_TESS_COORD_TOO_LARGE        = GLU_TESS_ERROR5;

+  GLU_TESS_NEED_COMBINE_CALLBACK  = GLU_TESS_ERROR6;

+

+  //***           NURBS constants                 ****/

+

+  // NurbsProperty

+  GLU_AUTO_LOAD_MATRIX            = 100200;

+  GLU_CULLING                     = 100201;

+  GLU_SAMPLING_TOLERANCE          = 100203;

+  GLU_DISPLAY_MODE                = 100204;

+  GLU_PARAMETRIC_TOLERANCE        = 100202;

+  GLU_SAMPLING_METHOD             = 100205;

+  GLU_U_STEP                      = 100206;

+  GLU_V_STEP                      = 100207;

+

+  // NurbsSampling

+  GLU_PATH_LENGTH                 = 100215;

+  GLU_PARAMETRIC_ERROR            = 100216;

+  GLU_DOMAIN_DISTANCE             = 100217;

+

+

+  // NurbsTrim

+  GLU_MAP1_TRIM_2                 = 100210;

+  GLU_MAP1_TRIM_3                 = 100211;

+

+  // NurbsDisplay

+  //      GLU_FILL                = 100012;

+  GLU_OUTLINE_POLYGON             = 100240;

+  GLU_OUTLINE_PATCH               = 100241;

+

+  // NurbsCallback

+  //      GLU_ERROR               = 100103;

+

+  // NurbsErrors

+  GLU_NURBS_ERROR1        = 100251;

+  GLU_NURBS_ERROR2        = 100252;

+  GLU_NURBS_ERROR3        = 100253;

+  GLU_NURBS_ERROR4        = 100254;

+  GLU_NURBS_ERROR5        = 100255;

+  GLU_NURBS_ERROR6        = 100256;

+  GLU_NURBS_ERROR7        = 100257;

+  GLU_NURBS_ERROR8        = 100258;

+  GLU_NURBS_ERROR9        = 100259;

+  GLU_NURBS_ERROR10       = 100260;

+  GLU_NURBS_ERROR11       = 100261;

+  GLU_NURBS_ERROR12       = 100262;

+  GLU_NURBS_ERROR13       = 100263;

+  GLU_NURBS_ERROR14       = 100264;

+  GLU_NURBS_ERROR15       = 100265;

+  GLU_NURBS_ERROR16       = 100266;

+  GLU_NURBS_ERROR17       = 100267;

+  GLU_NURBS_ERROR18       = 100268;

+  GLU_NURBS_ERROR19       = 100269;

+  GLU_NURBS_ERROR20       = 100270;

+  GLU_NURBS_ERROR21       = 100271;

+  GLU_NURBS_ERROR22       = 100272;

+  GLU_NURBS_ERROR23       = 100273;

+  GLU_NURBS_ERROR24       = 100274;

+  GLU_NURBS_ERROR25       = 100275;

+  GLU_NURBS_ERROR26       = 100276;

+  GLU_NURBS_ERROR27       = 100277;

+  GLU_NURBS_ERROR28       = 100278;

+  GLU_NURBS_ERROR29       = 100279;

+  GLU_NURBS_ERROR30       = 100280;

+  GLU_NURBS_ERROR31       = 100281;

+  GLU_NURBS_ERROR32       = 100282;

+  GLU_NURBS_ERROR33       = 100283;

+  GLU_NURBS_ERROR34       = 100284;

+  GLU_NURBS_ERROR35       = 100285;

+  GLU_NURBS_ERROR36       = 100286;

+  GLU_NURBS_ERROR37       = 100287;

+

+//***           Backwards compatibility for old tesselator           ****/

+

+var

+  gluBeginPolygon: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluNextContour: procedure(tess: PGLUtesselator; atype: GLenum); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+  gluEndPolygon: procedure(tess: PGLUtesselator); {$IFDEF WIN32}stdcall;{$ELSE}cdecl;{$ENDIF}

+

+const

+  // Contours types -- obsolete!

+  GLU_CW          = 100120;

+  GLU_CCW         = 100121;

+  GLU_INTERIOR    = 100122;

+  GLU_EXTERIOR    = 100123;

+  GLU_UNKNOWN     = 100124;

+

+  // Names without "TESS_" prefix

+  GLU_BEGIN       = GLU_TESS_BEGIN;

+  GLU_VERTEX      = GLU_TESS_VERTEX;

+  GLU_END         = GLU_TESS_END;

+  GLU_ERROR       = GLU_TESS_ERROR;

+  GLU_EDGE_FLAG   = GLU_TESS_EDGE_FLAG;

+

+procedure LoadGLu(const dll: PChar);

+procedure FreeGLu;

+

+implementation

+

+var

+  LibGlu: TModuleHandle;

+  

+procedure FreeGLu;

+begin

+

+  @gluErrorString := nil;

+  @gluErrorUnicodeStringEXT := nil;

+  @gluGetString := nil;

+  @gluOrtho2D := nil;

+  @gluPerspective := nil;

+  @gluPickMatrix := nil;

+  @gluLookAt := nil;

+  @gluProject := nil;

+  @gluUnProject := nil;

+  @gluScaleImage := nil;

+  @gluBuild1DMipmaps := nil;

+  @gluBuild2DMipmaps := nil;

+  @gluNewQuadric := nil;

+  @gluDeleteQuadric := nil;

+  @gluQuadricNormals := nil;

+  @gluQuadricTexture := nil;

+  @gluQuadricOrientation := nil;

+  @gluQuadricDrawStyle := nil;

+  @gluCylinder := nil;

+  @gluDisk := nil;

+  @gluPartialDisk := nil;

+  @gluSphere := nil;

+  @gluQuadricCallback := nil;

+  @gluNewTess := nil;

+  @gluDeleteTess := nil;

+  @gluTessBeginPolygon := nil;

+  @gluTessBeginContour := nil;

+  @gluTessVertex := nil;

+  @gluTessEndContour := nil;

+  @gluTessEndPolygon := nil;

+  @gluTessProperty := nil;

+  @gluTessNormal := nil;

+  @gluTessCallback := nil;

+  @gluGetTessProperty := nil;

+  @gluNewNurbsRenderer := nil;

+  @gluDeleteNurbsRenderer := nil;

+  @gluBeginSurface := nil;

+  @gluBeginCurve := nil;

+  @gluEndCurve := nil;

+  @gluEndSurface := nil;

+  @gluBeginTrim := nil;

+  @gluEndTrim := nil;

+  @gluPwlCurve := nil;

+  @gluNurbsCurve := nil;

+  @gluNurbsSurface := nil;

+  @gluLoadSamplingMatrices := nil;

+  @gluNurbsProperty := nil;

+  @gluGetNurbsProperty := nil;

+  @gluNurbsCallback := nil;

+  @gluBeginPolygon := nil;

+  @gluNextContour := nil;

+  @gluEndPolygon := nil;

+

+  UnLoadModule(LibGlu);

+

+end;

+

+procedure LoadGLu(const dll: PChar);

+begin

+

+  FreeGLu;

+  

+  if LoadModule( LibGlu, dll ) then

+  begin

+    @gluErrorString := GetModuleSymbol(LibGlu, 'gluErrorString');

+    @gluErrorUnicodeStringEXT := GetModuleSymbol(LibGlu, 'gluErrorUnicodeStringEXT');

+    @gluGetString := GetModuleSymbol(LibGlu, 'gluGetString');

+    @gluOrtho2D := GetModuleSymbol(LibGlu, 'gluOrtho2D');

+    @gluPerspective := GetModuleSymbol(LibGlu, 'gluPerspective');

+    @gluPickMatrix := GetModuleSymbol(LibGlu, 'gluPickMatrix');

+    @gluLookAt := GetModuleSymbol(LibGlu, 'gluLookAt');

+    @gluProject := GetModuleSymbol(LibGlu, 'gluProject');

+    @gluUnProject := GetModuleSymbol(LibGlu, 'gluUnProject');

+    @gluScaleImage := GetModuleSymbol(LibGlu, 'gluScaleImage');

+    @gluBuild1DMipmaps := GetModuleSymbol(LibGlu, 'gluBuild1DMipmaps');

+    @gluBuild2DMipmaps := GetModuleSymbol(LibGlu, 'gluBuild2DMipmaps');

+    @gluNewQuadric := GetModuleSymbol(LibGlu, 'gluNewQuadric');

+    @gluDeleteQuadric := GetModuleSymbol(LibGlu, 'gluDeleteQuadric');

+    @gluQuadricNormals := GetModuleSymbol(LibGlu, 'gluQuadricNormals');

+    @gluQuadricTexture := GetModuleSymbol(LibGlu, 'gluQuadricTexture');

+    @gluQuadricOrientation := GetModuleSymbol(LibGlu, 'gluQuadricOrientation');

+    @gluQuadricDrawStyle := GetModuleSymbol(LibGlu, 'gluQuadricDrawStyle');

+    @gluCylinder := GetModuleSymbol(LibGlu, 'gluCylinder');

+    @gluDisk := GetModuleSymbol(LibGlu, 'gluDisk');

+    @gluPartialDisk := GetModuleSymbol(LibGlu, 'gluPartialDisk');

+    @gluSphere := GetModuleSymbol(LibGlu, 'gluSphere');

+    @gluQuadricCallback := GetModuleSymbol(LibGlu, 'gluQuadricCallback');

+    @gluNewTess := GetModuleSymbol(LibGlu, 'gluNewTess');

+    @gluDeleteTess := GetModuleSymbol(LibGlu, 'gluDeleteTess');

+    @gluTessBeginPolygon := GetModuleSymbol(LibGlu, 'gluTessBeginPolygon');

+    @gluTessBeginContour := GetModuleSymbol(LibGlu, 'gluTessBeginContour');

+    @gluTessVertex := GetModuleSymbol(LibGlu, 'gluTessVertex');

+    @gluTessEndContour := GetModuleSymbol(LibGlu, 'gluTessEndContour');

+    @gluTessEndPolygon := GetModuleSymbol(LibGlu, 'gluTessEndPolygon');

+    @gluTessProperty := GetModuleSymbol(LibGlu, 'gluTessProperty');

+    @gluTessNormal := GetModuleSymbol(LibGlu, 'gluTessNormal');

+    @gluTessCallback := GetModuleSymbol(LibGlu, 'gluTessCallback');

+    @gluGetTessProperty := GetModuleSymbol(LibGlu, 'gluGetTessProperty');

+    @gluNewNurbsRenderer := GetModuleSymbol(LibGlu, 'gluNewNurbsRenderer');

+    @gluDeleteNurbsRenderer := GetModuleSymbol(LibGlu, 'gluDeleteNurbsRenderer');

+    @gluBeginSurface := GetModuleSymbol(LibGlu, 'gluBeginSurface');

+    @gluBeginCurve := GetModuleSymbol(LibGlu, 'gluBeginCurve');

+    @gluEndCurve := GetModuleSymbol(LibGlu, 'gluEndCurve');

+    @gluEndSurface := GetModuleSymbol(LibGlu, 'gluEndSurface');

+    @gluBeginTrim := GetModuleSymbol(LibGlu, 'gluBeginTrim');

+    @gluEndTrim := GetModuleSymbol(LibGlu, 'gluEndTrim');

+    @gluPwlCurve := GetModuleSymbol(LibGlu, 'gluPwlCurve');

+    @gluNurbsCurve := GetModuleSymbol(LibGlu, 'gluNurbsCurve');

+    @gluNurbsSurface := GetModuleSymbol(LibGlu, 'gluNurbsSurface');

+    @gluLoadSamplingMatrices := GetModuleSymbol(LibGlu, 'gluLoadSamplingMatrices');

+    @gluNurbsProperty := GetModuleSymbol(LibGlu, 'gluNurbsProperty');

+    @gluGetNurbsProperty := GetModuleSymbol(LibGlu, 'gluGetNurbsProperty');

+    @gluNurbsCallback := GetModuleSymbol(LibGlu, 'gluNurbsCallback');

+

+    @gluBeginPolygon := GetModuleSymbol(LibGlu, 'gluBeginPolygon');

+    @gluNextContour := GetModuleSymbol(LibGlu, 'gluNextContour');

+    @gluEndPolygon := GetModuleSymbol(LibGlu, 'gluEndPolygon');

+  end;

+end;

+

+initialization

+

+  LoadGLu( GLuLibName );

+

+finalization

+

+  FreeGLu;

+

+end.