package GLU is

type viewPortRec is record
     X, Y:           aliased GL.int;
     Width, Height:  aliased GL.int;
  end record;

type floatMatrix      is array ( 0..3, 0..3 ) of aliased GL.float;

type doubleMatrix     is array ( 0..3, 0..3 ) of aliased GL.double;

type viewPortRecPtr   is access all viewPortRec;

type floatMatrixPtr   is access all floatMatrix;

type doubleMatrixPtr  is access all doubleMatrix;

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;

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
  );

type DrawStyleEnm is
  (
     GLU_POINT,
     GLU_LINE,
     GLU_FILL,
     GLU_SILHOUETTE
  );

type OrientationEnm is
  (
     GLU_OUTSIDE,
     GLU_INSIDE
  );

type NormalsEnm is
  (
     GLU_SMOOTH,
     GLU_FLAT,
     GLU_NONE
  );

type CallbackEnm is
  (
     GLU_ERROR
  );

type QuadricCallbackFunction is access procedure (Error:  ErrorEnm);

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
  );

type NurbsDisplayModeEnm is
  (
     GLU_FILL,
     GLU_OUTLINE_POLYGON,
     GLU_OUTLINE_PATCH
  );

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
  );

type PwlCurveTypeEnm is
  (
     GLU_MAP1_TRIM_2,
     GLU_MAP1_TRIM_3
  );

type NurbsCallbackFunction is access procedure (Error:  NurbsErrorEnm);

type TessCallbackEnm is
  (
     GLU_BEGIN,
     GLU_VERTEX,
     GLU_END,
     GLU_ERROR,
     GLU_EDGE_FLAG
  );

type TessBeginEnm is
  (
     GL_LINE_LOOP,
     GL_TRIANGLES,
     GL_TRIANGLE_STRIP,
     GL_TRIANGLE_FAN
  );

type TessBeginCallbackFunction is access procedure (ObjType:  TessBeginEnm);

type TessVertexCallbackFunction is access procedure (VertexData:  GL.pointer);

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
  );

type TessErrorCallbackFunction is access procedure (Error:  TessErrorEnm);

type TessEdgeFlagCallbackFunction is access procedure (Flag:  GL.GL_boolean);

type ContourTypeEnm is
  (
     GLU_CW,
     GLU_CCW,
     GLU_INTERIOR,
     GLU_EXTERIOR,
     GLU_UNKNOWN
  );

type StringEnm is
  (
     GLU_VERSION,
     GLU_EXTENSIONS
  );

VERSION_1_1                     : constant := 1;

GL_FALSE                           : constant := GL.GL_FALSE;

GL_TRUE                            : constant := GL.GL_TRUE;

GLU_PATH_LENGTH                     : constant := 16#18777#;

GLU_PARAMETRIC_ERROR                : constant := 16#18778#;

GLU_DOMAIN_DISTANCE                 : constant := 16#18779#;

function ErrorString 
(
errorCode
: ErrorEnm)
return GL.ubytePtr;

function ErrorString 
(
errorCode
: gl.ErrorEnm)
return GL.ubytePtr;

function ScaleImage 
(
format
: GL.PixelFormatEnm;
widthin
: GL.int;
heightin
: GL.int;
typein
: GL.PixelDataTypeEnm;
datain
: GL.pointer;
widthout
: GL.int;
heightout
: GL.int;
typeout
: GL.PixelDataTypeEnm;
dataout
: GL.pointer)
return GL.int;

function Build1DMipmaps 
(
target
: GL.TargetTex1DOnlyEnm;
components
: GL.int;
width
: GL.int;
format
: GL.TexPixelFormatEnm;
c_type
: GL.PixelDataTypeEnm;
data
: GL.pointer)
return GL.int;

function Build2DMipmaps 
(
target
: GL.TargetTex2DOnlyEnm;
components
: GL.int;
width
: GL.int;
height
: GL.int;
format
: GL.TexPixelFormatEnm;
c_type
: GL.PixelDataTypeEnm;
data
: GL.pointer)
return GL.int;

function NewQuadric  return GLUquadricObjPtr;

procedure DeleteQuadric 
(
state
: GLUquadricObjPtr);

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

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

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

procedure QuadricTexture 
(
quadObject
: GLUquadricObjPtr;
textureCoords
: GL.GL_boolean);

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

procedure Cylinder 
(
qobj
: GLUquadricObjPtr;
baseRadius
: GL.double;
topRadius
: GL.double;
height
: GL.double;
slices
: GL.int;
stacks
: GL.int);

procedure Sphere 
(
qobj
: GLUquadricObjPtr;
radius
: GL.double;
slices
: GL.int;
stacks
: GL.int);

procedure Disk 
(
qobj
: GLUquadricObjPtr;
innerRadius
: GL.double;
outerRadius
: GL.double;
slices
: GL.int;
loops
: GL.int);

procedure PartialDisk 
(
qobj
: GLUquadricObjPtr;
innerRadius
: GL.double;
outerRadius
: GL.double;
slices
: GL.int;
loops
: GL.int;
startAngle
: GL.double;
sweepAngle
: GL.double);

function NewNurbsRenderer  return GLUnurbsObjPtr;

procedure DeleteNurbsRenderer 
(
nobj
: GLUnurbsObjPtr);

procedure LoadSamplingMatrices 
(
nobj
: GLUnurbsObjPtr;
modelMatrix
: floatMatrixPtr;
projMatrix
: floatMatrixPtr;
viewport
: viewPortRecPtr);

