Interface GL10

The OES_byte_coordinates,
OES_single_precision, OES_fixed_point,
OES_read_format, and
OES_compressed_paletted_texture extensions are
included as part of this interface.

Methods with an x or xv suffix belong
to the OES_fixed_point extension and take one or more
fixed-point arguments. Fixed-point arguments may be derived from
floating-point values by multiplying by 65536 (2^16) and rounding
to the nearest integer.

For ease of use, this interface documents method behavior for
all versions of OpenGL ES including version 1.1 and extensions.
When running on an OpenGL ES 1.0 implementation, sections marked
"(1.1 only)" should be disregarded.

See the GL interface for a description of how to
obtain an instance of this interface.

GL_LIGHT6

GL_LIGHT7

Method Detail

glActiveTexture

void glActiveTexture(int texture)

Select server-side active texture unit.

glActiveTexture selects which texture unit
subsequent texture state calls will affect. The number of texture
units an implementation supports is implementation dependent, it
must be at least 1 for OpenGL ES 1.0, or 2 for OpenGL ES 1.1.

Notes

It is always the case that GL_TEXTUREi =
GL_TEXTURE0 + i.

A texture unit consists of the texture enable state, texture
matrix stack, texture environment and currently bound
texture. Modifying any of these states has an effect only on the
active texture unit.

Vertex arrays are client-side GL resources, which are selected by
the glClientActiveTexture routine.

Errors

GL_INVALID_ENUM is generated if
texture is not one of
GL_TEXTUREi, where 0 <= i <
GL_MAX_TEXTURE_UNITS.

Associated Gets

glGetIntegerv with argument
GL_MAX_TEXTURE_UNITS.

Parameters:

texture - Specifies which texture unit to make active. The
number of texture units is implementation dependent, but must be
at least one (for 1.0) or two (for 1.1). texture
must be one of GL_TEXTUREi, where 0 <=
i < GL_MAX_TEXTURE_UNITS, which is an
implementation-dependent value. The intial value is
GL_TEXTURE0.

glAlphaFunc

void glAlphaFunc(int func,
float ref)

Specify the alpha test function.

The alpha test discards fragments depending on the outcome of a
comparison between an incoming fragment's alpha value and a
constant reference value. glAlphaFunc specifies the
reference value and the comparison function. The comparison is
performed only if alpha testing is enabled. To enable and disable
alpha testing, call glEnable and
glDisable with argument
GL_ALPHA_TEST. Alpha testing is initially disabled.

func and ref specify the conditions
under which the pixel is drawn. The incoming alpha value is
compared to ref using the function specified by
func. If the value passes the comparison, the
incoming fragment is drawn if it also passes subsequent stencil
and depth buffer tests. If the value fails the comparison, no
change is made to the frame buffer at that pixel location. The
comparison functions are as follows:

GL_NEVER

Never passes.

GL_LESS

Passes if the incoming alpha value is less than the reference value.

GL_EQUAL

Passes if the incoming alpha value is equal to the reference value.

GL_LEQUAL

Passes if the incoming alpha value is less than or equal to the
reference value.

GL_GREATER

Passes if the incoming alpha value is greater than the reference value.

GL_NOTEQUAL

Passes if the incoming alpha value is not equal to the reference value.

GL_GEQUAL

Passes if the incoming alpha value is greater than or equal to
the reference value.

GL_ALWAYS

Always passes (initial value).

glAlphaFunc operates on all pixel write
operations, including those resulting from the scan conversion of
points, lines, and polygons. glAlphaFunc does not
affect glClear.

glAlphaFuncx

glBindTexture

void glBindTexture(int target,
int texture)

Bind a named texture to a texturing target.

glBindTexture lets you create or use a named
texture. Calling glBindTexture with
target set to GL_TEXTURE_2D, and
texture set to the name of the new texture binds the
texture name to the target. When a texture is bound to a target,
the previous binding for that target is automatically broken.

Texture names are unsigned integers. The value 0 is reserved
to represent the default texture for each texture target. Texture
names and the corresponding texture contents are local to the
shared texture-object space (see eglCreateContext)
of the current GL rendering context.

You may use glGenTextures to generate a set of new
texture names.

While a texture is bound, GL operations on the target to which it
is bound affect the bound texture. If texture mapping of the
dimensionality of the target to which a texture is bound is
active, the bound texture is used. In effect, the texture targets
become aliases for the textures currently bound to them, and the
texture name 0 refers to the default textures that were bound to
them at initialization.

A texture binding created with glBindTexture remains
active until a different texture is bound to the same target, or
until the bound texture is deleted with
glDeleteTextures.

Once created, a named texture may be re-bound to the target of
the matching dimensionality as often as needed. It is usually
much faster to use glBindTexture to bind an existing named
texture to one of the texture targets than it is to reload the
texture image using glTexImage2D.

Errors

GL_INVALID_ENUM is generated if
target is not one of the allowable values.

Parameters:

target - Specifies the target to which the texture is
bound. Must be GL_TEXTURE_2D.

texture - Specifies the name of a texture.

glBlendFunc

void glBlendFunc(int sfactor,
int dfactor)

Specify pixel arithmetic.

Pixels can be drawn using a function that blends the incoming
(source) values with the values that are already in the color
buffer (the destination values). Use glEnable and
glDisable with argument GL_BLEND to
enable and disable blending. Blending is initially disabled.

glBlendFunc defines the operation of blending
when it is enabled. sfactor specifies which of eleven
methods is used to scale the source color
components. dfactor specifies which of ten methods
is used to scale the destination color components. The eleven
possible methods are described in the following table. Each
method defines four scale factors, one each for red, green, blue,
and alpha.

In the table and in subsequent equations, source and
destination color components are referred to as (Rs, Gs,
Bs, As) and (Rd, Gd, Bd, Ad). They are
understood to have integer values between 0 and (kR, kG,
kB, kA), where

kc = 2mc - 1

and (mR, mG, mB, mA) is the number of red, green,
blue, and alpha bitplanes.

Source and destination scale factors are referred to as
(sR, sG, sB, sA) and (dR, dG, dB,
dA). The scale factors described in the table, denoted
(fR, fG, fB, fA), represent either source or
destination factors. All scale factors have range [0, 1].

Despite the apparent precision of the above equations,
blending arithmetic is not exactly specified, because blending
operates with imprecise integer color values. However, a blend
factor that should be equal to 1 is guaranteed not to modify its
multiplicand, and a blend factor equal to 0 reduces its
multiplicand to 0. For example, when sfactor is
GL_SRC_ALPHA, dfactor is
GL_ONE_MINUS_SRC_ALPHA, and As is equal
to kA, the equations reduce to simple replacement:

Rd = Rs
Gd = Gs
Bd = Bs
Ad = As

glBlendFunc operates on all pixel write
operations, including the scan conversion of points, lines, and
polygons. glBlendFunc does not affect
glClear.

Examples

Transparency is best implemented using
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) with
primitives sorted from farthest to nearest. Note that this
transparency calculation does not require the presence of alpha
bitplanes in the color buffer.

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) is
also useful for rendering antialiased points and lines.

glClearDepthx

glClearStencil

glClearStencil specifies the index used by
glClear to clear the stencil buffer. s
is masked with 2^m - 1, where m is the number of
bits in the stencil buffer.

Associated Gets

glGetIntegerv with argument
GL_STENCIL_BITS

Parameters:

s - Specifies the index used when the stencil buffer is
cleared. The initial value is 0.

glClientActiveTexture

void glClientActiveTexture(int texture)

Select client-side active texture unit.

glClientActiveTexture selects the vertex array
client state parameters to be modified by
glTexCoordPointer, and enabled or disabled with
glEnableClientState or
glDisableClientState, respectively, when called with
a parameter of GL_TEXTURE_COORD_ARRAY.

Notes

It is always the case that GL_TEXTUREi =
GL_TEXTURE0 + i.

Errors

GL_INVALID_ENUM is generated if
texture is not one of
GL_TEXTUREi, where 0 <= i <
GL_MAX_TEXTURE_UNITS.

Associated Gets

glGetIntegerv with argument
GL_MAX_TEXTURE_UNITS

Parameters:

texture - Specifies which texture unit to make active. The
number of texture units is implementation dependent, but must be
at least one (for 1.0), or two (for 1.1). texture
must be one of GL_TEXTUREi, 0 <=
i < GL_MAX_TEXTURE_UNITS, which is an
implementation-dependent value. The initial value is
GL_TEXTURE0.

glColor4f

void glColor4f(float red,
float green,
float blue,
float alpha)

Set the current color.

The GL stores a current four-valued RGBA
color. glColor sets a new four-valued RGBA color.

Current color values are stored in fixed-point or
floating-point. In case the values are stored in floating-point,
the mantissa and exponent sizes are unspecified.

Neither fixed-point nor floating-point values are clamped to
the range [0, 1] before the current color is
updated. However, color components are clamped to this range
before they are interpolated or written into the color buffer.

Parameters:

red - Specifies a new red value for the current color. The
initial value is 1.

green - Specifies a new green value for the current color. The
initial value is 1.

blue - Specifies a new blue value for the current color. The
initial value is 1.

alpha - Specifies a new alpha value for the current color. The
initial value is 1.

glColorMask

glColorMask specifies whether the individual
components in the color buffer can or cannot be written. If
red is false, for example, no change
is made to the red component of any pixel in the color buffer,
regardless of the drawing operation attempted, including
glClear.

Changes to individual bits of components cannot be
controlled. Rather, changes are either enabled or disabled for
entire color components.

Parameters:

red - Specifies whether red can or cannot be written into
the color buffer. The initial value is true, indicating
that the color component can be written.

green - Specifies whether green can or cannot be written into
the color buffer. The initial value is true, indicating
that the color component can be written.

blue - Specifies whether blue can or cannot be written into
the color buffer. The initial value is true, indicating
that the color component can be written.

alpha - Specifies whether alpha can or cannot be written
into the color buffer. The initial value is true,
indicating that the color component can be written.

glColorPointer

glColorPointer specifies an array of color
components to use when rendering. size specifies the
number of components per color, and must be 4. type
specifies the data type of each color component, and
stride specifies the byte stride from one color to
the next allowing vertices and attributes to be packed into a
single array or stored in separate arrays. (Single-array storage
may be more efficient on some implementations.)

When a color array is specified, size,
type, stride, and pointer
are saved as client-side state.

If the color array is enabled, it is used when
glDrawArrays, or glDrawElements is
called. To enable and disable the color array, call
glEnableClientState and
glDisableClientState with the argument
GL_COLOR_ARRAY. The color array is initially
disabled and isn't accessed when glDrawArrays or
glDrawElements is called.

Use glDrawArrays to construct a sequence of
primitives (all of the same type) from prespecified vertex and
vertex attribute arrays. Use glDrawElements to
construct a sequence of primitives by indexing vertices and
vertex attributes.

Setting pointer to null releases any
previously set Buffer.

Notes

glColorPointer is typically implemented on the
client side.

Errors

GL_INVALID_VALUE is generated if
size is not 4.

GL_INVALID_ENUM is generated if type
is not an accepted value.

GL_INVALID_VALUE is generated if
stride is negative.

The pointer argument must be a direct buffer
with a type matching that specified by the type
argument.

Parameters:

size - Specifies the number of components per color. Must be
4. The initial value is 4.

type - Specifies the data type of each color component in
the array. Symbolic constants GL_UNSIGNED_BYTE,
GL_FIXED, and GL_FLOAT are
accepted. The initial value is GL_FLOAT.

stride - Specifies the byte offset between consecutive
colors. If stride is 0, the colors are understood to
be tightly packed in the array. The initial value is 0.

pointer - Specifies a Buffer containing the
colors.

Throws:

java.lang.IllegalStateException - if OpenGL ES 1.1 is being used and
VBOs are enabled.

The supported compressed formats are paletted textures. The
layout of the compressed image is a palette followed by multiple
mip-levels of texture indices used for lookup into the
palette. The palette format can be one of R5_G6_B5,
RGBA4, RGB5_A1, RGB8, or
RGBA8. The texture indices can have a resolution of
4 or 8 bits. As a result, the number of palette entries is either
16 or 256. If level is 0, only one mip-level of texture indices
is described in data. Otherwise, the negative value of level
specifies up to which mip-level the texture indices are
described. A possibly remaining pad nibble (half byte) for the
lowest resolution mip-level is ignored.

Notes

glPixelStore has no effect on compressed texture
images.

glCompressedTexImage2D specifies the
two-dimensional texture for the currently bound texture,
specified with glBindTexture, and the current
texture unit, specified with glActiveTexture.

Errors

GL_INVALID_ENUM is generated if
target is not GL_TEXTURE_2D.

GL_INVALID_VALUE may be generated if
level is greater than 0 or the absolute value of
level is greater than log_2(max), where max is the
returned value of GL_MAX_TEXTURE_SIZE.

(1.0) GL_INVALID_VALUE is generated if
internalformat is not one of the accepted symbolic
constants.

(1.1) GL_INVALID_ENUM is generated if
internalformat is not one of the accepted symbolic
constants.

GL_INVALID_VALUE is generated if
width or height is less than 0 or
greater than 2 + GL_MAX_TEXTURE_SIZE, or if either
cannot be represented as 2^k + 2*border for
some integer k.

GL_INVALID_VALUE is generated if
border is not 0.

GL_INVALID_VALUE is generated if
imageSize is not consistent with format, dimentions,
and contents of the compressed image.

Parameters:

target - Specifies the target texture. Must be
GL_TEXTURE_2D.

level - Specifies the level-of-detail number. Must be less
than or equal to 0. Level 0 indicates a single
mip-level. Negative values indicate how many mip-levels are
described by data.

glCompressedTexSubImage2D

glCompressedTexSubImage2D redefines a contiguous
subregion of an existing two-dimensional compressed texture
image. The texels referenced by pixels replace the
portion of the existing texture array with x indices
xoffset and xoffset +
width - 1, inclusive, and y indices
yoffset and yoffset +
height - 1, inclusive. This region may not include
any texels outside the range of the texture array as it was
originally specified. It is not an error to specify a subtexture
with zero width or height, but such a specification has no
effect.

Currently, there is no supported compressed format for this
function.

Notes

glPixelStore has no effect on compressed texture
images.

glCompressedTexSubImage2D specifies the
two-dimensional sub texture for the currently bound texture,
specified with glBindTexture, and the current
texture unit, specified with glActiveTexture.

Errors

GL_INVALID_ENUM is generated if
target is not GL_TEXTURE_2D.

GL_INVALID_OPERATION is generated if the texture
array has not been defined by a previous
glCompressedTexImage2D operation.

GL_INVALID_VALUE is generated if
level is less than 0.

GL_INVALID_VALUE may be generated if
level is greater than log2(max), where
max is the returned value of
GL_MAX_TEXTURE_SIZE.

GL_INVALID_VALUE is generated if
xoffset < -b, xoffset + width >
(w - b), yoffset < -b, or
yoffset + height > (h - b)
, where w is the texture width, h is the texture
height, and b is the border of the texture image being
modified. Note that w and h include twice the
border width.

GL_INVALID_VALUE is generated if
width or height is less than 0.

GL_INVALID_ENUM is generated if type
is not a type constant.

