paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-04-19 23:39:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

* Completed GLU and GLUT support

Browse Source 
* Some minor fixes (missing "const"s, changed some untyped "var" arguments
  to "const" arguments etc.)
This commit is contained in:
sg 2000-05-25 18:59:50 +00:00
parent b00b177c52
commit e9ee3ce8ae
10 changed files with 1500 additions and 915 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
packages/opengl/build/README
View File

@ -10,7 +10,10 @@ holds the informations in the read .def file.
c_linuxd.pp
-----------
This program creates the Linux units "linux/gl.pp" and "linux/glut.pp".
This program creates the Linux units "linux/gl.pp" and "linux/glut.pp". It is
a kind of template processor which reads in the Linux specific .tpl template
files; at specially marked places within the template file it inserts
converted data read in from .def files.
*.def

48
packages/opengl/build/c_linuxd.pp
View File

@ -2,14 +2,17 @@
$Id$
GL unit creation tool for Linux dynamic version
(c) 1999 Sebastian Guenther, sg@freepascal.org
(c) 1999-2000 Sebastian Guenther, sg@freepascal.org
}
program c_linuxd;
{$MODE objfpc}
{$H+}
program c_linuxd;
uses SysUtils, Classes, buildgl;
var
f: Text;
@ -26,7 +29,8 @@ var
i, j: Integer;
s: String;
begin
for i := 0 to procs.Count - 1 do begin
for i := 0 to procs.Count - 1 do
begin
s := procs.Strings[i];
j := Pos('//', s);
if (Length(s) = 0) or ((j > 0) and (Trim(s)[1] = '/')) then
@ -43,7 +47,8 @@ var
i, j: Integer;
s: String;
begin
for i := 0 to procs.Count - 1 do begin
for i := 0 to procs.Count - 1 do
begin
s := Trim(procs.Strings[i]);
j := Pos(':', s);
s := Trim(Copy(s, 1, j - 1));
@ -57,7 +62,7 @@ begin
WriteLn(f);
WriteLn(f);
WriteLn(f, '{');
WriteLn(f, ' $', 'Log:$'); // needed because _this_ file might be in CVS, too
WriteLn(f, ' $', 'Log:$'); // this source file (c_linuxd.pp) is in CVS, too!
WriteLn(f, '}');
end;
@ -65,9 +70,8 @@ var
DefGL, DefGLExt, DefGLU, DefGLX, DefGLUT: TDefReader;
tpl: Text;
s: String;
j: Integer;
begin
WriteLn('File Generator for OpenGL related Units');
WriteLn('Template processor for OpenGL related Units');
// Load definition files
@ -88,9 +92,11 @@ begin
Rewrite(f);
Assign(tpl, 'gl_linux.tpl');
Reset(tpl);
while not EOF(tpl) do begin
while not EOF(tpl) do
begin
ReadLn(tpl, s);
if Copy(s, 1, 1) = '%' then begin
if Copy(s, 1, 1) = '%' then
begin
if s = '%GLDecls' then
PrintInterface(DefGL.InterfaceBlock, f)
else if s = '%GLProcs1' then
@ -126,15 +132,17 @@ begin
// Build GLUT unit
WriteLn('Generating GLut unit for Linux...');
WriteLn('Generating GLUT unit for Linux...');
Assign(f, '../linux/glut.pp');
Rewrite(f);
Assign(tpl, 'glut_linux.tpl');
Reset(tpl);
while not EOF(tpl) do begin
while not EOF(tpl) do
begin
ReadLn(tpl, s);
if Copy(s, 1, 1) = '%' then begin
if Copy(s, 1, 1) = '%' then
begin
if s = '%GLUTDecls' then
PrintInterface(DefGLUT.InterfaceBlock, f)
else if s = '%GLUTProcs1' then
@ -143,13 +151,8 @@ begin
PrintProcLoaders(DefGLUT.Procs, 'libglut')
else
WriteLn(f, '// ### c_linuxd: Don''t know what to insert here!: ', s);
end else if Copy(s, 1, 1) <> '#' then begin
j := Pos('#extdecl', s);
if j = 0 then
WriteLn(f, s)
else
WriteLn(f, Copy(s, 1, j - 1), 'cdecl', Copy(s, j + 8, Length(s)));
end;
end else if Copy(s, 1, 1) <> '#' then
WriteLn(f, s);
end;
PrintCVSLogSection;
Close(f);
@ -160,7 +163,12 @@ end.
{
$Log$
Revision 1.1 1999-12-23 13:51:50 peter
Revision 1.2 2000-05-25 18:59:50 sg
* Completed GLU and GLUT support
* Some minor fixes (missing "const"s, changed some untyped "var" arguments
to "const" arguments etc.)
Revision 1.1 1999/12/23 13:51:50 peter
* reorganized, it now doesn't depend on fcl anymore by default
Revision 1.2 1999/12/01 00:55:44 alex

301
packages/opengl/build/gl.def
View File

@ -1,6 +1,22 @@
# This is the definition file for all GL functions and types.
%COPY_INTERFACE
// C types
type
SignedChar = ShortInt;
UnsignedChar = Byte;
Short = SmallInt;
SignedShort = Short;
UnsignedShort = Word;
Int = LongInt;
SignedInt = Int;
UnsignedInt = LongWord;
Float = Single;
PInt = ^Int;
// ===================================================================
// GL consts, types and functions
// ===================================================================
@ -12,15 +28,24 @@
type
PSingle = ^Single;
PDouble = ^Double;
PGLvoid = Pointer;
GLboolean = Boolean;
GLbyte = SignedChar; // 1-byte signed
GLshort = Short; // 2-byte signed
GLint = Int; // 4-byte signed
GLubyte = UnsignedChar; // 1-byte unsigned
GLushort = UnsignedShort; // 2-byte unsigned
GLuint = UnsignedInt; // 4-byte unsigned
GLsizei = Int; // 4-byte signed
GLfloat = Float; // single precision float
GLclampf = Float; // single precision float in [0,1]
GLdouble = Double; // double precision float
GLclampd = Double; // double precision float in [0,1]
GLclampf = Single; // single precision float in [0,1]
GLclampd = Double; // double precision float in [0,1]
PGLfloat = ^GLfloat;
GLenum = Integer;
type
GLbitfield = set of (GL_CURRENT_BIT, GL_POINT_BIT, GL_LINE_BIT,
GL_POLYGON_BIT, GL_POLYGON_STIPPLE_BIT, GL_PIXEL_MODE_BIT,
GL_LIGHTING_BIT, GL_FOG_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT,
@ -40,8 +65,8 @@ const
GL_NO_ERROR = 0;
// Boolean values
GL_FALSE = 0;
GL_TRUE = 1;
GL_FALSE = False;
GL_TRUE = True;
// Data types
GL_BYTE = $1400;
@ -670,7 +695,7 @@ var
%PROCS
// Miscellaneous
glClearIndex: procedure(c: Single);
glClearIndex: procedure(c: GLfloat);
glClearColor: procedure(red, green, blue, alpha: GLclampf);
glClear: procedure(mask: GLbitfield);
glIndexMask: procedure(mask: LongWord);
@ -680,18 +705,18 @@ var
glLogicOp: procedure(opcode: GLenum);
glCullFace: procedure(mode: GLenum);
glFrontFace: procedure(mode: GLenum);
glPointSize: procedure(size: Single);
glLineWidth: procedure(width: Single);
glPointSize: procedure(size: GLfloat);
glLineWidth: procedure(width: GLfloat);
glLineStipple: procedure(factor: LongInt; pattern: Word);
glPolygonMode: procedure(face, mode: GLenum);
glPolygonOffset: procedure(factor, units: Single);
glPolygonOffset: procedure(factor, units: GLfloat);
glPolygonStipple: procedure(var mask: Byte);
glGetPolygonStipple: procedure(var mask: Byte);
glEdgeFlag: procedure(flag: Boolean);
glEdgeFlagv: procedure(var flag: Boolean);
glScissor: procedure(x, y, width, height: LongInt);
glClipPlane: procedure(plane: GLenum; var equation: Double);
glGetClipPlane: procedure(plane: GLenum; var equation: Double);
glClipPlane: procedure(plane: GLenum; var equation: GLdouble);
glGetClipPlane: procedure(plane: GLenum; var equation: GLdouble);
glDrawBuffer: procedure(mode: GLenum);
glReadBuffer: procedure(mode: GLenum);
glEnable: procedure(cap: LongInt);
@ -700,8 +725,8 @@ var
glEnableClientState: procedure(cap: GLenum); // 1.1
glDisableClientState: procedure(cap: GLenum); // 1.1
glGetBooleanv: procedure(pname: GLenum; var params: Boolean);
glGetDoublev: procedure(pname: GLenum; var params: Double);
glGetFloatv: procedure(pname: GLenum; var params: Single);
glGetDoublev: procedure(pname: GLenum; var params: GLdouble);
glGetFloatv: procedure(pname: GLenum; var params: GLfloat);
glGetIntegerv: procedure(pname: GLenum; var params: LongInt);
glPushAttrib: procedure(mask: GLbitfield);
glPopAttrib: procedure;
@ -722,27 +747,27 @@ var
glDepthRange: procedure(near_val, far_val: GLclampd);
// Accumulation Buffer
glClearAccum: procedure(red, green, blue, alpha: Single);
glAccum: procedure(op: GLenum; value: Single);
glClearAccum: procedure(red, green, blue, alpha: GLfloat);
glAccum: procedure(op: GLenum; value: GLfloat);
// Tranformation
glMatrixMode: procedure(mode: GLenum);
glOrtho: procedure(left, right, bottom, top, near_val, far_val: Double);
glFrustum: procedure(left, right, bottom, top, near_val, far_val: Double);
glOrtho: procedure(left, right, bottom, top, near_val, far_val: GLdouble);
glFrustum: procedure(left, right, bottom, top, near_val, far_val: GLdouble);
glViewport: procedure(x, y, width, height: LongInt);
glPushMatrix: procedure;
glPopMatrix: procedure;
glLoadIdentity: procedure;
glLoadMatrixd: procedure(var m: Double);
glLoadMatrixf: procedure(var m: PSingle);
glMultMatrixd: procedure(var m: Double);
glMultMatrixf: procedure(var m: Single);
glRotated: procedure(angle, x, y, z: Double);
glRotatef: procedure(angle, x, y, z: Single);
glScaled: procedure(x, y, z: Double);
glScalef: procedure(x, y, z: Single);
glTranslated: procedure(x, y, z: Double);
glTranslatef: procedure(x, y, z: Single);
glLoadMatrixd: procedure(var m: GLdouble);
glLoadMatrixf: procedure(var m: PGLfloat);
glMultMatrixd: procedure(var m: GLdouble);
glMultMatrixf: procedure(var m: GLfloat);
glRotated: procedure(angle, x, y, z: GLdouble);
glRotatef: procedure(angle, x, y, z: GLfloat);
glScaled: procedure(x, y, z: GLdouble);
glScalef: procedure(x, y, z: GLfloat);
glTranslated: procedure(x, y, z: GLdouble);
glTranslatef: procedure(x, y, z: GLfloat);
// Display Lists
glIsList: function(list: LongWord): Boolean;
@ -757,144 +782,144 @@ var
// Drawing Functions
glBegin: procedure(mode: GLenum);
glEnd: procedure;
glVertex2d: procedure(x, y: Double);
glVertex2f: procedure(x, y: Single);
glVertex2d: procedure(x, y: GLdouble);
glVertex2f: procedure(x, y: GLfloat);
glVertex2i: procedure(x, y: LongInt);
glVertex2s: procedure(x, y: SmallInt);
glVertex3d: procedure(x, y, z: Double);
glVertex3f: procedure(x, y, z: Single);
glVertex3d: procedure(x, y, z: GLdouble);
glVertex3f: procedure(x, y, z: GLfloat);
glVertex3i: procedure(x, y, z: LongInt);
glVertex3s: procedure(x, y, z: SmallInt);
glVertex4d: procedure(x, y, z, w: Double);
glVertex4f: procedure(x, y, z, w: Single);
glVertex4d: procedure(x, y, z, w: GLdouble);
glVertex4f: procedure(x, y, z, w: GLfloat);
glVertex4i: procedure(x, y, z, w: LongInt);
glVertex4s: procedure(x, y, z, w: SmallInt);
glVertex2dv: procedure(var v: Double);
glVertex2fv: procedure(var v: Single);
glVertex2dv: procedure(var v: GLdouble);
glVertex2fv: procedure(var v: GLfloat);
glVertex2iv: procedure(var v: LongInt);
glVertex2sv: procedure(var v: SmallInt);
glVertex3dv: procedure(var v: Double);
glVertex3fv: procedure(var v: Single);
glVertex3dv: procedure(var v: GLdouble);
glVertex3fv: procedure(var v: GLfloat);
glVertex3iv: procedure(var v: LongInt);
glVertex3sv: procedure(var v: SmallInt);
glVertex4dv: procedure(var v: Double);
glVertex4fv: procedure(var v: Single);
glVertex4dv: procedure(var v: GLdouble);
glVertex4fv: procedure(var v: GLfloat);
glVertex4iv: procedure(var v: LongInt);
glVertex4sv: procedure(var v: SmallInt);
glNormal3b: procedure(nx, ny, nz: Byte);
glNormal3d: procedure(nx, ny, nz: Double);
glNormal3f: procedure(nx, ny, nz: Single);
glNormal3d: procedure(nx, ny, nz: GLdouble);
glNormal3f: procedure(nx, ny, nz: GLfloat);
glNormal3i: procedure(nx, ny, nz: LongInt);
glNormal3s: procedure(nx, ny, nz: SmallInt);
glNormal3bv: procedure(var v: ShortInt);
glNormal3dv: procedure(var v: Double);
glNormal3fv: procedure(var v: Single);
glNormal3dv: procedure(var v: GLdouble);
glNormal3fv: procedure(var v: GLfloat);
glNormal3iv: procedure(var v: LongInt);
glNormal3sv: procedure(var v: SmallInt);
glIndexd: procedure(c: Double);
glIndexf: procedure(c: Single);
glIndexd: procedure(c: GLdouble);
glIndexf: procedure(c: GLfloat);
glIndexi: procedure(c: LongInt);
glIndexs: procedure(c: SmallInt);
glIndexub: procedure(c: Byte); // 1.1
glIndexdv: procedure(var c: Double);
glIndexfv: procedure(var c: Single);
glIndexdv: procedure(var c: GLdouble);
glIndexfv: procedure(var c: GLfloat);
glIndexiv: procedure(var c: LongInt);
glIndexsv: procedure(var c: SmallInt);
glIndexubv: procedure(var c: Byte); // 1.1
glColor3b : procedure(red, green, blue: ShortInt);
glColor3d : procedure(red, green, blue: Double);
glColor3f : procedure(red, green, blue: Single);
glColor3d : procedure(red, green, blue: GLdouble);
glColor3f : procedure(red, green, blue: GLfloat);
glColor3i : procedure(red, green, blue: LongInt);
glColor3s : procedure(red, green, blue: SmallInt);
glColor3ub: procedure(red, green, blue: Byte);
glColor3ui: procedure(red, green, blue: LongWord);
glColor3us: procedure(red, green, blue: Word);
glColor4b : procedure(red, green, blue, alpha: ShortInt);
glColor4d : procedure(red, green, blue, alpha: Double);
glColor4f : procedure(red, green, blue, alpha: Single);
glColor4d : procedure(red, green, blue, alpha: GLdouble);
glColor4f : procedure(red, green, blue, alpha: GLfloat);
glColor4i : procedure(red, green, blue, alpha: LongInt);
glColor4s : procedure(red, green, blue, alpha: SmallInt);
glColor4ub: procedure(red, green, blue, alpha: Byte);
glColor4ui: procedure(red, green, blue, alpha: LongWord);
glColor4us: procedure(red, green, blue, alpha: Word);
glColor3bv : procedure(var v: ShortInt);
glColor3dv : procedure(var v: Double);
glColor3fv : procedure(var v: Single);
glColor3dv : procedure(var v: GLdouble);
glColor3fv : procedure(var v: GLfloat);
glColor3iv : procedure(var v: LongInt);
glColor3sv : procedure(var v: SmallInt);
glColor3ubv: procedure(var v: Byte);
glColor3uiv: procedure(var v: LongWord);
glColor3usv: procedure(var v: Word);
glColor4bv : procedure(var v: ShortInt);
glColor4dv : procedure(var v: Double);
glColor4fv : procedure(var v: Single);
glColor4dv : procedure(var v: GLdouble);
glColor4fv : procedure(var v: GLfloat);
glColor4iv : procedure(var v: LongInt);
glColor4sv : procedure(var v: SmallInt);
glColor4ubv: procedure(var v: Byte);
glColor4uiv: procedure(var v: LongWord);
glColor4usv: procedure(var v: Word);
glTexCoord1d: procedure(s: Double);
glTexCoord1f: procedure(s: Single);
glTexCoord1d: procedure(s: GLdouble);
glTexCoord1f: procedure(s: GLfloat);
glTexCoord1i: procedure(s: LongInt);
glTexCoord1s: procedure(s: SmallInt);
glTexCoord2d: procedure(s, t: Double);
glTexCoord2f: procedure(s, t: Single);
glTexCoord2d: procedure(s, t: GLdouble);
glTexCoord2f: procedure(s, t: GLfloat);
glTexCoord2i: procedure(s, t: LongInt);
glTexCoord2s: procedure(s, t: SmallInt);
glTexCoord3d: procedure(s, t, r: Double);
glTexCoord3f: procedure(s, t, r: Single);
glTexCoord3d: procedure(s, t, r: GLdouble);
glTexCoord3f: procedure(s, t, r: GLfloat);
glTexCoord3i: procedure(s, t, r: LongInt);
glTexCoord3s: procedure(s, t, r: SmallInt);
glTexCoord4d: procedure(s, t, r, q: Double);
glTexCoord4f: procedure(s, t, r, q: Single);
glTexCoord4d: procedure(s, t, r, q: GLdouble);
glTexCoord4f: procedure(s, t, r, q: GLfloat);
glTexCoord4i: procedure(s, t, r, q: LongInt);
glTexCoord4s: procedure(s, t, r, q: SmallInt);
glTexCoord1dv: procedure(var v: Double);
glTexCoord1fv: procedure(var v: Single);
glTexCoord1dv: procedure(var v: GLdouble);
glTexCoord1fv: procedure(var v: GLfloat);
glTexCoord1iv: procedure(var v: LongInt);
glTexCoord1sv: procedure(var v: SmallInt);
glTexCoord2dv: procedure(var v: Double);
glTexCoord2fv: procedure(var v: Single);
glTexCoord2dv: procedure(var v: GLdouble);
glTexCoord2fv: procedure(var v: GLfloat);
glTexCoord2iv: procedure(var v: LongInt);
glTexCoord2sv: procedure(var v: SmallInt);
glTexCoord3dv: procedure(var v: Double);
glTexCoord3fv: procedure(var v: Single);
glTexCoord3dv: procedure(var v: GLdouble);
glTexCoord3fv: procedure(var v: GLfloat);
glTexCoord3iv: procedure(var v: LongInt);
glTexCoord3sv: procedure(var v: SmallInt);
glTexCoord4dv: procedure(var v: Double);
glTexCoord4fv: procedure(var v: Single);
glTexCoord4dv: procedure(var v: GLdouble);
glTexCoord4fv: procedure(var v: GLfloat);
glTexCoord4iv: procedure(var v: LongInt);
glTexCoord4sv: procedure(var v: SmallInt);
glRasterPos2d: procedure(x, y: Double);
glRasterPos2f: procedure(x, y: Single);
glRasterPos2d: procedure(x, y: GLdouble);
glRasterPos2f: procedure(x, y: GLfloat);
glRasterPos2i: procedure(x, y: LongInt);
glRasterPos2s: procedure(x, y: SmallInt);
glRasterPos3d: procedure(x, y, z: Double);
glRasterPos3f: procedure(x, y, z: Single);
glRasterPos3d: procedure(x, y, z: GLdouble);
glRasterPos3f: procedure(x, y, z: GLfloat);
glRasterPos3i: procedure(x, y, z: LongInt);
glRasterPos3s: procedure(x, y, z: SmallInt);
glRasterPos4d: procedure(x, y, z, w: Double);
glRasterPos4f: procedure(x, y, z, w: Single);
glRasterPos4d: procedure(x, y, z, w: GLdouble);
glRasterPos4f: procedure(x, y, z, w: GLfloat);
glRasterPos4i: procedure(x, y, z, w: LongInt);
glRasterPos4s: procedure(x, y, z, w: SmallInt);
glRasterPos2dv: procedure(var v: Double);
glRasterPos2fv: procedure(var v: Single);
glRasterPos2dv: procedure(var v: GLdouble);
glRasterPos2fv: procedure(var v: GLfloat);
glRasterPos2iv: procedure(var v: LongInt);
glRasterPos2sv: procedure(var v: SmallInt);
glRasterPos3dv: procedure(var v: Double);
glRasterPos3fv: procedure(var v: Single);
glRasterPos3dv: procedure(var v: GLdouble);
glRasterPos3fv: procedure(var v: GLfloat);
glRasterPos3iv: procedure(var v: LongInt);
glRasterPos3sv: procedure(var v: SmallInt);
glRasterPos4dv: procedure(var v: Double);
glRasterPos4fv: procedure(var v: Single);
glRasterPos4dv: procedure(var v: GLdouble);
glRasterPos4fv: procedure(var v: GLfloat);
glRasterPos4iv: procedure(var v: LongInt);
glRasterPos4sv: procedure(var v: SmallInt);
glRectd: procedure(x1, y1, x2, y2: Double);
glRectf: procedure(x1, y1, x2, y2: Single);
glRectd: procedure(x1, y1, x2, y2: GLdouble);
glRectf: procedure(x1, y1, x2, y2: GLfloat);
glRecti: procedure(x1, y1, x2, y2: LongInt);
glRects: procedure(x1, y1, x2, y2: SmallInt);
glRectdv: procedure(var v1, v2: Double);
glRectfv: procedure(var v1, v2: Single);
glRectdv: procedure(var v1, v2: GLdouble);
glRectfv: procedure(var v1, v2: GLfloat);
glRectiv: procedure(var v1, v2: LongInt);
glRectsv: procedure(var v1, v2: SmallInt);
@ -913,37 +938,37 @@ var
// Lighting
glShadeModel: procedure(mode: GLenum);
glLightf: procedure(light, pname: GLenum; param: Single);
glLightf: procedure(light, pname: GLenum; param: GLfloat);
glLighti: procedure(light, pname: GLenum; param: LongInt);
glLightfv: procedure(light, pname: GLenum; var params: Single);
glLightfv: procedure(light, pname: GLenum; var params: GLfloat);
glLightiv: procedure(light, pname: GLenum; var params: LongInt);
glGetLightfv: procedure(light, pname: GLenum; var params: Single);
glGetLightfv: procedure(light, pname: GLenum; var params: GLfloat);
glGetLightiv: procedure(light, pname: GLenum; var params: LongInt);
glLightModelf: procedure(pname: GLenum; param: Single);
glLightModelf: procedure(pname: GLenum; param: GLfloat);
glLightModeli: procedure(pname: GLenum; param: LongInt);
glLightModelfv: procedure(pname: GLenum; var params: Single);
glLightModelfv: procedure(pname: GLenum; var params: GLfloat);
glLightModeliv: procedure(pname: GLenum; var param: LongInt);
glMaterialf: procedure(face, pname: GLenum; param: Single);
glMaterialf: procedure(face, pname: GLenum; param: GLfloat);
glMateriali: procedure(face, pname: GLenum; param: LongInt);
glMaterialfv: procedure(face, pname: GLenum; var params: Single);
glMaterialfv: procedure(face, pname: GLenum; var params: GLfloat);
glMaterialiv: procedure(face, pname: GLenum; var params: LongInt);
glGetMaterialfv: procedure(face, pname: GLenum; var params: Single);
glGetMaterialfv: procedure(face, pname: GLenum; var params: GLfloat);
glGetMaterialiv: procedure(face, pname: GLenum; var params: LongInt);
glColorMaterial: procedure(face, mode: GLenum);
// Raster Functions
glPixelZoom: procedure(xfactor, yfactor: Single);
glPixelStoref: procedure(pname: GLenum; param: Single);
glPixelZoom: procedure(xfactor, yfactor: GLfloat);
glPixelStoref: procedure(pname: GLenum; param: GLfloat);
glPixelStorei: procedure(pname: GLenum; param: LongInt);
glPixelTransferf: procedure(pname: GLenum; param: Single);
glPixelTransferf: procedure(pname: GLenum; param: GLfloat);
glPixelTransferi: procedure(pname: GLenum; param: LongInt);
glPixelMapfv: procedure(map: GLenum; mapsize: LongInt; var values: Single);
glPixelMapfv: procedure(map: GLenum; mapsize: LongInt; var values: GLfloat);
glPixelMapuiv: procedure(map: GLenum; mapsize: LongInt; var values: LongWord);
glPixelMapusv: procedure(map: GLenum; mapsize: LongInt; var values: Word);
glGetPixelMapfv: procedure(map: GLenum; var values: Single);
glGetPixelMapfv: procedure(map: GLenum; var values: GLfloat);
glGetPixelMapuiv: procedure(map: GLenum; var values: LongWord);
glGetPixelMapusv: procedure(map: GLenum; var values: Word);
glBitmap: procedure(width, height: LongInt; xorig, yorig, xmove, ymove: Single; var bitmap);
glBitmap: procedure(width, height: LongInt; xorig, yorig, xmove, ymove: GLfloat; var bitmap);
glReadPixels: procedure(x, y, width, height: LongInt; format, AType: GLenum; var pixels);
glDrawPixels: procedure(width, height: LongInt; format, AType: GLenum; var pixels);
glCopyPixels: procedure(x, y, width, height: LongInt; AType: GLenum);
@ -955,28 +980,28 @@ var
glClearStencil: procedure(s: LongInt);
// Texture Mapping
glTexGend: procedure(cord, pname: GLenum; param: Double);
glTexGenf: procedure(cord, pname: GLenum; param: Single);
glTexGend: procedure(cord, pname: GLenum; param: GLdouble);
glTexGenf: procedure(cord, pname: GLenum; param: GLfloat);
glTexGeni: procedure(cord, pname: GLenum; param: LongInt);
glTexGendv: procedure(cord, pname: GLenum; var params: Double);
glTexGenfv: procedure(cord, pname: GLenum; var params: Single);
glTexGendv: procedure(cord, pname: GLenum; var params: GLdouble);
glTexGenfv: procedure(cord, pname: GLenum; var params: GLfloat);
glTexGeniv: procedure(cord, pname: GLenum; var params: LongInt);
glGetTexGendv: procedure(cord, pname: GLenum; var params: Double);
glGetTexGenfv: procedure(cord, pname: GLenum; var params: Single);
glGetTexGendv: procedure(cord, pname: GLenum; var params: GLdouble);
glGetTexGenfv: procedure(cord, pname: GLenum; var params: GLfloat);
glGetTexGeniv: procedure(cord, pname: GLenum; var params: LongInt);
glTexEnvf: procedure(target, pname: GLenum; param: Single);
glTexEnvf: procedure(target, pname: GLenum; param: GLfloat);
glTexEnvi: procedure(target, pname: GLenum; param: LongInt);
glTexEnvfv: procedure(target, pname: GLenum; var params: Single);
glTexEnvfv: procedure(target, pname: GLenum; var params: GLfloat);
glTexEnviv: procedure(target, pname: GLenum; var params: LongInt);
glGetTexEnvfv: procedure(target, pname: GLenum; var params: Single);
glGetTexEnvfv: procedure(target, pname: GLenum; var params: GLfloat);
glGetTexEnviv: procedure(target, pname: GLenum; var params: LongInt);
glTexParameterf: procedure(target, pname: GLenum; param: Single);
glTexParameterf: procedure(target, pname: GLenum; param: GLfloat);
glTexParameteri: procedure(target, pname: GLenum; param: LongInt);
glTexParameterfv: procedure(target, pname: GLenum; var params: Single);
glTexParameterfv: procedure(target, pname: GLenum; var params: GLfloat);
glTexParameteriv: procedure(target, pname: GLenum; var params: LongInt);
glGetTexParameterfv: procedure(target, pname: GLenum; var params: Single);
glGetTexParameterfv: procedure(target, pname: GLenum; var params: GLfloat);
glGetTexParameteriv: procedure(target, pname: GLenum; var params: LongInt);
glGetTexLevelParameterfv: procedure(target: GLenum; level: LongInt; pname: GLenum; var params: Single);
glGetTexLevelParameterfv: procedure(target: GLenum; level: LongInt; pname: GLenum; var params: GLfloat);
glGetTexLevelParameteriv: procedure(target: GLenum; level: LongInt; pname: GLenum; var params: LongInt);
glTexImage1D: procedure(target: GLenum; level, internalFormat, width, border: LongInt; format, AType: GLenum; var pixels);
glTexImage2D: procedure(target: GLenum; level, internalFormat, width, height, border: LongInt; format, AType: GLenum; var pixels);
@ -996,39 +1021,39 @@ var
glCopyTexSubImage2D: procedure(target: GLenum; level, xoffset, yoffset, x, y, width, height: LongInt);
// Evaluators
glMap1d: procedure(target: GLenum; u1, u2: Double; stride, order: LongInt; var points: Double);
glMap1f: procedure(target: GLenum; u1, u2: Single; stride, order: LongInt; var points: Single);
glMap2d: procedure(target: GLenum; u1, u2: Double; ustride, uorder: LongInt; v1, v2: Double; vstride, vorder: LongInt; var points: Double);
glMap2f: procedure(target: GLenum; u1, u2: Single; ustride, uorder: LongInt; v1, v2: Single; vstride, vorder: LongInt; var points: Single);
glGetMapdv: procedure(target, query: GLenum; var v: Double);
glGetMapfv: procedure(target, query: GLenum; var v: Single);
glMap1d: procedure(target: GLenum; u1, u2: GLdouble; stride, order: LongInt; var points: GLdouble);
glMap1f: procedure(target: GLenum; u1, u2: GLfloat; stride, order: LongInt; var points: GLfloat);
glMap2d: procedure(target: GLenum; u1, u2: GLdouble; ustride, uorder: LongInt; v1, v2: GLdouble; vstride, vorder: LongInt; var points: GLdouble);
glMap2f: procedure(target: GLenum; u1, u2: GLfloat; ustride, uorder: LongInt; v1, v2: GLfloat; vstride, vorder: LongInt; var points: GLfloat);
glGetMapdv: procedure(target, query: GLenum; var v: GLdouble);
glGetMapfv: procedure(target, query: GLenum; var v: GLfloat);
glGetMapiv: procedure(target, query: GLenum; var v: LongInt);
glEvalCoord1d: procedure(u: Double);
glEvalCoord1f: procedure(u: Single);
glEvalCoord1dv: procedure(var u: Double);
glEvalCoord1fv: procedure(var u: Single);
glEvalCoord2d: procedure(u, v: Double);
glEvalCoord2f: procedure(u, v: Single);
glEvalCoord2dv: procedure(var u, v: Double);
glEvalCoord2fv: procedure(var u, v: Single);
glMapGrid1d: procedure(un: LongInt; u1, u2: Double);
glMapGrid1f: procedure(un: LongInt; u1, u2: Single);
glMapGrid2d: procedure(un: LongInt; u1, u2: Double; vn: LongInt; v1, v2: Double);
glMapGrid2f: procedure(un: LongInt; u1, u2: Single; vn: LongInt; v1, v2: Single);
glEvalCoord1d: procedure(u: GLdouble);
glEvalCoord1f: procedure(u: GLfloat);
glEvalCoord1dv: procedure(var u: GLdouble);
glEvalCoord1fv: procedure(var u: GLfloat);
glEvalCoord2d: procedure(u, v: GLdouble);
glEvalCoord2f: procedure(u, v: GLfloat);
glEvalCoord2dv: procedure(var u, v: GLdouble);
glEvalCoord2fv: procedure(var u, v: GLfloat);
glMapGrid1d: procedure(un: LongInt; u1, u2: GLdouble);
glMapGrid1f: procedure(un: LongInt; u1, u2: GLfloat);
glMapGrid2d: procedure(un: LongInt; u1, u2: GLdouble; vn: LongInt; v1, v2: GLdouble);
glMapGrid2f: procedure(un: LongInt; u1, u2: GLfloat; vn: LongInt; v1, v2: GLfloat);
glEvalPoint1: procedure(i: LongInt);
glEvalPoint2: procedure(i, j: LongInt);
glEvalMesh1: procedure(mode: GLenum; i1, i2: LongInt);
glEvalMesh2: procedure(mode: GLenum; i1, i2, j1, j2: LongInt);
// Fog
glFogf: procedure(pname: GLenum; param: Single);
glFogf: procedure(pname: GLenum; param: GLfloat);
glFogi: procedure(pname: GLenum; param: LongInt);
glFogfv: procedure(pname: GLenum; var params: Single);
glFogfv: procedure(pname: GLenum; var params: GLfloat);
glFogiv: procedure(pname: GLenum; var params: LongInt);
// Selection and Feedback
glFeedbackBuffer: procedure(size: LongInt; AType: GLenum; var buffer: Single);
glPassThrough: procedure(token: Single);
glFeedbackBuffer: procedure(size: LongInt; AType: GLenum; var buffer: GLfloat);
glPassThrough: procedure(token: GLfloat);
glSelectBuffer: procedure(size: LongInt; var buffer: LongWord);
glInitNames: procedure;
glLoadName: procedure(name: LongWord);

72
packages/opengl/build/gl_linux.tpl
View File

@ -1,41 +1,47 @@
{
$Id$
Translation of the Mesa GL, GLU and GLX headers for Free Pascal
Linux Version, Copyright (C) 1999-2000 Sebastian Guenther
Translation of the Mesa GL, GLU and GLX headers for Free Pascal, Linux version
Copyright (C) 1999-2000 Sebastian Guenther, sg@freepascal.org
Mesa 3-D graphics library
Version: 3.0
Copyright (C) 1995-1998 Brian Paul
Version: 3.1
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
Copyright (C) 1999 Brian Paul All Rights Reserved.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
}
{$MODE delphi} // objfpc would not work because of direct proc var assignments
unit GL;
{$MODE delphi} // objfpc would not work because of direct proc var assignments
interface
uses X,XLib,XUtil;
uses X, XLib, XUtil;
// ===================================================================
// Unit specific extensions
// ===================================================================
function InitGLFromLibrary(libname: PChar): Boolean;
function InitGLUFromLibrary(libname: PChar): Boolean;
function InitGLFromLibrary(const libname: PChar): Boolean;
function InitGLUFromLibrary(const libname: PChar): Boolean;
// Requires that the GL library has already been initialized:
function InitGLX: Boolean;
@ -81,12 +87,12 @@ function dlopen(AFile: PChar; mode: LongInt): Pointer; external 'dl';
function dlclose(handle: Pointer): LongInt; external 'dl';
function dlsym(handle: Pointer; name: PChar): Pointer; external 'dl';
function LoadLibrary(name: PChar): Pointer;
function LoadLibrary(const name: PChar): Pointer;
begin
Result := dlopen(name, $101 {RTLD_GLOBAL or RTLD_LAZY});
end;
function GetProc(handle: Pointer; name: PChar): Pointer;
function GetProc(handle: Pointer; const name: PChar): Pointer;
begin
Result := dlsym(handle, name);
if not Assigned(Result) and GLDumpUnresolvedFunctions then
@ -96,11 +102,12 @@ end;
var
libGL, libGLU, libGLX: Pointer;
function InitGLFromLibrary(libname: PChar): Boolean;
function InitGLFromLibrary(const libname: PChar): Boolean;
begin
Result := False;
libGL := LoadLibrary(libname);
if not Assigned(libGL) then exit;
if not Assigned(libGL) then
exit;
%GLProcs2
# // Extensions:
@ -110,11 +117,12 @@ begin
Result := True;
end;
function InitGLUFromLibrary(libname: PChar): Boolean;
function InitGLUFromLibrary(const libname: PChar): Boolean;
begin
Result := False;
libGLU := LoadLibrary(libname);
if not Assigned(libGLU) then exit;
if not Assigned(libGLU) then
exit;
%GLUProcs2
@ -125,7 +133,8 @@ end;
function InitGLX: Boolean;
begin
Result := False;
if not Assigned(libGL) then exit;
if not Assigned(libGL) then
exit;
%GLXProcs2
@ -146,9 +155,12 @@ begin
end;
finalization
if Assigned(libGL) then dlclose(libGL);
if Assigned(libGLU) then dlclose(libGLU);
if Assigned(libGLX) then dlclose(libGLX);
// Free all loaded libraries
if Assigned(libGLX) then
dlclose(libGLX);
if Assigned(libGLU) then
dlclose(libGLU);
if Assigned(libGL) then
dlclose(libGL);
end.

96
packages/opengl/build/glext.def
View File

@ -156,7 +156,7 @@ var
glBlendColorEXT: procedure(red, green, blue, alpha: GLclampf);
// GL_EXT_polygon_offset
glPolygonOffsetEXT: procedure(factor, bias: Single);
glPolygonOffsetEXT: procedure(factor, bias: GLfloat);
// GL_EXT_vertex_array
glVertexPointerEXT: procedure(size: LongInt; AType: GLenum; stride, count: LongInt; var ptr);
@ -186,38 +186,38 @@ var
glColorTableEXT: procedure(target, internalformat: GLenum; width: LongInt; format, AType: GLenum; var table);
glColorSubTableEXT: procedure(target: GLenum; start, count: LongInt; format, AType: GLEnum; var data);
glGetColorTableEXT: procedure(target, format, AType: GLenum; var table);
glGetColorTableParameterfvEXT: procedure(target, pname: GLenum; var params: Single);
glGetColorTableParameterfvEXT: procedure(target, pname: GLenum; var params: GLfloat);
glGetColorTableParameterivEXT: procedure(target, pname: GLenum; var params: LongInt);
// GL_SGIS_multitexture
glMultiTexCoord1dSGIS: procedure(target: GLenum; s: Double);
glMultiTexCoord1dvSGIS: procedure(target: GLenum; var v: Double);
glMultiTexCoord1fSGIS: procedure(target: GLenum; s: Single);
glMultiTexCoord1fvSGIS: procedure(target: GLenum; var v: Single);
glMultiTexCoord1dSGIS: procedure(target: GLenum; s: GLdouble);
glMultiTexCoord1dvSGIS: procedure(target: GLenum; var v: GLdouble);
glMultiTexCoord1fSGIS: procedure(target: GLenum; s: GLfloat);
glMultiTexCoord1fvSGIS: procedure(target: GLenum; var v: GLfloat);
glMultiTexCoord1iSGIS: procedure(target: GLenum; s: LongInt);
glMultiTexCoord1ivSGIS: procedure(target: GLenum; var v: LongInt);
glMultiTexCoord1sSGIS: procedure(target: GLenum; s: ShortInt);
glMultiTexCoord1svSGIS: procedure(target: GLenum; var v: ShortInt);
glMultiTexCoord2dSGIS: procedure(target: GLenum; s, t: Double);
glMultiTexCoord2dvSGIS: procedure(target: GLenum; var v: Double);
glMultiTexCoord2fSGIS: procedure(target: GLenum; s, t: Single);
glMultiTexCoord2fvSGIS: procedure(target: GLenum; var v: Single);
glMultiTexCoord2dSGIS: procedure(target: GLenum; s, t: GLdouble);
glMultiTexCoord2dvSGIS: procedure(target: GLenum; var v: GLdouble);
glMultiTexCoord2fSGIS: procedure(target: GLenum; s, t: GLfloat);
glMultiTexCoord2fvSGIS: procedure(target: GLenum; var v: GLfloat);
glMultiTexCoord2iSGIS: procedure(target: GLenum; s, t: LongInt);
glMultiTexCoord2ivSGIS: procedure(target: GLenum; var v: LongInt);
glMultiTexCoord2sSGIS: procedure(target: GLenum; s, t: ShortInt);
glMultiTexCoord2svSGIS: procedure(target: GLenum; var v: ShortInt);
glMultiTexCoord3dSGIS: procedure(target: GLenum; s, t, r: Double);
glMultiTexCoord3dvSGIS: procedure(target: GLenum; var v: Double);
glMultiTexCoord3fSGIS: procedure(target: GLenum; s, t, r: Single);
glMultiTexCoord3fvSGIS: procedure(target: GLenum; var v: Single);
glMultiTexCoord3dSGIS: procedure(target: GLenum; s, t, r: GLdouble);
glMultiTexCoord3dvSGIS: procedure(target: GLenum; var v: GLdouble);
glMultiTexCoord3fSGIS: procedure(target: GLenum; s, t, r: GLfloat);
glMultiTexCoord3fvSGIS: procedure(target: GLenum; var v: GLfloat);
glMultiTexCoord3iSGIS: procedure(target: GLenum; s, t, r: LongInt);
glMultiTexCoord3ivSGIS: procedure(target: GLenum; var v: LongInt);
glMultiTexCoord3sSGIS: procedure(target: GLenum; s, t, r: ShortInt);
glMultiTexCoord3svSGIS: procedure(target: GLenum; var v: ShortInt);
glMultiTexCoord4dSGIS: procedure(target: GLenum; s, t, r, q: Double);
glMultiTexCoord4dvSGIS: procedure(target: GLenum; var v: Double);
glMultiTexCoord4fSGIS: procedure(target: GLenum; s, t, r, q: Single);
glMultiTexCoord4fvSGIS: procedure(target: GLenum; var v: Single);
glMultiTexCoord4dSGIS: procedure(target: GLenum; s, t, r, q: GLdouble);
glMultiTexCoord4dvSGIS: procedure(target: GLenum; var v: GLdouble);
glMultiTexCoord4fSGIS: procedure(target: GLenum; s, t, r, q: GLfloat);
glMultiTexCoord4fvSGIS: procedure(target: GLenum; var v: GLfloat);
glMultiTexCoord4iSGIS: procedure(target: GLenum; s, t, r, q: LongInt);
glMultiTexCoord4ivSGIS: procedure(target: GLenum; var v: LongInt);
glMultiTexCoord4sSGIS: procedure(target: GLenum; s, t, r, q: ShortInt);
@ -227,34 +227,34 @@ var
glSelectTextureCoordSetSGIS: procedure(target: GLenum);
// GL_EXT_multitexture
glMultiTexCoord1dEXT: procedure(target: GLenum; s: Double);
glMultiTexCoord1dvEXT: procedure(target: GLenum; var v: Double);
glMultiTexCoord1fEXT: procedure(target: GLenum; s: Single);
glMultiTexCoord1fvEXT: procedure(target: GLenum; var v: Single);
glMultiTexCoord1dEXT: procedure(target: GLenum; s: GLdouble);
glMultiTexCoord1dvEXT: procedure(target: GLenum; var v: GLdouble);
glMultiTexCoord1fEXT: procedure(target: GLenum; s: GLfloat);
glMultiTexCoord1fvEXT: procedure(target: GLenum; var v: GLfloat);
glMultiTexCoord1iEXT: procedure(target: GLenum; s: LongInt);
glMultiTexCoord1ivEXT: procedure(target: GLenum; var v: LongInt);
glMultiTexCoord1sEXT: procedure(target: GLenum; s: ShortInt);
glMultiTexCoord1svEXT: procedure(target: GLenum; var v: ShortInt);
glMultiTexCoord2dEXT: procedure(target: GLenum; s, t: Double);
glMultiTexCoord2dvEXT: procedure(target: GLenum; var v: Double);
glMultiTexCoord2fEXT: procedure(target: GLenum; s, t: Single);
glMultiTexCoord2fvEXT: procedure(target: GLenum; var v: Single);
glMultiTexCoord2dEXT: procedure(target: GLenum; s, t: GLdouble);
glMultiTexCoord2dvEXT: procedure(target: GLenum; var v: GLdouble);
glMultiTexCoord2fEXT: procedure(target: GLenum; s, t: GLfloat);
glMultiTexCoord2fvEXT: procedure(target: GLenum; var v: GLfloat);
glMultiTexCoord2iEXT: procedure(target: GLenum; s, t: LongInt);
glMultiTexCoord2ivEXT: procedure(target: GLenum; var v: LongInt);
glMultiTexCoord2sEXT: procedure(target: GLenum; s, t: ShortInt);
glMultiTexCoord2svEXT: procedure(target: GLenum; var v: ShortInt);
glMultiTexCoord3dEXT: procedure(target: GLenum; s, t, r: Double);
glMultiTexCoord3dvEXT: procedure(target: GLenum; var v: Double);
glMultiTexCoord3fEXT: procedure(target: GLenum; s, t, r: Single);
glMultiTexCoord3fvEXT: procedure(target: GLenum; var v: Single);
glMultiTexCoord3dEXT: procedure(target: GLenum; s, t, r: GLdouble);
glMultiTexCoord3dvEXT: procedure(target: GLenum; var v: GLdouble);
glMultiTexCoord3fEXT: procedure(target: GLenum; s, t, r: GLfloat);
glMultiTexCoord3fvEXT: procedure(target: GLenum; var v: GLfloat);
glMultiTexCoord3iEXT: procedure(target: GLenum; s, t, r: LongInt);
glMultiTexCoord3ivEXT: procedure(target: GLenum; var v: LongInt);
glMultiTexCoord3sEXT: procedure(target: GLenum; s, t, r: ShortInt);
glMultiTexCoord3svEXT: procedure(target: GLenum; var v: ShortInt);
glMultiTexCoord4dEXT: procedure(target: GLenum; s, t, r, q: Double);
glMultiTexCoord4dvEXT: procedure(target: GLenum; var v: Double);
glMultiTexCoord4fEXT: procedure(target: GLenum; s, t, r, q: Single);
glMultiTexCoord4fvEXT: procedure(target: GLenum; var v: Single);
glMultiTexCoord4dEXT: procedure(target: GLenum; s, t, r, q: GLdouble);
glMultiTexCoord4dvEXT: procedure(target: GLenum; var v: GLdouble);
glMultiTexCoord4fEXT: procedure(target: GLenum; s, t, r, q: GLfloat);
glMultiTexCoord4fvEXT: procedure(target: GLenum; var v: GLfloat);
glMultiTexCoord4iEXT: procedure(target: GLenum; s, t, r, q: LongInt);
glMultiTexCoord4ivEXT: procedure(target: GLenum; var v: LongInt);
glMultiTexCoord4sEXT: procedure(target: GLenum; s, t, r, q: ShortInt);
@ -265,34 +265,34 @@ var
glSelectTextureTransformEXT: procedure(target: GLenum);
// GL_EXT_point_parameters
glPointParameterfEXT: procedure(pname: GLenum; param: Single);
glPointParameterfvEXT: procedure(pname: GLenum; var params: Single);
glPointParameterfEXT: procedure(pname: GLenum; param: GLfloat);
glPointParameterfvEXT: procedure(pname: GLenum; var params: GLfloat);
// GL_MESA_window_pos
glWindowPos2iMESA: procedure(x, y: LongInt);
glWindowPos2sMESA: procedure(x, y: ShortInt);
glWindowPos2fMESA: procedure(x, y: Single);
glWindowPos2dMESA: procedure(x, y: Double);
glWindowPos2fMESA: procedure(x, y: GLfloat);
glWindowPos2dMESA: procedure(x, y: GLdouble);
glWindowPos2ivMESA: procedure(var p: LongInt);
glWindowPos2svMESA: procedure(var p: ShortInt);
glWindowPos2fvMESA: procedure(var p: Single);
glWindowPos2dvMESA: procedure(var p: Double);
glWindowPos2fvMESA: procedure(var p: GLfloat);
glWindowPos2dvMESA: procedure(var p: GLdouble);
glWindowPos3iMESA: procedure(x, y, z: LongInt);
glWindowPos3sMESA: procedure(x, y, z: ShortInt);
glWindowPos3fMESA: procedure(x, y, z: Single);
glWindowPos3dMESA: procedure(x, y, z: Double);
glWindowPos3fMESA: procedure(x, y, z: GLfloat);
glWindowPos3dMESA: procedure(x, y, z: GLdouble);
glWindowPos3ivMESA: procedure(var p: LongInt);
glWindowPos3svMESA: procedure(var p: ShortInt);
glWindowPos3fvMESA: procedure(var p: Single);
glWindowPos3dvMESA: procedure(var p: Double);
glWindowPos3fvMESA: procedure(var p: GLfloat);
glWindowPos3dvMESA: procedure(var p: GLdouble);
glWindowPos4iMESA: procedure(x, y, z, w: LongInt);
glWindowPos4sMESA: procedure(x, y, z, w: ShortInt);
glWindowPos4fMESA: procedure(x, y, z, w: Single);
glWindowPos4dMESA: procedure(x, y, z, w: Double);
glWindowPos4fMESA: procedure(x, y, z, w: GLfloat);
glWindowPos4dMESA: procedure(x, y, z, w: GLdouble);
glWindowPos4ivMESA: procedure(var p: LongInt);
glWindowPos4svMESA: procedure(var p: ShortInt);
glWindowPos4fvMESA: procedure(var p: Single);
glWindowPos4dvMESA: procedure(var p: Double);
glWindowPos4fvMESA: procedure(var p: GLfloat);
glWindowPos4dvMESA: procedure(var p: GLdouble);
// GL_MESA_resize_buffers
glResizeBuffersMESA: procedure;

145
packages/opengl/build/glu.def
View File

@ -25,29 +25,40 @@ const
GLU_INSIDE = 100021;
// Tesselator
GLU_BEGIN = 100100;
GLU_VERTEX = 100101;
GLU_END = 100102;
GLU_ERROR = 100103;
GLU_EDGE_FLAG = 100104;
GLU_TESS_BEGIN = 100100;
GLU_TESS_VERTEX = 100101;
GLU_TESS_END = 100102;
GLU_TESS_ERROR = 100103;
GLU_TESS_EDGE_FLAG = 100104;
GLU_TESS_COMBINE = 100105;
GLU_TESS_BEGIN_DATA = 100106;
GLU_TESS_VERTEX_DATA = 100107;
GLU_TESS_END_DATA = 100108;
GLU_TESS_ERROR_DATA = 100109;
GLU_TESS_EDGE_FLAG_DATA = 100110;
GLU_TESS_COMBINE_DATA = 100111;
// Contour types
GLU_CW = 100120;
GLU_CCW = 100121;
GLU_INTERIOR = 100122;
GLU_EXTERIOR = 100123;
GLU_UNKNOWN = 100124;
// Winding rules
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;
// Tesselation errors
GLU_TESS_ERROR1 = 100151; // missing gluEndPolygon
GLU_TESS_ERROR2 = 100152; // missing gluBeginPolygon
GLU_TESS_ERROR3 = 100153; // misoriented contour
GLU_TESS_ERROR4 = 100154; // vertex/edge intersection
GLU_TESS_ERROR5 = 100155; // misoriented or self-intersecting loops
GLU_TESS_ERROR6 = 100156; // coincident vertices
GLU_TESS_ERROR7 = 100157; // all vertices collinear
GLU_TESS_ERROR8 = 100158; // intersecting edges
GLU_TESS_ERROR9 = 100159; // not coplanar contours
// Tessellation properties
GLU_TESS_WINDING_RULE = 100140;
GLU_TESS_BOUNDARY_ONLY = 100141;
GLU_TESS_TOLERANCE = 100142;
// Tessellation errors
GLU_TESS_ERROR1 = 100151; // Missing gluBeginPolygon
GLU_TESS_ERROR2 = 100152; // Missing gluBeginContour
GLU_TESS_ERROR3 = 100153; // Missing gluEndPolygon
GLU_TESS_ERROR4 = 100154; // Missing gluEndContour
GLU_TESS_ERROR5 = 100155;
GLU_TESS_ERROR6 = 100156;
GLU_TESS_ERROR7 = 100157;
GLU_TESS_ERROR8 = 100158;
// NURBS
GLU_AUTO_LOAD_MATRIX = 100200;
@ -117,22 +128,44 @@ const
GLU_VERSION = 100800;
GLU_EXTENSIONS = 100801;
// === GLU 1.0 tessellation - obsolete! ===
// Contour types
GLU_CW = 100120;
GLU_CCW = 100121;
GLU_INTERIOR = 100122;
GLU_EXTERIOR = 100123;
GLU_UNKNOWN = 100124;
// Tessellator
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;
type
PGLUquadricObj = ^TGLUquadricObj;
TGLUquadricObj = record end;
PGLUtriangulatorObj = ^TGLUtriangulatorObj;
TGLUtriangulatorObj = record end;
PGLUnurbsObj = ^TGLUnurbsObj;
TGLUnurbsObj = record end;
PGLUtesselator = ^TGLUtesselator;
TGLUtesselator = record end;
PGLUtriangulatorObj = PGLUtesselator;
// Callback function declarations
TGLUQuadricCallback = procedure; cdecl;
TGLUNurbsCallback = procedure; cdecl;
TGLUTessCallback = procedure; cdecl;
// We need some private array types
TGLUViewport = array[0..3] of LongInt;
TGLUMatrixd = array[0..15] of Double;
TGLUMatrixf = array[0..15] of Single;
TGLUVectord = array[0..2] of Double;
TGLUMatrixd = array[0..15] of GLdouble;
TGLUMatrixf = array[0..15] of GLfloat;
TGLUVectord = array[0..2] of GLdouble;
var
%END
@ -143,18 +176,18 @@ var
%PROCS
// Miscellaneous functions
gluLookAt: procedure(eye, eyey, eyez, centerx, centery, centerz, upx, upy, upz: Double);
gluOrtho2D: procedure(left, right, bottom, top: Double);
gluPerspective: procedure(fovy, aspect, zNear, zFar: Double);
gluPickMatrix: procedure(x, y, width, height: Double; const viewport: TGLUViewport);
gluProject: procedure(objx, objy, objz: Double; const modelMatrix, projMatrix: TGLUMatrixd; const viewport: TGLUViewport; winx, winy, winz: Double);
gluUnProject: procedure(winx, winy, winz: Double; const modelMatrix, projMatrix: TGLUMatrixd; const viewport: TGLUViewport; objx, objy, objz: Double);
gluErrorString: procedure(errorCode: GLenum);
gluLookAt: procedure(eye, eyey, eyez, centerx, centery, centerz, upx, upy, upz: GLdouble);
gluOrtho2D: procedure(left, right, bottom, top: GLdouble);
gluPerspective: procedure(fovy, aspect, zNear, zFar: GLdouble);
gluPickMatrix: procedure(x, y, width, height: GLdouble; const viewport: TGLUViewport);
gluProject: function(objx, objy, objz: GLdouble; const modelMatrix, projMatrix: TGLUMatrixd; const viewport: TGLUViewport; var winx, winy, winz: GLdouble): LongInt;
gluUnProject: function(winx, winy, winz: GLdouble; const modelMatrix, projMatrix: TGLUMatrixd; const viewport: TGLUViewport; var objx, objy, objz: GLdouble): LongInt;
gluErrorString: function(errorCode: GLenum): PChar;
// Mipmapping and image scaling
gluScaleImage: procedure(format: GLenum; within, heightin: LongInt; typein: GLenum; var datain; widthout, heightout: LongInt; typeout: GLenum; var dataout);
gluBuild1DMipmaps: procedure(target: GLenum; components, width: LongInt; format, AType: GLEnum; var data);
gluBuild2DMipmaps: procedure(target: GLenum; components, width, height: LongInt; format, AType: GLEnum; var data);
gluScaleImage: procedure(format: GLenum; within, heightin: LongInt; typein: GLenum; const datain; widthout, heightout: LongInt; typeout: GLenum; var dataout);
gluBuild1DMipmaps: procedure(target: GLenum; components, width: LongInt; format, AType: GLEnum; const data);
gluBuild2DMipmaps: procedure(target: GLenum; components, width, height: LongInt; format, AType: GLEnum; const data);
// Quadrics
gluNewQuadric: function: PGLUquadricObj;
@ -164,37 +197,45 @@ var
gluQuadricNormals: procedure(quadObject: PGLUquadricObj; normals: GLenum);
gluQuadricTexture: procedure(quadObject: PGLUquadricObj; textureCoords: Boolean);
gluQuadricCallback: procedure(quadObject: PGLUquadricObj; which: GLenum; fn: TGLUQuadricCallback);
gluCylinder: procedure(qobj: PGLUquadricObj; baseRadius, topRadius, height: Double; slices, stacks: LongInt);
gluSphere: procedure(qobj: PGLUquadricObj; radius: Double; slices, stacks: LongInt);
gluDisk: procedure(qobj: PGLUquadricObj; innerRadius, outerRadius: Double; slices, loops: LongInt);
gluPartialDisk: procedure(qobj: PGLUquadricObj; innerRadius, outerRadius: Double; slices, loops: LongInt; startAngle, sweepAngle: Double);
gluCylinder: procedure(qobj: PGLUquadricObj; baseRadius, topRadius, height: GLdouble; slices, stacks: LongInt);
gluSphere: procedure(qobj: PGLUquadricObj; radius: GLdouble; slices, stacks: LongInt);
gluDisk: procedure(qobj: PGLUquadricObj; innerRadius, outerRadius: GLdouble; slices, loops: LongInt);
gluPartialDisk: procedure(qobj: PGLUquadricObj; innerRadius, outerRadius: GLdouble; slices, loops: LongInt; startAngle, sweepAngle: GLdouble);
// Nurbs
gluNewNurbsRenderer: function: PGLUnurbsObj;
gluDeleteNurbsRenderer: procedure(nobj: PGLUnurbsObj);
gluLoadSamplingMatrices: procedure(nobj: PGLUnurbsObj; const modelMatrix, projMatrix: TGLUMatrixf; const viewport: TGLUViewport);
gluNurbsProperty: procedure(nobj: PGLUnurbsObj; AProperty: GLenum; value: Single);
gluGetNurbsProperty: procedure(nobj: PGLUnurbsObj; AProperty: GLEnum; var value: Single);
gluNurbsProperty: procedure(nobj: PGLUnurbsObj; AProperty: GLenum; value: GLfloat);
gluGetNurbsProperty: procedure(nobj: PGLUnurbsObj; AProperty: GLEnum; var value: GLfloat);
gluBeginCurve: procedure(nobj: PGLUnurbsObj);
gluEndCurve: procedure(nobj: PGLUnurbsObj);
gluNurbsCurve: procedure(nobj: PGLUnurbsObj; nknots: LongInt; var know: Single; stride: LongInt; var ctlarray: Single; order: LongInt; AType: GLenum);
gluNurbsCurve: procedure(nobj: PGLUnurbsObj; nknots: LongInt; var know: GLfloat; stride: LongInt; var ctlarray: GLfloat; order: LongInt; AType: GLenum);
gluBeginSurface: procedure(nobj: PGLUnurbsObj);
gluEndSurface: procedure(nobj: PGLUnurbsObj);
gluNurbsSurface: procedure(nobj: PGLUnurbsObj; sknot_count: LongInt; var sknot: Single; tknot_count: LongInt; var tknot: Single; s_stride, t_stride: LongInt; var ctlarray: Single; sorder, torder: LongInt; AType: GLenum);
gluNurbsSurface: procedure(nobj: PGLUnurbsObj; sknot_count: LongInt; var sknot: GLfloat; tknot_count: LongInt; var tknot: GLfloat; s_stride, t_stride: LongInt; var ctlarray: GLfloat; sorder, torder: LongInt; AType: GLenum);
gluBeginTrim: procedure(nobj: PGLUnurbsObj);
gluEndTrim: procedure(nobj: PGLUnurbsObj);
gluPwlCurve: procedure(nobj: PGLUnurbsObj; count: LongInt; var AArray: Single; stride: LongInt; AType: GLenum);
gluPwlCurve: procedure(nobj: PGLUnurbsObj; count: LongInt; var AArray: GLfloat; stride: LongInt; AType: GLenum);
gluNurbsCallback: procedure(nobj: PGLUnurbsObj; which: GLenum; fn: TGLUNurbsCallback);
// Polygon tesselation
gluNewTess: function: PGLUtriangulatorObj;
gluTessCallback: procedure(tobj: PGLUtriangulatorObj; which: GLenum; fn: TGLUTessCallback);
gluNewTess: function: PGLUtesselator;
gluDeleteTess: procedure(tobj: PGLUtesselator);
gluTessBeginPolygon: procedure(tobj: PGLUtesselator; var polygon_data);
gluTessBeginContour: procedure(tobj: PGLUtesselator);
gluTessVertex: procedure(tobj: PGLUtesselator; v: TGLUVectord; var data);
gluTessEndContour: procedure(tobj: PGLUtesselator);
gluTessEndPolygon: procedure(tobj: PGLUtesselator);
gluTessProperty: procedure(tobj: PGLUtesselator; which: GLenum; value: GLdouble);
gluTessNormal: procedure(tobj: PGLUtesselator; x, y, z: GLdouble);
gluTessCallback: procedure(tobj: PGLUtesselator; which: GLenum; fn: TGLUTessCallback);
gluGetTessProperty: procedure(tobj: PGLUtesselator; which: GLenum; var value: GLdouble);
gluDeleteTess: procedure(tobj: PGLUtriangulatorObj);
gluBeginPolygon: procedure(tobj: PGLUtriangulatorObj);
gluEndPolygon: procedure(tobj: PGLUtriangulatorObj);
gluNextContour: procedure(tobj: PGLUtriangulatorObj; AType: GLenum);
gluTessVertex: procedure(tobj: PGLUtriangulatorObj; v: TGLUVectord; var data);
// Obsolete 1.0 tessellation functions
gluBeginPolygon: procedure(tobj: PGLUtesselator);
gluNextContour: procedure(tobj: PGLUtesselator; AType: GLenum);
gluEndPolygon: procedure(tobj: PGLUtesselator);
// New functions in GLU 1.1
gluGetString: function(name: GLenum): PChar;

439
packages/opengl/build/glut.def
View File

@ -1,6 +1,275 @@
# This is the definition file for all GLUT stuff
%COPY_INTERFACE
{ GLUT API revision history:
GLUT_API_VERSION is updated to reflect incompatible GLUT
API changes (interface changes, semantic changes, deletions,
or additions).
GLUT_API_VERSION=1 First public release of GLUT. 11/29/94
GLUT_API_VERSION=2 Added support for OpenGL/GLX multisampling,
extension. Supports new input devices like tablet, dial and button
box, and Spaceball. Easy to query OpenGL extensions.
GLUT_API_VERSION=3 glutMenuStatus added.
GLUT_API_VERSION=4 glutInitDisplayString, glutWarpPointer,
glutBitmapLength, glutStrokeLength, glutWindowStatusFunc, dynamic
video resize subAPI, glutPostWindowRedisplay, glutKeyboardUpFunc,
glutSpecialUpFunc, glutIgnoreKeyRepeat, glutSetKeyRepeat,
glutJoystickFunc, glutForceJoystickFunc (NOT FINALIZED!). }
const
GLUT_API_VERSION = 4;
// Display mode bit masks
GLUT_RGB = 0;
GLUT_RGBA = GLUT_RGB;
GLUT_INDEX = 1;
GLUT_SINGLE = 0;
GLUT_DOUBLE = 2;
GLUT_ACCUM = 4;
GLUT_ALPHA = 8;
GLUT_DEPTH = 16;
GLUT_STENCIL = 32;
GLUT_MULTISAMPLE = 128;
GLUT_STEREO = 256;
GLUT_LUMINANCE = 512;
// Mouse buttons
GLUT_LEFT_BUTTON = 0;
GLUT_MIDDLE_BUTTON = 1;
GLUT_RIGHT_BUTTON = 2;
// Mouse button state
GLUT_DOWN = 0;
GLUT_UP = 1;
// function keys
GLUT_KEY_F1 = 1;
GLUT_KEY_F2 = 2;
GLUT_KEY_F3 = 3;
GLUT_KEY_F4 = 4;
GLUT_KEY_F5 = 5;
GLUT_KEY_F6 = 6;
GLUT_KEY_F7 = 7;
GLUT_KEY_F8 = 8;
GLUT_KEY_F9 = 9;
GLUT_KEY_F10 = 10;
GLUT_KEY_F11 = 11;
GLUT_KEY_F12 = 12;
// directional keys
GLUT_KEY_LEFT = 100;
GLUT_KEY_UP = 101;
GLUT_KEY_RIGHT = 102;
GLUT_KEY_DOWN = 103;
GLUT_KEY_PAGE_UP = 104;
GLUT_KEY_PAGE_DOWN = 105;
GLUT_KEY_HOME = 106;
GLUT_KEY_END = 107;
GLUT_KEY_INSERT = 108;
// Enter / exit state
GLUT_LEFT = 0;
GLUT_ENTERED = 1;
// Menu usage state
GLUT_MENU_NOT_IN_USE = 0;
GLUT_MENU_IN_USE = 1;
// Visibility state
GLUT_NOT_VISIBLE = 0;
GLUT_VISIBLE = 1;
// Window status state
GLUT_HIDDEN = 0;
GLUT_FULLY_RETAINED = 1;
GLUT_PARTIALLY_RETAINED = 2;
GLUT_FULLY_COVERED = 3;
// Color index component selection values
GLUT_RED = 0;
GLUT_GREEN = 1;
GLUT_BLUE = 2;
// Layers for use
GLUT_NORMAL = 0;
GLUT_OVERLAY = 1;
// glutGet parameters
GLUT_WINDOW_X = 100;
GLUT_WINDOW_Y = 101;
GLUT_WINDOW_WIDTH = 102;
GLUT_WINDOW_HEIGHT = 103;
GLUT_WINDOW_BUFFER_SIZE = 104;
GLUT_WINDOW_STENCIL_SIZE = 105;
GLUT_WINDOW_DEPTH_SIZE = 106;
GLUT_WINDOW_RED_SIZE = 107;
GLUT_WINDOW_GREEN_SIZE = 108;
GLUT_WINDOW_BLUE_SIZE = 109;
GLUT_WINDOW_ALPHA_SIZE = 110;
GLUT_WINDOW_ACCUM_RED_SIZE = 111;
GLUT_WINDOW_ACCUM_GREEN_SIZE = 112;
GLUT_WINDOW_ACCUM_BLUE_SIZE = 113;
GLUT_WINDOW_ACCUM_ALPHA_SIZE = 114;
GLUT_WINDOW_DOUBLEBUFFER = 115;
GLUT_WINDOW_RGBA = 116;
GLUT_WINDOW_PARENT = 117;
GLUT_WINDOW_NUM_CHILDREN = 118;
GLUT_WINDOW_COLORMAP_SIZE = 119;
GLUT_WINDOW_NUM_SAMPLES = 120;
GLUT_WINDOW_STEREO = 121;
GLUT_WINDOW_CURSOR = 122;
GLUT_SCREEN_WIDTH = 200;
GLUT_SCREEN_HEIGHT = 201;
GLUT_SCREEN_WIDTH_MM = 202;
GLUT_SCREEN_HEIGHT_MM = 203;
GLUT_MENU_NUM_ITEMS = 300;
GLUT_DISPLAY_MODE_POSSIBLE = 400;
GLUT_INIT_WINDOW_X = 500;
GLUT_INIT_WINDOW_Y = 501;
GLUT_INIT_WINDOW_WIDTH = 502;
GLUT_INIT_WINDOW_HEIGHT = 503;
GLUT_INIT_DISPLAY_MODE = 504;
GLUT_ELAPSED_TIME = 700;
GLUT_WINDOW_FORMAT_ID = 123;
// glutDeviceGet parameters
GLUT_HAS_KEYBOARD = 600;
GLUT_HAS_MOUSE = 601;
GLUT_HAS_SPACEBALL = 602;
GLUT_HAS_DIAL_AND_BUTTON_BOX = 603;
GLUT_HAS_TABLET = 604;
GLUT_NUM_MOUSE_BUTTONS = 605;
GLUT_NUM_SPACEBALL_BUTTONS = 606;
GLUT_NUM_BUTTON_BOX_BUTTONS = 607;
GLUT_NUM_DIALS = 608;
GLUT_NUM_TABLET_BUTTONS = 609;
GLUT_DEVICE_IGNORE_KEY_REPEAT = 610;
GLUT_DEVICE_KEY_REPEAT = 611;
GLUT_HAS_JOYSTICK = 612;
GLUT_OWNS_JOYSTICK = 613;
GLUT_JOYSTICK_BUTTONS = 614;
GLUT_JOYSTICK_AXES = 615;
GLUT_JOYSTICK_POLL_RATE = 616;
// glutLayerGet parameters
GLUT_OVERLAY_POSSIBLE = 800;
GLUT_LAYER_IN_USE = 801;
GLUT_HAS_OVERLAY = 802;
GLUT_TRANSPARENT_INDEX = 803;
GLUT_NORMAL_DAMAGED = 804;
GLUT_OVERLAY_DAMAGED = 805;
// glutVideoResizeGet parameters
GLUT_VIDEO_RESIZE_POSSIBLE = 900;
GLUT_VIDEO_RESIZE_IN_USE = 901;
GLUT_VIDEO_RESIZE_X_DELTA = 902;
GLUT_VIDEO_RESIZE_Y_DELTA = 903;
GLUT_VIDEO_RESIZE_WIDTH_DELTA = 904;
GLUT_VIDEO_RESIZE_HEIGHT_DELTA= 905;
GLUT_VIDEO_RESIZE_X = 906;
GLUT_VIDEO_RESIZE_Y = 907;
GLUT_VIDEO_RESIZE_WIDTH = 908;
GLUT_VIDEO_RESIZE_HEIGHT = 909;
// glutGetModifiers return mask
GLUT_ACTIVE_SHIFT = 1;
GLUT_ACTIVE_CTRL = 2;
GLUT_ACTIVE_ALT = 4;
// glutSetCursor parameters
// Basic arrows
GLUT_CURSOR_RIGHT_ARROW = 0;
GLUT_CURSOR_LEFT_ARROW = 1;
// Symbolic cursor shapes
GLUT_CURSOR_INFO = 2;
GLUT_CURSOR_DESTROY = 3;
GLUT_CURSOR_HELP = 4;
GLUT_CURSOR_CYCLE = 5;
GLUT_CURSOR_SPRAY = 6;
GLUT_CURSOR_WAIT = 7;
GLUT_CURSOR_TEXT = 8;
GLUT_CURSOR_CROSSHAIR = 9;
// Directional cursors
GLUT_CURSOR_UP_DOWN = 10;
GLUT_CURSOR_LEFT_RIGHT = 11;
// Sizing cursors
GLUT_CURSOR_TOP_SIDE = 12;
GLUT_CURSOR_BOTTOM_SIDE = 13;
GLUT_CURSOR_LEFT_SIDE = 14;
GLUT_CURSOR_RIGHT_SIDE = 15;
GLUT_CURSOR_TOP_LEFT_CORNER = 16;
GLUT_CURSOR_TOP_RIGHT_CORNER = 17;
GLUT_CURSOR_BOTTOM_RIGHT_CORNER = 18;
GLUT_CURSOR_BOTTOM_LEFT_CORNER = 19;
// Inherit from parent window
GLUT_CURSOR_INHERIT = 100;
// Blank cursor
GLUT_CURSOR_NONE = 101;
// Fullscreen crosshair (if available)
GLUT_CURSOR_FULL_CROSSHAIR = 102;
type
// GLUT menu sub-API
TGlutCreateMenuFunc = procedure(arg: Int); cdecl;
// GLUT window callback sub-API
TGlutDisplayFunc = procedure; cdecl;
TGlutReshapeFunc = procedure(width, height: Int); cdecl;
TGlutKeyboardFunc = procedure(key: Char; x, y: Int); cdecl;
TGlutMouseFunc = procedure(button, state, x, y: Int); cdecl;
TGlutMotionFunc = procedure(x, y: Int); cdecl;
TGlutPassiveMotionFunc = procedure(x, y: Int); cdecl;
TGlutEntryFunc = procedure(x, y: Int); cdecl;
TGlutVisibilityFunc = procedure(state: Int); cdecl;
TGlutIdleFunc = procedure; cdecl;
TGlutTimerFunc = procedure(value: Int); cdecl;
TGlutMenuStateFunc = procedure(state: Int); cdecl;
TGlutSpecialFunc = procedure(key, x, y: Int); cdecl;
TGlutSpaceballMotionFunc = procedure(x, y, z: Int); cdecl;
TGlutSpaceballRotateFunc = procedure(x, y, z: Int); cdecl;
TGlutSpaceballButtonFunc = procedure(button, state: Int); cdecl;
TGlutButtonBoxFunc = procedure(button, state: Int); cdecl;
TGlutDialsFunc = procedure(dial, value: Int); cdecl;
TGlutTabletMotionFunc = procedure(x, y: Int); cdecl;
TGlutTabletButtonFunc = procedure(button, state, x, y: Int); cdecl;
TGlutMenuStatusFunc = procedure(status, x, y: Int); cdecl;
TGlutOverlayDisplayFunc = procedure; cdecl;
TGlutWindowStatusFunc = procedure(state: Int); cdecl;
TGlutKeyboardUpFunc = procedure(key: Char; x, y: Int); cdecl;
TGlutSpecialUpFunc = procedure(key, x, y: Int); cdecl;
TGlutJoystickFunc = procedure(buttonMask: UnsignedInt; x, y, z: Int); cdecl;
const
// GLUT device control sub-API
// glutSetKeyRepeat modes.
GLUT_KEY_REPEAT_OFF = 0;
GLUT_KEY_REPEAT_ON = 1;
GLUT_KEY_REPEAT_DEFAULT = 2;
// Joystick button masks
GLUT_JOYSTICK_BUTTON_A = 1;
GLUT_JOYSTICK_BUTTON_B = 2;
GLUT_JOYSTICK_BUTTON_C = 4;
GLUT_JOYSTICK_BUTTON_D = 8;
// GLUT game mode sub-API
// glutGameModeGet
GLUT_GAME_MODE_ACTIVE = 0;
GLUT_GAME_MODE_POSSIBLE = 1;
GLUT_GAME_MODE_WIDTH = 2;
GLUT_GAME_MODE_HEIGHT = 3;
GLUT_GAME_MODE_PIXEL_DEPTH = 4;
GLUT_GAME_MODE_REFRESH_RATE = 5;
GLUT_GAME_MODE_DISPLAY_CHANGED= 6;
var
%END
@ -10,98 +279,142 @@
%PROCS
// GLUT initialization sub-API
glutInit: procedure(var argcp: Integer; var argv: PChar);
glutInitDisplayMode: procedure(mode: LongWord);
glutInitDisplayString: procedure(AString: PChar);
glutInitWindowPosition: procedure(x, y: Integer);
glutInitWindowSize: procedure(width, height: Integer);
glutInit: procedure(argcp: PInt; argv: PPChar);
glutInitDisplayMode: procedure(mode: UnsignedInt);
glutInitDisplayString: procedure(const AString: PChar);
glutInitWindowPosition: procedure(x, y: Int);
glutInitWindowSize: procedure(width, height: Int);
glutMainLoop: procedure;
// GLUT window sub-API
glutCreateWindow: function(title: PChar): Integer;
glutCreateSubWindow: function(win, x, y, width, height: Integer): Integer;
glutDestroyWindow: procedure(win: Integer);
glutCreateWindow: function(const title: PChar): Int;
glutCreateSubWindow: function(win, x, y, width, height: Int): Int;
glutDestroyWindow: procedure(win: Int);
glutPostRedisplay: procedure;
glutPostWindowRedisplay: procedure(win: Integer);
glutPostWindowRedisplay: procedure(win: Int);
glutSwapBuffers: procedure;
glutGetWindow: function: Integer;
glutSetWindow: procedure(win: Integer);
glutSetWindowTitle: procedure(title: PChar);
glutGetWindow: function: Int;
glutSetWindow: procedure(win: Int);
glutSetWindowTitle: procedure(const title: PChar);
glutSetIconTitle: procedure(title: PChar);
glutPositionWindow: procedure(x, y: Integer);
glutReshapeWindow: procedure(width, height: Integer);
glutPositionWindow: procedure(x, y: Int);
glutReshapeWindow: procedure(width, height: Int);
glutPopWindow: procedure;
glutPushWindow: procedure;
glutIconifyWindow: procedure;
glutShowWindow: procedure;
glutHideWindow: procedure;
glutFullScreen: procedure;
glutSetCursor: procedure(cursor: Integer);
glutWarpPointer: procedure(x, y: Integer);
glutSetCursor: procedure(cursor: Int);
glutWarpPointer: procedure(x, y: Int);
//overlays ###
// GLUT overlay sub-API
glutEstablishOverlay: procedure;
glutRemoveOverlay: procedure;
glutUseLayer: procedure(layer: GLenum);
glutPostOverlayRedisplay: procedure;
glutPostWindowOverlayRedisplay: procedure(win: Int);
glutShowOverlay: procedure;
glutHideOverlay: procedure;
//menus ###
// GLUT menu sub-API
glutCreateMenu: function(func: TGlutCreateMenuFunc): Int;
glutDestroyMenu: procedure(menu: Int);
glutGetMenu: function: Int;
glutSetMenu: procedure(menu: Int);
glutAddMenuEntry: procedure(const ALabel: PChar; value: Int);
glutAddSubMenu: procedure(const ALabel: PChar; submenu: Int);
glutChangeToMenuEntry: procedure(item: Int; const ALabel: PChar; value: Int);
glutChangeToSubMenu: procedure(item: Int; const ALabel: PChar; submenu: Int);
glutRemoveMenuItem: procedure(item: Int);
glutAttachMenu: procedure(button: Int);
glutDetachMenu: procedure(button: Int);
// GLUT window callback sub-API
glutDisplayFunc: procedure(func: TGlutDisplayFunc);
glutReshapeFunc: procedure(func: TGlutReshapeFunc);
glutTimerFunc: procedure(millis: LongWord; func: TGlutTimerFunc; value: Integer);
// GLUTAPI void APIENTRY glutDisplayFunc(void (GLUTCALLBACK * func)(void));
// GLUTAPI void APIENTRY glutReshapeFunc(void (GLUTCALLBACK * func)(int width, int height));
// GLUTAPI void APIENTRY glutKeyboardFunc(void (GLUTCALLBACK * func)(unsigned char key, int x, int y));
// GLUTAPI void APIENTRY glutMouseFunc(void (GLUTCALLBACK * func)(int button, int state, int x, int y));
// GLUTAPI void APIENTRY glutMotionFunc(void (GLUTCALLBACK * func)(int x, int y));
// GLUTAPI void APIENTRY glutPassiveMotionFunc(void (GLUTCALLBACK * func)(int x, int y));
// GLUTAPI void APIENTRY glutEntryFunc(void (GLUTCALLBACK * func)(int state));
// GLUTAPI void APIENTRY glutVisibilityFunc(void (GLUTCALLBACK * func)(int state));
// GLUTAPI void APIENTRY glutIdleFunc(void (GLUTCALLBACK * func)(void));
// GLUTAPI void APIENTRY glutTimerFunc(unsigned int millis, void (GLUTCALLBACK * func)(int value), int value);
// GLUTAPI void APIENTRY glutMenuStateFunc(void (GLUTCALLBACK * func)(int state));
// GLUTAPI void APIENTRY glutSpecialFunc(void (GLUTCALLBACK * func)(int key, int x, int y));
// GLUTAPI void APIENTRY glutSpaceballMotionFunc(void (GLUTCALLBACK * func)(int x, int y, int z));
// GLUTAPI void APIENTRY glutSpaceballRotateFunc(void (GLUTCALLBACK * func)(int x, int y, int z));
// GLUTAPI void APIENTRY glutSpaceballButtonFunc(void (GLUTCALLBACK * func)(int button, int state));
// GLUTAPI void APIENTRY glutButtonBoxFunc(void (GLUTCALLBACK * func)(int button, int state));
// GLUTAPI void APIENTRY glutDialsFunc(void (GLUTCALLBACK * func)(int dial, int value));
// GLUTAPI void APIENTRY glutTabletMotionFunc(void (GLUTCALLBACK * func)(int x, int y));
// GLUTAPI void APIENTRY glutTabletButtonFunc(void (GLUTCALLBACK * func)(int button, int state, int x, int y));
// GLUTAPI void APIENTRY glutMenuStatusFunc(void (GLUTCALLBACK * func)(int status, int x, int y));
// GLUTAPI void APIENTRY glutOverlayDisplayFunc(void (GLUTCALLBACK * func)(void));
// GLUTAPI void APIENTRY glutWindowStatusFunc(void (GLUTCALLBACK * func)(int state));
// GLUTAPI void APIENTRY glutKeyboardUpFunc(void (GLUTCALLBACK * func)(unsigned char key, int x, int y));
// GLUTAPI void APIENTRY glutSpecialUpFunc(void (GLUTCALLBACK * func)(int key, int x, int y));
// GLUTAPI void APIENTRY glutJoystickFunc(void (GLUTCALLBACK * func)(unsigned int buttonMask, int x, int y, int z), int pollInterval)
glutKeyboardFunc: procedure(func: TGlutKeyboardFunc);
glutMouseFunc: procedure(func: TGlutMouseFunc);
glutMotionFunc: procedure(func: TGlutMotionFunc);
glutPassiveMotionFunc: procedure(func: TGlutPassiveMotionFunc);
glutEntryFunc: procedure(func: TGlutEntryFunc);
glutIdleFunc: procedure(func: TGlutIdleFunc);
glutTimerFunc: procedure(millis: UnsignedInt; func: TGlutTimerFunc; value: Int);
glutMenuStateFunc: procedure(func: TGlutMenuStateFunc);
glutSpecialFunc: procedure(func: TGlutSpecialFunc);
glutSpaceballMotionFunc: procedure(func: TGlutSpaceballMotionFunc);
glutSpaceballRotateFunc: procedure(func: TGlutSpaceballRotateFunc);
glutSpaceballButtonFunc: procedure(func: TGlutSpaceballButtonFunc);
glutButtonBoxFunc: procedure(func: TGlutButtonBoxFunc);
glutDialsFunc: procedure(func: TGlutDialsFunc);
glutTabletMotionFunc: procedure(func: TGlutTabletMotionFunc);
glutTabletButtonFunc: procedure(func: TGlutTabletButtonFunc);
glutMenuStatusFunc: procedure(func: TGlutMenuStatusFunc);
glutOverlayDisplayFunc: procedure(func: TGlutOverlayDisplayFunc);
glutWindowStatusFunc: procedure(func: TGlutWindowStatusFunc);
glutKeyboardUpFunc: procedure(func: TGlutKeyboardUpFunc);
glutSpecialUpFunc: procedure(func: TGlutSpecialUpFunc);
glutJoystickFunc: procedure(func: TGlutJoystickFunc; pollinterval: Int);
// GLUT color index sub-API
glutSetColor: procedure(index: Integer; red, green, blue: Single);
glutGetColor: function(ndx, component: Integer): Single;
glutCopyColormap: procedure(win: Integer);
glutSetColor: procedure(index: Int; red, green, blue: GLfloat);
glutGetColor: function(ndx, component: Int): GLfloat;
glutCopyColormap: procedure(win: Int);
// GLUT state retrieval sub-API
glutGet: function(AType: GLEnum): Integer;
glutDeviceGet: function(AType: GLEnum): Integer;
glutExtensionSupported: function(name: PChar): Integer;
glutGetModifiers: function: Integer;
glutLayerGet: function(AType: GLEnum): Integer;
glutGet: function(AType: GLEnum): Int;
glutDeviceGet: function(AType: GLEnum): Int;
glutExtensionSupported: function(const name: PChar): Int;
glutGetModifiers: function: Int;
glutLayerGet: function(AType: GLEnum): Int;
// fonts ###
// GLUT font sub-API
glutBitmapCharacter: procedure(font: Pointer; character: Int);
glutBitmapWidth: function(font: Pointer; character: Int): Int;
glutStrokeCharacter: procedure(font: Pointer; character: Int);
glutStrokeWidth: function(font: Pointer; character: Int): Int;
glutBitmapLength: function(font: Pointer; const AString: PChar): Int;
glutStrokeLength: function(font: Pointer; const AString: PChar): Int;
// pre-built models ###
// GLUT pre-built models sub-API
glutWireSphere: procedure(radius: GLdouble; slices, stacks: GLint);
glutSolidSphere: procedure(radius: GLdouble; slices, stacks: GLint);
glutWireCone: procedure(base: GLdouble; height: GLdouble; slices, stacks: GLint);
glutSolidCone: procedure(base: GLdouble; height: GLdouble; slices, stacks: GLint);
glutWireCube: procedure(size: GLdouble);
glutSolidCube: procedure(size: GLdouble);
glutWireTorus: procedure(innerRadius, outerRadius: GLdouble; sides, rings: GLint);
glutSolidTorus: procedure(innerRadius, outerRadius: GLdouble; sides, rings: GLint);
glutWireDodecahedron: procedure;
glutSolidDodecahedron: procedure;
glutWireTeapot: procedure(size: GLdouble);
glutSolidTeapot: procedure(size: GLdouble);
glutWireOctahedron: procedure;
glutSolidOctahedron: procedure;
glutWireTetrahedron: procedure;
glutSolidTetrahedron: procedure;
glutWireIcosahedron: procedure;
glutSolidIcosahedron: procedure;
// video resize ###
// GLUT video resize sub-API
glutVideoResizeGet: function(param: GLenum): Int;
glutSetupVideoResizing: procedure;
glutStopVideoResizing: procedure;
glutVideoResize: procedure(x, y, width, height: Int);
glutVideoPan: procedure(x, y, width, height: Int);
// debugging ###
// device control ###
// GLUT debugging sub-API
glutReportErrors: procedure;
// GLUT device control sub-API
glutIgnoreKeyRepeat: procedure(ignore: Int);
glutSetKeyRepeat: procedure(repeatMode: Int);
glutForceJoystickFunc: procedure;
// GLUT game mode sub-API
glutGameModeString: procedure(AString: PChar);
glutGameModeString: procedure(const AString: PChar);
glutEnterGameMode: function: Integer;
glutLeaveGameMode: procedure;
glutGameModeGet: function(mode: GLEnum): Integer;
glutGameModeGet: function(mode: GLEnum): Int;
%END

231
packages/opengl/build/glut_linux.tpl
View File

@ -1,39 +1,27 @@
{
$Id$
Translation of the Mesa GLUT headers for FreePascal
Linux Version, Copyright (C) 1999-2000 Sebastian Guenther
Translation of the GLUT 3.7 headers for Free Pascal, Linux version
Copyright (C) 1999-2000 Sebastian Guenther, sg@freepascal.org
Mesa 3-D graphics library
Version: 3.0
Copyright (C) 1995-1998 Brian Paul
Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1998.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
This program is freely distributable without licensing fees and is
provided without guarantee or warrantee expressed or implied. This
program is -not- in the public domain.
}
{$MODE delphi}
unit GLUT;
{$MODE delphi}
interface
uses GL;
function InitGLUTFromLibrary(libname: PChar): Boolean;
function InitGLUTFromLibrary(const libname: PChar): Boolean;
// determines automatically which library to use:
function InitGLUT: Boolean;
@ -46,169 +34,35 @@ var
unresolved GLUT functions dumped to the console }
GLUTDumpUnresolvedFunctions: Boolean;
%GLUTDecls
const
// Display mode bit masks
GLUT_RGB = 0;
GLUT_RGBA = GLUT_RGB;
GLUT_INDEX = 1;
GLUT_SINGLE = 0;
GLUT_DOUBLE = 2;
GLUT_ACCUM = 4;
GLUT_ALPHA = 8;
GLUT_DEPTH = 16;
GLUT_STENCIL = 32;
GLUT_MULTISAMPLE = 128;
GLUT_STEREO = 256;
GLUT_LUMINANCE = 512;
// Mouse buttons
GLUT_LEFT_BUTTON = 0;
GLUT_MIDDLE_BUTTON = 1;
GLUT_RIGHT_BUTTON = 2;
// Mouse button state
GLUT_DOWN = 0;
GLUT_UP = 1;
// Keys ###
// Enter / exit state
GLUT_LEFT = 0;
GLUT_ENTERED = 1;
// Menu usage state
GLUT_MENU_NOT_IN_USE = 0;
GLUT_MENU_IN_USE = 1;
// Visibility state
GLUT_NOT_VISIBLE = 0;
GLUT_VISIBLE = 1;
// Window status state
GLUT_HIDDEN = 0;
GLUT_FULLY_RETAINED = 1;
GLUT_PARTIALLY_RETAINED = 2;
GLUT_FULLY_COVERED = 3;
// Color index component selection values
GLUT_RED = 0;
GLUT_GREEN = 1;
GLUT_BLUE = 2;
// Layers for use
GLUT_NORMAL = 0;
GLUT_OVERLAY = 1;
// Bitmap stuff###
// glutGet parameters
GLUT_WINDOW_X = 100;
GLUT_WINDOW_Y = 101;
GLUT_WINDOW_WIDTH = 102;
GLUT_WINDOW_HEIGHT = 103;
GLUT_WINDOW_BUFFER_SIZE = 104;
GLUT_WINDOW_STENCIL_SIZE = 105;
GLUT_WINDOW_DEPTH_SIZE = 106;
GLUT_WINDOW_RED_SIZE = 107;
GLUT_WINDOW_GREEN_SIZE = 108;
GLUT_WINDOW_BLUE_SIZE = 109;
GLUT_WINDOW_ALPHA_SIZE = 110;
GLUT_WINDOW_ACCUM_RED_SIZE = 111;
GLUT_WINDOW_ACCUM_GREEN_SIZE = 112;
GLUT_WINDOW_ACCUM_BLUE_SIZE = 113;
GLUT_WINDOW_ACCUM_ALPHA_SIZE = 114;
GLUT_WINDOW_DOUBLEBUFFER = 115;
GLUT_WINDOW_RGBA = 116;
GLUT_WINDOW_PARENT = 117;
GLUT_WINDOW_NUM_CHILDREN = 118;
GLUT_WINDOW_COLORMAP_SIZE = 119;
GLUT_WINDOW_NUM_SAMPLES = 120;
GLUT_WINDOW_STEREO = 121;
GLUT_WINDOW_CURSOR = 122;
GLUT_SCREEN_WIDTH = 200;
GLUT_SCREEN_HEIGHT = 201;
GLUT_SCREEN_WIDTH_MM = 202;
GLUT_SCREEN_HEIGHT_MM = 203;
GLUT_MENU_NUM_ITEMS = 300;
GLUT_DISPLAY_MODE_POSSIBLE = 400;
GLUT_INIT_WINDOW_X = 500;
GLUT_INIT_WINDOW_Y = 501;
GLUT_INIT_WINDOW_WIDTH = 502;
GLUT_INIT_WINDOW_HEIGHT = 503;
GLUT_INIT_DISPLAY_MODE = 504;
GLUT_ELAPSED_TIME = 700;
GLUT_WINDOW_FORMAT_ID = 123;
// glutDeviceGet parameters
GLUT_HAS_KEYBOARD = 600;
GLUT_HAS_MOUSE = 601;
GLUT_HAS_SPACEBALL = 602;
GLUT_HAS_DIAL_AND_BUTTON_BOX = 603;
GLUT_HAS_TABLET = 604;
GLUT_NUM_MOUSE_BUTTONS = 605;
GLUT_NUM_SPACEBALL_BUTTONS = 606;
GLUT_NUM_BUTTON_BOX_BUTTONS = 607;
GLUT_NUM_DIALS = 608;
GLUT_NUM_TABLET_BUTTONS = 609;
GLUT_DEVICE_IGNORE_KEY_REPEAT = 610;
GLUT_DEVICE_KEY_REPEAT = 611;
GLUT_HAS_JOYSTICK = 612;
GLUT_OWNS_JOYSTICK = 613;
GLUT_JOYSTICK_BUTTONS = 614;
GLUT_JOYSTICK_AXES = 615;
GLUT_JOYSTICK_POLL_RATE = 616;
// glutLayerGet parameters
GLUT_OVERLAY_POSSIBLE = 800;
GLUT_LAYER_IN_USE = 801;
GLUT_HAS_OVERLAY = 802;
GLUT_TRANSPARENT_INDEX = 803;
GLUT_NORMAL_DAMAGED = 804;
GLUT_OVERLAY_DAMAGED = 805;
// glutVideoResizeGet parameters
GLUT_VIDEO_RESIZE_POSSIBLE = 900;
GLUT_VIDEO_RESIZE_IN_USE = 901;
GLUT_VIDEO_RESIZE_X_DELTA = 902;
GLUT_VIDEO_RESIZE_Y_DELTA = 903;
GLUT_VIDEO_RESIZE_WIDTH_DELTA = 904;
GLUT_VIDEO_RESIZE_HEIGHT_DELTA= 905;
GLUT_VIDEO_RESIZE_X = 906;
GLUT_VIDEO_RESIZE_Y = 907;
GLUT_VIDEO_RESIZE_WIDTH = 908;
GLUT_VIDEO_RESIZE_HEIGHT = 909;
// glutGetModifiers return mask
GLUT_ACTIVE_SHIFT = 1;
GLUT_ACTIVE_CTRL = 2;
GLUT_ACTIVE_ALT = 4;
// Cursor stuff ###
// GLUT window callback sub-API
type
TGlutDisplayFunc = procedure; #extdecl;
TGlutReshapeFunc = procedure(width, height: Integer); #extdecl;
TGlutTimerFunc = procedure(value: Integer); #extdecl;
// GLUT game mode sub-API
// glutGameModeGet
const
GLUT_GAME_MODE_ACTIVE = 0;
GLUT_GAME_MODE_POSSIBLE = 1;
GLUT_GAME_MODE_WIDTH = 2;
GLUT_GAME_MODE_HEIGHT = 3;
GLUT_GAME_MODE_PIXEL_DEPTH = 4;
GLUT_GAME_MODE_REFRESH_RATE = 5;
GLUT_GAME_MODE_DISPLAY_CHANGED= 6;
{ The following stuff does not exist in the Win32 version: }
(* commented out because cvars don't work in Delphi mode...
// Stroke font opaque addresses (use constants instead in source code).
var
glutStrokeRoman, glutStrokeMonoRoman: Pointer; cvar; external;
// Stroke font constants (use these in GLUT program).
const
GLUT_STROKE_ROMAN = @glutStrokeRoman;
GLUT_STROKE_MONO_ROMAN = @glutStrokeMonoRoman;
// Bitmap font opaque addresses (use constants instead in source code).
var
glutBitmap9By15, glutBitmap8By13, glutBitmapTimesRoman10,
glutBitmapTimesRoman24, glutBitmapHelvetica10, glutBitmapHelvetica12,
glutBitmapHelvetica18: Pointer; cdecl; external;
// Bitmap font constants (use these in GLUT program).
const
GLUT_BITMAP_9_BY_15 = @glutBitmap9By15;
GLUT_BITMAP_8_BY_13 = @glutBitmap8By13;
GLUT_BITMAP_TIMES_ROMAN_10 = @glutBitmapTimesRoman10;
GLUT_BITMAP_TIMES_ROMAN_24 = @glutBitmapTimesRoman24;
GLUT_BITMAP_HELVETICA_10 = @glutBitmapHelvetica10;
GLUT_BITMAP_HELVETICA_12 = @glutBitmapHelvetica12;
GLUT_BITMAP_HELVETICA_18 = @glutBitmapHelvetica18;*)
%GLUTProcs1
@ -216,11 +70,11 @@ implementation
{$LINKLIB Xmu}
function dlopen(AFile: PChar; mode: LongInt): Pointer; external 'dl';
function dlopen(const AFile: PChar; mode: LongInt): Pointer; external 'dl';
function dlclose(handle: Pointer): LongInt; external 'dl';
function dlsym(handle: Pointer; name: PChar): Pointer; external 'dl';
function dlsym(handle: Pointer; const name: PChar): Pointer; external 'dl';
function LoadLibrary(name: PChar): Pointer;
function LoadLibrary(const name: PChar): Pointer;
begin
Result := dlopen(name, $101 {RTLD_GLOBAL or RTLD_LAZY});
end;
@ -230,7 +84,7 @@ begin
dlclose(handle);
end;
function GetProc(handle: Pointer; name: PChar): Pointer;
function GetProc(handle: Pointer; const name: PChar): Pointer;
begin
Result := dlsym(handle, name);
if not Assigned(Result) and GLUTDumpUnresolvedFunctions then
@ -240,11 +94,12 @@ end;
var
libGLUT: Pointer;
function InitGLUTFromLibrary(libname: PChar): Boolean;
function InitGLUTFromLibrary(const libname: PChar): Boolean;
begin
Result := False;
libGLUT := LoadLibrary(libname);
if not Assigned(libGLUT) then exit;
if not Assigned(libGLUT) then
exit;
%GLUTProcs2

631
packages/opengl/linux/gl.pp
View File

File diff suppressed because it is too large Load Diff

447
packages/opengl/linux/glut.pp
View File

@ -1,39 +1,27 @@
{
$Id$
Translation of the Mesa GLUT headers for FreePascal
Linux Version, Copyright (C) 1999-2000 Sebastian Guenther
Translation of the GLUT 3.7 headers for Free Pascal, Linux version
Copyright (C) 1999-2000 Sebastian Guenther, sg@freepascal.org
Mesa 3-D graphics library
Version: 3.0
Copyright (C) 1995-1998 Brian Paul
Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1998.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
This program is freely distributable without licensing fees and is
provided without guarantee or warrantee expressed or implied. This
program is -not- in the public domain.
}
{$MODE delphi}
unit GLUT;
{$MODE delphi}
interface
uses GL;
function InitGLUTFromLibrary(libname: PChar): Boolean;
function InitGLUTFromLibrary(const libname: PChar): Boolean;
// determines automatically which library to use:
function InitGLUT: Boolean;
@ -47,9 +35,29 @@ var
GLUTDumpUnresolvedFunctions: Boolean;
{ GLUT API revision history:
GLUT_API_VERSION is updated to reflect incompatible GLUT
API changes (interface changes, semantic changes, deletions,
or additions).
GLUT_API_VERSION=1 First public release of GLUT. 11/29/94
GLUT_API_VERSION=2 Added support for OpenGL/GLX multisampling,
extension. Supports new input devices like tablet, dial and button
box, and Spaceball. Easy to query OpenGL extensions.
GLUT_API_VERSION=3 glutMenuStatus added.
GLUT_API_VERSION=4 glutInitDisplayString, glutWarpPointer,
glutBitmapLength, glutStrokeLength, glutWindowStatusFunc, dynamic
video resize subAPI, glutPostWindowRedisplay, glutKeyboardUpFunc,
glutSpecialUpFunc, glutIgnoreKeyRepeat, glutSetKeyRepeat,
glutJoystickFunc, glutForceJoystickFunc (NOT FINALIZED!). }
const
GLUT_API_VERSION = 4;
// Display mode bit masks
GLUT_RGB = 0;
GLUT_RGBA = GLUT_RGB;
@ -73,7 +81,29 @@ const
GLUT_DOWN = 0;
GLUT_UP = 1;
// Keys ###
// function keys
GLUT_KEY_F1 = 1;
GLUT_KEY_F2 = 2;
GLUT_KEY_F3 = 3;
GLUT_KEY_F4 = 4;
GLUT_KEY_F5 = 5;
GLUT_KEY_F6 = 6;
GLUT_KEY_F7 = 7;
GLUT_KEY_F8 = 8;
GLUT_KEY_F9 = 9;
GLUT_KEY_F10 = 10;
GLUT_KEY_F11 = 11;
GLUT_KEY_F12 = 12;
// directional keys
GLUT_KEY_LEFT = 100;
GLUT_KEY_UP = 101;
GLUT_KEY_RIGHT = 102;
GLUT_KEY_DOWN = 103;
GLUT_KEY_PAGE_UP = 104;
GLUT_KEY_PAGE_DOWN = 105;
GLUT_KEY_HOME = 106;
GLUT_KEY_END = 107;
GLUT_KEY_INSERT = 108;
// Enter / exit state
GLUT_LEFT = 0;
@ -102,9 +132,6 @@ const
GLUT_NORMAL = 0;
GLUT_OVERLAY = 1;
// Bitmap stuff###
// glutGet parameters
GLUT_WINDOW_X = 100;
GLUT_WINDOW_Y = 101;
@ -187,18 +214,85 @@ const
GLUT_ACTIVE_CTRL = 2;
GLUT_ACTIVE_ALT = 4;
// Cursor stuff ###
// glutSetCursor parameters
// Basic arrows
GLUT_CURSOR_RIGHT_ARROW = 0;
GLUT_CURSOR_LEFT_ARROW = 1;
// Symbolic cursor shapes
GLUT_CURSOR_INFO = 2;
GLUT_CURSOR_DESTROY = 3;
GLUT_CURSOR_HELP = 4;
GLUT_CURSOR_CYCLE = 5;
GLUT_CURSOR_SPRAY = 6;
GLUT_CURSOR_WAIT = 7;
GLUT_CURSOR_TEXT = 8;
GLUT_CURSOR_CROSSHAIR = 9;
// Directional cursors
GLUT_CURSOR_UP_DOWN = 10;
GLUT_CURSOR_LEFT_RIGHT = 11;
// Sizing cursors
GLUT_CURSOR_TOP_SIDE = 12;
GLUT_CURSOR_BOTTOM_SIDE = 13;
GLUT_CURSOR_LEFT_SIDE = 14;
GLUT_CURSOR_RIGHT_SIDE = 15;
GLUT_CURSOR_TOP_LEFT_CORNER = 16;
GLUT_CURSOR_TOP_RIGHT_CORNER = 17;
GLUT_CURSOR_BOTTOM_RIGHT_CORNER = 18;
GLUT_CURSOR_BOTTOM_LEFT_CORNER = 19;
// Inherit from parent window
GLUT_CURSOR_INHERIT = 100;
// Blank cursor
GLUT_CURSOR_NONE = 101;
// Fullscreen crosshair (if available)
GLUT_CURSOR_FULL_CROSSHAIR = 102;
// GLUT window callback sub-API
type
TGlutDisplayFunc = procedure; cdecl;
TGlutReshapeFunc = procedure(width, height: Integer); cdecl;
TGlutTimerFunc = procedure(value: Integer); cdecl;
// GLUT menu sub-API
TGlutCreateMenuFunc = procedure(arg: Int); cdecl;
// GLUT window callback sub-API
TGlutDisplayFunc = procedure; cdecl;
TGlutReshapeFunc = procedure(width, height: Int); cdecl;
TGlutKeyboardFunc = procedure(key: Char; x, y: Int); cdecl;
TGlutMouseFunc = procedure(button, state, x, y: Int); cdecl;
TGlutMotionFunc = procedure(x, y: Int); cdecl;
TGlutPassiveMotionFunc = procedure(x, y: Int); cdecl;
TGlutEntryFunc = procedure(x, y: Int); cdecl;
TGlutVisibilityFunc = procedure(state: Int); cdecl;
TGlutIdleFunc = procedure; cdecl;
TGlutTimerFunc = procedure(value: Int); cdecl;
TGlutMenuStateFunc = procedure(state: Int); cdecl;
TGlutSpecialFunc = procedure(key, x, y: Int); cdecl;
TGlutSpaceballMotionFunc = procedure(x, y, z: Int); cdecl;
TGlutSpaceballRotateFunc = procedure(x, y, z: Int); cdecl;
TGlutSpaceballButtonFunc = procedure(button, state: Int); cdecl;
TGlutButtonBoxFunc = procedure(button, state: Int); cdecl;
TGlutDialsFunc = procedure(dial, value: Int); cdecl;
TGlutTabletMotionFunc = procedure(x, y: Int); cdecl;
TGlutTabletButtonFunc = procedure(button, state, x, y: Int); cdecl;
TGlutMenuStatusFunc = procedure(status, x, y: Int); cdecl;
TGlutOverlayDisplayFunc = procedure; cdecl;
TGlutWindowStatusFunc = procedure(state: Int); cdecl;
TGlutKeyboardUpFunc = procedure(key: Char; x, y: Int); cdecl;
TGlutSpecialUpFunc = procedure(key, x, y: Int); cdecl;
TGlutJoystickFunc = procedure(buttonMask: UnsignedInt; x, y, z: Int); cdecl;
const
// GLUT device control sub-API
// glutSetKeyRepeat modes.
GLUT_KEY_REPEAT_OFF = 0;
GLUT_KEY_REPEAT_ON = 1;
GLUT_KEY_REPEAT_DEFAULT = 2;
// Joystick button masks
GLUT_JOYSTICK_BUTTON_A = 1;
GLUT_JOYSTICK_BUTTON_B = 2;
GLUT_JOYSTICK_BUTTON_C = 4;
GLUT_JOYSTICK_BUTTON_D = 8;
// GLUT game mode sub-API
// glutGameModeGet
const
// glutGameModeGet
GLUT_GAME_MODE_ACTIVE = 0;
GLUT_GAME_MODE_POSSIBLE = 1;
GLUT_GAME_MODE_WIDTH = 2;
@ -209,112 +303,184 @@ const
var
{ The following stuff does not exist in the Win32 version: }
(* commented out because cvars don't work in Delphi mode...
// Stroke font opaque addresses (use constants instead in source code).
var
glutStrokeRoman, glutStrokeMonoRoman: Pointer; cvar; external;
// Stroke font constants (use these in GLUT program).
const
GLUT_STROKE_ROMAN = @glutStrokeRoman;
GLUT_STROKE_MONO_ROMAN = @glutStrokeMonoRoman;
// Bitmap font opaque addresses (use constants instead in source code).
var
glutBitmap9By15, glutBitmap8By13, glutBitmapTimesRoman10,
glutBitmapTimesRoman24, glutBitmapHelvetica10, glutBitmapHelvetica12,
glutBitmapHelvetica18: Pointer; cdecl; external;
// Bitmap font constants (use these in GLUT program).
const
GLUT_BITMAP_9_BY_15 = @glutBitmap9By15;
GLUT_BITMAP_8_BY_13 = @glutBitmap8By13;
GLUT_BITMAP_TIMES_ROMAN_10 = @glutBitmapTimesRoman10;
GLUT_BITMAP_TIMES_ROMAN_24 = @glutBitmapTimesRoman24;
GLUT_BITMAP_HELVETICA_10 = @glutBitmapHelvetica10;
GLUT_BITMAP_HELVETICA_12 = @glutBitmapHelvetica12;
GLUT_BITMAP_HELVETICA_18 = @glutBitmapHelvetica18;*)
// GLUT initialization sub-API
glutInit: procedure(var argcp: Integer; var argv: PChar); cdecl;
glutInitDisplayMode: procedure(mode: LongWord); cdecl;
glutInitDisplayString: procedure(AString: PChar); cdecl;
glutInitWindowPosition: procedure(x, y: Integer); cdecl;
glutInitWindowSize: procedure(width, height: Integer); cdecl;
glutInit: procedure(argcp: PInt; argv: PPChar); cdecl;
glutInitDisplayMode: procedure(mode: UnsignedInt); cdecl;
glutInitDisplayString: procedure(const AString: PChar); cdecl;
glutInitWindowPosition: procedure(x, y: Int); cdecl;
glutInitWindowSize: procedure(width, height: Int); cdecl;
glutMainLoop: procedure; cdecl;
// GLUT window sub-API
glutCreateWindow: function(title: PChar): Integer; cdecl;
glutCreateSubWindow: function(win, x, y, width, height: Integer): Integer; cdecl;
glutDestroyWindow: procedure(win: Integer); cdecl;
glutCreateWindow: function(const title: PChar): Int; cdecl;
glutCreateSubWindow: function(win, x, y, width, height: Int): Int; cdecl;
glutDestroyWindow: procedure(win: Int); cdecl;
glutPostRedisplay: procedure; cdecl;
glutPostWindowRedisplay: procedure(win: Integer); cdecl;
glutPostWindowRedisplay: procedure(win: Int); cdecl;
glutSwapBuffers: procedure; cdecl;
glutGetWindow: function: Integer; cdecl;
glutSetWindow: procedure(win: Integer); cdecl;
glutSetWindowTitle: procedure(title: PChar); cdecl;
glutGetWindow: function: Int; cdecl;
glutSetWindow: procedure(win: Int); cdecl;
glutSetWindowTitle: procedure(const title: PChar); cdecl;
glutSetIconTitle: procedure(title: PChar); cdecl;
glutPositionWindow: procedure(x, y: Integer); cdecl;
glutReshapeWindow: procedure(width, height: Integer); cdecl;
glutPositionWindow: procedure(x, y: Int); cdecl;
glutReshapeWindow: procedure(width, height: Int); cdecl;
glutPopWindow: procedure; cdecl;
glutPushWindow: procedure; cdecl;
glutIconifyWindow: procedure; cdecl;
glutShowWindow: procedure; cdecl;
glutHideWindow: procedure; cdecl;
glutFullScreen: procedure; cdecl;
glutSetCursor: procedure(cursor: Integer); cdecl;
glutWarpPointer: procedure(x, y: Integer); cdecl;
glutSetCursor: procedure(cursor: Int); cdecl;
glutWarpPointer: procedure(x, y: Int); cdecl;
//overlays ###
// GLUT overlay sub-API
glutEstablishOverlay: procedure; cdecl;
glutRemoveOverlay: procedure; cdecl;
glutUseLayer: procedure(layer: GLenum); cdecl;
glutPostOverlayRedisplay: procedure; cdecl;
glutPostWindowOverlayRedisplay: procedure(win: Int); cdecl;
glutShowOverlay: procedure; cdecl;
glutHideOverlay: procedure; cdecl;
//menus ###
// GLUT menu sub-API
glutCreateMenu: function(func: TGlutCreateMenuFunc): Int; cdecl;
glutDestroyMenu: procedure(menu: Int); cdecl;
glutGetMenu: function: Int; cdecl;
glutSetMenu: procedure(menu: Int); cdecl;
glutAddMenuEntry: procedure(const ALabel: PChar; value: Int); cdecl;
glutAddSubMenu: procedure(const ALabel: PChar; submenu: Int); cdecl;
glutChangeToMenuEntry: procedure(item: Int; const ALabel: PChar; value: Int); cdecl;
glutChangeToSubMenu: procedure(item: Int; const ALabel: PChar; submenu: Int); cdecl;
glutRemoveMenuItem: procedure(item: Int); cdecl;
glutAttachMenu: procedure(button: Int); cdecl;
glutDetachMenu: procedure(button: Int); cdecl;
// GLUT window callback sub-API
glutDisplayFunc: procedure(func: TGlutDisplayFunc); cdecl;
glutReshapeFunc: procedure(func: TGlutReshapeFunc); cdecl;
glutTimerFunc: procedure(millis: LongWord; func: TGlutTimerFunc; value: Integer); cdecl;
// GLUTAPI void APIENTRY glutDisplayFunc(void (GLUTCALLBACK * func)(void));
// GLUTAPI void APIENTRY glutReshapeFunc(void (GLUTCALLBACK * func)(int width, int height));
// GLUTAPI void APIENTRY glutKeyboardFunc(void (GLUTCALLBACK * func)(unsigned char key, int x, int y));
// GLUTAPI void APIENTRY glutMouseFunc(void (GLUTCALLBACK * func)(int button, int state, int x, int y));
// GLUTAPI void APIENTRY glutMotionFunc(void (GLUTCALLBACK * func)(int x, int y));
// GLUTAPI void APIENTRY glutPassiveMotionFunc(void (GLUTCALLBACK * func)(int x, int y));
// GLUTAPI void APIENTRY glutEntryFunc(void (GLUTCALLBACK * func)(int state));
// GLUTAPI void APIENTRY glutVisibilityFunc(void (GLUTCALLBACK * func)(int state));
// GLUTAPI void APIENTRY glutIdleFunc(void (GLUTCALLBACK * func)(void));
// GLUTAPI void APIENTRY glutTimerFunc(unsigned int millis, void (GLUTCALLBACK * func)(int value), int value);
// GLUTAPI void APIENTRY glutMenuStateFunc(void (GLUTCALLBACK * func)(int state));
// GLUTAPI void APIENTRY glutSpecialFunc(void (GLUTCALLBACK * func)(int key, int x, int y));
// GLUTAPI void APIENTRY glutSpaceballMotionFunc(void (GLUTCALLBACK * func)(int x, int y, int z));
// GLUTAPI void APIENTRY glutSpaceballRotateFunc(void (GLUTCALLBACK * func)(int x, int y, int z));
// GLUTAPI void APIENTRY glutSpaceballButtonFunc(void (GLUTCALLBACK * func)(int button, int state));
// GLUTAPI void APIENTRY glutButtonBoxFunc(void (GLUTCALLBACK * func)(int button, int state));
// GLUTAPI void APIENTRY glutDialsFunc(void (GLUTCALLBACK * func)(int dial, int value));
// GLUTAPI void APIENTRY glutTabletMotionFunc(void (GLUTCALLBACK * func)(int x, int y));
// GLUTAPI void APIENTRY glutTabletButtonFunc(void (GLUTCALLBACK * func)(int button, int state, int x, int y));
// GLUTAPI void APIENTRY glutMenuStatusFunc(void (GLUTCALLBACK * func)(int status, int x, int y));
// GLUTAPI void APIENTRY glutOverlayDisplayFunc(void (GLUTCALLBACK * func)(void));
// GLUTAPI void APIENTRY glutWindowStatusFunc(void (GLUTCALLBACK * func)(int state));
// GLUTAPI void APIENTRY glutKeyboardUpFunc(void (GLUTCALLBACK * func)(unsigned char key, int x, int y));
// GLUTAPI void APIENTRY glutSpecialUpFunc(void (GLUTCALLBACK * func)(int key, int x, int y));
// GLUTAPI void APIENTRY glutJoystickFunc(void (GLUTCALLBACK * func)(unsigned int buttonMask, int x, int y, int z), int pollInterval)
glutKeyboardFunc: procedure(func: TGlutKeyboardFunc); cdecl;
glutMouseFunc: procedure(func: TGlutMouseFunc); cdecl;
glutMotionFunc: procedure(func: TGlutMotionFunc); cdecl;
glutPassiveMotionFunc: procedure(func: TGlutPassiveMotionFunc); cdecl;
glutEntryFunc: procedure(func: TGlutEntryFunc); cdecl;
glutIdleFunc: procedure(func: TGlutIdleFunc); cdecl;
glutTimerFunc: procedure(millis: UnsignedInt; func: TGlutTimerFunc; value: Int); cdecl;
glutMenuStateFunc: procedure(func: TGlutMenuStateFunc); cdecl;
glutSpecialFunc: procedure(func: TGlutSpecialFunc); cdecl;
glutSpaceballMotionFunc: procedure(func: TGlutSpaceballMotionFunc); cdecl;
glutSpaceballRotateFunc: procedure(func: TGlutSpaceballRotateFunc); cdecl;
glutSpaceballButtonFunc: procedure(func: TGlutSpaceballButtonFunc); cdecl;
glutButtonBoxFunc: procedure(func: TGlutButtonBoxFunc); cdecl;
glutDialsFunc: procedure(func: TGlutDialsFunc); cdecl;
glutTabletMotionFunc: procedure(func: TGlutTabletMotionFunc); cdecl;
glutTabletButtonFunc: procedure(func: TGlutTabletButtonFunc); cdecl;
glutMenuStatusFunc: procedure(func: TGlutMenuStatusFunc); cdecl;
glutOverlayDisplayFunc: procedure(func: TGlutOverlayDisplayFunc); cdecl;
glutWindowStatusFunc: procedure(func: TGlutWindowStatusFunc); cdecl;
glutKeyboardUpFunc: procedure(func: TGlutKeyboardUpFunc); cdecl;
glutSpecialUpFunc: procedure(func: TGlutSpecialUpFunc); cdecl;
glutJoystickFunc: procedure(func: TGlutJoystickFunc; pollinterval: Int); cdecl;
// GLUT color index sub-API
glutSetColor: procedure(index: Integer; red, green, blue: Single); cdecl;
glutGetColor: function(ndx, component: Integer): Single; cdecl;
glutCopyColormap: procedure(win: Integer); cdecl;
glutSetColor: procedure(index: Int; red, green, blue: GLfloat); cdecl;
glutGetColor: function(ndx, component: Int): GLfloat; cdecl;
glutCopyColormap: procedure(win: Int); cdecl;
// GLUT state retrieval sub-API
glutGet: function(AType: GLEnum): Integer; cdecl;
glutDeviceGet: function(AType: GLEnum): Integer; cdecl;
glutExtensionSupported: function(name: PChar): Integer; cdecl;
glutGetModifiers: function: Integer; cdecl;
glutLayerGet: function(AType: GLEnum): Integer; cdecl;
glutGet: function(AType: GLEnum): Int; cdecl;
glutDeviceGet: function(AType: GLEnum): Int; cdecl;
glutExtensionSupported: function(const name: PChar): Int; cdecl;
glutGetModifiers: function: Int; cdecl;
glutLayerGet: function(AType: GLEnum): Int; cdecl;
// fonts ###
// GLUT font sub-API
glutBitmapCharacter: procedure(font: Pointer; character: Int); cdecl;
glutBitmapWidth: function(font: Pointer; character: Int): Int; cdecl;
glutStrokeCharacter: procedure(font: Pointer; character: Int); cdecl;
glutStrokeWidth: function(font: Pointer; character: Int): Int; cdecl;
glutBitmapLength: function(font: Pointer; const AString: PChar): Int; cdecl;
glutStrokeLength: function(font: Pointer; const AString: PChar): Int; cdecl;
// pre-built models ###
// GLUT pre-built models sub-API
glutWireSphere: procedure(radius: GLdouble; slices, stacks: GLint); cdecl;
glutSolidSphere: procedure(radius: GLdouble; slices, stacks: GLint); cdecl;
glutWireCone: procedure(base: GLdouble; height: GLdouble; slices, stacks: GLint); cdecl;
glutSolidCone: procedure(base: GLdouble; height: GLdouble; slices, stacks: GLint); cdecl;
glutWireCube: procedure(size: GLdouble); cdecl;
glutSolidCube: procedure(size: GLdouble); cdecl;
glutWireTorus: procedure(innerRadius, outerRadius: GLdouble; sides, rings: GLint); cdecl;
glutSolidTorus: procedure(innerRadius, outerRadius: GLdouble; sides, rings: GLint); cdecl;
glutWireDodecahedron: procedure; cdecl;
glutSolidDodecahedron: procedure; cdecl;
glutWireTeapot: procedure(size: GLdouble); cdecl;
glutSolidTeapot: procedure(size: GLdouble); cdecl;
glutWireOctahedron: procedure; cdecl;
glutSolidOctahedron: procedure; cdecl;
glutWireTetrahedron: procedure; cdecl;
glutSolidTetrahedron: procedure; cdecl;
glutWireIcosahedron: procedure; cdecl;
glutSolidIcosahedron: procedure; cdecl;
// video resize ###
// GLUT video resize sub-API
glutVideoResizeGet: function(param: GLenum): Int; cdecl;
glutSetupVideoResizing: procedure; cdecl;
glutStopVideoResizing: procedure; cdecl;
glutVideoResize: procedure(x, y, width, height: Int); cdecl;
glutVideoPan: procedure(x, y, width, height: Int); cdecl;
// debugging ###
// device control ###
// GLUT debugging sub-API
glutReportErrors: procedure; cdecl;
// GLUT device control sub-API
glutIgnoreKeyRepeat: procedure(ignore: Int); cdecl;
glutSetKeyRepeat: procedure(repeatMode: Int); cdecl;
glutForceJoystickFunc: procedure; cdecl;
// GLUT game mode sub-API
glutGameModeString: procedure(AString: PChar); cdecl;
glutGameModeString: procedure(const AString: PChar); cdecl;
glutEnterGameMode: function: Integer; cdecl;
glutLeaveGameMode: procedure; cdecl;
glutGameModeGet: function(mode: GLEnum): Integer; cdecl;
glutGameModeGet: function(mode: GLEnum): Int; cdecl;
implementation
{$LINKLIB Xmu}
function dlopen(AFile: PChar; mode: LongInt): Pointer; external 'dl';
function dlopen(const AFile: PChar; mode: LongInt): Pointer; external 'dl';
function dlclose(handle: Pointer): LongInt; external 'dl';
function dlsym(handle: Pointer; name: PChar): Pointer; external 'dl';
function dlsym(handle: Pointer; const name: PChar): Pointer; external 'dl';
function LoadLibrary(name: PChar): Pointer;
function LoadLibrary(const name: PChar): Pointer;
begin
Result := dlopen(name, $101 {RTLD_GLOBAL or RTLD_LAZY});
end;
@ -324,7 +490,7 @@ begin
dlclose(handle);
end;
function GetProc(handle: Pointer; name: PChar): Pointer;
function GetProc(handle: Pointer; const name: PChar): Pointer;
begin
Result := dlsym(handle, name);
if not Assigned(Result) and GLUTDumpUnresolvedFunctions then
@ -334,11 +500,12 @@ end;
var
libGLUT: Pointer;
function InitGLUTFromLibrary(libname: PChar): Boolean;
function InitGLUTFromLibrary(const libname: PChar): Boolean;
begin
Result := False;
libGLUT := LoadLibrary(libname);
if not Assigned(libGLUT) then exit;
if not Assigned(libGLUT) then
exit;
glutInit := GetProc(libglut, 'glutInit');
glutInitDisplayMode := GetProc(libglut, 'glutInitDisplayMode');
@ -366,9 +533,48 @@ begin
glutFullScreen := GetProc(libglut, 'glutFullScreen');
glutSetCursor := GetProc(libglut, 'glutSetCursor');
glutWarpPointer := GetProc(libglut, 'glutWarpPointer');
glutEstablishOverlay := GetProc(libglut, 'glutEstablishOverlay');
glutRemoveOverlay := GetProc(libglut, 'glutRemoveOverlay');
glutUseLayer := GetProc(libglut, 'glutUseLayer');
glutPostOverlayRedisplay := GetProc(libglut, 'glutPostOverlayRedisplay');
glutPostWindowOverlayRedisplay := GetProc(libglut, 'glutPostWindowOverlayRedisplay');
glutShowOverlay := GetProc(libglut, 'glutShowOverlay');
glutHideOverlay := GetProc(libglut, 'glutHideOverlay');
glutCreateMenu := GetProc(libglut, 'glutCreateMenu');
glutDestroyMenu := GetProc(libglut, 'glutDestroyMenu');
glutGetMenu := GetProc(libglut, 'glutGetMenu');
glutSetMenu := GetProc(libglut, 'glutSetMenu');
glutAddMenuEntry := GetProc(libglut, 'glutAddMenuEntry');
glutAddSubMenu := GetProc(libglut, 'glutAddSubMenu');
glutChangeToMenuEntry := GetProc(libglut, 'glutChangeToMenuEntry');
glutChangeToSubMenu := GetProc(libglut, 'glutChangeToSubMenu');
glutRemoveMenuItem := GetProc(libglut, 'glutRemoveMenuItem');
glutAttachMenu := GetProc(libglut, 'glutAttachMenu');
glutDetachMenu := GetProc(libglut, 'glutDetachMenu');
glutDisplayFunc := GetProc(libglut, 'glutDisplayFunc');
glutReshapeFunc := GetProc(libglut, 'glutReshapeFunc');
glutKeyboardFunc := GetProc(libglut, 'glutKeyboardFunc');
glutMouseFunc := GetProc(libglut, 'glutMouseFunc');
glutMotionFunc := GetProc(libglut, 'glutMotionFunc');
glutPassiveMotionFunc := GetProc(libglut, 'glutPassiveMotionFunc');
glutEntryFunc := GetProc(libglut, 'glutEntryFunc');
glutIdleFunc := GetProc(libglut, 'glutIdleFunc');
glutTimerFunc := GetProc(libglut, 'glutTimerFunc');
glutMenuStateFunc := GetProc(libglut, 'glutMenuStateFunc');
glutSpecialFunc := GetProc(libglut, 'glutSpecialFunc');
glutSpaceballMotionFunc := GetProc(libglut, 'glutSpaceballMotionFunc');
glutSpaceballRotateFunc := GetProc(libglut, 'glutSpaceballRotateFunc');
glutSpaceballButtonFunc := GetProc(libglut, 'glutSpaceballButtonFunc');
glutButtonBoxFunc := GetProc(libglut, 'glutButtonBoxFunc');
glutDialsFunc := GetProc(libglut, 'glutDialsFunc');
glutTabletMotionFunc := GetProc(libglut, 'glutTabletMotionFunc');
glutTabletButtonFunc := GetProc(libglut, 'glutTabletButtonFunc');
glutMenuStatusFunc := GetProc(libglut, 'glutMenuStatusFunc');
glutOverlayDisplayFunc := GetProc(libglut, 'glutOverlayDisplayFunc');
glutWindowStatusFunc := GetProc(libglut, 'glutWindowStatusFunc');
glutKeyboardUpFunc := GetProc(libglut, 'glutKeyboardUpFunc');
glutSpecialUpFunc := GetProc(libglut, 'glutSpecialUpFunc');
glutJoystickFunc := GetProc(libglut, 'glutJoystickFunc');
glutSetColor := GetProc(libglut, 'glutSetColor');
glutGetColor := GetProc(libglut, 'glutGetColor');
glutCopyColormap := GetProc(libglut, 'glutCopyColormap');
@ -377,6 +583,39 @@ begin
glutExtensionSupported := GetProc(libglut, 'glutExtensionSupported');
glutGetModifiers := GetProc(libglut, 'glutGetModifiers');
glutLayerGet := GetProc(libglut, 'glutLayerGet');
glutBitmapCharacter := GetProc(libglut, 'glutBitmapCharacter');
glutBitmapWidth := GetProc(libglut, 'glutBitmapWidth');
glutStrokeCharacter := GetProc(libglut, 'glutStrokeCharacter');
glutStrokeWidth := GetProc(libglut, 'glutStrokeWidth');
glutBitmapLength := GetProc(libglut, 'glutBitmapLength');
glutStrokeLength := GetProc(libglut, 'glutStrokeLength');
glutWireSphere := GetProc(libglut, 'glutWireSphere');
glutSolidSphere := GetProc(libglut, 'glutSolidSphere');
glutWireCone := GetProc(libglut, 'glutWireCone');
glutSolidCone := GetProc(libglut, 'glutSolidCone');
glutWireCube := GetProc(libglut, 'glutWireCube');
glutSolidCube := GetProc(libglut, 'glutSolidCube');
glutWireTorus := GetProc(libglut, 'glutWireTorus');
glutSolidTorus := GetProc(libglut, 'glutSolidTorus');
glutWireDodecahedron := GetProc(libglut, 'glutWireDodecahedron');
glutSolidDodecahedron := GetProc(libglut, 'glutSolidDodecahedron');
glutWireTeapot := GetProc(libglut, 'glutWireTeapot');
glutSolidTeapot := GetProc(libglut, 'glutSolidTeapot');
glutWireOctahedron := GetProc(libglut, 'glutWireOctahedron');
glutSolidOctahedron := GetProc(libglut, 'glutSolidOctahedron');
glutWireTetrahedron := GetProc(libglut, 'glutWireTetrahedron');
glutSolidTetrahedron := GetProc(libglut, 'glutSolidTetrahedron');
glutWireIcosahedron := GetProc(libglut, 'glutWireIcosahedron');
glutSolidIcosahedron := GetProc(libglut, 'glutSolidIcosahedron');
glutVideoResizeGet := GetProc(libglut, 'glutVideoResizeGet');
glutSetupVideoResizing := GetProc(libglut, 'glutSetupVideoResizing');
glutStopVideoResizing := GetProc(libglut, 'glutStopVideoResizing');
glutVideoResize := GetProc(libglut, 'glutVideoResize');
glutVideoPan := GetProc(libglut, 'glutVideoPan');
glutReportErrors := GetProc(libglut, 'glutReportErrors');
glutIgnoreKeyRepeat := GetProc(libglut, 'glutIgnoreKeyRepeat');
glutSetKeyRepeat := GetProc(libglut, 'glutSetKeyRepeat');
glutForceJoystickFunc := GetProc(libglut, 'glutForceJoystickFunc');
glutGameModeString := GetProc(libglut, 'glutGameModeString');
glutEnterGameMode := GetProc(libglut, 'glutEnterGameMode');
glutLeaveGameMode := GetProc(libglut, 'glutLeaveGameMode');
@ -402,7 +641,9 @@ end.
{
$Log$
Revision 1.4 2000-03-16 17:40:39 sg
* Fixed GL* library loading functions
Revision 1.5 2000-05-25 18:59:50 sg
* Completed GLU and GLUT support
* Some minor fixes (missing "const"s, changed some untyped "var" arguments
to "const" arguments etc.)
}