procedure NurbsProperty 
(
nobj
: GLUnurbsObjPtr;
property
: NurbsPropertyEnm;
value
: GL.float);

procedure GetNurbsProperty 
(
nobj
: GLUnurbsObjPtr;
property
: NurbsPropertyEnm;
value
: GL.floatPtr);

procedure BeginCurve 
(
nobj
: GLUnurbsObjPtr);

procedure EndCurve 
(
nobj
: GLUnurbsObjPtr);

procedure NurbsCurve 
(
nobj
: GLUnurbsObjPtr;
nknots
: GL.int;
knot
: GL.floatPtr;
stride
: GL.int;
ctlarray
: GL.floatPtr;
order
: GL.int;
c_type
: GL.Map1TargetEnm);

procedure BeginSurface 
(
nobj
: GLUnurbsObjPtr);

procedure EndSurface 
(
nobj
: GLUnurbsObjPtr);

procedure NurbsSurface 
(
nobj
: GLUnurbsObjPtr;
sknot_count
: GL.int;
sknot
: GL.floatPtr;
tknot_count
: GL.int;
tknot
: GL.floatPtr;
s_stride
: GL.int;
t_stride
: GL.int;
ctlarray
: GL.floatPtr;
sorder
: GL.int;
torder
: GL.int;
c_type
: GL.Map2TargetEnm);

procedure BeginTrim 
(
nobj
: GLUnurbsObjPtr);

procedure EndTrim 
(
nobj
: GLUnurbsObjPtr);

procedure PwlCurve 
(
nobj
: GLUnurbsObjPtr;
count
: GL.int;
c_array
: GL.floatPtr;
stride
: GL.int;
c_type
: PwlCurveTypeEnm);

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

function NewTess  return GLUtriangulatorObjPtr;

procedure TessCallback 
(
tobj
: GLUtriangulatorObjPtr;
which
: TessCallbackEnm;
fn
: TessBeginCallbackFunction);

procedure TessCallback 
(
tobj
: GLUtriangulatorObjPtr;
which
: TessCallbackEnm;
fn
: TessVertexCallbackFunction);

procedure TessCallback 
(
tobj
: GLUtriangulatorObjPtr;
which
: TessCallbackEnm;
fn
: TessEndCallbackFunction);

procedure TessCallback 
(
tobj
: GLUtriangulatorObjPtr;
which
: TessCallbackEnm;
fn
: TessErrorCallbackFunction);

procedure TessCallback 
(
tobj
: GLUtriangulatorObjPtr;
which
: TessCallbackEnm;
fn
: TessEdgeFlagCallbackFunction);

procedure DeleteTess 
(
tobj
: GLUtriangulatorObjPtr);

procedure BeginPolygon 
(
tobj
: GLUtriangulatorObjPtr);

procedure EndPolygon 
(
tobj
: GLUtriangulatorObjPtr);

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

procedure TessVertex 
(
tobj
: GLUtriangulatorObjPtr;
v
: GL.doublePtr;
data
: GL.pointer);

function GetString 
(
name
: StringEnm)
return GL.ubytePtr;

procedure LookAt 
(
eyex
: GL.double;
eyey
: GL.double;
eyez
: GL.double;
centerx
: GL.double;
centery
: GL.double;
centerz
: GL.double;
upx
: GL.double;
upy
: GL.double;
upz
: GL.double);

procedure Ortho2D 
(
left
: GL.double;
right
: GL.double;
bottom
: GL.double;
top
: GL.double);

procedure Perspective 
(
fovy
: GL.double;
aspect
: GL.double;
zNear
: GL.double;
zFar
: GL.double);

procedure PickMatrix 
(
x
: GL.double;
y
: GL.double;
width
: GL.double;
height
: GL.double;
viewport
: viewPortRecPtr);

function Project 
(
objx
: GL.double;
objy
: GL.double;
objz
: GL.double;
modelMatrix
: doubleMatrixPtr;
projMatrix
: doubleMatrixPtr;
viewport
: viewPortRecPtr;
winx
: GL.doublePtr;
winy
: GL.doublePtr;
winz
: GL.doublePtr)
return GL.int;

procedure Project 
(
objx
: GL.double;
objy
: GL.double;
objz
: GL.double;
modelMatrix
: doubleMatrix;
projMatrix
: doubleMatrix;
viewport
: viewPortRec;
winx
: out GL.double;
winy
: out GL.double;
winz
: out GL.double;
result
: out Boolean );

function UnProject 
(
winx
: GL.double;
winy
: GL.double;
winz
: GL.double;
modelMatrix
: doubleMatrixPtr;
projMatrix
: doubleMatrixPtr;
viewport
: viewPortRecPtr;
objx
: GL.doublePtr;
objy
: GL.doublePtr;
objz
: GL.doublePtr)
return GL.int;

procedure Get 
(
pname
: GL.ParameterNameEnm;
params
: doubleMatrixPtr);

procedure Get 
(
pname
: GL.ParameterNameEnm;
params
: out doubleMatrix);

procedure Get 
(
pname
: GL.ParameterNameEnm;
params
: viewPortRecPtr);

procedure Get 
(
params
: out viewPortRec);

function ErrorString_1 
(
errorCode
: ErrorEnm)
return GL.ubytePtr;

function ErrorString_2 
(
errorCode
: gl.ErrorEnm)
return GL.ubytePtr;

procedure GetDoublev 
(
pname
: GL.ParameterNameEnm;
params
: doubleMatrixPtr);

procedure GetIntegerv 
(
pname
: GL.ParameterNameEnm;
params
: viewPortRecPtr);