GL_INVALID_OPERATION is generated if type
isGL_UNSIGNED_SHORT_5_6_5 and
format is not GL_RGB.

GL_INVALID_OPERATION is generated if
type is one of
GL_UNSIGNED_SHORT_4_4_4_4, or
GL_UNSIGNED_SHORT_5_5_5_1 and format is
not GL_RGBA.

GL_INVALID_OPERATION is generated if none of the
above error conditions apply.

Associated Gets

glGetIntegerv with argument
GL_MAX_TEXTURE_SIZE

Parameters:

target - Specifies the target texture. Must be
GL_TEXTURE_2D.

level - Specifies the level-of-detail number.

xoffset - Specifies a texel offset in the x direction within
the texture array.

yoffset - Specifies a texel offset in the y direction within
the texture array.

width - Specifies the width of the texture subimage.

height - Specifies the height of the texture subimage.

format - Specifies the format of the pixel data. Currently,
there is no supported format.

imageSize - Specifies the size of the compressed pixel data in bytes.

data - Specifies a Buffer containing the
compressed image data.

Throws:

java.lang.IllegalArgumentException - if data is
null.

java.lang.IllegalArgumentException - if
data.remaining() is less than
imageSize.

glCopyTexImage2D

Specify a two-dimensional texture image with pixels from the
color buffer.

glCopyTexImage2D defines a two-dimensional
texture image with pixels from the color buffer.

The screen-aligned pixel rectangle with lower left corner at
(x, y) and with a width of
width + 2*border and a height of
height + 2*border defines the texture
array at the mipmap level specified by
level. internalformat specifies the
color components of the texture.

The red, green, blue, and alpha components of each pixel that
is read are converted to an internal fixed-point or
floating-point format with unspecified precision. The conversion
maps the largest representable component value to 1.0, and
component value 0 to 0.0. The values are then converted to the
texture's internal format for storage in the texel array.

internalformat must be chosen such that color
buffer components can be dropped during conversion to the
internal format, but new components cannot be added. For example,
an RGB color buffer can be used to create LUMINANCE
or RGB textures, but not ALPHA,
LUMINANCE_ALPHA or RGBA textures.

Pixel ordering is such that lower x and y screen coordinates
correspond to lower s and t texture coordinates.

If any of the pixels within the specified rectangle of the
color buffer are outside the window associated with the current
rendering context, then the values obtained for those pixels are
undefined.

Notes

An image with height or width of 0
indicates a null-texture.

Errors

GL_INVALID_ENUM is generated if
target is not GL_TEXTURE_2D.

GL_INVALID_OPERATION is generated if
internalformat is not compatible with the color
buffer format.

GL_INVALID_VALUE is generated if
level is less than 0.

GL_INVALID_VALUE may be generated if level is
greater than log_2(max), where max is the returned
value of GL_MAX_TEXTURE_SIZE.

GL_INVALID_VALUE is generated if
width or height is less than 0, greater
than GL_MAX_TEXTURE_SIZE, or if width
or height cannot be represented as 2^k +
2*border for some integer k.

GL_INVALID_VALUE is generated if
border is not 0.

(1.0) GL_INVALID_VALUE is generated if
internalformat is not an accepted constant.

(1.1) GL_INVALID_ENUM is generated if
internalformat is not an accepted constant.

glCopyTexSubImage2D

Specify a two-dimensional texture subimage with pixels from the
color buffer.

glCopyTexSubImage2D replaces a rectangular portion of a
two-dimensional texture image with pixels from the color buffer.

The screen-aligned pixel rectangle with lower left corner at
(x, y) and with width width and height
height replaces the portion of the texture array with x indices
xoffset through xoffset +
width - 1, inclusive, and y indices
yoffset through yoffset +
height - 1, inclusive, at the mipmap level specified
by level.

The pixels in the rectangle are processed the same way as with
glCopyTexImage2D.

glCopyTexSubImage2D requires that the internal
format of the currently bound texture is such that color buffer
components can be dropped during conversion to the internal
format, but new components cannot be added. For example, an RGB
color buffer can be used to create LUMINANCE or RGB textures, but
not ALPHA, LUMINANCE_ALPHA or RGBA textures.

The destination rectangle in the texture array may not include
any texels outside the texture array as it was originally
specified. It is not an error to specify a subtexture with zero
width or height, but such a specification has no effect.

If any of the pixels within the specified rectangle of the
current color buffer are outside the read window associated with
the current rendering context, then the values obtained for those
pixels are undefined.

No change is made to the internalformat,
width, height, or border
parameters of the specified texture array or to texel values
outside the specified subregion.

Errors

GL_INVALID_ENUM is generated if
target is not GL_TEXTURE_2D.

GL_INVALID_OPERATION is generated if the texture
array has not been defined by a previous
glTexImage2D or glCopyTexImage2D
operation or if the internal format of the currently bound
texture is not compatible with the color buffer format.

GL_INVALID_VALUE is generated if
level is less than 0.

GL_INVALID_VALUE may be generated if
level is greater than log_2(max), where
max is the returned value of
GL_MAX_TEXTURE_SIZE.

GL_INVALID_VALUE is generated if x < -b,
or y < -b, where b is the border of the texture
being modified.

GL_INVALID_VALUE is generated if
xoffset < -b, xoffset +
width > (w - b) , yoffset <
-b, or yoffset + height > (h
- b) , where w is the texture width, h is the
texture height, and b is the border of the texture image
being modified. Note that w and h include twice the
border width.

glDeleteTextures

void glDeleteTextures(int n,
int[] textures,
int offset)

Delete named textures.

glDeleteTextures deletes n textures
named by the elements of the array textures. After a
texture is deleted, it has no contents or dimensionality, and its
name is free for reuse (for example by
glGenTextures). If a texture that is currently bound
is deleted, the binding reverts to 0 (the default texture).

glDeleteTextures silently ignores 0's and names
that do not correspond to existing textures.

Errors

GL_INVALID_VALUE is generated if n
is negative.

Parameters:

n - Specifies the number of textures to be deleted.

textures - Specifies an array of textures to be deleted.

offset - the starting offset within the
textures array.

Throws:

java.lang.IllegalArgumentException - if textures is
null.

java.lang.IllegalArgumentException - if offset is
less than 0.

java.lang.IllegalArgumentException - if textures.length -
offset is less than n.

glDepthFunc

void glDepthFunc(int func)

Specify the value used for depth buffer comparisons.

glDepthFunc specifies the function used to compare
each incoming pixel depth value with the depth value present in
the depth buffer. The comparison is performed only if depth
testing is enabled. To enable and disable depth testing, call
glEnable and glDisable with argument
GL_DEPTH_TEST. Depth testing is initially disabled.

func specifies the conditions under which the pixel will be
drawn. The comparison functions are as follows:

GL_NEVER

Never passes.

GL_LESS

Passes if the incoming depth value is less than the stored depth value.

GL_EQUAL

Passes if the incoming depth value is equal to the stored depth value.

GL_LEQUAL

Passes if the incoming depth value is less than or equal to the
stored depth value.

GL_GREATER

Passes if the incoming depth value is greater than the stored
depth value.

GL_NOTEQUAL

Passes if the incoming depth value is not equal to the stored
depth value.

GL_GEQUAL

Passes if the incoming depth value is greater than or equal to
the stored depth value.

GL_ALWAYS

Always passes.

The initial value of func is GL_LESS. Initially,
depth testing is disabled. Even if the depth buffer exists and
the depth mask is non-zero, the depth buffer is not updated if
the depth test is disabled.

glDepthRangef

After clipping and division by w, depth coordinates range from
-1 to 1, corresponding to the near and far clipping
planes. glDepthRange specifies a linear mapping of
the normalized depth coordinates in this range to window depth
coordinates. Regardless of the actual depth buffer
implementation, window coordinate depth values are treated as
though they range from 0 through 1 (like color components). Thus,
the values accepted by glDepthRange are both clamped
to this range before they are accepted.

The setting of (0, 1) maps the near plane to 0 and the far
plane to 1. With this mapping, the depth buffer range is fully
utilized.

Notes

It is not necessary that near be less than
far. Reverse mappings such as near = 1,
and far = 0 are acceptable.

Parameters:

zNear - Specifies the mapping of the near clipping plane to
window coordinates. The initial value is 0.

zFar - Specifies the mapping of the far clipping plane to
window coordinates. The initial value is 1.

glDisableClientState

glDrawArrays

void glDrawArrays(int mode,
int first,
int count)

Render primitives from array data.

glDrawArrays specifies multiple geometric
primitives with very few subroutine calls. You can prespecify
separate arrays of vertices, normals, colors, and texture
coordinates and use them to construct a sequence of primitives
with a single call to glDrawArrays.

When glDrawArrays is called, it uses
count sequential elements from each enabled array to
construct a sequence of geometric primitives, beginning with
element first. mode specifies what kind
of primitives are constructed, and how the array elements
construct those primitives. If GL_VERTEX_ARRAY is
not enabled, no geometric primitives are generated.

Vertex attributes that are modified by
glDrawArrays have an unspecified value after
glDrawArrays returns. For example, if
GL_COLOR_ARRAY is enabled, the value of the current
color is undefined after glDrawArrays
executes. Attributes that aren't modified remain well defined.

java.lang.ArrayIndexOutOfBoundsException - if any index in the
sequence first, ..., first + count - 1 will result
in a reference to an entry outside of the current vertex, color,
normal, texture coordinate, point size, matrix index, or weight
array.

glDrawElements

glDrawElements specifies multiple geometric
primitives with very few subroutine calls. You can prespecify
separate arrays of vertices, normals, colors, and texture
coordinates and use them to construct a sequence of primitives
with a single call to glDrawElements.

When glDrawElements is called, it uses
count sequential indices from indices
to lookup elements in enabled arrays to construct a sequence of
geometric primitives. mode specifies what kind of
primitives are constructed, and how the array elements construct
these primitives. If GL_VERTEX_ARRAY is not enabled,
no geometric primitives are constructed.

Vertex attributes that are modified by
glDrawElements have an unspecified value after
glDrawElements returns. For example, if
GL_COLOR_ARRAY is enabled, the value of the current
color is undefined after glDrawElements
executes. Attributes that aren't modified maintain their previous
values.

type - Specifies the type of the values in indices. Must be
either GL_UNSIGNED_BYTE or GL_UNSIGNED_SHORT.

indices - Specifies a pointer to the location where the
indices are stored.

Throws:

java.lang.IllegalStateException - if the most recent call to
glBindBuffer for the
GL_ELEMENT_ARRAY_BUFFER target had a non-zero
buffer parameter (i.e., an index buffer is bound).

java.lang.IllegalArgumentException - if indices is
null.

java.lang.ArrayIndexOutOfBoundsException - if any index in the
sequence of indices from 0 to count - 1
would result in a reference to an entry outside of the currently
bound index or data (vertex, color, normal, texture coordinate
array, weight, matrix index, or point size) array.

glEnable

void glEnable(int cap)

Enable server-side GL capabilities.

glEnable and glDisable enable and
disable various capabilities. The initial value for each
capability with the exception of GL_DITHER and
GL_MULTISAMPLE is GL_FALSE. The initial
value for GL_DITHER and GL_MULTISAMPLE
is GL_TRUE.

Both glEnable and glDisable take a
single argument, cap, which can assume one of the
following values:

GL_ALPHA_TEST

If enabled, do alpha testing. See glAlphaFunc.

GL_BLEND

If enabled, blend the incoming color values with the values in
the color buffers. See glBlendFunc.

GL_COLOR_LOGIC_OP

If enabled, apply the currently selected logical operation to the
incoming color and color buffer values. See glLogicOp.

GL_COLOR_MATERIAL

If enabled, have ambient and diffuse material parameters track
the current color.

GL_CULL_FACE

If enabled, cull polygons based on their winding in window
coordinates. See glCullFace.

GL_DEPTH_TEST

If enabled, do depth comparisons and update the depth
buffer. Note that even if the depth buffer exists and the depth
mask is non-zero, the depth buffer is not updated if the depth
test is disabled. See glDepthFunc,
glDepthMask, and glDepthRange.

GL_DITHER

If enabled, dither color components or indices before they are
written to the color buffer.

GL_FOG

If enabled, blend a fog color into the posttexturing color. See
glFog.

GL_LIGHTi

If enabled, include light i in the evaluation of the
lighting equation. See glLightModel and
glLight.

GL_LIGHTING

If enabled, use the current lighting parameters to compute the
vertex color. Otherwise, simply associate the current color with
each vertex. See glMaterial,
glLightModel, and glLight.

If enabled, a temporary coverage value is generated where each
bit is determined by the alpha value at the corresponding sample
location. The temporary coverage value is then ANDed with the
fragment coverage value. Otherwise the fragment coverage value is
unchanged at this point. See glSampleCoverage.

GL_SAMPLE_ALPHA_TO_ONE

If enabled, set fragment alpha to the maximum permissible value
after computing multisample coverage modification masks. See
glSampleCoverage.

GL_SAMPLE_MASK (1.0 only)

If enabled, apply a mask to modify fragment coverage during
multisampling. See glSampleCoverage.

GL_SAMPLE_COVERAGE (1.1 only)

If enabled, the fragment coverage is ANDed with another temporary
coverage. This temporary coverage is generated in the same manner
as for GL_SAMPLE_ALPHA_TO_COVERAGE described above,
but as a function of the value of
GL_SAMPLE_COVERAGE_VALUE. If
GL_SAMPLE_COVERAGE_INVERT is GL_TRUE,
the temporary coverage is inverted (all bit values are inverted)
before it is ANDed with the fragment coverage. See
glSampleCoverage.

GL_SCISSOR_TEST

If enabled, discard fragments that are outside the scissor
rectangle. See glScissor.

GL_STENCIL_TEST

If enabled, do stencil testing and update the stencil buffer. See
glStencilFunc, glStencilMask, and
glStencilOp.

GL_TEXTURE_2D

If enabled, two-dimensional texturing is performed for the active
texture unit. See glActiveTexture,
glTexImage2D, glCompressedTexImage2D,
and glCopyTexImage2D.

GL_CLIP_PLANEi (1.1 only)

If enabled, clipping plane i is enabled. See
glClipPlane.

GL_POINT_SPRITE_OES
(1.1 + OES_point_sprite extension)

If enabled, point sprites are enabled. See
glPointSize and glTexEnv.

Errors

GL_INVALID_ENUM is generated if cap is not one of
the values listed previously.

Parameters:

cap - Specifies a symbolic constant indicating a GL capability.

glEnableClientState

void glEnableClientState(int array)

Enable client-side capability.

glEnableClientState and
glDisableClientState enable or disable individual
client-side capabilities. By default, all client-side
capabilities are disabled. Both glEnableClientState
and glDisableClientState take a single argument,
array, which can assume one of the following values:

GL_COLOR_ARRAY

If enabled, the color array is enabled for writing and used
during rendering when glDrawArrays, or
glDrawElements is called. See
glColorPointer.

GL_NORMAL_ARRAY

If enabled, the normal array is enabled for writing and used
during rendering when glDrawArrays, or
glDrawElements is called. See
glNormalPointer.

GL_TEXTURE_COORD_ARRAY

If enabled, the texture coordinate array is enabled for writing
and used during rendering when glDrawArrays, or
glDrawElements is called. See
glTexCoordPointer.

