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.
