# glu

## A part of the standard OpenGL Utility api.

A part of the standard OpenGL Utility api.
See

Booleans are represented by integers 0 and 1.

#### Types

### enum() = integer() >= 0

### matrix() =

{float(),

float(),

float(),

float(),

float(),

float(),

float(),

float(),

float(),

float(),

float(),

float(),

float(),

float(),

float(),

float()}

### mem() = binary() | tuple()

### vertex() = {float(), float(), float()}

#### Functions

### tesselate(Normal, Vs::[Vs]) -> {Triangles, VertexPos}

`Normal = vertex()`

`Vs = vertex()`

`Triangles = [integer()]`

`VertexPos = binary()`

General purpose polygon triangulation. The first argument is the normal and the second a list of vertex positions. Returned is a list of indecies of the vertices and a binary (64bit native float) containing an array of vertex positions, it starts with the vertices in Vs and may contain newly created vertices in the end.

### build1DMipmapLevels(Target, InternalFormat, Width, Format, Type, Level, Base, Max, Data) -> integer()

`Target = enum()`

`InternalFormat = integer()`

`Width = integer()`

`Format = enum()`

`Type = enum()`

`Level = integer()`

`Base = integer()`

`Max = integer()`

`Data = binary()`

Builds a subset of one-dimensional mipmap levels

`glu:build1DMipmapLevels`

builds a subset of prefiltered one-dimensional texture maps
of decreasing resolutions called a mipmap. This is used for the antialiasing of texture
mapped primitives.

A return value of zero indicates success, otherwise a GLU error code is returned (see glu:errorString/1 ).

A series of mipmap levels from `Base`

to `Max`

is built by decimating `Data`

in half until size 1*1 is reached. At each level, each texel in the halved mipmap
level is an average of the corresponding two texels in the larger mipmap level. gl:texImage1D/8
is called to load these mipmap levels from `Base`

to `Max`

. If `Max`

is
larger than the highest mipmap level for the texture of the specified size, then a GLU
error code is returned (see glu:errorString/1 ) and nothing is loaded.

For example, if `Level`

is 2 and `Width`

is 16, the following levels are possible:
16*1, 8*1, 4*1, 2*1, 1*1. These correspond to levels 2 through 6 respectively.
If `Base`

is 3 and `Max`

is 5, then only mipmap levels 8*1, 4*1 and 2*1
are loaded. However, if `Max`

is 7, then an error is returned and nothing is loaded
since `Max`

is larger than the highest mipmap level which is, in this case, 6.

The highest mipmap level can be derived from the formula log 2(width*2 level).

See the gl:texImage1D/8 reference page for a description of the acceptable values
for `Type`

parameter. See the gl:drawPixels/5 reference page for a description
of the acceptable values for `Level`

parameter.

See

### build1DMipmaps(Target, InternalFormat, Width, Format, Type, Data) -> integer()

`Target = enum()`

`InternalFormat = integer()`

`Width = integer()`

`Format = enum()`

`Type = enum()`

`Data = binary()`

Builds a one-dimensional mipmap

`glu:build1DMipmaps`

builds a series of prefiltered one-dimensional texture maps of
decreasing resolutions called a mipmap. This is used for the antialiasing of texture mapped
primitives.

A return value of zero indicates success, otherwise a GLU error code is returned (see glu:errorString/1 ).

Initially, the `Width`

of `Data`

is checked to see if it is a power of 2. If
not, a copy of `Data`

is scaled up or down to the nearest power of 2. (If `Width`

is exactly between powers of 2, then the copy of `Data`

will scale upwards.) This
copy will be used for subsequent mipmapping operations described below. For example, if `Width`

is 57, then a copy of `Data`

will scale up to 64 before mipmapping takes place.

Then, proxy textures (see gl:texImage1D/8 ) are used to determine if the implementation
can fit the requested texture. If not, `Width`

is continually halved until it fits.

Next, a series of mipmap levels is built by decimating a copy of `Data`