GL_VERTEX_ARRAY

If enabled, the vertex array is enabled for writing and used
during rendering when glDrawArrays, or
glDrawElements is called. See
glVertexPointer.

GL_POINT_SIZE_ARRAY_OES
(OES_point_size_array extension)

If enabled, the point size array controls the sizes used to
render points and point sprites. In this case the point size
defined by glPointSize is ignored. The point sizes
supplied in the point size arrays will be the sizes used to
render both points and point sprites. See
glPointSize.

glFinish

void glFinish()

Block until all GL execution is complete.

glFinish does not return until the effects of all
previously called GL commands are complete. Such effects include
all changes to GL state, all changes to connection state, and all
changes to the frame buffer contents.

Notes

glFinish requires a round trip to the server.

glFlush

void glFlush()

Force execution of GL commands in finite time.

Different GL implementations buffer commands in several
different locations, including network buffers and the graphics
accelerator itself. glFlush empties all of these
buffers, causing all issued commands to be executed as quickly as
they are accepted by the actual rendering engine. Though this
execution may not be completed in any particular time period, it
does complete in finite time.

Because any GL program might be executed over a network, or on an
accelerator that buffers commands, all programs should call
glFlush whenever they count on having all of their previously
issued commands completed. For example, call glFlush before
waiting for user input that depends on the generated image.

Notes

glFlush can return at any time. It does not wait until the
execution of all previously issued GL commands is complete.

glFogf

void glFogf(int pname,
float param)

Specify fog parameters.

If fog is enabled, fog affects rasterized geometry, bitmaps,
and pixel blocks, but not buffer clear operations. To enable and
disable fog, call glEnable and
glDisable with argument GL_FOG. Fog is
initially disabled.

glFog assigns the value in param to
the fog parameter specified by pname. The following
values are accepted for pname:

GL_FOG_MODE

param is a single value that specifies the equation
to be used to compute the fog blend factor f. Three symbolic
constants are accepted: GL_LINEAR,
GL_EXP, and GL_EXP2. The equations
corresponding to these symbolic constants are defined below. The
initial fog mode is GL_EXP.

GL_FOG_DENSITY

param is a single value that specifies density, the
fog density used in both exponential fog equations. Only
nonnegative densities are accepted. The initial fog density is 1.

GL_FOG_START

param is a single value that specifies start, the
near distance used in the linear fog equation. The initial near
distance is 0.

GL_FOG_END

param is a single value that specifies end, the far
distance used in the linear fog equation. The initial far
distance is 1.

Errors

GL_INVALID_ENUM is generated if
pname is not an accepted value, or if
pname is GL_FOG_MODE and
param is not an accepted value.

GL_INVALID_VALUE is generated if
pname is GL_FOG_DENSITY, and
param is negative.

glFogfv

If fog is enabled, fog affects rasterized geometry, bitmaps,
and pixel blocks, but not buffer clear operations. To enable and
disable fog, call glEnable and
glDisable with argument GL_FOG. Fog is
initially disabled.

glFog assigns the value or values in
params to the fog parameter specified by
pname. The following values are accepted for
pname:

GL_FOG_MODE

params contains a single value that specifies the
equation to be used to compute the fog blend factor f. Three
symbolic constants are accepted: GL_LINEAR,
GL_EXP, and GL_EXP2. The equations
corresponding to these symbolic constants are defined below. The
initial fog mode is GL_EXP.

GL_FOG_DENSITY

params contains a single value that specifies
density, the fog density used in both exponential fog
equations. Only nonnegative densities are accepted. The initial
fog density is 1.

GL_FOG_START

params contains a single value that specifies start,
the near distance used in the linear fog equation. The initial
near distance is 0.

GL_FOG_END

params contains a single value that specifies end,
the far distance used in the linear fog equation. The initial far
distance is 1.

GL_FOG_COLOR

params contains four values that specify
Cf, the fog color. Both fixed-point and floating-point
values are mapped directly. After conversion, all color
components are clamped to the range [0, 1]. The
initial fog color is (0, 0, 0, 0).

Fog blends a fog color with each rasterized pixel fragment's
posttexturing color using a blending factor f. Factor f is computed in
one of three ways, depending on the fog mode. Let z be the distance in
eye coordinates from the origin to the fragment being fogged. The
equation for GL_LINEAR fog is

f = (end - z)/(end - start)

The equation for GL_EXP fog is

f = e -(density - z)

The equation for GL_EXP2 fog is

f = e -(density - z)2

Regardless of the fog mode, f is clamped to the range
[0, 1] after it is computed. Then, the fragment's
red, green, and blue colors, represented by Cr, are
replaced by:

C'r = f Cr + (1 - f) Cf

Fog does not affect a fragment's alpha component.

Errors

GL_INVALID_ENUM is generated if
pname is not an accepted value, or if
pname is GL_FOG_MODE and
params is not an accepted value.

GL_INVALID_VALUE is generated if
pname is GL_FOG_DENSITY, and the first
value in params is negative.

glFrontFace

void glFrontFace(int mode)

Define front- and back-facing polygons.

In a scene composed entirely of opaque closed surfaces,
back-facing polygons are never visible. Eliminating (culling)
these invisible polygons has the obvious benefit of speeding up
the rendering of the image. To enable and disable culling, call
glEnable and glDisable with argument
GL_CULL_FACE. Culling is initially disabled.

The projection of a polygon to window coordinates is said to
have clockwise winding if an imaginary object following the path
from its first vertex, its second vertex, and so on, to its last
vertex, and finally back to its first vertex, moves in a
clockwise direction about the interior of the polygon. The
polygon's winding is said to be counterclockwise if the imaginary
object following the same path moves in a counterclockwise
direction about the interior of the polygon. glFrontFace
specifies whether polygons with clockwise winding in window
coordinates, or counterclockwise winding in window coordinates,
are taken to be front-facing. Passing GL_CCW to
mode selects counterclockwise polygons as
front-facing. GL_CW selects clockwise polygons as
front-facing. By default, counterclockwise polygons are taken to
be front-facing.

Errors

GL_INVALID_ENUM is generated if mode
is not an accepted value.

Parameters:

mode - Specifies the orientation of front-facing
polygons. GL_CW and GL_CCW are
accepted. The initial value is GL_CCW.

glFrustumf

glFrustum describes a perspective matrix that
produces a perspective projection. The current matrix (see
glMatrixMode) is multiplied by this matrix and the
result replaces the current matrix, as if
glMultMatrix were called with the following matrix
as its argument:

Typically, the matrix mode is GL_PROJECTION, and
(left, bottom, -near) and
(right, top, -near)
specify the points on the near clipping plane that are mapped to
the lower left and upper right corners of the window, assuming
that the eye is located at (0, 0, 0). -far specifies
the location of the far clipping plane. Both near
and far must be positive.

Use glPushMatrix and glPopMatrix to
save and restore the current matrix stack.

Notes

Depth buffer precision is affected by the values specified for
near and far. The greater the ratio of far to
near is, the less effective the depth buffer will be
at distinguishing between surfaces that are near each other. If

r = far/near

roughly log_2(r) bits of depth buffer precision are
lost. Because r approaches infinity as near
approaches 0, near must never be set to 0.

Errors

GL_INVALID_VALUE is generated if
near or far is not positive, or if
left = right, or bottom =
top.

Parameters:

left - Specifies the coordinate for the left vertical
clipping plane.

right - Specifies the coordinate for the right vertical
clipping plane.

glFrustumx

glGenTextures

void glGenTextures(int n,
int[] textures,
int offset)

Generate texture names.

glGenTextures returns n texture
names in textures. There is no guarantee that the
names form a contiguous set of integers. However, it is
guaranteed that none of the returned names was in use immediately
before the call to glGenTextures.

The generated textures have no dimensionality; they assume the
dimensionality of the texture target to which they are first
bound (see glBindTexture).

Texture names returned by a call to glGenTextures are not
returned by subsequent calls, unless they are first deleted with
glDeleteTextures.

Errors

GL_INVALID_VALUE is generated if n
is negative.

Parameters:

n - Specifies the number of texture names to be generated.

textures - Specifies an array in which the generated texture
names are stored.

offset - the starting offset within the
textures array.

Throws:

java.lang.IllegalArgumentException - if textures is
null.

java.lang.IllegalArgumentException - if offset is
less than 0.

java.lang.IllegalArgumentException - if textures.length -
offset is less than n.

glGetError

int glGetError()

Return error information.

glGetError returns the value of the error
flag. Each detectable error is assigned a numeric code and
symbolic name. When an error occurs, the error flag is set to the
appropriate error code value. No other errors are recorded until
glGetError is called, the error code is returned,
and the flag is reset to GL_NO_ERROR. If a call to
glGetError returns GL_NO_ERROR, there
has been no detectable error since the last call to
glGetError, or since the GL was initialized.

To allow for distributed implementations, there may be several
error flags. If any single error flag has recorded an error, the
value of that flag is returned and that flag is reset to
GL_NO_ERROR when glGetError is
called. If more than one flag has recorded an error,
glGetError returns and clears an arbitrary error
flag value. Thus, glGetError should always be called
in a loop, until it returns GL_NO_ERROR, if all
error flags are to be reset.

Initially, all error flags are set to GL_NO_ERROR.

The following errors are currently defined:

GL_NO_ERROR

No error has been recorded. The value of this symbolic constant
is guaranteed to be 0.

GL_INVALID_ENUM

An unacceptable value is specified for an enumerated
argument. The offending command is ignored, and has no other side
effect than to set the error flag.

GL_INVALID_VALUE

A numeric argument is out of range. The offending command is
ignored, and has no other side effect than to set the error flag.

GL_INVALID_OPERATION

The specified operation is not allowed in the current state. The
offending command is ignored, and has no other side effect than
to set the error flag.

GL_STACK_OVERFLOW

This command would cause a stack overflow. The offending command
is ignored, and has no other side effect than to set the error
flag.

GL_STACK_UNDERFLOW

This command would cause a stack underflow. The offending command
is ignored, and has no other side effect than to set the error
flag.

GL_OUT_OF_MEMORY

There is not enough memory left to execute the command. The state
of the GL is undefined, except for the state of the error flags,
after this error is recorded.

When an error flag is set, results of a GL operation are
undefined only if GL_OUT_OF_MEMORY has occurred. In
all other cases, the command generating the error is ignored and
has no effect on the GL state or frame buffer contents. If the
generating command returns a value, it returns 0. If
glGetError itself generates an error, it returns 0.

Returns:

One of the error codes listed above.

glGetIntegerv

void glGetIntegerv(int pname,
int[] params,
int offset)

Return the value or values of a selected parameter.

glGet returns values for static state
variables in GL. pname is a symbolic constant
indicating the static state variable to be returned, and
params is an array of integers in which to place the
returned data.

A boolean value is interpreted as either 1 or 0, and a
floating-point value is rounded to the nearest integer, unless
the value is an RGBA color component, a DepthRange
value, a depth buffer clear value, or a normal coordinate. In
these cases, the glGet command does a linear mapping
that maps 1.0 to the most positive representable integer value,
and -1.0 to the most negative representable integer value.

params returns two values, the smallest and largest
supported sizes for aliased points. The range must include 1. See
glPointSize.

GL_ALIASED_LINE_WIDTH_RANGE

params returns two values, the smallest and largest
supported widths for aliased lines. The range must include 1. See
glLineWidth.

GL_ALPHA_BITS

params returns one value, the number of alpha
bitplanes in the color buffer.

GL_ALPHA_TEST_FUNC (1.1 only)

params returns one value, the symbolic name of
the alpha test function. See glAlphaFunc.

GL_ALPHA_TEST_REF (1.1 only)

params returns one value, the reference value for
the alpha test. An integer value, if requested, is linearly
mapped from the internal floating-point representation such that
1.0 returns the most positive representable integer value, and
-1.0 returns the most negative representable integer value. See
glAlphaFunc.

GL_BLEND_DST (1.1 only)

params returns one value, the symbolic constant
identifying the destination blend function set by
glBlendFunc, or the destination RGB blend function
set by glBlendFuncSeparate. See
glBlendFunc and glBlendFuncSeparate.

GL_BLUE_BITS

params returns one value, the number of blue
bitplanes in the color buffer.

glGetString

Return a string describing the underlying GL implementation. The
GL string is converted to UTF8 format to produce a standard Java
String object.

glGetString returns a String
describing some aspect of the current GL
implementation. name can be one of the following:

GL_VENDOR

Returns the company responsible for this GL implementation. This
name does not change from release to release.

GL_RENDERER

Returns the name of the renderer. This name is typically specific
to a particular configuration of a hardware platform. It does not
change from release to release.

GL_VERSION

Returns the particular OpenGL ES profile as well as the
version of that profile.

GL_EXTENSIONS

Returns a space-separated list of supported extensions to GL.

Because the GL does not include queries for the performance
characteristics of an implementation, some applications are
written to recognize known platforms and modify their GL usage
based on known performance characteristics of these
platforms. Strings GL_VENDOR and
GL_RENDERER together uniquely specify a
platform. They do not change from release to release and should
be used by platform-recognition algorithms.

Some applications want to make use of features that are not part
of the standard GL. These features may be implemented as
extensions to the standard GL. The GL_EXTENSIONS
string is a space-separated list of supported GL
extensions. (Extension names never contain a space character.)

The GL_VERSION string begins with a version
number. The version number uses one of these forms:

major_number.minor_number (1.0 only)

major_number.minor_number.release_number (1.0 only)

OpenGL ES-CM followed by
major_number.minor_number for the common profile (1.1 only).

OpenGL ES-CL followed by major_number.minor_number for
the common-lite profile (1.1 only).

On 1.0 implementations, vendor-specific information may
follow the version number. A space always separates the version
number and the vendor-specific information.

Notes

If an error is generated, glGetString returns NULL.

The client and server may support different versions or
extensions. glGetString always returns a compatible
version number or list of extensions. The release number always
describes the server.

Errors

GL_INVALID_ENUM is generated if name
is not an accepted value.

Parameters:

name - Specifies a symbolic constant, one of
GL_VENDOR, GL_RENDERER,
GL_VERSION, or GL_EXTENSIONS.

Returns:

A String formatted as described above.

glHint

void glHint(int target,
int mode)

Specify implementation-specific hints.

Certain aspects of GL behavior, when there is room for
interpretation, can be controlled with hints. A hint is specified
with two arguments. target is a symbolic constant
indicating the behavior to be controlled, and mode
is another symbolic constant indicating the desired behavior. The
initial value for each target is
GL_DONT_CARE. mode can be one of the
following:

GL_FASTEST

The most efficient option should be chosen.

GL_NICEST

The most correct, or highest quality, option should be chosen.

GL_DONT_CARE

No preference.

Though the implementation aspects that can be hinted are well
defined, the interpretation of the hints depends on the
implementation. The hint aspects that can be specified with
target, along with suggested semantics, are as follows:

GL_FOG_HINT

Indicates the accuracy of fog calculation. If per-pixel fog
calculation is not efficiently supported by the GL
implementation, hinting GL_DONT_CARE or
GL_FASTEST can result in per-vertex calculation of
fog effects.

GL_LINE_SMOOTH_HINT

Indicates the sampling quality of antialiased lines. If a larger
filter function is applied, hinting GL_NICEST can
result in more pixel fragments being generated during
rasterization,

