--
-- OpenGL 1.1 Ada binding, package GLU
--
-- W. M. Richards, NiEstu, Phoenix AZ, December 1997
-- 
-- Converted from Brian Paul's Mesa package glu.h header file, version 2,5.
-- As noted below in Brian's original comments, this code is distributed
-- under the terms of the GNU Library General Public License.
--
-- Version 0.1, 21 December 1997
--
--
-- Here are the original glu.h comments:
--
-- Mesa 3-D graphics library
-- Version:  2.4
-- Copyright (C) 1995-1997  Brian Paul
--
-- 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.
--


with Interfaces.C;

with GL;
use  GL;


package GLU is

GLU_VERSION_1_1                     : constant := 1;


-- The GLU boolean constants
GLU_FALSE                           : constant := GL_FALSE;
GLU_TRUE                            : constant := GL_TRUE;

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

type GLviewPortRec      is record
   X, Y:           aliased GLint;
   Width, Height:  aliased GLint;
end record;

type GLfloatMatrix      is array ( 0..3, 0..3 ) of GLfloat;
type GLdoubleMatrix     is array ( 0..3, 0..3 ) of GLdouble;

type GLviewPortRecPtr   is access all GLviewPortRec;
type GLfloatMatrixPtr   is access all GLfloatMatrix;
type GLdoubleMatrixPtr  is access all GLdoubleMatrix;

type GLUquadricObj      is private;
type GLUtriangulatorObj is private;
type GLUnurbsObj        is private;

type GLUquadricObjPtr      is access all GLUquadricObj;
type GLUtriangulatorObjPtr is access all GLUtriangulatorObj;
type GLUnurbsObjPtr        is access all GLUnurbsObj;

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


-- Error string
type ErrorEnm is
(
   GL_NO_ERROR,
   GL_INVALID_ENUM,
   GL_INVALID_VALUE,
   GL_INVALID_OPERATION,
   GL_STACK_OVERFLOW,
   GL_STACK_UNDERFLOW,
   GL_OUT_OF_MEMORY,
   GLU_INVALID_ENUM,
   GLU_INVALID_VALUE,
   GLU_OUT_OF_MEMORY,
   GLU_INCOMPATIBLE_GL_VERSION
);
for ErrorEnm use
(
   GL_NO_ERROR                                => 16#0000#,
   GL_INVALID_ENUM                            => 16#0500#,
   GL_INVALID_VALUE                           => 16#0501#,
   GL_INVALID_OPERATION                       => 16#0502#,
   GL_STACK_OVERFLOW                          => 16#0503#,
   GL_STACK_UNDERFLOW                         => 16#0504#,
   GL_OUT_OF_MEMORY                           => 16#0505#,
   GLU_INVALID_ENUM                           => 16#18A24#,
   GLU_INVALID_VALUE                          => 16#18A25#,
   GLU_OUT_OF_MEMORY                          => 16#18A26#,
   GLU_INCOMPATIBLE_GL_VERSION                => 16#18A27#  -- Mesa-specific?
);
for ErrorEnm'Size use GLenum'size;

function gluErrorString (errorCode: ErrorEnm)
return GLubytePtr;


-- Scale image
function gluScaleImage (format   : PixelFormatEnm;
                        widthin  : GLint;
                        heightin : GLint;
                        typein   : PixelDataTypeEnm;
                        datain   : GLpointer;
                        widthout : GLint;
                        heightout: GLint;
                        typeout  : PixelDataTypeEnm;
                        dataout  : GLpointer)
return GLint;


-- Build mipmaps
function gluBuild1DMipmaps (target    : TargetTex1DOnlyEnm;
                            components: GLint;
                            width     : GLint;
                            format    : TexPixelFormatEnm;
                            c_type    : PixelDataTypeEnm;
                            data      : GLpointer)
return GLint;

function gluBuild2DMipmaps (target    : TargetTex2DOnlyEnm;
                            components: GLint;
                            width     : GLint;
                            height    : GLint;
                            format    : TexPixelFormatEnm;
                            c_type    : PixelDataTypeEnm;
                            data      : GLpointer)
