Provided by: erlang-manpages_18.3-dfsg-1ubuntu3.1_all 
NAME
glu - A part of the standard OpenGL Utility api.
DESCRIPTION
A part of the standard OpenGL Utility api. See www.opengl.org
Booleans are represented by integers 0 and 1.
DATA TYPES
enum() = non_neg_integer():
See wx/include/gl.hrl or glu.hrl
matrix() = matrix12() | matrix16():
matrix12() = {float(), float(), float(), float(), float(), float(), float(), float(), float(), float(),
float(), float()}:
matrix16() = {float(), float(), float(), float(), float(), float(), float(), float(), float(), float(),
float(), float(), float(), float(), float(), float()}:
mem() = binary() | tuple():
Memory block
vertex() = {float(), float(), float()}:
EXPORTS
tesselate(Normal, Vs::[Vs]) -> {Triangles, VertexPos}
Types:
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()
Types:
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 external documentation.
build1DMipmaps(Target, InternalFormat, Width, Format, Type, Data) -> integer()
Types:
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 external documentation.
build2DMipmapLevels(Target, InternalFormat, Width, Height, Format, Type, Level, Base, Max, Data) ->
integer()
Types:
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 external documentation.
build2DMipmaps(Target, InternalFormat, Width, Height, Format, Type, Data) -> integer()
Types:
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.
A return value of zero indicates success, otherwise a GLU error code is returned (see
glu:errorString/1 ).
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 external documentation.
build3DMipmapLevels(Target, InternalFormat, Width, Height, Depth, Format, Type, Level, Base, Max, Data)
-> integer()
Types:
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 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×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 external documentation.
build3DMipmaps(Target, InternalFormat, Width, Height, Depth, Format, Type, Data) -> integer()
Types:
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.
A return value of zero indicates success, otherwise a GLU error code is returned (see
glu:errorString/1 ).
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.
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 external documentation.
checkExtension(ExtName, ExtString) -> 0 | 1
Types:
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 external documentation.
cylinder(Quad, Base, Top, Height, Slices, Stacks) -> ok
Types:
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 external documentation.
deleteQuadric(Quad) -> ok
Types:
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 external documentation.
disk(Quad, Inner, Outer, Slices, Loops) -> ok
Types:
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 external documentation.
errorString(Error) -> string()
Types:
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 external documentation.
getString(Name) -> string()
Types:
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_numbermajor_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 external documentation.
lookAt(EyeX, EyeY, EyeZ, CenterX, CenterY, CenterZ, UpX, UpY, UpZ) -> ok
Types:
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 external documentation.
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 external documentation.
ortho2D(Left, Right, Bottom, Top) -> ok
Types:
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 external documentation.
partialDisk(Quad, Inner, Outer, Slices, Loops, Start, Sweep) -> ok
Types:
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 external documentation.
perspective(Fovy, Aspect, ZNear, ZFar) -> ok
Types:
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 external documentation.
pickMatrix(X, Y, DelX, DelY, Viewport) -> ok
Types:
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 external documentation.
project(ObjX, ObjY, ObjZ, Model, Proj, View) -> {integer(), WinX::float(), WinY::float(), WinZ::float()}
Types:
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(3erl)×(v"(1)+1)/2
winZ=(v"(2)+1)/2
See external documentation.
quadricDrawStyle(Quad, Draw) -> ok
Types:
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 external documentation.
quadricNormals(Quad, Normal) -> ok
Types:
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 external documentation.
quadricOrientation(Quad, Orientation) -> ok
Types:
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 external documentation.
quadricTexture(Quad, Texture) -> ok
Types:
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 external documentation.
scaleImage(Format, WIn, HIn, TypeIn, DataIn, WOut, HOut, TypeOut, DataOut) -> integer()
Types:
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.
A return value of zero indicates success, otherwise a GLU error code is returned (see
glu:errorString/1 ).
See the gl:readPixels/7 reference page for a description of the acceptable values for the Format ,
TypeIn , and TypeOut parameters.
See external documentation.
sphere(Quad, Radius, Slices, Stacks) -> ok
Types:
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 external documentation.
unProject(WinX, WinY, WinZ, Model, Proj, View) -> {integer(), ObjX::float(), ObjY::float(),
ObjZ::float()}
Types:
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 external documentation.
unProject4(WinX, WinY, WinZ, ClipW, Model, Proj, View, NearVal, FarVal) -> {integer(), ObjX::float(),
ObjY::float(), ObjZ::float(), ObjW::float()}
Types:
WinX = float()
WinY = float()
WinZ = float()
ClipW = float()
Model = matrix()
Proj = matrix()
View = {integer(), integer(), integer(), integer()}
NearVal = float()
FarVal = float()
See unProject/6
AUTHORS
<>
wx 1.6.1 glu(3erl)