in half
until size 1*1 is reached. At each level, each texel in the halved mipmap level is an
average of the corresponding two texels in the larger mipmap level.

gl:texImage1D/8 is called to load each of these mipmap levels. Level 0 is a copy
of `Data`

. The highest level is (log 2)(width). For example, if `Width`

is 64 and the implementation
can store a texture of this size, the following mipmap levels are built: 64*1, 32*1,
16*1, 8*1, 4*1, 2*1, and 1*1. These correspond to levels 0 through 6, respectively.

See the gl:texImage1D/8 reference page for a description of the acceptable values
for the `Type`

parameter. See the gl:drawPixels/5 reference page for a description
of the acceptable values for the `Data`

parameter.

See

### build2DMipmapLevels(Target, InternalFormat, Width, Height, Format, Type, Level, Base, Max, Data) -> integer()

`Target = enum()`

`InternalFormat = integer()`

`Width = integer()`

`Height = integer()`

`Format = enum()`

`Type = enum()`

`Level = integer()`

`Base = integer()`

`Max = integer()`

`Data = binary()`

Builds a subset of two-dimensional mipmap levels

`glu:build2DMipmapLevels`

builds a subset of prefiltered two-dimensional texture maps
of decreasing resolutions called a mipmap. This is used for the antialiasing of texture
mapped primitives.

A return value of zero indicates success, otherwise a GLU error code is returned (see glu:errorString/1 ).

A series of mipmap levels from `Base`

to `Max`

is built by decimating `Data`

in half along both dimensions until size 1*1 is reached. At each level, each texel
in the halved mipmap level is an average of the corresponding four texels in the larger
mipmap level. (In the case of rectangular images, the decimation will ultimately reach
an N*1 or 1*N configuration. Here, two texels are averaged instead.) gl:texImage2D/9
is called to load these mipmap levels from `Base`

to `Max`

. If `Max`

is
larger than the highest mipmap level for the texture of the specified size, then a GLU
error code is returned (see glu:errorString/1 ) and nothing is loaded.

For example, if `Level`

is 2 and `Width`

is 16 and `Height`

is 8, the
following levels are possible: 16*8, 8*4, 4*2, 2*1, 1*1. These correspond to
levels 2 through 6 respectively. If `Base`

is 3 and `Max`

is 5, then only mipmap
levels 8*4, 4*2, and 2*1 are loaded. However, if `Max`

is 7, then an error is
returned and nothing is loaded since `Max`

is larger than the highest mipmap level
which is, in this case, 6.

The highest mipmap level can be derived from the formula log 2(max(width height)*2 level).

See the gl:texImage1D/8 reference page for a description of the acceptable values
for `Format`

parameter. See the gl:drawPixels/5 reference page for a description
of the acceptable values for `Type`

parameter.

See

### build2DMipmaps(Target, InternalFormat, Width, Height, Format, Type, Data) -> integer()

`Target = enum()`

`InternalFormat = integer()`

`Width = integer()`

`Height = integer()`

`Format = enum()`

`Type = enum()`

`Data = binary()`

Builds a two-dimensional mipmap

`glu:build2DMipmaps`

builds a series of prefiltered two-dimensional texture maps of
decreasing resolutions called a mipmap. This is used for the antialiasing of texture-mapped
primitives.

Initially, the `Width`

and `Height`

of `Data`

are checked to see if they
are a power of 2. If not, a copy of `Data`

(not `Data`

), is scaled up or down
to the nearest power of 2. This copy will be used for subsequent mipmapping operations
described below. (If `Width`

or `Height`

is exactly between powers of 2, then
the copy of `Data`

will scale upwards.) For example, if `Width`

is 57 and `Height`

is 23, then a copy of `Data`

will scale up to 64 in `Width`

and down to 16
in depth, before mipmapping takes place.