GL_PERSPECTIVE_CORRECTION_HINT

Indicates the quality of color and texture coordinate
interpolation. If perspective-corrected parameter interpolation
is not efficiently supported by the GL implementation, hinting
GL_DONT_CARE or GL_FASTEST can result
in simple linear interpolation of colors and/or texture
coordinates.

GL_POINT_SMOOTH_HINT

Indicates the sampling quality of antialiased points. If a larger
filter function is applied, hinting GL_NICEST can
result in more pixel fragments being generated during
rasterization.

glLightModelf

glLightModel sets the lighting model
parameter. pname names a parameter and param gives
the new value. There is one single-valued lighting model parameter:

GL_LIGHT_MODEL_TWO_SIDE

param specifies whether one- or two-sided lighting
calculations are done for polygons. It has no effect on the
lighting calculations for points, lines, or bitmaps. If
param is 0, one-sided lighting is specified, and
only the front material parameters are used in the lighting
equation. Otherwise, two-sided lighting is specified. In this
case, vertices of back-facing polygons are lighted using the back
material parameters, and have their normals reversed before the
lighting equation is evaluated. Vertices of front-facing polygons
are always lighted using the front material parameters, with no
change to their normals. The initial value is 0.

glLightModelfv

glLightModel sets the lighting model
parameter. pname names a parameter and
params gives the new value. There are two lighting
model parameters:

GL_LIGHT_MODEL_AMBIENT

params contains four values that specify the ambient
intensity of the entire scene. The values are not clamped. The
initial value is (0.2, 0.2, 0.2, 1.0).

GL_LIGHT_MODEL_TWO_SIDE

params contains a single value that specifies
whether one- or two-sided lighting calculations are done for
polygons. It has no effect on the lighting calculations for
points, lines, or bitmaps. If params contains 0,
one-sided lighting is specified, and only the front material
parameters are used in the lighting equation. Otherwise,
two-sided lighting is specified. In this case, vertices of
back-facing polygons are lighted using the back material
parameters, and have their normals reversed before the lighting
equation is evaluated. Vertices of front-facing polygons are
always lighted using the front material parameters, with no
change to their normals. The initial value is 0.

The lighted color of a vertex is the sum of the material
emission intensity, the product of the material ambient
reflectance and the lighting model full-scene ambient intensity,
and the contribution of each enabled light source. Each light
source contributes the sum of three terms: ambient, diffuse, and
specular. The ambient light source contribution is the product of
the material ambient reflectance and the light's ambient
intensity. The diffuse light source contribution is the product
of the material diffuse reflectance, the light's diffuse
intensity, and the dot product of the vertex's normal with the
normalized vector from the vertex to the light source. The
specular light source contribution is the product of the material
specular reflectance, the light's specular intensity, and the dot
product of the normalized vertex-to-eye and vertex-to-light
vectors, raised to the power of the shininess of the
material. All three light source contributions are attenuated
equally based on the distance from the vertex to the light source
and on light source direction, spread exponent, and spread cutoff
angle. All dot products are replaced with 0 if they evaluate to a
negative value.

The alpha component of the resulting lighted color is set to the
alpha value of the material diffuse reflectance.

glLightf

void glLightf(int light,
int pname,
float param)

Set light source parameters.

glLight sets the values of individual light
source parameters. light names the light and is a
symbolic name of the form GL_LIGHTi, where
0 <= i < GL_MAX_LIGHTS. pname
specifies one of ten light source parameters, again by symbolic
name. param contains the new value.

To enable and disable lighting calculation, call
glEnable and glDisable with argument
GL_LIGHTING. Lighting is initially disabled. When it
is enabled, light sources that are enabled contribute to the
lighting calculation. Light source i is enabled and disabled
using glEnable and glDisable with
argument GL_LIGHTi.

The light parameters are as follows:

GL_SPOT_EXPONENT

param is a single value that specifies the
intensity distribution of the light. Fixed-point and
floating-point values are mapped directly. Only values in the
range [0, 128] are accepted.

Effective light intensity is attenuated by the cosine of the
angle between the direction of the light and the direction from
the light to the vertex being lighted, raised to the power of the
spot exponent. Thus, higher spot exponents result in a more
focused light source, regardless of the spot cutoff angle (see
GL_SPOT_CUTOFF, next paragraph). The initial spot
exponent is 0, resulting in uniform light distribution.

GL_SPOT_CUTOFF

param is a single value that specifies the maximum
spread angle of a light source. Fixed-point and floating-point
values are mapped directly. Only values in the range [0, 90] and
the special value 180 are accepted. If the angle between the
direction of the light and the direction from the light to the
vertex being lighted is greater than the spot cutoff angle, the
light is completely masked. Otherwise, its intensity is
controlled by the spot exponent and the attenuation factors. The
initial spot cutoff is 180, resulting in uniform light
distribution.

param is a single value that specifies one of the
three light attenuation factors. Fixed-point and floating-point
values are mapped directly. Only nonnegative values are
accepted. If the light is positional, rather than directional,
its intensity is attenuated by the reciprocal of the sum of the
constant factor, the linear factor times the distance between the
light and the vertex being lighted, and the quadratic factor
times the square of the same distance. The initial attenuation
factors are (1, 0, 0), resulting in no attenuation.

Notes

It is always the case that GL_LIGHTi =
GL_LIGHT0 + i.

Errors

GL_INVALID_ENUM is generated if either
light or pname is not an accepted
value.

GL_INVALID_VALUE is generated if a spot exponent
value is specified outside the range [0, 128], or if spot cutoff
is specified outside the range [0, 90] (except for the special
value 180), or if a negative attenuation factor is specified.

Parameters:

light - Specifies a light. The number of lights depends on
the implementation, but at least eight lights are supported. They
are identified by symbolic names of the form
GL_LIGHTi where 0 <= i <
GL_MAX_LIGHTS.

param - Specifies the value that parameter
pname of light source light will be set to.

glLightfv

void glLightfv(int light,
int pname,
float[] params,
int offset)

Set light source parameters (array version).

glLight sets the values of individual light
source parameters. light names the light and is a
symbolic name of the form GL_LIGHTi, where
0 <= i < GL_MAX_LIGHTS. pname
specifies one of ten light source parameters, again by symbolic
name. params is an array that contains the new
values.

To enable and disable lighting calculation, call
glEnable and glDisable with argument
GL_LIGHTING. Lighting is initially disabled. When it
is enabled, light sources that are enabled contribute to the
lighting calculation. Light source i is enabled and disabled
using glEnable and glDisable with
argument GL_LIGHTi.

params contains four values that specify the diffuse
RGBA intensity of the light. Both fixed-point and floating-point
values are mapped directly. Neither fixed-point nor
floating-point values are clamped. The initial value for
GL_LIGHT0 is (1, 1, 1, 1). For other lights, the
initial value is (0, 0, 0, 0).

GL_SPECULAR

params contains four values that specify the
specular RGBA intensity of the light. Both fixed-point and
floating-point values are mapped directly. Neither fixed-point
nor floating-point values are clamped. The initial value for
GL_LIGHT0 is (1, 1, 1, 1). For other lights, the
initial value is (0, 0, 0, 0).

GL_POSITION (1.0 only)

params contains four values that specify the
position of the light in homogeneous object coordinates. Both
fixed-point and floating-point values are mapped
directly. Neither fixed-point nor floating-point values are
clamped.

The position is transformed by the modelview matrix when
glLight is called (just as if it were a point), and
it is stored in eye coordinates. If the w component of the
position is 0, the light is treated as a directional
source. Diffuse and specular lighting calculations take the
light's direction, but not its actual position, into account, and
attenuation is disabled. Otherwise, diffuse and specular lighting
calculations are based on the actual location of the light in eye
coordinates, and attenuation is enabled. The initial position is
(0, 0, 1, 0). Thus, the initial light source is directional,
parallel to, and in the direction of the -z axis.

GL_SPOT_DIRECTION

params contains three values that specify the
direction of the light in homogeneous object coordinates. Both
fixed-point and floating-point values are mapped
directly. Neither fixed-point nor floating-point values are
clamped.

The spot direction is transformed by the inverse of the modelview
matrix when glLight is called (just as if it were a
normal), and it is stored in eye coordinates. It is significant
only when GL_SPOT_CUTOFF is not 180, which it is
initially. The initial direction is (0, 0, -1).

GL_SPOT_EXPONENT

params is a single value that specifies the
intensity distribution of the light. Fixed-point and
floating-point values are mapped directly. Only values in the
range [0, 128] are accepted.

Effective light intensity is attenuated by the cosine of the
angle between the direction of the light and the direction from
the light to the vertex being lighted, raised to the power of the
spot exponent. Thus, higher spot exponents result in a more
focused light source, regardless of the spot cutoff angle (see
GL_SPOT_CUTOFF, next paragraph). The initial spot
exponent is 0, resulting in uniform light distribution.

GL_SPOT_CUTOFF

params is a single value that specifies the maximum
spread angle of a light source. Fixed-point and floating-point
values are mapped directly. Only values in the range [0, 90] and
the special value 180 are accepted. If the angle between the
direction of the light and the direction from the light to the
vertex being lighted is greater than the spot cutoff angle, the
light is completely masked. Otherwise, its intensity is
controlled by the spot exponent and the attenuation factors. The
initial spot cutoff is 180, resulting in uniform light
distribution.

params is a single value that specifies one of the
three light attenuation factors. Fixed-point and floating-point
values are mapped directly. Only nonnegative values are
accepted. If the light is positional, rather than directional,
its intensity is attenuated by the reciprocal of the sum of the
constant factor, the linear factor times the distance between the
light and the vertex being lighted, and the quadratic factor
times the square of the same distance. The initial attenuation
factors are (1, 0, 0), resulting in no attenuation.

Notes

It is always the case that GL_LIGHTi =
GL_LIGHT0 + i.

Errors

GL_INVALID_ENUM is generated if either
light or pname is not an accepted
value.

GL_INVALID_VALUE is generated if a spot exponent
value is specified outside the range [0, 128], or if spot cutoff
is specified outside the range [0, 90] (except for the special
value 180), or if a negative attenuation factor is specified.

Parameters:

light - Specifies a light. The number of lights depends on
the implementation, but at least eight lights are supported. They
are identified by symbolic names of the form
GL_LIGHTi where 0 <= i <
GL_MAX_LIGHTS.

glLineWidth

void glLineWidth(float width)

Specify the width of rasterized lines.

glLineWidth specifies the rasterized width of
both aliased and antialiased lines. Using a line width other than
1 has different effects, depending on whether line antialiasing
is enabled. To enable and disable line antialiasing, call
glEnable and glDisable with argument
GL_LINE_SMOOTH. Line antialiasing is initially
disabled.

If line antialiasing is disabled, the actual width is
determined by rounding the supplied width to the nearest
integer. (If the rounding results in the value 0, it is as if the
line width were 1.) If |delta x| >= |delta y|,
i pixels are filled in each column that is rasterized,
where i is the rounded value of
width. Otherwise, i pixels are filled in each
row that is rasterized.

If antialiasing is enabled, line rasterization produces a
fragment for each pixel square that intersects the region lying
within the rectangle having width equal to the current line
width, length equal to the actual length of the line, and
centered on the mathematical line segment. The coverage value for
each fragment is the window coordinate area of the intersection
of the rectangular region with the corresponding pixel
square. This value is saved and used in the final rasterization
step.

Not all widths can be supported when line antialiasing is
enabled. If an unsupported width is requested, the nearest
supported width is used. Only width 1 is guaranteed to be
supported; others depend on the implementation. Likewise, there
is a range for aliased line widths as well. To query the range of
supported widths and the size difference between supported widths
within the range, call glGetIntegerv with arguments
GL_ALIASED_LINE_WIDTH_RANGE,
GL_SMOOTH_LINE_WIDTH_RANGE,
GL_SMOOTH_LINE_WIDTH_GRANULARITY.

Notes

Nonantialiased line width may be clamped to an
implementation-dependent maximum. Call glGetIntegerv
with GL_ALIASED_LINE_WIDTH_RANGE to determine the
maximum width.

Errors

GL_INVALID_VALUE is generated if width is less
than or equal to 0.

Associated Gets

glGetIntegerv with argument
GL_ALIASED_LINE_WIDTH_RANGE

glGetIntegerv with argument
GL_SMOOTH_LINE_WIDTH_RANGE

Parameters:

width - Specifies the width of rasterized lines. The initial
value is 1.

glLineWidthx

glLoadIdentity

glLoadIdentity replaces the current matrix with
the identity matrix. It is semantically equivalent to calling
glLoadMatrix with the identity matrix

( 1 0 0 0 )
( 0 1 0 0 )
( 0 0 1 0 )
( 0 0 0 1 )

but in some cases it is more efficient.

glLoadMatrixf

void glLoadMatrixf(float[] m,
int offset)

Replace the current matrix with the specified matrix.

glLoadMatrix replaces the current matrix with the
one whose elements are specified by m. The current
matrix is the projection matrix, modelview matrix, or texture
matrix, depending on the current matrix mode (see glMatrixMode).

The current matrix, M, defines a transformation
of coordinates. For instance, assume M refers to the
modelview matrix. If v = (v[0], v[1], v[2], v[3]) is
the set of object coordinates of a vertex, and m is
an array of 16 fixed-point or single-precision floating-point
values m[0], m[1], ...,
m[15], then the modelview transformation
M(v) does the following:

glLogicOp

void glLogicOp(int opcode)

Specify a logical pixel operation.

glLogicOp specifies a logical operation that,
when enabled, is applied between the incoming color and the color
at the corresponding location in the frame buffer. To enable or
disable the logical operation, call glEnable and
glDisable with argument
GL_COLOR_LOGIC_OP. Logical operation is initially
disabled.

opcode is a symbolic constant chosen from the
list above. In the explanation of the logical operations,
s represents the incoming color and d represents
the color in the frame buffer. As in the Java language, "~"
represents bitwise negation, "&" represents bitwise AND, "|"
represents bitwise OR, and "^" represents bitwise XOR. As these
bitwise operators suggest, the logical operation is applied
independently to each bit pair of the source and destination
indices or colors.

glMaterialf

void glMaterialf(int face,
int pname,
float param)

Specify material parameters for the lighting model.

glMaterial assigns values to material
parameters. There are two matched sets of material
parameters. One, the front-facing set, is used to shade points,
lines, and all polygons (when two-sided lighting is disabled), or
just front-facing polygons (when two-sided lighting is
enabled). The other set, back-facing, is used to shade
back-facing polygons only when two-sided lighting is
enabled. Refer to the glLightModel reference page
for details concerning one- and two-sided lighting calculations.

glMaterial takes three arguments. The first,
face, must be GL_FRONT_AND_BACK and specifies that
both front and back materials will be modified. The second,
pname, specifies which of several parameters in one or both sets
will be modified. The third, params, specifies what value or
values will be assigned to the specified parameter.

Material parameters are used in the lighting equation that is
optionally applied to each vertex. The equation is discussed in
the glLightModel reference page. The parameters that
can be specified using glMaterial, and their
interpretations by the lighting equation, are as follows:

GL_AMBIENT