return GLint;


-- Quadric objects
type DrawStyleEnm is
(
   GLU_POINT,
   GLU_LINE,
   GLU_FILL,
   GLU_SILHOUETTE
);
for DrawStyleEnm use
(
   GLU_POINT                                  => 16#186AA#,
   GLU_LINE                                   => 16#186AB#,
   GLU_FILL                                   => 16#186AC#,
   GLU_SILHOUETTE                             => 16#186AD#
);
for DrawStyleEnm'Size use GLenum'size;

type OrientationEnm is
(
   GLU_OUTSIDE,
   GLU_INSIDE
);
for OrientationEnm use
(
   GLU_OUTSIDE                                => 16#186B4#,
   GLU_INSIDE                                 => 16#186B5#
);
for OrientationEnm'Size use GLenum'size;

type NormalsEnm is
(
   GLU_SMOOTH,
   GLU_FLAT,
   GLU_NONE
);
for NormalsEnm use
(
   GLU_SMOOTH                                 => 16#186A0#,
   GLU_FLAT                                   => 16#186A1#,
   GLU_NONE                                   => 16#186A2#
);
for NormalsEnm'Size use GLenum'size;

type CallbackEnm is
(
   GLU_ERROR
);
for CallbackEnm use
(
   GLU_ERROR                                  => 16#18707#
);
for CallbackEnm'Size use GLenum'size;

type QuadricCallbackFunction is access procedure (Error:  ErrorEnm);

function gluNewQuadric
return GLUquadricObjPtr;

procedure gluDeleteQuadric (state: GLUquadricObjPtr);

procedure gluQuadricDrawStyle (quadObject: GLUquadricObjPtr;
                               drawStyle : DrawStyleEnm);

procedure gluQuadricOrientation (quadObject : GLUquadricObjPtr;
                                 orientation: OrientationEnm);

procedure gluQuadricNormals (quadObject: GLUquadricObjPtr;
                             normals   : NormalsEnm);

procedure gluQuadricTexture (quadObject   : GLUquadricObjPtr;
                             textureCoords: GLboolean);

procedure gluQuadricCallback (qobj : GLUquadricObjPtr;
                              which: CallbackEnm;
                              fn   : QuadricCallbackFunction);

procedure gluCylinder (qobj      : GLUquadricObjPtr;
                       baseRadius: GLdouble;
                       topRadius : GLdouble;
                       height    : GLdouble;
                       slices    : GLint;
                       stacks    : GLint);

procedure gluSphere (qobj  : GLUquadricObjPtr;
                     radius: GLdouble;
                     slices: GLint;
                     stacks: GLint);

procedure gluDisk (qobj       : GLUquadricObjPtr;
                   innerRadius: GLdouble;
                   outerRadius: GLdouble;
                   slices     : GLint;
                   loops      : GLint);

procedure gluPartialDisk (qobj       : GLUquadricObjPtr;
                          innerRadius: GLdouble;
                          outerRadius: GLdouble;
                          slices     : GLint;
                          loops      : GLint;
                          startAngle : GLdouble;
                          sweepAngle : GLdouble);


-- Non-uniform rational B-splines (NURBS)
type NurbsPropertyEnm is
(
   GLU_AUTO_LOAD_MATRIX,
   GLU_CULLING,
   GLU_PARAMETRIC_TOLERANCE,
   GLU_SAMPLING_TOLERANCE,
   GLU_DISPLAY_MODE,
   GLU_SAMPLING_METHOD,
   GLU_U_STEP,
   GLU_V_STEP
);
for NurbsPropertyEnm use
(
   GLU_AUTO_LOAD_MATRIX                       => 16#18768#,
   GLU_CULLING                                => 16#18769#,
   GLU_PARAMETRIC_TOLERANCE                   => 16#1876A#,
   GLU_SAMPLING_TOLERANCE                     => 16#1876B#,
   GLU_DISPLAY_MODE                           => 16#1876C#,
   GLU_SAMPLING_METHOD                        => 16#1876D#,
   GLU_U_STEP                                 => 16#1876E#,
   GLU_V_STEP                                 => 16#1876F#
);
for NurbsPropertyEnm'Size use GLenum'size;