Then, proxy textures (see gl:texImage2D/9 ) are used to determine if the implementation
can fit the requested texture. If not, both dimensions are continually halved until it
fits. (If the OpenGL version is (<= 1.0, both maximum texture dimensions are clamped
to the value returned by gl:getBooleanv/1 with the argument `?GLU_MAX_TEXTURE_SIZE`

.)

Next, a series of mipmap levels is built by decimating a copy of `Data`

in half
along both dimensions until size 1*1 is reached. At each level, each texel in the halved
mipmap level is an average of the corresponding four texels in the larger mipmap level.
(In the case of rectangular images, the decimation will ultimately reach an N*1 or 1*N
configuration. Here, two texels are averaged instead.)

gl:texImage2D/9 is called to load each of these mipmap levels. Level 0 is a copy
of `Data`

. The highest level is (log 2)(max(width height)). For example, if `Width`

is 64 and `Height`

is 16 and the implementation can store a texture of this size, the following mipmap levels
are built: 64*16, 32*8, 16*4, 8*2, 4*1, 2*1, and 1*1 These correspond to
levels 0 through 6, respectively.

See the gl:texImage1D/8 reference page for a description of the acceptable values
for `Format`

parameter. See the gl:drawPixels/5 reference page for a description
of the acceptable values for `Type`

parameter.

See

### build3DMipmapLevels(Target, InternalFormat, Width, Height, Depth, Format, Type, Level, Base, Max, Data) -> integer()

`Target = enum()`

`InternalFormat = integer()`

`Width = integer()`

`Height = integer()`

`Depth = integer()`

`Format = enum()`

`Type = enum()`

`Level = integer()`

`Base = integer()`

`Max = integer()`

`Data = binary()`

Builds a subset of three-dimensional mipmap levels

`glu:build3DMipmapLevels`

builds a subset of prefiltered three-dimensional texture
maps of decreasing resolutions called a mipmap. This is used for the antialiasing of texture
mapped primitives.

A series of mipmap levels from `Base`

to `Max`

is built by decimating `Data`

in half along both dimensions until size 1*1*1 is reached. At each level, each texel
in the halved mipmap level is an average of the corresponding eight texels in the larger
mipmap level. (If exactly one of the dimensions is 1, four texels are averaged. If exactly
two of the dimensions are 1, two texels are averaged.) gl:texImage3D/10 is called
to load these mipmap levels from `Base`

to `Max`

. If `Max`

is larger than
the highest mipmap level for the texture of the specified size, then a GLU error code
is returned (see glu:errorString/1 ) and nothing is loaded.

For example, if `Level`

is 2 and `Width`

is 16, `Height`

is 8 and `Depth`

is 4, the following levels are possible: 16*8*4, 8*4*2, 4*2*1, 2*1*1, 1*1*1.
These correspond to levels 2 through 6 respectively. If `Base`

is 3 and `Max`

is 5, then only mipmap levels 8*4*2, 4*2*1, and 2*1*1 are loaded. However, if `Max`

is 7, then an error is returned and nothing is loaded, since `Max`

is larger than
the highest mipmap level which is, in this case, 6.

The highest mipmap level can be derived from the formula log 2(max(width height depth)*2 level).

See the gl:texImage1D/8 reference page for a description of the acceptable values
for `Format`

parameter. See the gl:drawPixels/5 reference page for a description
of the acceptable values for `Type`

parameter.

See

### build3DMipmaps(Target, InternalFormat, Width, Height, Depth, Format, Type, Data) -> integer()

`Target = enum()`

`InternalFormat = integer()`

`Width = integer()`

`Height = integer()`

`Depth = integer()`

`Format = enum()`

`Type = enum()`

`Data = binary()`

Builds a three-dimensional mipmap

`glu:build3DMipmaps`

builds a series of prefiltered three-dimensional texture maps
of decreasing resolutions called a mipmap. This is used for the antialiasing of texture-mapped
primitives.

Initially, the `Width`

, `Height`

and `Depth`

of `Data`

are checked
to see if they are a power of 2. If not, a copy of `Data`

is made and scaled up or
down to the nearest power of 2. (If `Width`

, `Height`

, or `Depth`

is exactly
between powers of 2, then the copy of `Data`

will scale upwards.) This copy will
be used for subsequent mipmapping operations described below. For example, if `Width`

is 57, `Height`

is 23, and `Depth`

is 24, then a copy of `Data`

will scale
up to 64 in width, down to 16 in height, and up to 32 in depth before mipmapping takes
place.

Then, proxy textures (see gl:texImage3D/10 ) are used to determine if the implementation can fit the requested texture. If not, all three dimensions are continually halved until it fits.

Next, a series of mipmap levels is built by decimating a copy of `Data`

in half
along all three dimensions until size 1*1*1 is reached. At each level, each texel in
the halved mipmap level is an average of the corresponding eight texels in the larger
mipmap level. (If exactly one of the dimensions is 1, four texels are averaged. If exactly
two of the dimensions are 1, two texels are averaged.)

gl:texImage3D/10 is called to load each of these mipmap levels. Level 0 is a copy
of `Data`

. The highest level is (log 2)(max(width height depth)). For example, if `Width`

is 64, `Height`

is 16, and `Depth`

is 32, and the implementation can store a texture of this size,
the following mipmap levels are built: 64*16*32, 32*8*16, 16*4*8, 8*2*4, 4*1*2,
2*1*1, and 1*1*1. These correspond to levels 0 through 6, respectively.

`Format`

parameter. See the gl:drawPixels/5 reference page for a description
of the acceptable values for `Type`

parameter.

See

### checkExtension(ExtName, ExtString) -> 0 | 1

`ExtName = string()`

`ExtString = string()`

Determines if an extension name is supported

`glu:checkExtension`

returns `?GLU_TRUE`

if `ExtName`

is supported otherwise
`?GLU_FALSE`

is returned.

This is used to check for the presence for OpenGL, GLU, or GLX extension names by passing
the extension strings returned by gl:getString/1 , glu:getString/1 , see `glXGetClientString`

, see `glXQueryExtensionsString`

, or see `glXQueryServerString`

, respectively,
as `ExtString`

.

See

### cylinder(Quad, Base, Top, Height, Slices, Stacks) -> ok

`Quad = integer()`

`Base = float()`

`Top = float()`

`Height = float()`

`Slices = integer()`

`Stacks = integer()`

Draw a cylinder

`glu:cylinder`

draws a cylinder oriented along the `z`

axis. The base of the
cylinder is placed at `z`

= 0 and the top at z= height. Like a sphere, a cylinder
is subdivided around the `z`

axis into slices and along the `z`

axis into stacks.

Note that if `Top`

is set to 0.0, this routine generates a cone.

If the orientation is set to `?GLU_OUTSIDE`

(with glu:quadricOrientation/2 ),
then any generated normals point away from the `z`

axis. Otherwise, they point toward
the `z`

axis.

If texturing is turned on (with glu:quadricTexture/2 ), then texture coordinates
are generated so that `t`

ranges linearly from 0.0 at `z`

= 0 to 1.0 at `z`

= `Height`

, and `s`

ranges from 0.0 at the +`y`

axis, to 0.25 at the +`x`

axis, to 0.5 at the -`y`

axis, to 0.75 at the -`x`

axis, and back to 1.0
at the +`y`

axis.

See

### deleteQuadric(Quad) -> ok

`Quad = integer()`

Destroy a quadrics object

`glu:deleteQuadric`

destroys the quadrics object (created with glu:newQuadric/0 )
and frees any memory it uses. Once `glu:deleteQuadric`

has been called, `Quad`

cannot be used again.

See

### disk(Quad, Inner, Outer, Slices, Loops) -> ok

`Quad = integer()`

`Inner = float()`

`Outer = float()`

`Slices = integer()`

`Loops = integer()`

Draw a disk

`glu:disk`

renders a disk on the `z`

= 0 plane. The disk has a radius of `Outer`

and contains a concentric circular hole with a radius of `Inner`

. If `Inner`

is 0, then no hole is generated. The disk is subdivided around the `z`

axis into
slices (like pizza slices) and also about the `z`

axis into rings (as specified by `Slices`

and `Loops`

, respectively).

With respect to orientation, the +`z`

side of the disk is considered to be `outside`

(see glu:quadricOrientation/2 ). This means that if the orientation is set to `?GLU_OUTSIDE`

, then any normals generated point along the +`z`

axis. Otherwise, they point along
the -`z`

axis.

If texturing has been turned on (with glu:quadricTexture/2 ), texture coordinates
are generated linearly such that where r= outer, the value at (`r`

, 0, 0) is (1,
0.5), at (0, `r`

, 0) it is (0.5, 1), at (-`r`

, 0, 0) it is (0, 0.5), and at
(0, -`r`

, 0) it is (0.5, 0).

See

### errorString(Error) -> string()

`Error = enum()`

Produce an error string from a GL or GLU error code

`glu:errorString`

produces an error string from a GL or GLU error code. The string
is in ISO Latin 1 format. For example, `glu:errorString`

(`?GLU_OUT_OF_MEMORY`

)
returns the string `out of memory`

.

The standard GLU error codes are `?GLU_INVALID_ENUM`

, `?GLU_INVALID_VALUE`

,
and `?GLU_OUT_OF_MEMORY`

. Certain other GLU functions can return specialized error
codes through callbacks. See the gl:getError/0 reference page for the list of
GL error codes.

See

### getString(Name) -> string()

`Name = enum()`

Return a string describing the GLU version or GLU extensions

`glu:getString`

returns a pointer to a static string describing the GLU version or
the GLU extensions that are supported.

The version number is one of the following forms:

`major_number.minor_number`

`major_number.minor_number.release_number`

.

The version string is of the following form:

`version number<space>vendor-specific information`

Vendor-specific information is optional. Its format and contents depend on the implementation.

The standard GLU contains a basic set of features and capabilities. If a company or group
of companies wish to support other features, these may be included as extensions to the
GLU. If `Name`

is `?GLU_EXTENSIONS`

, then `glu:getString`

returns a space-separated
list of names of supported GLU extensions. (Extension names never contain spaces.)

All strings are null-terminated.

See

### lookAt(EyeX, EyeY, EyeZ, CenterX, CenterY, CenterZ, UpX, UpY, UpZ) -> ok

`EyeX = float()`

`EyeY = float()`

`EyeZ = float()`

`CenterX = float()`

`CenterY = float()`

`CenterZ = float()`

`UpX = float()`

`UpY = float()`

`UpZ = float()`

Define a viewing transformation

`glu:lookAt`

creates a viewing matrix derived from an eye point, a reference point
indicating the center of the scene, and an `UP`

vector.

The matrix maps the reference point to the negative `z`

axis and the eye point to
the origin. When a typical projection matrix is used, the center of the scene therefore
maps to the center of the viewport. Similarly, the direction described by the `UP`

vector projected onto the viewing plane is mapped to the positive `y`

axis so that
it points upward in the viewport. The `UP`

vector must not be parallel to the line
of sight from the eye point to the reference point.

Let

F=(centerX-eyeX centerY-eyeY centerZ-eyeZ)

Let `UP`

be the vector (upX upY upZ).

Then normalize as follows: f= F/(||F||)

UP"= UP/(||UP||)

Finally, let s= f*UP", and u= s*f.

M is then constructed as follows: M=(s[0] s[1] s[2] 0 u[0] u[1] u[2] 0-f[0]-f[1]-f[2] 0 0 0 0 1)

and `glu:lookAt`

is equivalent to glMultMatrixf(M); glTranslated(-eyex, -eyey,
-eyez);

See

### newQuadric() -> integer()

Create a quadrics object

`glu:newQuadric`

creates and returns a pointer to a new quadrics object. This object
must be referred to when calling quadrics rendering and control functions. A return value
of 0 means that there is not enough memory to allocate the object.

See

### ortho2D(Left, Right, Bottom, Top) -> ok

`Left = float()`

`Right = float()`

`Bottom = float()`

`Top = float()`

Define a 2D orthographic projection matrix

`glu:ortho2D`

sets up a two-dimensional orthographic viewing region. This is equivalent
to calling gl:ortho/6 with near= -1 and far= 1.

See

### partialDisk(Quad, Inner, Outer, Slices, Loops, Start, Sweep) -> ok

`Quad = integer()`

`Inner = float()`

`Outer = float()`

`Slices = integer()`

`Loops = integer()`

`Start = float()`

`Sweep = float()`

Draw an arc of a disk

`glu:partialDisk`

renders a partial disk on the z= 0 plane. A partial disk is similar
to a full disk, except that only the subset of the disk from `Start`

through `Start`

+ `Sweep`

is included (where 0 degrees is along the +f2yf axis, 90 degrees along
the +`x`

axis, 180 degrees along the -`y`

axis, and 270 degrees along the -`x`

axis).

The partial disk has a radius of `Outer`

and contains a concentric circular hole
with a radius of `Inner`

. If `Inner`

is 0, then no hole is generated. The partial
disk is subdivided around the `z`

axis into slices (like pizza slices) and also about
the `z`

axis into rings (as specified by `Slices`

and `Loops`

, respectively).

With respect to orientation, the +`z`

side of the partial disk is considered to
be outside (see glu:quadricOrientation/2 ). This means that if the orientation
is set to `?GLU_OUTSIDE`

, then any normals generated point along the +`z`

axis.
Otherwise, they point along the -`z`

axis.

If texturing is turned on (with glu:quadricTexture/2 ), texture coordinates are
generated linearly such that where r= outer, the value at (`r`

, 0, 0) is (1.0,
0.5), at (0, `r`

, 0) it is (0.5, 1.0), at (-`r`

, 0, 0) it is (0.0, 0.5), and
at (0, -`r`

, 0) it is (0.5, 0.0).

See

### perspective(Fovy, Aspect, ZNear, ZFar) -> ok

`Fovy = float()`

`Aspect = float()`

`ZNear = float()`

`ZFar = float()`

Set up a perspective projection matrix

`glu:perspective`

specifies a viewing frustum into the world coordinate system. In
general, the aspect ratio in `glu:perspective`

should match the aspect ratio of the
associated viewport. For example, aspect= 2.0 means the viewer's angle of view is twice
as wide in `x`

as it is in `y`

. If the viewport is twice as wide as it is tall,
it displays the image without distortion.

The matrix generated by `glu:perspective`

is multipled by the current matrix, just
as if gl:multMatrixd/1 were called with the generated matrix. To load the perspective
matrix onto the current matrix stack instead, precede the call to `glu:perspective`

with a call to gl:loadIdentity/0 .

Given `f`

defined as follows:

f= cotangent(fovy/2) The generated matrix is

(f/aspect 0 0 0 0 f 0 0 0 0(zFar+zNear)/(zNear-zFar)(2*zFar*zNear)/(zNear-zFar) 0 0 -1 0)

See

### pickMatrix(X, Y, DelX, DelY, Viewport) -> ok

`X = float()`

`Y = float()`

`DelX = float()`

`DelY = float()`

`Viewport = {integer(), integer(), integer(), integer()}`

Define a picking region

`glu:pickMatrix`

creates a projection matrix that can be used to restrict drawing
to a small region of the viewport. This is typically useful to determine what objects
are being drawn near the cursor. Use `glu:pickMatrix`

to restrict drawing to a small
region around the cursor. Then, enter selection mode (with gl:renderMode/1 ) and
rerender the scene. All primitives that would have been drawn near the cursor are identified
and stored in the selection buffer.

The matrix created by `glu:pickMatrix`

is multiplied by the current matrix just as
if gl:multMatrixd/1 is called with the generated matrix. To effectively use the
generated pick matrix for picking, first call gl:loadIdentity/0 to load an identity
matrix onto the perspective matrix stack. Then call `glu:pickMatrix`

, and, finally,
call a command (such as glu:perspective/4 ) to multiply the perspective matrix by
the pick matrix.

When using `glu:pickMatrix`

to pick NURBS, be careful to turn off the NURBS property
`?GLU_AUTO_LOAD_MATRIX`

. If `?GLU_AUTO_LOAD_MATRIX`

is not turned off, then
any NURBS surface rendered is subdivided differently with the pick matrix than the way
it was subdivided without the pick matrix.

See

### project(ObjX, ObjY, ObjZ, Model, Proj, View) -> {integer(), WinX::float(), WinY::float(), WinZ::float()}

`ObjX = float()`

`ObjY = float()`

`ObjZ = float()`

`Model = matrix()`

`Proj = matrix()`

`View = {integer(), integer(), integer(), integer()}`

Map object coordinates to window coordinates

`glu:project`

transforms the specified object coordinates into window coordinates
using `Model`

, `Proj`

, and `View`

. The result is stored in `WinX`

, `WinY`

, and `WinZ`

. A return value of `?GLU_TRUE`

indicates success, a return value
of `?GLU_FALSE`

indicates failure.

To compute the coordinates, let v=(objX objY objZ 1.0) represented as a matrix with 4 rows and 1 column.
Then `glu:project`

computes v" as follows:

v"= P*M*v

where P is the current projection matrix `Proj`

and M is the current modelview
matrix `Model`

(both represented as 4*4 matrices in column-major order).

The window coordinates are then computed as follows:

winX= view(0)+view(2)*(v"(0)+1)/2

winY= view(1)+view(3)*(v"(1)+1)/2

winZ=(v"(2)+1)/2

See

### quadricDrawStyle(Quad, Draw) -> ok

`Quad = integer()`

`Draw = enum()`

Specify the draw style desired for quadrics

`glu:quadricDrawStyle`

specifies the draw style for quadrics rendered with `Quad`

.
The legal values are as follows:

`?GLU_FILL`

: Quadrics are rendered with polygon primitives. The polygons are drawn
in a counterclockwise fashion with respect to their normals (as defined with glu:quadricOrientation/2
).

`?GLU_LINE`

: Quadrics are rendered as a set of lines.

`?GLU_SILHOUETTE`

: Quadrics are rendered as a set of lines, except that edges separating
coplanar faces will not be drawn.

`?GLU_POINT`

: Quadrics are rendered as a set of points.

See

### quadricNormals(Quad, Normal) -> ok

`Quad = integer()`

`Normal = enum()`

Specify what kind of normals are desired for quadrics

`glu:quadricNormals`

specifies what kind of normals are desired for quadrics rendered
with `Quad`

. The legal values are as follows:

`?GLU_NONE`

: No normals are generated.

`?GLU_FLAT`

: One normal is generated for every facet of a quadric.

`?GLU_SMOOTH`

: One normal is generated for every vertex of a quadric. This is the
initial value.

See

### quadricOrientation(Quad, Orientation) -> ok

`Quad = integer()`

`Orientation = enum()`

Specify inside/outside orientation for quadrics

`glu:quadricOrientation`

specifies what kind of orientation is desired for quadrics
rendered with `Quad`

. The `Orientation`

values are as follows:

`?GLU_OUTSIDE`

: Quadrics are drawn with normals pointing outward (the initial value).

`?GLU_INSIDE`

: Quadrics are drawn with normals pointing inward.

Note that the interpretation of `outward`

and `inward`

depends on the quadric
being drawn.

See

### quadricTexture(Quad, Texture) -> ok

`Quad = integer()`

`Texture = 0 | 1`

Specify if texturing is desired for quadrics

`glu:quadricTexture`

specifies if texture coordinates should be generated for quadrics
rendered with `Quad`

. If the value of `Texture`

is `?GLU_TRUE`

, then texture
coordinates are generated, and if `Texture`

is `?GLU_FALSE`

, they are not.
The initial value is `?GLU_FALSE`

.

The manner in which texture coordinates are generated depends upon the specific quadric rendered.

See

### scaleImage(Format, WIn, HIn, TypeIn, DataIn, WOut, HOut, TypeOut, DataOut) -> integer()

`Format = enum()`

`WIn = integer()`

`HIn = integer()`

`TypeIn = enum()`

`DataIn = binary()`

`WOut = integer()`

`HOut = integer()`

`TypeOut = enum()`

`DataOut = mem()`

Scale an image to an arbitrary size

`glu:scaleImage`

scales a pixel image using the appropriate pixel store modes to
unpack data from the source image and pack data into the destination image.

When shrinking an image, `glu:scaleImage`

uses a box filter to sample the source
image and create pixels for the destination image. When magnifying an image, the pixels
from the source image are linearly interpolated to create the destination image.

See the gl:readPixels/7 reference page for a description of the acceptable values
for the `Format`

, `TypeIn`

, and `TypeOut`

parameters.

See

### sphere(Quad, Radius, Slices, Stacks) -> ok

`Quad = integer()`

`Radius = float()`

`Slices = integer()`

`Stacks = integer()`

Draw a sphere

`glu:sphere`

draws a sphere of the given radius centered around the origin. The sphere
is subdivided around the `z`

axis into slices and along the `z`

axis into
stacks (similar to lines of longitude and latitude).

If the orientation is set to `?GLU_OUTSIDE`

(with glu:quadricOrientation/2 ),
then any normals generated point away from the center of the sphere. Otherwise, they
point toward the center of the sphere.

If texturing is turned on (with glu:quadricTexture/2 ), then texture coordinates
are generated so that `t`

ranges from 0.0 at z=-radius to 1.0 at z= radius (`t`

increases linearly along longitudinal lines), and `s`

ranges from 0.0 at the +`y`

axis, to 0.25 at the +`x`

axis, to 0.5 at the -`y`

axis, to 0.75 at the -`x`

axis, and back to 1.0 at the +`y`

axis.

See

### unProject(WinX, WinY, WinZ, Model, Proj, View) -> {integer(), ObjX::float(), ObjY::float(), ObjZ::float()}

`WinX = float()`

`WinY = float()`

`WinZ = float()`

`Model = matrix()`

`Proj = matrix()`

`View = {integer(), integer(), integer(), integer()}`

Map window coordinates to object coordinates

`glu:unProject`

maps the specified window coordinates into object coordinates using `Model`

, `Proj`

, and `View`

. The result is stored in `ObjX`

, `ObjY`

, and `ObjZ`

. A return value of `?GLU_TRUE`

indicates success; a return value of `?GLU_FALSE`

indicates failure.

To compute the coordinates (objX objY objZ), `glu:unProject`

multiplies the normalized device coordinates
by the inverse of `Model`

* `Proj`

as follows:

(objX objY objZ W)= INV(P M) ((2(winX-view[0]))/(view[2])-1(2(winY-view[1]))/(view[3])-1 2(winZ)-1 1) INV denotes matrix inversion. W is an unused variable, included for consistent matrix notation.

See

### unProject4(WinX, WinY, WinZ, ClipW, Model, Proj, View, NearVal, FarVal) -> {integer(), ObjX::float(), ObjY::float(), ObjZ::float(), ObjW::float()}

`WinX = float()`

`WinY = float()`

`WinZ = float()`

`ClipW = float()`

`Model = matrix()`

`Proj = matrix()`

`View = {integer(), integer(), integer(), integer()}`

`NearVal = float()`

`FarVal = float()`

See unProject/6