params contains four fixed-point or
floating-point values that specify the ambient RGBA reflectance
of the material. The values are not clamped. The initial ambient
reflectance is (0.2, 0.2, 0.2, 1.0).

GL_DIFFUSE

params contains four fixed-point or
floating-point values that specify the diffuse RGBA reflectance
of the material. The values are not clamped. The initial diffuse
reflectance is (0.8, 0.8, 0.8, 1.0).

GL_SPECULAR

params contains four fixed-point or
floating-point values that specify the specular RGBA reflectance
of the material. The values are not clamped. The initial specular
reflectance is (0, 0, 0, 1).

GL_EMISSION

params contains four fixed-point or
floating-point values that specify the RGBA emitted light
intensity of the material. The values are not clamped. The
initial emission intensity is (0, 0, 0, 1).

GL_SHININESS

params is a single fixed-point or floating-point
value that specifies the RGBA specular exponent of the
material. Only values in the range [0, 128] are accepted. The
initial specular exponent is 0.

GL_AMBIENT_AND_DIFFUSE

Equivalent to calling glMaterial twice with the same
parameter values, once with GL_AMBIENT and once with
GL_DIFFUSE.

Notes

To change the diffuse and ambient material per vertex, color
material can be used. To enable and disable
GL_COLOR_MATERIAL, call glEnable and
glDisable with argument
GL_COLOR_MATERIAL. Color material is initially
disabled.

While the ambient, diffuse, specular and emission material
parameters all have alpha components, only the diffuse alpha
component is used in the lighting computation.

Errors

GL_INVALID_ENUM is generated if either face or
pname is not an accepted value.

GL_INVALID_VALUE is generated if a specular
exponent outside the range [0, 128] is specified.

Parameters:

face - Specifies which face or faces are being updated. Must
be GL_FRONT_AND_BACK.

pname - Specifies the single-valued material parameter of
the face or faces that is being updated. Must be
GL_SHININESS.

param - Specifies the value that parameter
GL_SHININESS will be set to.

glMaterialfv

void glMaterialfv(int face,
int pname,
float[] params,
int offset)

Specify material parameters for the lighting model (array
version).

glMaterial assigns values to material
parameters. There are two matched sets of material
parameters. One, the front-facing set, is used to shade points,
lines, and all polygons (when two-sided lighting is disabled), or
just front-facing polygons (when two-sided lighting is
enabled). The other set, back-facing, is used to shade
back-facing polygons only when two-sided lighting is
enabled. Refer to the glLightModel reference page
for details concerning one- and two-sided lighting calculations.

glMaterial takes three arguments. The first,
face, must be GL_FRONT_AND_BACK and specifies that
both front and back materials will be modified. The second,
pname, specifies which of several parameters in one or both sets
will be modified. The third, params, specifies what value or
values will be assigned to the specified parameter.

Material parameters are used in the lighting equation that is
optionally applied to each vertex. The equation is discussed in
the glLightModel reference page. The parameters that
can be specified using glMaterial, and their
interpretations by the lighting equation, are as follows:

GL_AMBIENT

params contains four fixed-point or
floating-point values that specify the ambient RGBA reflectance
of the material. The values are not clamped. The initial ambient
reflectance is (0.2, 0.2, 0.2, 1.0).

GL_DIFFUSE

params contains four fixed-point or
floating-point values that specify the diffuse RGBA reflectance
of the material. The values are not clamped. The initial diffuse
reflectance is (0.8, 0.8, 0.8, 1.0).

GL_SPECULAR

params contains four fixed-point or
floating-point values that specify the specular RGBA reflectance
of the material. The values are not clamped. The initial specular
reflectance is (0, 0, 0, 1).

GL_EMISSION

params contains four fixed-point or
floating-point values that specify the RGBA emitted light
intensity of the material. The values are not clamped. The
initial emission intensity is (0, 0, 0, 1).

GL_SHININESS

params is a single fixed-point or floating-point
value that specifies the RGBA specular exponent of the
material. Only values in the range [0, 128] are accepted. The
initial specular exponent is 0.

GL_AMBIENT_AND_DIFFUSE

Equivalent to calling glMaterial twice with the same
parameter values, once with GL_AMBIENT and once with
GL_DIFFUSE.

Notes

To change the diffuse and ambient material per vertex, color
material can be used. To enable and disable
GL_COLOR_MATERIAL, call glEnable and
glDisable with argument
GL_COLOR_MATERIAL. Color material is initially
disabled.

While the ambient, diffuse, specular and emission material
parameters all have alpha components, only the diffuse alpha
component is used in the lighting computation.

Errors

GL_INVALID_ENUM is generated if either face or
pname is not an accepted value.

GL_INVALID_VALUE is generated if a specular
exponent outside the range [0, 128] is specified.

Parameters:

face - Specifies which face or faces are being updated. Must
be GL_FRONT_AND_BACK.

pname - Specifies the material parameter of the face or
faces that is being updated. Must be one of
GL_AMBIENT, GL_DIFFUSE,
GL_SPECULAR, GL_EMISSION,
GL_SHININESS, or
GL_AMBIENT_AND_DIFFUSE.

params - Specifies a pointer to the value or values that
pname will be set to.

offset - the starting offset within the
params array.

Throws:

java.lang.IllegalArgumentException - if params is
null.

java.lang.IllegalArgumentException - if offset is
less than 0.

java.lang.IllegalArgumentException - if params.length -
offset is smaller than the number of values required by
the parameter.

Errors

GL_INVALID_ENUM is generated if mode is not an
accepted value.

Parameters:

mode - Specifies which matrix stack is the target for
subsequent matrix operations. These values are accepted:
GL_MODELVIEW, GL_PROJECTION, and
GL_TEXTURE. In the OES_matrix_palette
extension is available, GL_MATRIX_PALETTE_OES is
additionally accepted. The initial value is
GL_MODELVIEW.

glMultMatrixf

void glMultMatrixf(float[] m,
int offset)

Multiply the current matrix with the specified matrix.

glMultMatrix multiplies the current matrix with
the one specified using m, and replaces the current matrix with
the product.

The current matrix is determined by the current matrix mode (see
glMatrixMode). It is either the projection matrix, modelview
matrix, or the texture matrix.

Examples

If the current matrix is C, and the coordinates
to be transformed are, v = (v[0],
v[1], v[2], v[3]), then
the current transformation is C x v, or

where "x" denotes matrix multiplication, and v is
represented as a 4 × 1 matrix.

Notes

While the elements of the matrix may be specified with single or
double precision, the GL may store or operate on these values in
less than single precision.

The array elements are passed in as a one-dimensional
array in column-major order. The order of the multiplication
is important. For example, if the current transformation is a
rotation, and glMultMatrix is called with a
translation matrix, the translation is done directly on the
coordinates to be transformed, while the rotation is done on the
results of that translation.

Parameters:

m - Specifies an array of at least 16 consecutive values,
the first 16 of which are used as the elements of a 4 × 4
column-major matrix.

offset - the starting offset within the
m array.

Throws:

java.lang.IllegalArgumentException - if m is
null.

java.lang.IllegalArgumentException - if offset is
less than 0.

java.lang.IllegalArgumentException - if m.length -
offset is less than 16.

glMultiTexCoord4f

The current texture coordinates are part of the data that is
associated with each vertex.

Notes

It is always the case that GL_TEXTUREi =
GL_TEXTURE0 + i.

Associated Gets

glGetIntegerv with argument
GL_MAX_TEXTURE_UNITS.

Parameters:

target - Specifies texture unit whose coordinates should be
modified. The number of texture units is implementation
dependent, but must be at least one. Must be one of
GL_TEXTUREi, where 0 <= i <
GL_MAX_TEXTURE_UNITS, which is an implementation-dependent
value.

glMultiTexCoord4x

glNormal3f

void glNormal3f(float nx,
float ny,
float nz)

Set the current normal vector.

The current normal is set to the given coordinates whenever
glNormal is issued. Byte, short, or integer arguments are
converted to floating-point with a linear mapping that maps the
most positive representable integer value to 1.0, and the most
negative representable integer value to -1.0.

Normals specified with glNormal need not have
unit length. If GL_NORMALIZE is enabled, then
normals of any length specified with glNormal are
normalized after transformation. If
GL_RESCALE_NORMAL is enabled, normals are scaled by
a scaling factor derived from the modelview
matrix. GL_RESCALE_NORMAL requires that the
originally specified normals were of unit length, and that the
modelview matrix contain only uniform scales for proper
results. To enable and disable normalization, call
glEnable and glDisable with either
GL_NORMALIZE or
GL_RESCALE_NORMAL. Normalization is initially
disabled.

Parameters:

nx - Specifies the x coordinate of the new
current normal. The initial value is 0.

ny - Specifies the y coordinate of the new
current normal. The initial value is 0.

nz - Specifies the z coordinate of the new
current normal. The initial value is 1.

glNormalPointer

glNormalPointer specifies the location and data
of an array of normals to use when rendering. type specifies the
data type of the normal coordinates and stride gives the byte
stride from one normal to the next, allowing vertices and
attributes to be packed into a single array or stored in separate
arrays. (Single-array storage may be more efficient on some
implementations.) When a normal array is specified, type , stride
, and pointer are saved as client-side state.

If the normal array is enabled, it is used when
glDrawArrays or glDrawElements is
called. To enable and disable the normal array, call
glEnableClientState and
glDisableClientState with the argument
GL_NORMAL_ARRAY. The normal array is initially
disabled and isn't accessed when glDrawArrays or
glDrawElements is called.

Use glDrawArrays to construct a sequence of
primitives (all of the same type) from prespecified vertex and
vertex attribute arrays. Use glDrawElements to
construct a sequence of primitives by indexing vertices and
vertex attributes.

Notes

glNormalPointer is typically implemented on the
client side.

Errors

GL_INVALID_ENUM is generated if type is not an
accepted value.

GL_INVALID_VALUE is generated if stride is
negative.

The pointer argument must be a direct buffer
with a type matching that specified by the type
argument.

Parameters:

type - Specifies the data type of each coordinate in the
array. Symbolic constants GL_BYTE,
GL_SHORT, GL_FIXED, and
GL_FLOAT are accepted. The initial value is
GL_FLOAT.

stride - Specifies the byte offset between consecutive
normals. If stride is 0, the normals are understood to be tightly
packed in the array. The initial value is 0.

pointer - Specifies a pointer to the first coordinate of the
first normal in the array. The initial value is 0.

Throws:

java.lang.IllegalStateException - if OpenGL ES 1.1 is being used and
VBOs are enabled.

java.lang.IllegalArgumentException - if pointer is
null.

java.lang.IllegalArgumentException - if pointer is not direct.

glOrthof

glOrtho describes a transformation that produces
a parallel projection. The current matrix (see glMatrixMode) is
multiplied by this matrix and the result replaces the current
matrix, as if glMultMatrix were called with the
following matrix as its argument:

Typically, the matrix mode is GL_PROJECTION, and
(left, bottom, -near) and (right, top, -near) specify the points
on the near clipping plane that are mapped to the lower left and
upper right corners of the window, respectively, assuming that
the eye is located at (0, 0, 0). -far specifies the location of
the far clipping plane. Both near and far can be either positive
or negative.

Use glPushMatrix and glPopMatrix to
save and restore the current matrix stack.

Parameters:

left - Specifies the coordinate for the left
vertical clipping plane.

right - Specifies the coordinate for the right
vertical clipping plane.

glPixelStorei

glPixelStore sets pixel storage modes that affect
the operation of subsequent glReadPixels as well as
the unpacking of glTexImage2D, and
glTexSubImage2D.

pname is a symbolic constant indicating the
parameter to be set, and param is the new value. The
following storage parameter affects how pixel data is returned to
client memory. This value is significant for
glReadPixels:

GL_PACK_ALIGNMENT

Specifies the alignment requirements for the start of each pixel
row in memory. The allowable values are 1 (byte-alignment), 2
(rows aligned to even-numbered bytes), 4 (word-alignment), and 8
(rows start on double-word boundaries). The initial value is 4.

The following storage parameter affects how pixel data is read
from client memory. This value is significant for
glTexImage2D and glTexSubImage2D:

GL_UNPACK_ALIGNMENT

Specifies the alignment requirements for the start of each pixel
row in memory. The allowable values are 1 (byte-alignment), 2
(rows aligned to even-numbered bytes), 4 (word-alignment), and 8
(rows start on double-word boundaries). The initial value is 4.

Notes

Pixel storage modes are client states.

glCompressedTexImage2D and
glCompressedTexSubImage2D are not affected by
glPixelStore.

Errors

GL_INVALID_ENUM is generated if
pname is not an accepted value.

GL_INVALID_VALUE is generated if alignment is
specified as other than 1, 2, 4, or 8.

Parameters:

pname - Specifies the symbolic name of the parameter to be
set. GL_PACK_ALIGNMENT affects the packing of pixel
data into memory. GL_UNPACK_ALIGNMENT affects the
unpacking of pixel data from memory.

param - Specifies the value that pname is set
to.

glPointSize

void glPointSize(float size)

Specify the diameter of rasterized points.

glPointSize specifies the rasterized diameter of
both aliased and antialiased points. Using a point size other
than 1 has different effects, depending on whether point
antialiasing is enabled. To enable and disable point
antialiasing, call glEnable and
glDisable with argument
GL_POINT_SMOOTH. Point antialiasing is initially
disabled.

If point antialiasing is disabled, the actual size is determined
by rounding the supplied size to the nearest integer. (If the
rounding results in the value 0, it is as if the point size were
1.) If the rounded size is odd, then the center point (x, y) of
the pixel fragment that represents the point is computed as

(floor(xw) + 1/2, floor(yw) + 1/2)

where w subscripts indicate window coordinates. All pixels that
lie within the square grid of the rounded size centered at (x, y)
make up the fragment. If the size is even, the center point is

(floor(xw + 1/2), floor(yw + 1/2))

and the rasterized fragment's centers are the half-integer window
coordinates within the square of the rounded size centered at (x,
y). All pixel fragments produced in rasterizing a nonantialiased
point are assigned the same associated data, that of the vertex
corresponding to the point.

If antialiasing is enabled, then point rasterization produces a
fragment for each pixel square that intersects the region lying
within the circle having diameter equal to the current point size
and centered at the point's (xw, yw) . The coverage value for
each fragment is the window coordinate area of the intersection
of the circular region with the corresponding pixel square. This
value is saved and used in the final rasterization step. The data
associated with each fragment is the data associated with the
point being rasterized.

Not all sizes are supported when point antialiasing is
enabled. If an unsupported size is requested, the nearest
supported size is used. Only size 1 is guaranteed to be
supported; others depend on the implementation. To query the
range of supported sizes, call glGetIntegerv with the argument
GL_SMOOTH_POINT_SIZE_RANGE. For aliased points, query the
supported ranges glGetIntegerv with the argument
GL_ALIASED_POINT_SIZE_RANGE.

Notes

A non-antialiased point size may be clamped to an
implementation-dependent maximum. Although this maximum cannot be
queried, it must be no less than the maximum value for
antialiased points, rounded to the nearest integer value.

Errors

GL_INVALID_VALUE is generated if size is less
than or equal to 0.

Associated Gets

glGetIntegerv with argument
GL_ALIASED_POINT_SIZE_RANGE