type NurbsDisplayModeEnm is
(
   GLU_FILL,
   GLU_OUTLINE_POLYGON,
   GLU_OUTLINE_PATCH
);
for NurbsDisplayModeEnm use
(
   GLU_FILL                                   => 16#186AC#,
   GLU_OUTLINE_POLYGON                        => 16#18790#,
   GLU_OUTLINE_PATCH                          => 16#18791#
);
for NurbsDisplayModeEnm'Size use GLenum'size;

-- NURBS property values
GLU_PATH_LENGTH                     : constant := 16#18777#;
GLU_PARAMETRIC_ERROR                : constant := 16#18778#;
GLU_DOMAIN_DISTANCE                 : constant := 16#18779#;

type NurbsErrorEnm is
(
   GLU_NURBS_ERROR1,                                       -- spline order un-supported ,
   GLU_NURBS_ERROR2,                                       -- too few knots ,
   GLU_NURBS_ERROR3,                                       -- valid knot range is empty ,
   GLU_NURBS_ERROR4,                                       -- decreasing knot sequence ,
   GLU_NURBS_ERROR5,                                       -- knot multiplicity > spline order ,
   GLU_NURBS_ERROR6,                                       -- endcurve() must follow bgncurve() ,
   GLU_NURBS_ERROR7,                                       -- bgncurve() must precede endcurve() ,
   GLU_NURBS_ERROR8,                                       -- ctrlarray or knot vector is NULL ,
   GLU_NURBS_ERROR9,                                       -- can't draw pwlcurves ,
   GLU_NURBS_ERROR10,                                      -- missing gluNurbsCurve() ,
   GLU_NURBS_ERROR11,                                      -- missing gluNurbsSurface() ,
   GLU_NURBS_ERROR12,                                      -- endtrim() must precede endsurface() ,
   GLU_NURBS_ERROR13,                                      -- bgnsurface() must precede endsurface() ,
   GLU_NURBS_ERROR14,                                      -- curve of improper type passed as trim curve ,
   GLU_NURBS_ERROR15,                                      -- bgnsurface() must precede bgntrim() ,
   GLU_NURBS_ERROR16,                                      -- endtrim() must follow bgntrim() ,
   GLU_NURBS_ERROR17,                                      -- bgntrim() must precede endtrim(),
   GLU_NURBS_ERROR18,                                      -- invalid or missing trim curve,
   GLU_NURBS_ERROR19,                                      -- bgntrim() must precede pwlcurve() ,
   GLU_NURBS_ERROR20,                                      -- pwlcurve referenced twice,
   GLU_NURBS_ERROR21,                                      -- pwlcurve and nurbscurve mixed ,
   GLU_NURBS_ERROR22,                                      -- improper usage of trim data type ,
   GLU_NURBS_ERROR23,                                      -- nurbscurve referenced twice ,
   GLU_NURBS_ERROR24,                                      -- nurbscurve and pwlcurve mixed ,
   GLU_NURBS_ERROR25,                                      -- nurbssurface referenced twice ,
   GLU_NURBS_ERROR26,                                      -- invalid property ,
   GLU_NURBS_ERROR27,                                      -- endsurface() must follow bgnsurface() ,
   GLU_NURBS_ERROR28,                                      -- intersecting or misoriented trim curves ,
   GLU_NURBS_ERROR29,                                      -- intersecting trim curves ,
   GLU_NURBS_ERROR30,                                      -- UNUSED ,
   GLU_NURBS_ERROR31,                                      -- unconnected trim curves ,
   GLU_NURBS_ERROR32,                                      -- unknown knot error ,
   GLU_NURBS_ERROR33,                                      -- negative vertex count encountered ,
   GLU_NURBS_ERROR34,                                      -- negative byte-stride ,
   GLU_NURBS_ERROR35,                                      -- unknown type descriptor ,
   GLU_NURBS_ERROR36,                                      -- null control point reference ,
   GLU_NURBS_ERROR37                                       -- duplicate point on pwlcurve 
);
for NurbsErrorEnm use
(
   GLU_NURBS_ERROR1                           => 16#1879B#,
   GLU_NURBS_ERROR2                           => 16#1879C#,
   GLU_NURBS_ERROR3                           => 16#1879D#,
   GLU_NURBS_ERROR4                           => 16#1879E#,
   GLU_NURBS_ERROR5                           => 16#1879F#,
   GLU_NURBS_ERROR6                           => 16#187A0#,
   GLU_NURBS_ERROR7                           => 16#187A1#,
   GLU_NURBS_ERROR8                           => 16#187A2#,
   GLU_NURBS_ERROR9                           => 16#187A3#,
   GLU_NURBS_ERROR10                          => 16#187A4#,
   GLU_NURBS_ERROR11                          => 16#187A5#,
   GLU_NURBS_ERROR12                          => 16#187A6#,
   GLU_NURBS_ERROR13                          => 16#187A7#,
   GLU_NURBS_ERROR14                          => 16#187A8#,
   GLU_NURBS_ERROR15                          => 16#187A9#,
   GLU_NURBS_ERROR16                          => 16#187AA#,
   GLU_NURBS_ERROR17                          => 16#187AB#,
   GLU_NURBS_ERROR18                          => 16#187AC#,
   GLU_NURBS_ERROR19                          => 16#187AD#,
   GLU_NURBS_ERROR20                          => 16#187AE#,
   GLU_NURBS_ERROR21                          => 16#187AF#,
   GLU_NURBS_ERROR22                          => 16#187B0#,
   GLU_NURBS_ERROR23                          => 16#187B1#,
   GLU_NURBS_ERROR24                          => 16#187B2#,
   GLU_NURBS_ERROR25                          => 16#187B3#,
   GLU_NURBS_ERROR26                          => 16#187B4#,
   GLU_NURBS_ERROR27                          => 16#187B5#,
   GLU_NURBS_ERROR28                          => 16#187B6#,
   GLU_NURBS_ERROR29                          => 16#187B7#,
   GLU_NURBS_ERROR30                          => 16#187B8#,
   GLU_NURBS_ERROR31                          => 16#187B9#,
   GLU_NURBS_ERROR32                          => 16#187BA#,
   GLU_NURBS_ERROR33                          => 16#187BB#,
   GLU_NURBS_ERROR34                          => 16#187BC#,
   GLU_NURBS_ERROR35                          => 16#187BD#,
   GLU_NURBS_ERROR36                          => 16#187BE#,
   GLU_NURBS_ERROR37                          => 16#187BF#
);
for NurbsErrorEnm'Size use GLenum'size;

