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.