glGetIntegerv with argument
GL_SMOOTH_POINT_SIZE_RANGE

Parameters:

size - Specifies the diameter of rasterized points. The
initial value is 1.

glPointSizex

glPolygonOffset

void glPolygonOffset(float factor,
float units)

Set the scale and units used to calculate depth values.

When GL_POLYGON_OFFSET_FILL is enabled, each
fragment's depth value will be offset after it is interpolated
from the depth values of the appropriate vertices. The value of
the offset is m * factor + r * units, where m is a measurement of
the change in depth relative to the screen area of the polygon,
and r is the smallest value that is guaranteed to produce a
resolvable offset for a given implementation. The offset is added
before the depth test is performed and before the value is
written into the depth buffer.

glPolygonOffset is useful for for applying decals
to surfaces.

Parameters:

factor - Specifies a scale factor that is used to create a
variable depth offset for each polygon. The initial value is 0.

units - Is multiplied by an implementation-specific value to
create a constant depth offset. The initial value is 0.

glPopMatrix

glPushMatrix

void glPushMatrix()

Push the current matrix stack.

There is a stack of matrices for each of the matrix modes. In
GL_MODELVIEW mode, the stack depth is at least
16. In the other modes, GL_PROJECTION, and
GL_TEXTURE, the depth is at least 2. The current
matrix in any mode is the matrix on the top of the stack for that
mode.

glPushMatrix pushes the current matrix stack down
by one, duplicating the current matrix. That is, after a
glPushMatrix call, the matrix on top of the stack is identical to
the one below it.

glPopMatrix pops the current matrix stack,
replacing the current matrix with the one below it on the stack.

Initially, each of the stacks contains one matrix, an identity matrix.

It is an error to push a full matrix stack, or to pop a matrix
stack that contains only a single matrix. In either case, the
error flag is set and no other change is made to GL state.

Notes

Each texture unit has its own texture matrix stack. Use
glActiveTexture to select the desired texture matrix stack.

Errors

GL_STACK_OVERFLOW is generated if
glPushMatrix is called while the current matrix
stack is full.

GL_STACK_UNDERFLOW is generated if
glPopMatrix is called while the current matrix stack
contains only a single matrix.

Associated Gets

glGetIntegerv with argument
GL_MAX_MODELVIEW_STACK_DEPTH

glGetIntegerv with argument
GL_MAX_PROJECTION_STACK_DEPTH

glGetIntegerv with argument
GL_MAX_TEXTURE_STACK_DEPTH

glGetIntegerv with argument
GL_MAX_TEXTURE_UNITS

glReadPixels

glReadPixels returns pixel data from the color
buffer, starting with the pixel whose lower left corner is at
location (x, y), into client memory starting at location
pixels. The processing of the pixel data before it is placed into
client memory can be controlled with glPixelStore.

glReadPixels returns values from each pixel with
lower left corner at (x + i, y + j) for 0 <=
i < width and 0 <= j < height. This
pixel is said to be the ith pixel in the jth row. Pixels are
returned in row order from the lowest to the highest row, left to
right in each row.

format specifies the format of the returned pixel
values. GL_RGBA is always accepted, the value of
GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES may allow
another format:

GL_RGBA

Each color component is converted to floating point such that
zero intensity maps to 0 and full intensity maps to 1.

GL_RGB

Each element is an RGB triple. The GL converts it to floating
point and assembles it into an RGBA element by attaching 1 for
alpha.

GL_LUMINANCE

Each element is a single luminance value. The GL converts it to
floating point and assembles it into an RGBA element by
replicating the luminance value three times for red, green and
blue and attaching 1 for alpha.

GL_LUMINANCE_ALPHA

Each element is a luminance/alpha pair. The GL converts it to
floating point and assembles it into an RGBA element by
replicating the luminance value three times for red, green and
blue.

GL_ALPHA

Each element is a single alpha component. The GL converts it to
floating point and assembles it into an RGBA element by attaching
0 for red, green and blue.

Unneeded data is then discarded. For example,
GL_ALPHA discards the red, green, and blue
components, while GL_RGB discards only the alpha
component. GL_LUMINANCE computes a single-component
value as the sum of the red, green, and blue components, and
GL_LUMINANCE_ALPHA does the same, while keeping
alpha as a second value. The final values are clamped to the
range [0, 1].

Finally, the components are converted to the proper, as specified
by type where each component is multiplied by 2^n - 1, where n is
the number of bits per component.

Return values are placed in memory as follows. If format is
GL_ALPHA, or GL_LUMINANCE, a single
value is returned and the data for the ith pixel in the jth row
is placed in location j * width + i. GL_RGB returns
three values, GL_RGBA returns four values, and
GL_LUMINANCE_ALPHA returns two values for each
pixel, with all values corresponding to a single pixel occupying
contiguous space in pixels. Storage parameter
GL_PACK_ALIGNMENT set by glPixelStore,
affects the way that data is written into memory. See
glPixelStore for a description.

Notes

Values for pixels that lie outside the window connected to the
current GL context are undefined.

If an error is generated, no change is made to the contents of pixels.

Errors

GL_INVALID_ENUM is generated if format is not
GL_RGBA or the value of
GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES.

GL_INVALID_ENUM is generated if type is not
GL_UNSIGNED_BYTE or the value of
GL_IMPLEMENTATION_COLOR_READ_TYPE_OES.

GL_INVALID_VALUE is generated if either width or
height is negative.

GL_INVALID_OPERATION is generated if format and
type are neither (GL_RGBA,
GL_UNSIGNED_BYTE) nor the values of
(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES,
GL_IMPLEMENTATION_COLOR_READ_TYPE_OES).

Associated Gets

glGetIntegerv with argument
GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES

glGetIntegerv with argument
GL_IMPLEMENTATION_COLOR_READ_TYPE_OES

Parameters:

x - Specifies the window x coordinate of the first pixel
that is read from the color buffer. This location is the lower
left corner of a rectangular block of pixels.

y - Specifies the window y coordinate of the first pixel
that is read from the color buffer. This location is the lower
left corner of a rectangular block of pixels.

width - Specifies the width of the pixel
rectangle. width and height of one correspond to a single pixel.

height - Specifies the height of the pixel
rectangle. width and height of one correspond to a single pixel.

format - Specifies the format of the pixel data. Must be
either GL_RGBA or the value of
GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES.

type - Specifies the data type of the pixel data. Must be
either GL_UNSIGNED_BYTE or the value of
GL_IMPLEMENTATION_COLOR_READ_TYPE_OES.

pixels - Returns the pixel data.

Throws:

java.lang.IllegalArgumentException - if pixels is
null.

java.lang.IllegalArgumentException - if pixels does
not contain enough room for the pixel data.

glRotatef

void glRotatef(float angle,
float x,
float y,
float z)

Multiply the current matrix by a rotation matrix.

glRotate produces a rotation of angle degrees
around the vector (x, y, z) . The current matrix (see
glMatrixMode) is multiplied by a rotation matrix with the product
replacing the current matrix, as if glMultMatrix
were called with the following matrix as its argument:

If the matrix mode is either GL_MODELVIEW or
GL_PROJECTION, all objects drawn after
glRotate is called are rotated. Use
glPushMatrix and glPopMatrix to save
and restore the unrotated coordinate system.

Notes

This rotation follows the right-hand rule, so if the vector (x,
y, z) points toward the user, the rotation will be
counterclockwise.

glRotatex

glSampleCoverage

void glSampleCoverage(float value,
boolean invert)

Specify mask to modify multisampled pixel fragments.

glSampleCoverage defines a mask to modify the coverage of
multisampled pixel fragments. This capability is used for
antialiased screen-door transparency and smooth transitions
between two renderings of an object (often for level-of-detail
management in simulation systems).

When multisampling is enabled (see glEnable with
argument GL_MULTISAMPLE) a ``fragment mask'' is
computed for each fragment generated by a primitive. This mask
reflects the amount of the pixel covered by the fragment, and
determines the frame buffer samples that may be affected by the
fragment.

If conversion of alpha values to masks is enabled
(glEnable with argument
GL_SAMPLE_ALPHA_TO_MASK), the fragment alpha value
is used to generate a temporary modification mask which is then
ANDed with the fragment mask. One way to interpret this is as a
form of dithering: a multivalued alpha (coverage or opacity) for
the whole fragment is converted to simple binary values of
coverage at many locations (the samples).

After conversion of alpha values to masks, if replacement of
alpha values is enabled (glEnable with argument
GL_SAMPLE_ALPHA_TO_ONE), the fragment's alpha is set
to the maximum allowable value.

Finally, if fragment mask modification is enabled
(glEnable with argument
GL_SAMPLE_MASK), glSampleCoverage
defines an additional modification mask. value is used to
generate a modification mask in much the same way alpha was used
above. If invert is GL_TRUE, then the modification
mask specified by value will be inverted. The final modification
mask will then be ANDed with the fragment mask resulting from the
previous steps. This can be viewed as an ``override'' control
that selectively fades the effects of multisampled fragments.

Note that glSampleCoverage(value, GL_TRUE) is not
necessarily equivalent to glSampleCoverage(1.0 - value,
GL_FALSE); due to round-off and other issues, complementing
the coverage will not necessarily yield an inverted modification
mask.

Parameters:

value - Specifies the coverage of the modification mask. The
value is clamped to the range [0, 1], where 0
represents no coverage and 1 full coverage. The initial value is
1.

invert - Specifies whether the modification mask implied by
value is inverted or not. The initial value is GL_FALSE.

glScalef

glScale produces a nonuniform scaling along the
x, y, and z axes. The three parameters indicate the desired scale
factor along each of the three axes.

The current matrix (see glMatrixMode) is multiplied by this scale
matrix, and the product replaces the current matrix as if glScale
were called with the following matrix as its argument:

( x 0 0 0 )
( 0 y 0 0 )
( 0 0 z 0 )
( 0 0 0 1 )

If the matrix mode is either GL_MODELVIEW or
GL_PROJECTION, all objects drawn after
glScale is called are scaled.

Use glPushMatrix and glPopMatrix to
save and restore the unscaled coordinate system.

Notes

If scale factors other than 1 are applied to the modelview matrix
and lighting is enabled, lighting often appears wrong. In that
case, enable automatic normalization of normals by calling
glEnable with the argument GL_NORMALIZE.

Parameters:

x - Specifies the scale factor along the x axis.

y - Specifies the scale factor along the y axis.

z - Specifies the scale factor along the z axis.

glScalex

glScissor

void glScissor(int x,
int y,
int width,
int height)

Define the scissor box.

glScissor defines a rectangle, called the scissor
box, in window coordinates. The first two arguments, x and y,
specify the lower left corner of the box. width and height
specify the width and height of the box.

To enable and disable the scissor test, call
glEnable and glDisable with argument
GL_SCISSOR_TEST. The scissor test is initially
disabled. While scissor test is enabled, only pixels that lie
within the scissor box can be modified by drawing
commands. Window coordinates have integer values at the shared
corners of frame buffer pixels. glScissor(0, 0, 1, 1) allows
modification of only the lower left pixel in the window, and
glScissor(0, 0, 0, 0) doesn't allow modification of any pixels in
the window.

When the scissor test is disabled, it is as though the scissor
box includes the entire window.

Errors

GL_INVALID_VALUE is generated if either width or
height is negative.

Parameters:

x - Specifies the x coordinate of the lower left corner
of the scissor box, in pixels. The initial value is 0.

y - Specifies the y coordinate of the lower left corner
of the scissor box, in pixels. The initial value is 0.

width - Specifies the width of the scissor box. When a GL
context is first attached to a surface (e.g. window), width and
height are set to the dimensions of that surface.

height - Specifies the height of the scissor box. When a GL
context is first attached to a surface (e.g. window), width and
height are set to the dimensions of that surface.

glShadeModel

void glShadeModel(int mode)

Select flat or smooth shading.

GL primitives can have either flat or smooth shading. Smooth
shading, the default, causes the computed colors of vertices to
be interpolated as the primitive is rasterized, typically
assigning different colors to each resulting pixel fragment. Flat
shading selects the computed color of just one vertex and assigns
it to all the pixel fragments generated by rasterizing a single
primitive. In either case, the computed color of a vertex is the
result of lighting if lighting is enabled, or it is the current
color at the time the vertex was specified if lighting is
disabled.

Flat and smooth shading are indistinguishable for
points. Starting at the beginning of the vertex array and
counting vertices and primitives from 1, the GL gives each
flat-shaded line segment i the computed color of
vertex i + 1, its second vertex. Counting similarly from 1,
the GL gives each flat-shaded polygon the computed color of
vertex i + 2, which is the last vertex to specify the
polygon.

Flat and smooth shading are specified by
glShadeModel with mode set to GL_FLAT
and GL_SMOOTH, respectively.

Errors

GL_INVALID_ENUM is generated if mode is any value
other than GL_FLAT or GL_SMOOTH.

glStencilFunc

void glStencilFunc(int func,
int ref,
int mask)

Set function and reference value for stencil testing.

Stenciling, like depth-buffering, enables and disables drawing on
a per-pixel basis. You draw into the stencil planes using GL
drawing primitives, then render geometry and images, using the
stencil planes to mask out portions of the screen. Stenciling is
typically used in multipass rendering algorithms to achieve
special effects, such as decals, outlining, and constructive
solid geometry rendering.

The stencil test conditionally eliminates a pixel based on the
outcome of a comparison between the reference value and the value
in the stencil buffer. To enable and disable stencil test, call
glEnable and glDisable with argument
GL_STENCIL_TEST. Stencil test is initially
disabled. To specify actions based on the outcome of the stencil
test, call glStencilOp.

func is a symbolic constant that determines the
stencil comparison function. It accepts one of eight values,
shown in the following list. ref is an integer
reference value that is used in the stencil comparison. It is
clamped to the range [0, 2^n - 1], where n is
the number of bitplanes in the stencil buffer. mask
is bitwise ANDed with both the reference value and the stored
stencil value, with the ANDed values participating in the
comparison.

If stencil represents the value stored in the
corresponding stencil buffer location, the following list shows
the effect of each comparison function that can be specified by
func. Only if the comparison succeeds is the pixel passed through
to the next stage in the rasterization process (see
glStencilOp). All tests treat stencil values as unsigned integers
in the range [0, 2^n - 1], where n is the
number of bitplanes in the stencil buffer.

The following values are accepted by func:

GL_NEVER

Always fails.

GL_LESS

Passes if (ref & mask) < (stencil & mask) .

GL_LEQUAL

Passes if (ref & mask) <= (stencil & mask) .

GL_GREATER

Passes if (ref & mask) > (stencil & mask) .

GL_GEQUAL

Passes if (ref & mask) >= (stencil & mask) .

GL_EQUAL

Passes if (ref & mask) == (stencil & mask) .

GL_NOTEQUAL

Passes if (ref & mask) != (stencil & mask) .

GL_ALWAYS

Always passes.

Notes

Initially, the stencil test is disabled. If there is no stencil
buffer, no stencil modification can occur and it is as if the
stencil test always passes.

Errors

GL_INVALID_ENUM is generated if func is not one
of the eight accepted values.

ref - Specifies the reference value for the stencil
test. ref is clamped to the range [0, 2^n -
1], where n is the number of bitplanes in the
stencil buffer. The initial value is 0.