type PwlCurveTypeEnm is
(
   GLU_MAP1_TRIM_2,
   GLU_MAP1_TRIM_3
);
for PwlCurveTypeEnm use
(
   GLU_MAP1_TRIM_2                            => 16#18772#,
   GLU_MAP1_TRIM_3                            => 16#18773#
);
for PwlCurveTypeEnm'Size use GLenum'size;

type NurbsCallbackFunction is access procedure (Error:  NurbsErrorEnm);

function gluNewNurbsRenderer
return GLUnurbsObjPtr;

procedure gluDeleteNurbsRenderer (nobj: GLUnurbsObjPtr);

procedure gluLoadSamplingMatrices (nobj       : GLUnurbsObjPtr;
                                   modelMatrix: GLfloatMatrixPtr;
                                   projMatrix : GLfloatMatrixPtr;
                                   viewport   : GLviewPortRecPtr);

procedure gluNurbsProperty (nobj    : GLUnurbsObjPtr;
                            property: NurbsPropertyEnm;
                            value   : GLfloat);

procedure gluGetNurbsProperty (nobj    : GLUnurbsObjPtr;
                               property: NurbsPropertyEnm;
                               value   : GLfloatPtr);

procedure gluBeginCurve (nobj: GLUnurbsObjPtr);

procedure gluEndCurve (nobj: GLUnurbsObjPtr);

procedure gluNurbsCurve (nobj    : GLUnurbsObjPtr;
                         nknots  : GLint;
                         knot    : GLfloatPtr;
                         stride  : GLint;
                         ctlarray: GLfloatPtr;
                         order   : GLint;
                         c_type  : Map1TargetEnm);

procedure gluBeginSurface (nobj: GLUnurbsObjPtr);

procedure gluEndSurface (nobj: GLUnurbsObjPtr);

procedure gluNurbsSurface (nobj       : GLUnurbsObjPtr;
                           sknot_count: GLint;
                           sknot      : GLfloatPtr;
                           tknot_count: GLint;
                           tknot      : GLfloatPtr;
                           s_stride   : GLint;
                           t_stride   : GLint;
                           ctlarray   : GLfloatPtr;
                           sorder     : GLint;
                           torder     : GLint;
                           c_type     : Map2TargetEnm);

procedure gluBeginTrim (nobj: GLUnurbsObjPtr);

procedure gluEndTrim (nobj: GLUnurbsObjPtr);

procedure gluPwlCurve (nobj   : GLUnurbsObjPtr;
                       count  : GLint;
                       c_array: GLfloatPtr;
                       stride : GLint;
                       c_type : PwlCurveTypeEnm);

procedure gluNurbsCallback (nobj : GLUnurbsObjPtr;
                            which: CallbackEnm;
                            fn   : NurbsCallbackFunction);


-- Polygon tesselation
type TessCallbackEnm is
(
   GLU_BEGIN,
   GLU_VERTEX,
   GLU_END,
   GLU_ERROR,
   GLU_EDGE_FLAG
);
for TessCallbackEnm use
(
   GLU_BEGIN                                  => 16#18704#,  -- Note: some implementations use "GLU_TESS_..."
   GLU_VERTEX                                 => 16#18705#,
   GLU_END                                    => 16#18706#,
   GLU_ERROR                                  => 16#18707#,
   GLU_EDGE_FLAG                              => 16#18708#
);
for TessCallbackEnm'Size use GLenum'size;

type TessBeginEnm is
(
   GL_LINE_LOOP,
   GL_TRIANGLES,
   GL_TRIANGLE_STRIP,
   GL_TRIANGLE_FAN
);
for TessBeginEnm use
(
   GL_LINE_LOOP                               => 16#0002#,
   GL_TRIANGLES                               => 16#0004#,
   GL_TRIANGLE_STRIP                          => 16#0005#,
   GL_TRIANGLE_FAN                            => 16#0006#
);
for TessBeginEnm'Size use GLenum'size;
type TessBeginCallbackFunction is access procedure (ObjType:  TessBeginEnm);

type TessVertexCallbackFunction is access procedure (VertexData:  GLpointer);

type TessEndCallbackFunction is access procedure;

type TessErrorEnm is
(
   GLU_TESS_ERROR1,                                        -- missing gluEndPolygon ,
   GLU_TESS_ERROR2,                                        -- missing gluBeginPolygon ,
   GLU_TESS_ERROR3,                                        -- misoriented contour ,
   GLU_TESS_ERROR4,                                        -- vertex/edge intersection ,
   GLU_TESS_ERROR5,                                        -- misoriented or self-intersecting loops ,
   GLU_TESS_ERROR6,                                        -- coincident vertices ,
   GLU_TESS_ERROR7,                                        -- all vertices collinear ,
   GLU_TESS_ERROR8,                                        -- intersecting edges ,
   GLU_TESS_ERROR9                                         -- not coplanar contours 
);
for TessErrorEnm use
(
   GLU_TESS_ERROR1                            => 16#18737#,
   GLU_TESS_ERROR2                            => 16#18738#,
   GLU_TESS_ERROR3                            => 16#18739#,
   GLU_TESS_ERROR4                            => 16#1873A#,
   GLU_TESS_ERROR5                            => 16#1873B#,
   GLU_TESS_ERROR6                            => 16#1873C#,
   GLU_TESS_ERROR7                            => 16#1873D#,
   GLU_TESS_ERROR8                            => 16#1873E#,
   GLU_TESS_ERROR9                            => 16#1873F#
);
for TessErrorEnm'Size use GLenum'size;
type TessErrorCallbackFunction is access procedure (Error:  TessErrorEnm);