mask - Specifies a mask that is ANDed with both the
reference value and the stored stencil value when the test is
done. The initial value is all 1's.

glStencilMask

void glStencilMask(int mask)

Control the writing of individual bits in the stencil planes.

glStencilMask controls the writing of individual
bits in the stencil planes. The least significant n bits of mask,
where n is the number of bits in the stencil buffer, specify a
mask. Where a 1 appears in the mask, it's possible to write to
the corresponding bit in the stencil buffer. Where a 0 appears,
the corresponding bit is write-protected. Initially, all bits are
enabled for writing.

Associated Gets

glGetIntegerv with argument GL_STENCIL_BITS

Parameters:

mask - Specifies a bit mask to enable and disable writing of
individual bits in the stencil planes. The initial value is all
1's.

glStencilOp

void glStencilOp(int fail,
int zfail,
int zpass)

Set stencil test actions.

Stenciling, like depth-buffering, enables and disables drawing on
a per-pixel basis. You draw into the stencil planes using GL
drawing primitives, then render geometry and images, using the
stencil planes to mask out portions of the screen. Stenciling is
typically used in multipass rendering algorithms to achieve
special effects, such as decals, outlining, and constructive
solid geometry rendering.

The stencil test conditionally eliminates a pixel based on the
outcome of a comparison between the value in the stencil buffer
and a reference value. To enable and disable stencil test, call
glEnable and glDisable with argument
GL_STENCIL_TEST. To control it, call
glStencilFunc. Stenciling is initially disabled.

glStencilOp takes three arguments that indicate
what happens to the stored stencil value while stenciling is
enabled. If the stencil test fails, no change is made to the
pixel's color or depth buffers, and fail specifies what happens
to the stencil buffer contents. The following six actions are
possible.

GL_KEEP

Keeps the current value.

GL_ZERO

Sets the stencil buffer value to 0.

GL_REPLACE

Sets the stencil buffer value to ref, as specified by
glStencilFunc.

GL_INCR

Increments the current stencil buffer value. Clamps to the
maximum representable unsigned value.

Decrements the current stencil buffer value, wrapping around
to the maximum representable unsigned value if less than 0.

(OES_stencil_wrap extension)
GL_INCR

Increments the current stencil buffer value, wrapping around
to 0 if greater than the maximum representable unsigned value.
-->

Stencil buffer values are treated as unsigned integers. When
incremented and decremented, values are clamped to 0 and 2^n - 1,
where n is the value returned by querying GL_STENCIL_BITS.

The other two arguments to glStencilOp specify
stencil buffer actions that depend on whether subsequent depth
buffer tests succeed (zpass) or fail
(zfail) (see glDepthFunc). The actions
are specified using the same six symbolic constants as
fail. Note that zfail is ignored when
there is no depth buffer, or when the depth buffer is not
enabled. In these cases, fail and zpass
specify stencil action when the stencil test fails and passes,
respectively.

Notes

If there is no stencil buffer, no stencil modification can occur
and it is as if the stencil tests always pass, regardless of any
call to glStencilOp.

Errors

GL_INVALID_ENUM is generated if fail, zfail, or
zpass is any value other than the six defined constant values.

Associated Gets

glGetIntegerv with argument GL_STENCIL_BITS

Parameters:

fail - Specifies the action to take when the stencil test
fails. Six symbolic constants are accepted: GL_KEEP,
GL_ZERO, GL_REPLACE,
GL_INCR, GL_DECR, and
GL_INVERT . The initial value is GL_KEEP.

zfail - Specifies the stencil action when the stencil test
passes, but the depth test fails. zfail accepts the
same symbolic constants as fail. The initial value
is GL_KEEP.

zpass - Specifies the stencil action when both the stencil
test and the depth test pass, or when the stencil test passes and
either there is no depth buffer or depth testing is not
enabled. zpass accepts the same symbolic constants
as fail. The initial value is GL_KEEP.

glTexCoordPointer

glTexCoordPointer specifies the location and data
of an array of texture coordinates to use when rendering. size
specifies the number of coordinates per element, and must be 2,
3, or 4. type specifies the data type of each texture coordinate
and stride specifies the byte stride from one array element to
the next allowing vertices and attributes to be packed into a
single array or stored in separate arrays. (Single-array storage
may be more efficient on some implementations.)

When a texture coordinate array is specified, size, type, stride,
and pointer are saved as client-side state.

If the texture coordinate array is enabled, it is used when
glDrawArrays, or glDrawElements is
called. To enable and disable the texture coordinate array for
the client-side active texture unit, call
glEnableClientState and
glDisableClientState with the argument
GL_TEXTURE_COORD_ARRAY. The texture coordinate array
is initially disabled for all client-side active texture units
and isn't accessed when glDrawArrays or
glDrawElements is called.

Use glDrawArrays to construct a sequence of
primitives (all of the same type) from prespecified vertex and
vertex attribute arrays. Use glDrawElements to
construct a sequence of primitives by indexing vertices and
vertex attributes.

Notes

glTexCoordPointer is typically implemented on the
client side.

glTexCoordPointer updates the texture coordinate
array state of the client-side active texture unit, specified
with glClientActiveTexture.

Errors

GL_INVALID_VALUE is generated if size is not 2, 3, or 4.

GL_INVALID_ENUM is generated if type is not an
accepted value.

GL_INVALID_VALUE is generated if stride is negative.

The pointer argument must be a direct buffer
with a type matching that specified by the type
argument.

Parameters:

size - Specifies the number of coordinates per array
element. Must be 2, 3 or 4. The initial value is 4.

stride - Specifies the byte offset between consecutive array
elements. If stride is 0, the array elements are understood to be
tightly packed. The initial value is 0.

pointer - Specifies a pointer to the first coordinate of the
first element in the array. The initial value is 0.

Throws:

java.lang.IllegalStateException - if OpenGL ES 1.1 is being used and
VBOs are enabled.

java.lang.IllegalArgumentException - if pointer is
null or is not direct.

glTexEnvf

void glTexEnvf(int target,
int pname,
float param)

Set texture environment parameters.

If target is GL_TEXTURE_ENV, then
the following applies:

A texture environment specifies how texture values are
interpreted when a fragment is textured. target must
be GL_TEXTURE_ENV. pname can be either
GL_TEXTURE_ENV_MODE or
GL_TEXTURE_ENV_COLOR.

If pname is GL_TEXTURE_ENV_MODE,
then params contains the symbolic name of a texture
function. Four texture functions may be specified:
GL_MODULATE, GL_DECAL,
GL_BLEND, and GL_REPLACE.

A texture function acts on the fragment to be textured using
the texture image value that applies to the fragment (see
glTexParameter) and produces an RGBA color for that
fragment. The following table shows how the RGBA color is
produced for each of the three texture functions that can be
chosen. C is a triple of color values (RGB) and A
is the associated alpha value. RGBA values extracted from a
texture image are in the range [0, 1]. The subscript
f refers to the incoming fragment, the subscript t
to the texture image, the subscript c to the texture
environment color, and subscript v indicates a value
produced by the texture function.

A texture image can have up to four components per texture
element (see glTexImage2D, and
glCopyTexImage2D). In a one-component image,
Lt indicates that single component. A two-component image
uses Lt and At. A three-component image has only a
color value, Ct. A four-component image has both a color
value Ct and an alpha value At.

If pname is GL_TEXTURE_ENV_COLOR,
params is a pointer to an array that holds an RGBA
color consisting of four values. The values are clamped to the
range [0, 1] when they are specified. Cc
takes these four values.

The initial value of GL_TEXTURE_ENV_MODE is
GL_MODULATE. The initial value of
GL_TEXTURE_ENV_COLOR is (0, 0, 0, 0).

1.1 Notes

If the value of GL_TEXTURE_ENV_MODE is
GL_COMBINE, then the form of the texture function
depends on the values of GL_COMBINE_RGB and
GL_COMBINE_ALPHA.

The RGB and ALPHA results of the texture function are then
multiplied by the values of GL_RGB_SCALE and
GL_ALPHA_SCALE, respectively.

The results are clamped to [0, 1].

The arguments Arg0, Arg1, Arg2 are
determined by the values of
GL_SRCn_RGB,
GL_SRCn_ALPHA,
GL_OPERANDn_RGB,
GL_OPERANDn_ALPHA, where
n = 0, 1, or 2, Cs and As denote the texture
source color and alpha from the texture image bound to texture
unit n.

The state required for the current texture environment, for
each texture unit, consists of a six-valued integer indicating
the texture function, an eight-valued integer indicating the RGB
combiner function and a six-valued integer indicating the ALPHA
combiner function, six four-valued integers indicating the
combiner RGB and ALPHA source arguments, three four-valued
integers indicating the combiner RGB operands, three two-valued
integers indicating the combiner ALPHA operands, and four
floating-point environment color values. In the initial state,
the texture and combiner functions are each
GL_MODULATE, the combiner RGB and ALPHA sources are
each GL_TEXTURE, GL_PREVIOUS, and
GL_CONSTANT for sources 0, 1, and 2 respectively,
the combiner RGB operands for sources 0 and 1 are each
SRC_COLOR, the combiner RGB operand for source 2, as
well as for the combiner ALPHA operands, are each
GL_SRC_ALPHA, and the environment color is (0, 0, 0,
0).

The state required for the texture filtering parameters, for
each texture unit, consists of a single floating-point level of
detail bias. The initial value of the bias is 0.0.

If pname is GL_TEXTURE_ENV_COLOR,
then params is an array that holds an RGBA color
consisting of four values. The values are clamped to the range
[0, 1] when they are specified. Cc takes
these four values.

The initial value of GL_TEXTURE_ENV_MODE is
GL_MODULATE. The initial value of
GL_TEXTURE_ENV_COLOR is (0, 0, 0, 0).

If target is GL_POINT_SPRITE_OES
then the following applies:

If pname is GL_COORD_REPLACE_OES,
then the point sprite texture coordinate replacement mode is set
from the value given by param, which may either be
GL_FALSE or GL_TRUE. The default value
for each texture unit is for point sprite texture coordinate
replacement to be disabled.

Errors

GL_INVALID_ENUM is generated when target or pname
is not one of the accepted values, or when params
should have a defined constant value (based on the value of
pname) and does not.

Associated Gets (1.1 only)

glGetTexEnv

Parameters:

target - Specifies a texture environment. Can be either
GL_TEXTURE_ENV or GL_POINT_SPRITE_OES
(OES_point_sprite extension).

pname - Specifies the symbolic name of a single-valued
texture environment parameter. Must be one of
GL_TEXTURE_ENV_MODE,
GL_TEXTURE_ENV_COLOR (1.1 only),
GL_COMBINE_RGB (1.1 only),
GL_COMBINE_ALPHA (1.1 only), or
GL_COORD_REPLACE_OES (OES_point_sprite
extension).

glTexEnvfv

A texture environment specifies how texture values are
interpreted when a fragment is textured. target must
be GL_TEXTURE_ENV. pname can be either
GL_TEXTURE_ENV_MODE or
GL_TEXTURE_ENV_COLOR.

If pname is GL_TEXTURE_ENV_MODE,
then params contains the symbolic name of a texture
function. Four texture functions may be specified:
GL_MODULATE, GL_DECAL,
GL_BLEND, and GL_REPLACE.

A texture function acts on the fragment to be textured using
the texture image value that applies to the fragment (see
glTexParameter) and produces an RGBA color for that
fragment. The following table shows how the RGBA color is
produced for each of the three texture functions that can be
chosen. C is a triple of color values (RGB) and A is the
associated alpha value. RGBA values extracted from a texture
image are in the range [0, 1]. The subscript
f refers to the incoming fragment, the subscript t
to the texture image, the subscript c to the texture
environment color, and subscript v indicates a value
produced by the texture function.

A texture image can have up to four components per texture
element (see glTexImage2D, and
glCopyTexImage2D). In a one-component image,
Lt indicates that single component. A two-component image
uses Lt and At. A three-component image has only a
color value, Ct. A four-component image has both a color
value Ct and an alpha value At.

glTexImage2D

Texturing maps a portion of a specified texture image onto
each graphical primitive for which texturing is enabled. To
enable and disable two-dimensional texturing, call
glEnable and glDisable with argument
GL_TEXTURE_2D. Two-dimensional texturing is
initially disabled.

To define texture images, call glTexImage2D. The arguments
describe the parameters of the texture image, such as height,
width, width of the border, level-of-detail number (see
glTexParameter), and number of color components provided. The
last three arguments describe how the image is represented in
memory.

Data is read from pixels as a sequence of unsigned bytes or
shorts, depending on type. These values are grouped into sets of
one, two, three, or four values, depending on format, to form
elements.

When type is GL_UNSIGNED_BYTE, each of these
bytes is interpreted as one color component, depending on
format. When type is one of GL_UNSIGNED_SHORT_5_6_5,
GL_UNSIGNED_SHORT_4_4_4_4,
GL_UNSIGNED_SHORT_5_5_5_1, each unsigned value is
interpreted as containing all the components for a single pixel,
with the color components arranged according to format.

The first element corresponds to the lower left corner of the
texture image. Subsequent elements progress left-to-right through
the remaining texels in the lowest row of the texture image, and
then in successively higher rows of the texture image. The final
element corresponds to the upper right corner of the texture
image.

By default, adjacent pixels are taken from adjacent memory
locations, except that after all width pixels are read, the read
pointer is advanced to the next four-byte boundary. The four-byte
row alignment is specified by glPixelStore with argument
GL_UNPACK_ALIGNMENT, and it can be set to one, two, four, or
eight bytes.

format determines the composition of each element in pixels. It
can assume one of the following symbolic values:

GL_ALPHA

Each element is a single alpha component. The GL converts it to
floating point and assembles it into an RGBA element by attaching
0 for red, green, and blue.

GL_RGB

Each element is an RGB triple. The GL converts it to fixed-point
or floating-point and assembles it into an RGBA element by
attaching 1 for alpha.

GL_RGBA

Each element contains all four components. The GL converts it to
fixed-point or floating-point.

GL_LUMINANCE

Each element is a single luminance value. The GL converts it to
fixed-point or floating-point, then assembles it into an RGBA
element by replicating the luminance value three times for red,
green, and blue and attaching 1 for alpha.

GL_LUMINANCE_ALPHA

Each element is a luminance/alpha pair. The GL converts it to
fixed-point or floating point, then assembles it into an RGBA
element by replicating the luminance value three times for red,
green, and blue.

Notes

pixels may be NULL. In this case texture memory is allocated to
accommodate a texture of width width and height height. You can
then download subtextures to initialize this texture memory. The
image is undefined if the user tries to apply an uninitialized
portion of the texture image to a primitive.

glTexImage2D specifies the two-dimensional texture for the
currently bound texture specified with glBindTexture, and the
current texture unit, specified with glActiveTexture.

Errors

GL_INVALID_ENUM is generated if target is not
GL_TEXTURE_2D.

GL_INVALID_ENUM is generated if format is not an
accepted constant.

GL_INVALID_ENUM is generated if type is not a
type constant.

GL_INVALID_VALUE is generated if level is less
than 0.

GL_INVALID_VALUE may be generated if level is
greater than log2max, where max is the returned value of
GL_MAX_TEXTURE_SIZE.