type TessEdgeFlagCallbackFunction is access procedure (Flag:  GLboolean);

type ContourTypeEnm is
(
   GLU_CW,
   GLU_CCW,
   GLU_INTERIOR,
   GLU_EXTERIOR,
   GLU_UNKNOWN
);
for ContourTypeEnm use
(
   GLU_CW                                     => 16#18718#,
   GLU_CCW                                    => 16#18719#,
   GLU_INTERIOR                               => 16#1871A#,
   GLU_EXTERIOR                               => 16#1871B#,
   GLU_UNKNOWN                                => 16#1871C#
);
for ContourTypeEnm'Size use GLenum'size;

function gluNewTess
return GLUtriangulatorObjPtr;

procedure gluTessCallback (tobj : GLUtriangulatorObjPtr;
                           which: TessCallbackEnm;
                           fn   : TessBeginCallbackFunction);
procedure gluTessCallback (tobj : GLUtriangulatorObjPtr;
                           which: TessCallbackEnm;
                           fn   : TessVertexCallbackFunction);
procedure gluTessCallback (tobj : GLUtriangulatorObjPtr;
                           which: TessCallbackEnm;
                           fn   : TessEndCallbackFunction);
procedure gluTessCallback (tobj : GLUtriangulatorObjPtr;
                           which: TessCallbackEnm;
                           fn   : TessErrorCallbackFunction);
procedure gluTessCallback (tobj : GLUtriangulatorObjPtr;
                           which: TessCallbackEnm;
                           fn   : TessEdgeFlagCallbackFunction);

procedure gluDeleteTess (tobj: GLUtriangulatorObjPtr);

procedure gluBeginPolygon (tobj: GLUtriangulatorObjPtr);

procedure gluEndPolygon (tobj: GLUtriangulatorObjPtr);

procedure gluNextContour (tobj  : GLUtriangulatorObjPtr;
                          c_type: ContourTypeEnm);

procedure gluTessVertex (tobj: GLUtriangulatorObjPtr;
                         v   : GLdoublePtr;
                         data: GLpointer);


-- GLU strings
type StringEnm is
(
   GLU_VERSION,
   GLU_EXTENSIONS
);
for StringEnm use
(
   GLU_VERSION                                => 16#189C0#,
   GLU_EXTENSIONS                             => 16#189C1#
);
for StringEnm'Size use GLenum'size;

function gluGetString (name: StringEnm)
return GLubytePtr;


-- Projections
procedure gluLookAt (eyex   : GLdouble;
                     eyey   : GLdouble;
                     eyez   : GLdouble;
                     centerx: GLdouble;
                     centery: GLdouble;
                     centerz: GLdouble;
                     upx    : GLdouble;
                     upy    : GLdouble;
                     upz    : GLdouble);

procedure gluOrtho2D (left  : GLdouble;
                      right : GLdouble;
                      bottom: GLdouble;
                      top   : GLdouble);

procedure gluPerspective (fovy  : GLdouble;
                          aspect: GLdouble;
                          zNear : GLdouble;
                          zFar  : GLdouble);

procedure gluPickMatrix (x       : GLdouble;
                         y       : GLdouble;
                         width   : GLdouble;
                         height  : GLdouble;
                         viewport: GLviewPortRecPtr);