GL_INVALID_VALUE is generated if internalformat
is not an accepted constant.

GL_INVALID_VALUE is generated if width or height
is less than 0 or greater than GL_MAX_TEXTURE_SIZE,
or if either cannot be represented as 2^k + 2*border for some
integer k.

GL_INVALID_VALUE is generated if border is not 0.

GL_INVALID_OPERATION is generated if
internalformat and format are not the same.

GL_INVALID_OPERATION is generated if type is
GL_UNSIGNED_SHORT_5_6_5 and format is not
GL_RGB.

GL_INVALID_OPERATION is generated if typeis one
of GL_UNSIGNED_SHORT_4_4_4_4, or
GL_UNSIGNED_SHORT_5_5_5_1 and formatis not
GL_RGBA.

internalformat - Specifies the color components in the
texture. Must be same as format. The following symbolic values
are accepted: GL_ALPHA, GL_RGB,
GL_RGBA, GL_LUMINANCE, or
GL_LUMINANCE_ALPHA.

width - Specifies the width of the texture image. Must be
2^n + 2*border for some integer n. All implementations support
texture images that are at least 64 texels wide.

height - Specifies the height of the texture image. Must be
2^m + 2*border for some integer m. All implementations support
texture images that are at least 64 texels high.

border - Specifies the width of the border. Must be 0.

format - Specifies the format of the pixel data. Must be
same as internalformat. The following symbolic values are
accepted: GL_ALPHA, GL_RGB,
GL_RGBA, GL_LUMINANCE, and
GL_LUMINANCE_ALPHA.

type - Specifies the data type of the pixel data. The
following symbolic values are accepted:
GL_UNSIGNED_BYTE,
GL_UNSIGNED_SHORT_5_6_5,
GL_UNSIGNED_SHORT_4_4_4_4, and
GL_UNSIGNED_SHORT_5_5_5_1.

pixels - Specifies a pointer to the image data in memory.

Throws:

java.lang.IllegalArgumentException - if pixels is
null.

java.lang.IllegalArgumentException - if pixels does
not contain the desired number of pixels.

glTexParameterf

void glTexParameterf(int target,
int pname,
float param)

Set texture parameters.

Texture mapping is a technique that applies an image onto an
object's surface as if the image were a decal or cellophane
shrink-wrap. The image is created in texture space, with an (s,
t) coordinate system. A texture is a one- or two-dimensional
image and a set of parameters that determine how samples are
derived from the image.

glTexParameter assigns the value or values in
param to the texture parameter specified as
pname. target defines the target
texture, which must be GL_TEXTURE_2D. The following
symbols are accepted in pname:

GL_TEXTURE_MIN_FILTER

The texture minifying function is used whenever the pixel being
textured maps to an area greater than one texture element. There
are six defined minifying functions. Two of them use the nearest
one or nearest four texture elements to compute the texture
value. The other four use mipmaps.

A mipmap is an ordered set of arrays representing the same image
at progressively lower resolutions. If the texture has dimensions
2^n × 2^m, there are max (n, m) + 1 mipmaps. The first mipmap is
the original texture, with dimensions 2^n × 2^m. Each subsequent
mipmap has dimensions 2^(k - 1) × 2^(l - 1), where 2^k × 2^l are
the dimensions of the previous mipmap, until either k = 0 or l =
0. At that point, subsequent mipmaps have dimension 1 × 2^(l - 1)
or 2^(k - 1) × 1 until the final mipmap, which has dimension 1 ×
1. To define the mipmaps, call glTexImage2D or
glCopyTexImage2D with the level argument indicating the order of
the mipmaps. Level 0 is the original texture. Level max (n, m) is
the final 1 × 1 mipmap.

param supplies a function for minifying the
texture as one of the following:

GL_NEAREST

Returns the value of the texture element that is nearest (in
Manhattan distance) to the center of the pixel being textured.

GL_LINEAR

Returns the weighted average of the four texture elements that
are closest to the center of the pixel being textured. These can
include border texture elements, depending on the values of
GL_TEXTURE_WRAP_S and
GL_TEXTURE_WRAP_T, and on the exact mapping.

GL_NEAREST_MIPMAP_NEAREST

Chooses the mipmap that most closely matches the size of the
pixel being textured and uses the GL_NEAREST
criterion (the texture element nearest to the center of the
pixel) to produce a texture value.

GL_LINEAR_MIPMAP_NEAREST

Chooses the mipmap that most closely matches the size of the
pixel being textured and uses the GL_LINEAR
criterion (a weighted average of the four texture elements that
are closest to the center of the pixel) to produce a texture
value.

GL_NEAREST_MIPMAP_LINEAR

Chooses the two mipmaps that most closely match the size of the
pixel being textured and uses the GL_NEAREST criterion (the
texture element nearest to the center of the pixel) to produce a
texture value from each mipmap. The final texture value is a
weighted average of those two values.

GL_LINEAR_MIPMAP_LINEAR

Chooses the two mipmaps that most closely match the size of the
pixel being textured and uses the GL_LINEAR
criterion (a weighted average of the four texture elements that
are closest to the center of the pixel) to produce a texture
value from each mipmap. The final texture value is a weighted
average of those two values.

As more texture elements are sampled in the minification process,
fewer aliasing artifacts will be apparent. While the
GL_NEAREST and GL_LINEAR minification
functions can be faster than the other four, they sample only one
or four texture elements to determine the texture value of the
pixel being rendered and can produce moire patterns or ragged
transitions.

The initial value of GL_TEXTURE_MIN_FILTER is
GL_NEAREST_MIPMAP_LINEAR.

GL_TEXTURE_MAG_FILTER

The texture magnification function is used when the pixel being
textured maps to an area less than or equal to one texture
element. It sets the texture magnification function to either
GL_NEAREST or GL_LINEAR (see
below). GL_NEAREST is generally faster than
GL_LINEAR, but it can produce textured images with
sharper edges because the transition between texture elements is
not as smooth.

The initial value of GL_TEXTURE_MAG_FILTER is
GL_LINEAR.

GL_NEAREST

Returns the value of the texture element that is nearest (in
Manhattan distance) to the center of the pixel being textured.

GL_LINEAR

Returns the weighted average of the four texture elements that
are closest to the center of the pixel being textured. These can
include border texture elements, depending on the values of
GL_TEXTURE_WRAP_S and
GL_TEXTURE_WRAP_T, and on the exact mapping.

GL_TEXTURE_WRAP_S

Sets the wrap parameter for texture coordinate s to
either GL_CLAMP, GL_CLAMP_TO_EDGE, or
GL_REPEAT . GL_CLAMP causes s coordinates to
be clamped to the range [0, 1] and is useful for
preventing wrapping artifacts when mapping a single image onto an
object. GL_CLAMP_TO_EDGE causes s coordinates
to be clamped to the range [1/(2N), 1 -
1/(2N)], where N is the size of the texture
in the direction of clamping. GL_REPEAT causes the
integer part of the s coordinate to be ignored; the GL
uses only the fractional part, thereby creating a repeating
pattern. Border texture elements are accessed only if wrapping is
set to GL_CLAMP.

Initially, GL_TEXTURE_WRAP_S is set to
GL_REPEAT.

GL_TEXTURE_WRAP_T

Sets the wrap parameter for texture coordinate t to
either GL_CLAMP, GL_CLAMP_TO_EDGE, or
GL_REPEAT . See the
discussion under GL_TEXTURE_WRAP_S.

Initially, GL_TEXTURE_WRAP_T is set to
GL_REPEAT.

GL_GENERATE_MIPMAP (1.1 only)

Sets the automatic mipmap generation parameter. If set to
GL_TRUE, making any change to the interior or border
texels of the levelbase array of a mipmap will also compute a
complete set of mipmap arrays derived from the modified levelbase
array. Array levels levelbase + 1 through p are
replaced with the derived arrays, regardless of their previous
contents. All other mipmap arrays, including the levelbase array,
are left unchanged by this computation.

The initial value of GL_GENERATE_MIPMAP is
GL_FALSE.

Notes

Suppose that a program has enabled texturing (by calling
glEnable with argument GL_TEXTURE_2D and has set
GL_TEXTURE_MIN_FILTER to one of the functions that
requires a mipmap. If either the dimensions of the texture images
currently defined (with previous calls to
glTexImage2D, or glCopyTexImage2D) do not follow the
proper sequence for mipmaps (described above), or there are fewer
texture images defined than are needed, or the set of texture
images have differing numbers of texture components, then it is
as if texture mapping were disabled.

Errors

GL_INVALID_ENUM is generated if target or pname
is not one of the accepted defined values.

GL_INVALID_ENUM is generated if param should have
a defined constant value (based on the value of pname) and does
not.

Parameters:

target - Specifies the target texture, which must be
GL_TEXTURE_2D.

pname - Specifies the symbolic name of a single-valued
texture parameter. pname can be one of the
following: GL_TEXTURE_MIN_FILTER,
GL_TEXTURE_MAG_FILTER,
GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, or
GL_GENERATE_MIPMAP (1.1 only) .

glTexSubImage2D

Texturing maps a portion of a specified texture image onto
each graphical primitive for which texturing is enabled. To
enable and disable two-dimensional texturing, call
glEnable and glDisable with argument
GL_TEXTURE_2D. Two-dimensional texturing is
initially disabled.

glTexSubImage2D redefines a contiguous subregion
of an existing two-dimensional texture image. The texels
referenced by pixels replace the portion of the existing texture
array with x indices xoffset and xoffset + width - 1, inclusive,
and y indices yoffset and yoffset + height - 1, inclusive. This
region may not include any texels outside the range of the
texture array as it was originally specified. It is not an error
to specify a subtexture with zero width or height, but such a
specification has no effect.

Notes

glPixelStore affects texture images in exactly
the way it affects glTexImage2D.

glTexSubImage2D specifies a two-dimensional sub
texture for the currently bound texture, specified with
glBindTexture and current texture unit, specified
with glActiveTexture.

Errors

GL_INVALID_ENUM is generated if target is not
GL_TEXTURE_2D.

GL_INVALID_OPERATION is generated if the texture
array has not been defined by a previous
glTexImage2D or glCopyTexImage2D operation.

GL_INVALID_VALUE is generated if level is less
than 0.

GL_INVALID_VALUE may be generated if level is
greater than log2max, where max is the returned value of
GL_MAX_TEXTURE_SIZE.

xoffset - Specifies a texel offset in the x direction within
the texture array.

yoffset - Specifies a texel offset in the y direction within
the texture array.

width - Specifies the width of the texture subimage.

height - Specifies the height of the texture subimage.

format - Specifies the of the pixel data. The following
symbolic values are accepted: GL_ALPHA,
GL_RGB, GL_RGBA,
GL_LUMINANCE, and GL_LUMINANCE_ALPHA.

type - Specifies the data type of the pixel data. The
following symbolic values are accepted:
GL_UNSIGNED_BYTE,
GL_UNSIGNED_SHORT_5_6_5,
GL_UNSIGNED_SHORT_4_4_4_4, and
GL_UNSIGNED_SHORT_5_5_5_1.

pixels - Specifies the image data.

Throws:

java.lang.IllegalArgumentException - if pixels is
null.

java.lang.IllegalArgumentException - if pixels does
not contain the desired number of pixels.

glTranslatef

void glTranslatef(float x,
float y,
float z)

Multiply the current matrix by a translation matrix.

glTranslate produces a translation by (x, y, z).
The current matrix (see glMatrixMode) is multiplied by this
translation matrix, with the product replacing the current
matrix, as if glMultMatrix were called with the
following matrix for its argument:

( 1 0 0 x )
( 0 1 0 y )
( 0 0 1 z )
( 0 0 0 1 )

If the matrix mode is either GL_MODELVIEW or
GL_PROJECTION, all objects drawn after a call to
glTranslate are translated.

Use glPushMatrix and glPopMatrix to
save and restore the untranslated coordinate system.

glVertexPointer

glVertexPointer specifies the location and data
of an array of vertex coordinates to use when
rendering. size specifies the number of coordinates
per vertex and type the data type of the
coordinates. stride specifies the byte stride from
one vertex to the next allowing vertices and attributes to be
packed into a single array or stored in separate
arrays. (Single-array storage may be more efficient on some
implementations.)

When a vertex array is specified, size,
type, stride, and pointer
are saved as client-side state.

If the vertex array is enabled, it is used when
glDrawArrays, or glDrawElements is
called. To enable and disable the vertex array, call
glEnableClientState and
glDisableClientState with the argument
GL_VERTEX_ARRAY. The vertex array is initially
disabled and isn't accessed when glDrawArrays or
glDrawElements is called.

Use glDrawArrays to construct a sequence of
primitives (all of the same type) from prespecified vertex and
vertex attribute arrays. Use glDrawElements to
construct a sequence of primitives by indexing vertices and
vertex attributes.

Notes

glVertexPointer is typically implemented on the
client side.

Errors

GL_INVALID_VALUE is generated if size is not 2,
3, or 4.

GL_INVALID_ENUM is generated if type is is not an
accepted value.

GL_INVALID_VALUE is generated if stride is
negative.

The pointer argument must be a direct buffer
with a type matching that specified by the type
argument.

Parameters:

size - Specifies the number of coordinates per vertex. Must
be 2, 3, or 4. The initial value is 4.

type - Specifies the data type of each vertex coordinate in
the array. Symbolic constants GL_BYTE,
GL_SHORT, GL_FIXED, and
GL_FLOAT are accepted. The initial value is
GL_FLOAT.

stride - Specifies the byte offset between consecutive
vertices. If stride is 0, the vertices are understood to be
tightly packed in the array. The initial value is 0.

pointer - Specifies a Buffer containing the coordinates of
the vertices.

Throws:

java.lang.IllegalStateException - if OpenGL ES 1.1 is being used and
VBOs are enabled.

java.lang.IllegalArgumentException - if pointer
is not direct.

glViewport

void glViewport(int x,
int y,
int width,
int height)

Set the viewport.

glViewport specifies the affine transformation of
x and y from normalized device coordinates to window
coordinates. Let (xnd, ynd) be normalized device
coordinates. Then the window coordinates (xw, yw) are computed as
follows:

xw = ( xnd + 1 ) width/2 + x
yw = ( ynd + 1 ) height/2 + y

Viewport width and height are silently clamped to a range that
depends on the implementation. To query this range, call
glGetIntegerv with argument
GL_MAX_VIEWPORT_DIMS.

Errors

GL_INVALID_VALUE is generated if either width or
height is negative.

Associated Gets

glGetIntegerv with argument
GL_MAX_VIEWPORT_DIMS

Parameters:

x - Specifies the x coordinate of the lower left corner of
the viewport rectangle, in pixels. The initial value is 0.

y - Specifies the y coordinate of the lower left corner of
the viewport rectangle, in pixels. The initial value is 0.

width - Specifies the width of the viewport. When a GL
context is first attached to a surface (e.g. window), width and
height are set to the dimensions of that surface.

height - Specifies the height of the viewport. When a GL
context is first attached to a surface (e.g. window), width and
height are set to the dimensions of that surface.

Use is subject to License Terms. Your use of this web site or any of its contents or software indicates your agreement to be bound by these License Terms.

A script enabled browser is required for this page to function properly.A script enabled browser is required for this page to function properly.A script enabled browser is required for this page to function properly.