function gluProject (objx       : GLdouble;
                     objy       : GLdouble;
                     objz       : GLdouble;
                     modelMatrix: GLdoubleMatrixPtr;
                     projMatrix : GLdoubleMatrixPtr;
                     viewport   : GLviewPortRecPtr;
                     winx       : GLdoublePtr;
                     winy       : GLdoublePtr;
                     winz       : GLdoublePtr)
return GLint;

function gluUnProject (winx       : GLdouble;
                       winy       : GLdouble;
                       winz       : GLdouble;
                       modelMatrix: GLdoubleMatrixPtr;
                       projMatrix : GLdoubleMatrixPtr;
                       viewport   : GLviewPortRecPtr;
                       objx       : GLdoublePtr;
                       objy       : GLdoublePtr;
                       objz       : GLdoublePtr)
return GLint;

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

private

type GLUquadricObj      is record null; end record;
type GLUtriangulatorObj is record null; end record;
type GLUnurbsObj        is record null; end record;

pragma Import (C, gluLookAt, "gluLookAt");
pragma Import (C, gluOrtho2D, "gluOrtho2D");
pragma Import (C, gluPerspective, "gluPerspective");
pragma Import (C, gluPickMatrix, "gluPickMatrix");
pragma Import (C, gluProject, "gluProject");
pragma Import (C, gluUnProject, "gluUnProject");
pragma Import (C, gluErrorString, "gluErrorString");
pragma Import (C, gluScaleImage, "gluScaleImage");
pragma Import (C, gluBuild1DMipmaps, "gluBuild1DMipmaps");
pragma Import (C, gluBuild2DMipmaps, "gluBuild2DMipmaps");
pragma Import (C, gluNewQuadric, "gluNewQuadric");
pragma Import (C, gluDeleteQuadric, "gluDeleteQuadric");
pragma Import (C, gluQuadricDrawStyle, "gluQuadricDrawStyle");
pragma Import (C, gluQuadricOrientation, "gluQuadricOrientation");
pragma Import (C, gluQuadricNormals, "gluQuadricNormals");
pragma Import (C, gluQuadricTexture, "gluQuadricTexture");
pragma Import (C, gluQuadricCallback, "gluQuadricCallback");
pragma Import (C, gluCylinder, "gluCylinder");
pragma Import (C, gluSphere, "gluSphere");
pragma Import (C, gluDisk, "gluDisk");
pragma Import (C, gluPartialDisk, "gluPartialDisk");
pragma Import (C, gluNewNurbsRenderer, "gluNewNurbsRenderer");
pragma Import (C, gluDeleteNurbsRenderer, "gluDeleteNurbsRenderer");
pragma Import (C, gluLoadSamplingMatrices, "gluLoadSamplingMatrices");
pragma Import (C, gluNurbsProperty, "gluNurbsProperty");
pragma Import (C, gluGetNurbsProperty, "gluGetNurbsProperty");
pragma Import (C, gluBeginCurve, "gluBeginCurve");
pragma Import (C, gluEndCurve, "gluEndCurve");
pragma Import (C, gluNurbsCurve, "gluNurbsCurve");
pragma Import (C, gluBeginSurface, "gluBeginSurface");
pragma Import (C, gluEndSurface, "gluEndSurface");
pragma Import (C, gluNurbsSurface, "gluNurbsSurface");
pragma Import (C, gluBeginTrim, "gluBeginTrim");
pragma Import (C, gluEndTrim, "gluEndTrim");
pragma Import (C, gluPwlCurve, "gluPwlCurve");
pragma Import (C, gluNurbsCallback, "gluNurbsCallback");
pragma Import (C, gluNewTess, "gluNewTess");
pragma Import (C, gluTessCallback, "gluTessCallback");
pragma Import (C, gluDeleteTess, "gluDeleteTess");
pragma Import (C, gluBeginPolygon, "gluBeginPolygon");
pragma Import (C, gluEndPolygon, "gluEndPolygon");
pragma Import (C, gluNextContour, "gluNextContour");
pragma Import (C, gluTessVertex, "gluTessVertex");
pragma Import (C, gluGetString, "gluGetString");

end GLU;