gl
(wx)Standard OpenGL api.
Standard OpenGL api.
See
Booleans are represented by integers 0 and 1.
Types
clamp() = float()
enum() = integer() >= 0
matrix() =
{float(),
float(),
float(),
float(),
float(),
float(),
float(),
float(),
float(),
float(),
float(),
float(),
float(),
float(),
float(),
float()}
mem() = binary() | tuple()
offset() = integer() >= 0
Functions
clearIndex(C) -> ok
C = float()
Specify the clear value for the color index buffers
gl:clearIndex
specifies the index used by gl:clear/1 to clear the color index
buffers. C
is not clamped. Rather, C
is converted to a fixed-point value
with unspecified precision to the right of the binary point. The integer part of this
value is then masked with 2 m-1, where m is the number of bits in a color index stored
in the frame buffer.
See
clearColor(Red, Green, Blue, Alpha) -> ok
Red = clamp()
Green = clamp()
Blue = clamp()
Alpha = clamp()
Specify clear values for the color buffers
gl:clearColor
specifies the red, green, blue, and alpha values used by gl:clear/1
to clear the color buffers. Values specified by gl:clearColor
are clamped to the
range [0 1].
See
clear(Mask) -> ok
Mask = integer()
Clear buffers to preset values
gl:clear
sets the bitplane area of the window to values previously selected by gl:clearColor
, gl:clearDepth
, and gl:clearStencil
. Multiple color buffers can be cleared
simultaneously by selecting more than one buffer at a time using gl:drawBuffer/1 .
The pixel ownership test, the scissor test, dithering, and the buffer writemasks affect
the operation of gl:clear
. The scissor box bounds the cleared region. Alpha function,
blend function, logical operation, stenciling, texture mapping, and depth-buffering are
ignored by gl:clear
.
gl:clear
takes a single argument that is the bitwise OR of several values indicating
which buffer is to be cleared.
The values are as follows:
?GL_COLOR_BUFFER_BIT
: Indicates the buffers currently enabled for color writing.
?GL_DEPTH_BUFFER_BIT
: Indicates the depth buffer.
?GL_STENCIL_BUFFER_BIT
: Indicates the stencil buffer.
The value to which each buffer is cleared depends on the setting of the clear value for that buffer.
See
indexMask(Mask) -> ok
Mask = integer()
Control the writing of individual bits in the color index buffers
gl:indexMask
controls the writing of individual bits in the color index buffers.
The least significant n bits of Mask
, where n is the number of bits in a color
index buffer, specify a mask. Where a 1 (one) appears in the mask, it's possible to write
to the corresponding bit in the color index buffer (or buffers). Where a 0 (zero) appears,
the corresponding bit is write-protected.
This mask is used only in color index mode, and it affects only the buffers currently selected for writing (see gl:drawBuffer/1 ). Initially, all bits are enabled for writing.
See
colorMask(Red, Green, Blue, Alpha) -> ok
Red = 0 | 1
Green = 0 | 1
Blue = 0 | 1
Alpha = 0 | 1
Enable and disable writing of frame buffer color components
gl:colorMask
and gl:colorMaski
specify whether the individual color components
in the frame buffer can or cannot be written. gl:colorMaski
sets the mask for a
specific draw buffer, whereas gl:colorMask
sets the mask for all draw buffers. If Red
is ?GL_FALSE
, for example, no change is made to the red component of any pixel
in any of the color buffers, regardless of the drawing operation attempted.
Changes to individual bits of components cannot be controlled. Rather, changes are either enabled or disabled for entire color components.
See
alphaFunc(Func, Ref) -> ok
Func = enum()
Ref = clamp()
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. gl:alphaFunc
specifies
the reference value and the comparison function. The comparison is performed only if alpha
testing is enabled. By default, it is not enabled. (See gl:enable/1 and gl:enable/1
of ?GL_ALPHA_TEST
.)
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).
gl:alphaFunc
operates on all pixel write operations, including those resulting from
the scan conversion of points, lines, polygons, and bitmaps, and from pixel draw and copy
operations. gl:alphaFunc
does not affect screen clear operations.
See
blendFunc(Sfactor, Dfactor) -> ok
Sfactor = enum()
Dfactor = enum()
Specify pixel arithmetic
Pixels can be drawn using a function that blends the incoming (source) RGBA values with
the RGBA values that are already in the frame buffer (the destination values). Blending
is initially disabled. Use gl:enable/1 and gl:enable/1 with argument ?GL_BLEND
to enable and disable blending.
gl:blendFunc
defines the operation of blending for all draw buffers when it is enabled.
gl:blendFunci
defines the operation of blending for a single draw buffer specified
by Buf
when enabled for that draw buffer. Sfactor
specifies which method
is used to scale the source color components. Dfactor
specifies which method is
used to scale the destination color components. Both parameters must be one of the following
symbolic constants: ?GL_ZERO
, ?GL_ONE
, ?GL_SRC_COLOR
, ?GL_ONE_MINUS_SRC_COLOR
, ?GL_DST_COLOR
, ?GL_ONE_MINUS_DST_COLOR
, ?GL_SRC_ALPHA
, ?GL_ONE_MINUS_SRC_ALPHA
, ?GL_DST_ALPHA
, ?GL_ONE_MINUS_DST_ALPHA
, ?GL_CONSTANT_COLOR
, ?GL_ONE_MINUS_CONSTANT_COLOR
, ?GL_CONSTANT_ALPHA
, ?GL_ONE_MINUS_CONSTANT_ALPHA
, ?GL_SRC_ALPHA_SATURATE
, ?GL_SRC1_COLOR
, ?GL_ONE_MINUS_SRC1_COLOR
, ?GL_SRC1_ALPHA
, and ?GL_ONE_MINUS_SRC1_ALPHA
. The 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, first source, second source and destination color components are referred to
as (R s0 G s0 B s0 A s0), (R s1 G s1 B s1 A s1) and (R d G d B d A d), respectively. The color specified by gl:blendColor/4 is referred to
as (R c G c B c A c). They are understood to have integer values between 0 and (k R k G k B k A), where
k c=2(m c)-1
and (m R m G m B m A) is the number of red, green, blue, and alpha bitplanes.
Source and destination scale factors are referred to as (s R s G s B s A) and (d R d G d B d A). The scale factors described in the table, denoted (f R f G f B f A), represent either source or destination factors. All scale factors have range [0 1].
Parameter
(f R f G f B f A)?GL_ZERO
(0 0 0 0)?GL_ONE
(1 1 1 1)?GL_SRC_COLOR
(R s0 k/R G s0 k/G B s0 k/B A s0 k/A)?GL_ONE_MINUS_SRC_COLOR
(1 1 1 1)-(R s0 k/R G s0 k/G B s0 k/B
A s0 k/A)?GL_DST_COLOR
(R d k/R G d k/G B d k/B A d k/A)?GL_ONE_MINUS_DST_COLOR
(1 1 1 1)-(R d k/R G d k/G B d k/B
A d k/A)?GL_SRC_ALPHA
(A s0 k/A A s0 k/A A s0 k/A A s0 k/A)?GL_ONE_MINUS_SRC_ALPHA
(1 1 1 1)-(A s0 k/A A s0 k/A A s0
k/A A s0 k/A)?GL_DST_ALPHA
(A d k/A A d k/A A d k/A A d k/A)?GL_ONE_MINUS_DST_ALPHA
(1 1 1 1)-(A d k/A A d k/A A d k/A
A d k/A)?GL_CONSTANT_COLOR
(R c G c B c A c)?GL_ONE_MINUS_CONSTANT_COLOR
(1 1 1 1)-(R c G c B c A c)?GL_CONSTANT_ALPHA
(A c A c A c A c)?GL_ONE_MINUS_CONSTANT_ALPHA
(1 1 1 1)-(A c A c A c A c)?GL_SRC_ALPHA_SATURATE
(i i i 1)?GL_SRC1_COLOR
(R s1 k/R G s1 k/G B s1 k/B A s1 k/A)?GL_ONE_MINUS_SRC1_COLOR
(1 1 1 1)-(R s1 k/R G s1 k/G B
s1 k/B A s1 k/A)?GL_SRC1_ALPHA
(A s1 k/A A s1 k/A A s1 k/A A s1 k/A)?GL_ONE_MINUS_SRC1_ALPHA
(1 1 1 1)-(A s1 k/A A s1 k/A A
s1 k/A A s1 k/A)In the table,
i=min(A s k A-A d) k/A
To determine the blended RGBA values of a pixel, the system uses the following equations:
R d=min(k R R s s R+R d d R) G d=min(k G G s s G+G d d G) B d=min(k B B s s B+B d d B) A d=min(k A A s s A+A d d A)
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 A s is equal to k A, the equations
reduce to simple replacement:
R d=R s G d=G s B d=B s A d=A s
See
logicOp(Opcode) -> ok
Opcode = enum()
Specify a logical pixel operation for rendering
gl:logicOp
specifies a logical operation that, when enabled, is applied between
the incoming RGBA color and the RGBA color at the corresponding location in the frame
buffer. To enable or disable the logical operation, call gl:enable/1 and gl:enable/1
using the symbolic constant ?GL_COLOR_LOGIC_OP
. The initial value is disabled.
Opcode
Resulting Operation
?GL_CLEAR
0 ?GL_SET
1
?GL_COPY
s ?GL_COPY_INVERTED
~s ?GL_NOOP
d ?GL_INVERT
~d ?GL_AND
s & d ?GL_NAND
~(s & d) ?GL_OR
s | d ?GL_NOR
~(s | d) ?GL_XOR
s ^ d ?GL_EQUIV
~(s ^ d) ?GL_AND_REVERSE
s & ~d ?GL_AND_INVERTED
~s & d ?GL_OR_REVERSE
s | ~d ?GL_OR_INVERTED
~s | d 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. Standard C-language operators are used. As these bitwise
operators suggest, the logical operation is applied independently to each bit pair of
the source and destination colors.
See
cullFace(Mode) -> ok
Mode = enum()
Specify whether front- or back-facing facets can be culled
gl:cullFace
specifies whether front- or back-facing facets are culled (as specified
by mode
) when facet culling is enabled. Facet culling is initially disabled. To
enable and disable facet culling, call the gl:enable/1 and gl:enable/1
commands with the argument ?GL_CULL_FACE
. Facets include triangles, quadrilaterals,
polygons, and rectangles.
gl:frontFace/1 specifies which of the clockwise and counterclockwise facets are front-facing and back-facing. See gl:frontFace/1 .
See
frontFace(Mode) -> ok
Mode = enum()
Define front- and back-facing polygons
In a scene composed entirely of opaque closed surfaces, back-facing polygons are never
visible. Eliminating these invisible polygons has the obvious benefit of speeding up the
rendering of the image. To enable and disable elimination of back-facing polygons, call gl:enable/1
and gl:enable/1 with argument ?GL_CULL_FACE
.
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. gl:frontFace
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.
See
pointSize(Size) -> ok
Size = float()
Specify the diameter of rasterized points
gl:pointSize
specifies the rasterized diameter of points. If point size mode is
disabled (see gl:enable/1 with parameter ?GL_PROGRAM_POINT_SIZE
), this value
will be used to rasterize points. Otherwise, the value written to the shading language
built-in variable gl_PointSize will be used.
See
lineWidth(Width) -> ok
Width = float()
Specify the width of rasterized lines
gl:lineWidth
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 gl:enable/1 and gl:enable/1
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 |Δ x|>=|Δ 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 gl:getBooleanv/1 with arguments ?GL_ALIASED_LINE_WIDTH_RANGE
, ?GL_SMOOTH_LINE_WIDTH_RANGE
, and ?GL_SMOOTH_LINE_WIDTH_GRANULARITY
.
See
lineStipple(Factor, Pattern) -> ok
Factor = integer()
Pattern = integer()
Specify the line stipple pattern
Line stippling masks out certain fragments produced by rasterization; those fragments
will not be drawn. The masking is achieved by using three parameters: the 16-bit line
stipple pattern Pattern
, the repeat count Factor
, and an integer stipple
counter s.
Counter s is reset to 0 whenever gl:'begin'/1 is called and before each line segment
of a gl:'begin'/1 (?GL_LINES
)/ gl:'begin'/1 sequence is generated. It is
incremented after each fragment of a unit width aliased line segment is generated or after
each i fragments of an i width line segment are generated. The i fragments associated
with count s are masked out if
Pattern
bit (s/factor)% 16
is 0, otherwise these fragments are sent to the frame buffer. Bit zero of Pattern
is the least significant bit.
Antialiased lines are treated as a sequence of 1×width rectangles for purposes of stippling. Whether rectangle s is rasterized or not depends on the fragment rule described for aliased lines, counting rectangles rather than groups of fragments.
To enable and disable line stippling, call gl:enable/1 and gl:enable/1
with argument ?GL_LINE_STIPPLE
. When enabled, the line stipple pattern is applied
as described above. When disabled, it is as if the pattern were all 1's. Initially, line
stippling is disabled.
See
polygonMode(Face, Mode) -> ok
Face = enum()
Mode = enum()
Select a polygon rasterization mode
gl:polygonMode
controls the interpretation of polygons for rasterization. Face
describes which polygons Mode
applies to: both front and back-facing polygons (?GL_FRONT_AND_BACK
). The polygon mode affects only the final rasterization of polygons. In particular, a
polygon's vertices are lit and the polygon is clipped and possibly culled before these
modes are applied.
Three modes are defined and can be specified in Mode
:
?GL_POINT
: Polygon vertices that are marked as the start of a boundary edge are
drawn as points. Point attributes such as ?GL_POINT_SIZE
and ?GL_POINT_SMOOTH
control the rasterization of the points. Polygon rasterization attributes other than ?GL_POLYGON_MODE
have no effect.
?GL_LINE
: Boundary edges of the polygon are drawn as line segments. Line attributes
such as ?GL_LINE_WIDTH
and ?GL_LINE_SMOOTH
control the rasterization of
the lines. Polygon rasterization attributes other than ?GL_POLYGON_MODE
have no
effect.
?GL_FILL
: The interior of the polygon is filled. Polygon attributes such as ?GL_POLYGON_SMOOTH
control the rasterization of the polygon.
See
polygonOffset(Factor, Units) -> ok
Factor = float()
Units = float()
Set the scale and units used to calculate depth values
When ?GL_POLYGON_OFFSET_FILL
, ?GL_POLYGON_OFFSET_LINE
, or ?GL_POLYGON_OFFSET_POINT
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
factor×DZ+r×units, where DZ 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.
gl:polygonOffset
is useful for rendering hidden-line images, for applying decals
to surfaces, and for rendering solids with highlighted edges.
See
polygonStipple(Mask) -> ok
Mask = binary()
Set the polygon stippling pattern
Polygon stippling, like line stippling (see gl:lineStipple/2 ), masks out certain fragments produced by rasterization, creating a pattern. Stippling is independent of polygon antialiasing.
Pattern
is a pointer to a 32×32 stipple pattern that is stored in memory just
like the pixel data supplied to a gl:drawPixels/5 call with height and width
both equal to 32, a pixel format of ?GL_COLOR_INDEX
, and data type of ?GL_BITMAP
. That is, the stipple pattern is represented as a 32×32 array of 1-bit color indices
packed in unsigned bytes. gl:pixelStoref/2 parameters like ?GL_UNPACK_SWAP_BYTES
and ?GL_UNPACK_LSB_FIRST
affect the assembling of the bits into a stipple pattern.
Pixel transfer operations (shift, offset, pixel map) are not applied to the stipple image,
however.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a stipple pattern is specified, Pattern
is
treated as a byte offset into the buffer object's data store.
To enable and disable polygon stippling, call gl:enable/1 and gl:enable/1
with argument ?GL_POLYGON_STIPPLE
. Polygon stippling is initially disabled. If
it's enabled, a rasterized polygon fragment with window coordinates x w and y w is
sent to the next stage of the GL if and only if the ( x w% 32)th bit in the ( y w% 32)th
row of the stipple pattern is 1 (one). When polygon stippling is disabled, it is as if
the stipple pattern consists of all 1's.
See
getPolygonStipple() -> binary()
Return the polygon stipple pattern
gl:getPolygonStipple
returns to Pattern
a 32×32 polygon stipple pattern.
The pattern is packed into memory as if gl:readPixels/7 with both height
and width
of 32, type
of ?GL_BITMAP
, and format
of ?GL_COLOR_INDEX
were called, and the stipple pattern were stored in an internal 32×32 color index buffer.
Unlike gl:readPixels/7 , however, pixel transfer operations (shift, offset, pixel
map) are not applied to the returned stipple image.
If a non-zero named buffer object is bound to the ?GL_PIXEL_PACK_BUFFER
target
(see gl:bindBuffer/2 ) while a polygon stipple pattern is requested, Pattern
is treated as a byte offset into the buffer object's data store.
See
edgeFlag(Flag) -> ok
Flag = 0 | 1
Flag edges as either boundary or nonboundary
Each vertex of a polygon, separate triangle, or separate quadrilateral specified between
a gl:'begin'/1 / gl:'begin'/1 pair is marked as the start of either a boundary or
nonboundary edge. If the current edge flag is true when the vertex is specified, the vertex
is marked as the start of a boundary edge. Otherwise, the vertex is marked as the start
of a nonboundary edge. gl:edgeFlag
sets the edge flag bit to ?GL_TRUE
if Flag
is ?GL_TRUE
and to ?GL_FALSE
otherwise.
The vertices of connected triangles and connected quadrilaterals are always marked as boundary, regardless of the value of the edge flag.
Boundary and nonboundary edge flags on vertices are significant only if ?GL_POLYGON_MODE
is set to ?GL_POINT
or ?GL_LINE
. See gl:polygonMode/2 .
See
scissor(X, Y, Width, Height) -> ok
X = integer()
Y = integer()
Width = integer()
Height = integer()
Define the scissor box
gl:scissor
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 gl:enable/1 and gl:enable/1
with argument ?GL_SCISSOR_TEST
. The test is initially disabled. While the 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.
See
clipPlane(Plane, Equation) -> ok
Plane = enum()
Equation = {float(), float(), float(), float()}
Specify a plane against which all geometry is clipped
Geometry is always clipped against the boundaries of a six-plane frustum in x
, y
, and z
. gl:clipPlane
allows the specification of additional planes, not
necessarily perpendicular to the x
, y
, or z
axis, against which all
geometry is clipped. To determine the maximum number of additional clipping planes, call gl:getBooleanv/1
with argument ?GL_MAX_CLIP_PLANES
. All implementations support at least six such
clipping planes. Because the resulting clipping region is the intersection of the defined
half-spaces, it is always convex.
gl:clipPlane
specifies a half-space using a four-component plane equation. When gl:clipPlane
is called, Equation
is transformed by the inverse of the modelview matrix and
stored in the resulting eye coordinates. Subsequent changes to the modelview matrix have
no effect on the stored plane-equation components. If the dot product of the eye coordinates
of a vertex with the stored plane equation components is positive or zero, the vertex is in
with respect to that clipping plane. Otherwise, it is out
.
To enable and disable clipping planes, call gl:enable/1 and gl:enable/1
with the argument ?GL_CLIP_PLANE
i
, where i
is the plane number.
All clipping planes are initially defined as (0, 0, 0, 0) in eye coordinates and are disabled.
See
getClipPlane(Plane) -> {float(), float(), float(), float()}
Plane = enum()
Return the coefficients of the specified clipping plane
gl:getClipPlane
returns in Equation
the four coefficients of the plane equation
for Plane
.
See
drawBuffer(Mode) -> ok
Mode = enum()
Specify which color buffers are to be drawn into
When colors are written to the frame buffer, they are written into the color buffers
specified by gl:drawBuffer
. The specifications are as follows:
?GL_NONE
: No color buffers are written.
?GL_FRONT_LEFT
: Only the front left color buffer is written.
?GL_FRONT_RIGHT
: Only the front right color buffer is written.
?GL_BACK_LEFT
: Only the back left color buffer is written.
?GL_BACK_RIGHT
: Only the back right color buffer is written.
?GL_FRONT
: Only the front left and front right color buffers are written. If there
is no front right color buffer, only the front left color buffer is written.
?GL_BACK
: Only the back left and back right color buffers are written. If there
is no back right color buffer, only the back left color buffer is written.
?GL_LEFT
: Only the front left and back left color buffers are written. If there
is no back left color buffer, only the front left color buffer is written.
?GL_RIGHT
: Only the front right and back right color buffers are written. If there
is no back right color buffer, only the front right color buffer is written.
?GL_FRONT_AND_BACK
: All the front and back color buffers (front left, front right,
back left, back right) are written. If there are no back color buffers, only the front
left and front right color buffers are written. If there are no right color buffers, only
the front left and back left color buffers are written. If there are no right or back
color buffers, only the front left color buffer is written.
If more than one color buffer is selected for drawing, then blending or logical operations are computed and applied independently for each color buffer and can produce different results in each buffer.
Monoscopic contexts include only left
buffers, and stereoscopic contexts include
both left
and right
buffers. Likewise, single-buffered contexts include
only front
buffers, and double-buffered contexts include both front
and back
buffers. The context is selected at GL initialization.
See
readBuffer(Mode) -> ok
Mode = enum()
Select a color buffer source for pixels
gl:readBuffer
specifies a color buffer as the source for subsequent gl:readPixels/7
, gl:copyTexImage1D/7 , gl:copyTexImage2D/8 , gl:copyTexSubImage1D/6 , gl:copyTexSubImage2D/8
, and gl:copyTexSubImage3D/9 commands. Mode
accepts one of twelve or more
predefined values. In a fully configured system, ?GL_FRONT
, ?GL_LEFT
, and ?GL_FRONT_LEFT
all name the front left buffer, ?GL_FRONT_RIGHT
and ?GL_RIGHT
name the
front right buffer, and ?GL_BACK_LEFT
and ?GL_BACK
name the back left buffer.
Further more, the constants ?GL_COLOR_ATTACHMENT
i
may be used to indicate
the i
th color attachment where i
ranges from zero to the value of ?GL_MAX_COLOR_ATTACHMENTS
minus one.
Nonstereo double-buffered configurations have only a front left and a back left buffer.
Single-buffered configurations have a front left and a front right buffer if stereo, and
only a front left buffer if nonstereo. It is an error to specify a nonexistent buffer to gl:readBuffer
.
Mode
is initially ?GL_FRONT
in single-buffered configurations and ?GL_BACK
in double-buffered configurations.
See
enable(Cap) -> ok
Cap = enum()
Enable or disable server-side GL capabilities
gl:enable
and gl:enable/1 enable and disable various capabilities. Use gl:isEnabled/1
or gl:getBooleanv/1 to determine the current setting of any capability. 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 gl:enable
and gl:enable/1 take a single argument, Cap
, which
can assume one of the following values:
Some of the GL's capabilities are indexed. gl:enablei
and gl:disablei
enable
and disable indexed capabilities.
?GL_BLEND
: If enabled, blend the computed fragment color values with the values
in the color buffers. See gl:blendFunc/2 .
?GL_CLIP_DISTANCE
i
: If enabled, clip geometry against user-defined half
space i
.
?GL_COLOR_LOGIC_OP
: If enabled, apply the currently selected logical operation
to the computed fragment color and color buffer values. See gl:logicOp/1 .
?GL_CULL_FACE
: If enabled, cull polygons based on their winding in window coordinates.
See gl:cullFace/1 .
?GL_DEPTH_CLAMP
: If enabled, the -w c≤ z c≤ w c plane equation is
ignored by view volume clipping (effectively, there is no near or far plane clipping).
See gl:depthRange/2 .
?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 gl:depthFunc/1 and gl:depthRange/2
.
?GL_DITHER
: If enabled, dither color components or indices before they are written
to the color buffer.
?GL_FRAMEBUFFER_SRGB
: If enabled and the value of ?GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING
for the framebuffer attachment corresponding to the destination buffer is ?GL_SRGB
,
the R, G, and B destination color values (after conversion from fixed-point to floating-point)
are considered to be encoded for the sRGB color space and hence are linearized prior to
their use in blending.
?GL_LINE_SMOOTH
: If enabled, draw lines with correct filtering. Otherwise, draw
aliased lines. See gl:lineWidth/1 .
?GL_MULTISAMPLE
: If enabled, use multiple fragment samples in computing the final
color of a pixel. See gl:sampleCoverage/2 .
?GL_POLYGON_OFFSET_FILL
: If enabled, and if the polygon is rendered in ?GL_FILL
mode, an offset is added to depth values of a polygon's fragments before the depth comparison
is performed. See gl:polygonOffset/2 .
?GL_POLYGON_OFFSET_LINE
: If enabled, and if the polygon is rendered in ?GL_LINE
mode, an offset is added to depth values of a polygon's fragments before the depth comparison
is performed. See gl:polygonOffset/2 .
?GL_POLYGON_OFFSET_POINT
: If enabled, an offset is added to depth values of a
polygon's fragments before the depth comparison is performed, if the polygon is rendered
in ?GL_POINT
mode. See gl:polygonOffset/2 .
?GL_POLYGON_SMOOTH
: If enabled, draw polygons with proper filtering. Otherwise,
draw aliased polygons. For correct antialiased polygons, an alpha buffer is needed and
the polygons must be sorted front to back.
?GL_PRIMITIVE_RESTART
: Enables primitive restarting. If enabled, any one of the
draw commands which transfers a set of generic attribute array elements to the GL will
restart the primitive when the index of the vertex is equal to the primitive restart
index. See gl:primitiveRestartIndex/1 .
?GL_SAMPLE_ALPHA_TO_COVERAGE
: If enabled, compute a temporary coverage value 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.
?GL_SAMPLE_ALPHA_TO_ONE
: If enabled, each sample alpha value is replaced by the
maximum representable alpha value.
?GL_SAMPLE_COVERAGE
: If enabled, the fragment's coverage is ANDed with the temporary
coverage value. If ?GL_SAMPLE_COVERAGE_INVERT
is set to ?GL_TRUE
, invert
the coverage value. See gl:sampleCoverage/2 .
?GL_SAMPLE_SHADING
: If enabled, the active fragment shader is run once for each
covered sample, or at fraction of this rate as determined by the current value of ?GL_MIN_SAMPLE_SHADING_VALUE
. See gl:minSampleShading/1 .
?GL_SAMPLE_MASK
: If enabled, the sample coverage mask generated for a fragment
during rasterization will be ANDed with the value of ?GL_SAMPLE_MASK_VALUE
before
shading occurs. See gl:sampleMaski/2 .
?GL_SCISSOR_TEST
: If enabled, discard fragments that are outside the scissor rectangle.
See gl:scissor/4 .
?GL_STENCIL_TEST
: If enabled, do stencil testing and update the stencil buffer.
See gl:stencilFunc/3 and gl:stencilOp/3 .
?GL_TEXTURE_CUBE_MAP_SEAMLESS
: If enabled, cubemap textures are sampled such that
when linearly sampling from the border between two adjacent faces, texels from both faces
are used to generate the final sample value. When disabled, texels from only a single
face are used to construct the final sample value.
?GL_PROGRAM_POINT_SIZE
: If enabled and a vertex or geometry shader is active,
then the derived point size is taken from the (potentially clipped) shader builtin ?gl_PointSize
and clamped to the implementation-dependent point size range.
See
isEnabled(Cap) -> 0 | 1
Cap = enum()
Test whether a capability is enabled
gl:isEnabled
returns ?GL_TRUE
if Cap
is an enabled capability and
returns ?GL_FALSE
otherwise. Boolean states that are indexed may be tested with gl:isEnabledi
. For gl:isEnabledi
, Index
specifies the index of the capability to test. Index
must be between zero and the count of indexed capabilities for Cap
. Initially
all capabilities except ?GL_DITHER
are disabled; ?GL_DITHER
is initially
enabled.
The following capabilities are accepted for Cap
:
Constant
See
?GL_BLEND
gl:blendFunc/2
, gl:logicOp/1 ?GL_CLIP_DISTANCE
i
gl:enable/1
?GL_COLOR_LOGIC_OP
gl:logicOp/1 ?GL_CULL_FACE
gl:cullFace/1 ?GL_DEPTH_CLAMP
gl:enable/1
?GL_DEPTH_TEST
gl:depthFunc/1 , gl:depthRange/2
?GL_DITHER
gl:enable/1 ?GL_FRAMEBUFFER_SRGB
gl:enable/1 ?GL_LINE_SMOOTH
gl:lineWidth/1
?GL_MULTISAMPLE
gl:sampleCoverage/2 ?GL_POLYGON_SMOOTH
gl:polygonMode/2 ?GL_POLYGON_OFFSET_FILL
gl:polygonOffset/2 ?GL_POLYGON_OFFSET_LINE
gl:polygonOffset/2 ?GL_POLYGON_OFFSET_POINT
gl:polygonOffset/2
?GL_PROGRAM_POINT_SIZE
gl:enable/1 ?GL_PRIMITIVE_RESTART
gl:enable/1 , gl:primitiveRestartIndex/1
?GL_SAMPLE_ALPHA_TO_COVERAGE
gl:sampleCoverage/2 ?GL_SAMPLE_ALPHA_TO_ONE
gl:sampleCoverage/2 ?GL_SAMPLE_COVERAGE
gl:sampleCoverage/2 ?GL_SAMPLE_MASK
gl:enable/1 ?GL_SCISSOR_TEST
gl:scissor/4
?GL_STENCIL_TEST
gl:stencilFunc/3 , gl:stencilOp/3
?GL_TEXTURE_CUBEMAP_SEAMLESS
gl:enable/1 See
enableClientState(Cap) -> ok
Cap = enum()
Enable or disable client-side capability
gl:enableClientState
and gl:enableClientState/1 enable or disable individual
client-side capabilities. By default, all client-side capabilities are disabled. Both gl:enableClientState
and gl:enableClientState/1 take a single argument, Cap
, 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 gl:arrayElement/1 , gl:drawArrays/3 , gl:drawElements/4 ,
gl:drawRangeElements/6 gl:multiDrawArrays/3 , or see glMultiDrawElements
is called. See gl:colorPointer/4 .
?GL_EDGE_FLAG_ARRAY
: If enabled, the edge flag array is enabled for writing and
used during rendering when gl:arrayElement/1 , gl:drawArrays/3 , gl:drawElements/4
, gl:drawRangeElements/6 gl:multiDrawArrays/3 , or see glMultiDrawElements
is called. See gl:edgeFlagPointer/2 .
?GL_FOG_COORD_ARRAY
: If enabled, the fog coordinate array is enabled for writing
and used during rendering when gl:arrayElement/1 , gl:drawArrays/3 , gl:drawElements/4
, gl:drawRangeElements/6 gl:multiDrawArrays/3 , or see glMultiDrawElements
is called. See gl:fogCoordPointer/3 .
?GL_INDEX_ARRAY
: If enabled, the index array is enabled for writing and used during
rendering when gl:arrayElement/1 , gl:drawArrays/3 , gl:drawElements/4 ,
gl:drawRangeElements/6 gl:multiDrawArrays/3 , or see glMultiDrawElements
is called. See gl:indexPointer/3 .
?GL_NORMAL_ARRAY
: If enabled, the normal array is enabled for writing and used
during rendering when gl:arrayElement/1 , gl:drawArrays/3 , gl:drawElements/4
, gl:drawRangeElements/6 gl:multiDrawArrays/3 , or see glMultiDrawElements
is called. See gl:normalPointer/3 .
?GL_SECONDARY_COLOR_ARRAY
: If enabled, the secondary color array is enabled for
writing and used during rendering when gl:arrayElement/1 , gl:drawArrays/3 , gl:drawElements/4
, gl:drawRangeElements/6 gl:multiDrawArrays/3 , or see glMultiDrawElements
is called. See gl:colorPointer/4 .
?GL_TEXTURE_COORD_ARRAY
: If enabled, the texture coordinate array is enabled for
writing and used during rendering when gl:arrayElement/1 , gl:drawArrays/3 , gl:drawElements/4
, gl:drawRangeElements/6 gl:multiDrawArrays/3 , or see glMultiDrawElements
is called. See gl:texCoordPointer/4 .
?GL_VERTEX_ARRAY
: If enabled, the vertex array is enabled for writing and used
during rendering when gl:arrayElement/1 , gl:drawArrays/3 , gl:drawElements/4
, gl:drawRangeElements/6 gl:multiDrawArrays/3 , or see glMultiDrawElements
is called. See gl:vertexPointer/4 .
See
getBooleanv(Pname) -> [0 | 1]
Pname = enum()
Return the value or values of a selected parameter
These four commands return values for simple state variables in GL. Pname
is a
symbolic constant indicating the state variable to be returned, and Params
is a
pointer to an array of the indicated type in which to place the returned data.
Type conversion is performed if Params
has a different type than the state variable
value being requested. If gl:getBooleanv
is called, a floating-point (or integer)
value is converted to ?GL_FALSE
if and only if it is 0.0 (or 0). Otherwise, it
is converted to ?GL_TRUE
. If gl:getIntegerv
is called, boolean values are
returned as ?GL_TRUE
or ?GL_FALSE
, and most floating-point values are rounded
to the nearest integer value. Floating-point colors and normals, however, are returned
with a linear mapping that maps 1.0 to the most positive representable integer value and
-1.0 to the most negative representable integer value. If gl:getFloatv
or gl:getDoublev
is called, boolean values are returned as ?GL_TRUE
or ?GL_FALSE
, and integer
values are converted to floating-point values.
The following symbolic constants are accepted by Pname
:
?GL_ACTIVE_TEXTURE
: Params
returns a single value indicating the active
multitexture unit. The initial value is ?GL_TEXTURE0
. See gl:activeTexture/1 .
?GL_ALIASED_LINE_WIDTH_RANGE
: Params
returns a pair of values indicating
the range of widths supported for aliased lines. See gl:lineWidth/1 .
?GL_ARRAY_BUFFER_BINDING
: Params
returns a single value, the name of the
buffer object currently bound to the target ?GL_ARRAY_BUFFER
. If no buffer object
is bound to this target, 0 is returned. The initial value is 0. See gl:bindBuffer/2 .
?GL_BLEND
: Params
returns a single boolean value indicating whether blending
is enabled. The initial value is ?GL_FALSE
. See gl:blendFunc/2 .
?GL_BLEND_COLOR
: Params
returns four values, the red, green, blue, and alpha
values which are the components of the blend color. See gl:blendColor/4 .
?GL_BLEND_DST_ALPHA
: Params
returns one value, the symbolic constant identifying
the alpha destination blend function. The initial value is ?GL_ZERO
. See gl:blendFunc/2
and gl:blendFuncSeparate/4 .
?GL_BLEND_DST_RGB
: Params
returns one value, the symbolic constant identifying
the RGB destination blend function. The initial value is ?GL_ZERO
. See gl:blendFunc/2
and gl:blendFuncSeparate/4 .
?GL_BLEND_EQUATION_RGB
: Params
returns one value, a symbolic constant indicating
whether the RGB blend equation is ?GL_FUNC_ADD
, ?GL_FUNC_SUBTRACT
, ?GL_FUNC_REVERSE_SUBTRACT
, ?GL_MIN
or ?GL_MAX
. See gl:blendEquationSeparate/2 .
?GL_BLEND_EQUATION_ALPHA
: Params
returns one value, a symbolic constant
indicating whether the Alpha blend equation is ?GL_FUNC_ADD
, ?GL_FUNC_SUBTRACT
, ?GL_FUNC_REVERSE_SUBTRACT
, ?GL_MIN
or ?GL_MAX
. See gl:blendEquationSeparate/2
.
?GL_BLEND_SRC_ALPHA
: Params
returns one value, the symbolic constant identifying
the alpha source blend function. The initial value is ?GL_ONE
. See gl:blendFunc/2
and gl:blendFuncSeparate/4 .
?GL_BLEND_SRC_RGB
: Params
returns one value, the symbolic constant identifying
the RGB source blend function. The initial value is ?GL_ONE
. See gl:blendFunc/2
and gl:blendFuncSeparate/4 .
?GL_COLOR_CLEAR_VALUE
: Params
returns four values: the red, green, blue,
and alpha values used to clear the color buffers. Integer values, if requested, are 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. The initial value is (0, 0, 0, 0). See gl:clearColor/4 .
?GL_COLOR_LOGIC_OP
: Params
returns a single boolean value indicating whether
a fragment's RGBA color values are merged into the framebuffer using a logical operation.
The initial value is ?GL_FALSE
. See gl:logicOp/1 .
?GL_COLOR_WRITEMASK
: Params
returns four boolean values: the red, green,
blue, and alpha write enables for the color buffers. The initial value is (?GL_TRUE
,
?GL_TRUE
, ?GL_TRUE
, ?GL_TRUE
). See gl:colorMask/4 .
?GL_COMPRESSED_TEXTURE_FORMATS
: Params
returns a list of symbolic constants
of length ?GL_NUM_COMPRESSED_TEXTURE_FORMATS
indicating which compressed texture
formats are available. See gl:compressedTexImage2D/8 .
?GL_CONTEXT_FLAGS
: Params
returns one value, the flags with which the context
was created (such as debugging functionality).
?GL_CULL_FACE
: Params
returns a single boolean value indicating whether
polygon culling is enabled. The initial value is ?GL_FALSE
. See gl:cullFace/1
.
?GL_CURRENT_PROGRAM
: Params
returns one value, the name of the program object
that is currently active, or 0 if no program object is active. See gl:useProgram/1 .
?GL_DEPTH_CLEAR_VALUE
: Params
returns one value, the value that is used
to clear the depth buffer. Integer values, if requested, are 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. The initial
value is 1. See gl:clearDepth/1 .
?GL_DEPTH_FUNC
: Params
returns one value, the symbolic constant that indicates
the depth comparison function. The initial value is ?GL_LESS
. See gl:depthFunc/1
.
?GL_DEPTH_RANGE
: Params
returns two values: the near and far mapping limits
for the depth buffer. Integer values, if requested, are 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. The initial value
is (0, 1). See gl:depthRange/2 .
?GL_DEPTH_TEST
: Params
returns a single boolean value indicating whether
depth testing of fragments is enabled. The initial value is ?GL_FALSE
. See gl:depthFunc/1
and gl:depthRange/2 .
?GL_DEPTH_WRITEMASK
: Params
returns a single boolean value indicating if
the depth buffer is enabled for writing. The initial value is ?GL_TRUE
. See gl:depthMask/1
.
?GL_DITHER
: Params
returns a single boolean value indicating whether dithering
of fragment colors and indices is enabled. The initial value is ?GL_TRUE
.
?GL_DOUBLEBUFFER
: Params
returns a single boolean value indicating whether
double buffering is supported.
?GL_DRAW_BUFFER
: Params
returns one value, a symbolic constant indicating
which buffers are being drawn to. See gl:drawBuffer/1 . The initial value is ?GL_BACK
if there are back buffers, otherwise it is ?GL_FRONT
.
?GL_DRAW_BUFFER
i
: Params
returns one value, a symbolic constant indicating
which buffers are being drawn to by the corresponding output color. See gl:drawBuffers/1
. The initial value of ?GL_DRAW_BUFFER0
is ?GL_BACK
if there are back buffers,
otherwise it is ?GL_FRONT
. The initial values of draw buffers for all other output
colors is ?GL_NONE
.
?GL_DRAW_FRAMEBUFFER_BINDING
: Params
returns one value, the name of the
framebuffer object currently bound to the ?GL_DRAW_FRAMEBUFFER
target. If the default
framebuffer is bound, this value will be zero. The initial value is zero. See gl:bindFramebuffer/2
.
?GL_READ_FRAMEBUFFER_BINDING
: Params
returns one value, the name of the
framebuffer object currently bound to the ?GL_READ_FRAMEBUFFER
target. If the default
framebuffer is bound, this value will be zero. The initial value is zero. See gl:bindFramebuffer/2
.
?GL_ELEMENT_ARRAY_BUFFER_BINDING
: Params
returns a single value, the name
of the buffer object currently bound to the target ?GL_ELEMENT_ARRAY_BUFFER
. If
no buffer object is bound to this target, 0 is returned. The initial value is 0. See gl:bindBuffer/2
.
?GL_FRAGMENT_SHADER_DERIVATIVE_HINT
: Params
returns one value, a symbolic
constant indicating the mode of the derivative accuracy hint for fragment shaders. The
initial value is ?GL_DONT_CARE
. See gl:hint/2 .
?GL_IMPLEMENTATION_COLOR_READ_FORMAT
: Params
returns a single GLenum value
indicating the implementation's preferred pixel data format. See gl:readPixels/7 .
?GL_IMPLEMENTATION_COLOR_READ_TYPE
: Params
returns a single GLenum value
indicating the implementation's preferred pixel data type. See gl:readPixels/7 .
?GL_LINE_SMOOTH
: Params
returns a single boolean value indicating whether
antialiasing of lines is enabled. The initial value is ?GL_FALSE
. See gl:lineWidth/1
.
?GL_LINE_SMOOTH_HINT
: Params
returns one value, a symbolic constant indicating
the mode of the line antialiasing hint. The initial value is ?GL_DONT_CARE
. See gl:hint/2
.
?GL_LINE_WIDTH
: Params
returns one value, the line width as specified with gl:lineWidth/1
. The initial value is 1.
?GL_LAYER_PROVOKING_VERTEX
: Params
returns one value, the implementation
dependent specifc vertex of a primitive that is used to select the rendering layer. If
the value returned is equivalent to ?GL_PROVOKING_VERTEX
, then the vertex selection
follows the convention specified by gl:provokingVertex/1 . If the value returned
is equivalent to ?GL_FIRST_VERTEX_CONVENTION
, then the selection is always taken
from the first vertex in the primitive. If the value returned is equivalent to ?GL_LAST_VERTEX_CONVENTION
, then the selection is always taken from the last vertex in the primitive. If the value
returned is equivalent to ?GL_UNDEFINED_VERTEX
, then the selection is not guaranteed
to be taken from any specific vertex in the primitive.
?GL_LINE_WIDTH_GRANULARITY
: Params
returns one value, the width difference
between adjacent supported widths for antialiased lines. See gl:lineWidth/1 .
?GL_LINE_WIDTH_RANGE
: Params
returns two values: the smallest and largest
supported widths for antialiased lines. See gl:lineWidth/1 .
?GL_LOGIC_OP_MODE
: Params
returns one value, a symbolic constant indicating
the selected logic operation mode. The initial value is ?GL_COPY
. See gl:logicOp/1
.
?GL_MAJOR_VERSION
: Params
returns one value, the major version number of
the OpenGL API supported by the current context.
?GL_MAX_3D_TEXTURE_SIZE
: Params
returns one value, a rough estimate of the
largest 3D texture that the GL can handle. The value must be at least 64. Use ?GL_PROXY_TEXTURE_3D
to determine if a texture is too large. See gl:texImage3D/10 .
?GL_MAX_ARRAY_TEXTURE_LAYERS
: Params
returns one value. The value indicates
the maximum number of layers allowed in an array texture, and must be at least 256. See gl:texImage2D/9
.
?GL_MAX_CLIP_DISTANCES
: Params
returns one value, the maximum number of
application-defined clipping distances. The value must be at least 8.
?GL_MAX_COLOR_TEXTURE_SAMPLES
: Params
returns one value, the maximum number
of samples in a color multisample texture.
?GL_MAX_COMBINED_ATOMIC_COUNTERS
: Params
returns a single value, the maximum
number of atomic counters available to all active shaders.
?GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS
: Params
returns one value,
the number of words for fragment shader uniform variables in all uniform blocks (including
default). The value must be at least 1. See gl:uniform1f/2 .
?GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS
: Params
returns one value,
the number of words for geometry shader uniform variables in all uniform blocks (including
default). The value must be at least 1. See gl:uniform1f/2 .
?GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
: Params
returns one value, the maximum
supported texture image units that can be used to access texture maps from the vertex
shader and the fragment processor combined. If both the vertex shader and the fragment
processing stage access the same texture image unit, then that counts as using two texture
image units against this limit. The value must be at least 48. See gl:activeTexture/1
.
?GL_MAX_COMBINED_UNIFORM_BLOCKS
: Params
returns one value, the maximum number
of uniform blocks per program. The value must be at least 36. See gl:uniformBlockBinding/3
.
?GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS
: Params
returns one value, the
number of words for vertex shader uniform variables in all uniform blocks (including default).
The value must be at least 1. See gl:uniform1f/2 .
?GL_MAX_CUBE_MAP_TEXTURE_SIZE
: Params
returns one value. The value gives
a rough estimate of the largest cube-map texture that the GL can handle. The value must
be at least 1024. Use ?GL_PROXY_TEXTURE_CUBE_MAP
to determine if a texture is too
large. See gl:texImage2D/9 .
?GL_MAX_DEPTH_TEXTURE_SAMPLES
: Params
returns one value, the maximum number
of samples in a multisample depth or depth-stencil texture.
?GL_MAX_DRAW_BUFFERS
: Params
returns one value, the maximum number of simultaneous
outputs that may be written in a fragment shader. The value must be at least 8. See gl:drawBuffers/1
.
?GL_MAX_DUALSOURCE_DRAW_BUFFERS
: Params
returns one value, the maximum number
of active draw buffers when using dual-source blending. The value must be at least 1.
See gl:blendFunc/2 and gl:blendFuncSeparate/4 .
?GL_MAX_ELEMENTS_INDICES
: Params
returns one value, the recommended maximum
number of vertex array indices. See gl:drawRangeElements/6 .
?GL_MAX_ELEMENTS_VERTICES
: Params
returns one value, the recommended maximum
number of vertex array vertices. See gl:drawRangeElements/6 .
?GL_MAX_FRAGMENT_ATOMIC_COUNTERS
: Params
returns a single value, the maximum
number of atomic counters available to fragment shaders.
?GL_MAX_FRAGMENT_INPUT_COMPONENTS
: Params
returns one value, the maximum
number of components of the inputs read by the fragment shader, which must be at least
128.
?GL_MAX_FRAGMENT_UNIFORM_COMPONENTS
: Params
returns one value, the maximum
number of individual floating-point, integer, or boolean values that can be held in uniform
variable storage for a fragment shader. The value must be at least 1024. See gl:uniform1f/2
.
?GL_MAX_FRAGMENT_UNIFORM_VECTORS
: Params
returns one value, the maximum
number of individual 4-vectors of floating-point, integer, or boolean values that can
be held in uniform variable storage for a fragment shader. The value is equal to the value
of ?GL_MAX_FRAGMENT_UNIFORM_COMPONENTS
divided by 4 and must be at least 256. See gl:uniform1f/2
.
?GL_MAX_FRAGMENT_UNIFORM_BLOCKS
: Params
returns one value, the maximum number
of uniform blocks per fragment shader. The value must be at least 12. See gl:uniformBlockBinding/3
.
?GL_MAX_GEOMETRY_ATOMIC_COUNTERS
: Params
returns a single value, the maximum
number of atomic counters available to geometry shaders.
?GL_MAX_GEOMETRY_INPUT_COMPONENTS
: Params
returns one value, the maximum
number of components of inputs read by a geometry shader, which must be at least 64.
?GL_MAX_GEOMETRY_OUTPUT_COMPONENTS
: Params
returns one value, the maximum
number of components of outputs written by a geometry shader, which must be at least 128.
?GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS
: Params
returns one value, the maximum
supported texture image units that can be used to access texture maps from the geometry
shader. The value must be at least 16. See gl:activeTexture/1 .
?GL_MAX_GEOMETRY_UNIFORM_BLOCKS
: Params
returns one value, the maximum number
of uniform blocks per geometry shader. The value must be at least 12. See gl:uniformBlockBinding/3
.
?GL_MAX_GEOMETRY_UNIFORM_COMPONENTS
: Params
returns one value, the maximum
number of individual floating-point, integer, or boolean values that can be held in uniform
variable storage for a geometry shader. The value must be at least 1024. See gl:uniform1f/2
.
?GL_MAX_INTEGER_SAMPLES
: Params
returns one value, the maximum number of
samples supported in integer format multisample buffers.
?GL_MIN_MAP_BUFFER_ALIGNMENT
: Params
returns one value, the minimum alignment
in basic machine units of pointers returned fromsee glMapBuffer
and see glMapBufferRange
. This value must be a power of two and must be at least 64.
?GL_MAX_PROGRAM_TEXEL_OFFSET
: Params
returns one value, the maximum texel
offset allowed in a texture lookup, which must be at least 7.
?GL_MIN_PROGRAM_TEXEL_OFFSET
: Params
returns one value, the minimum texel
offset allowed in a texture lookup, which must be at most -8.
?GL_MAX_RECTANGLE_TEXTURE_SIZE
: Params
returns one value. The value gives
a rough estimate of the largest rectangular texture that the GL can handle. The value
must be at least 1024. Use ?GL_PROXY_RECTANGLE_TEXTURE
to determine if a texture
is too large. See gl:texImage2D/9 .
?GL_MAX_RENDERBUFFER_SIZE
: Params
returns one value. The value indicates
the maximum supported size for renderbuffers. See gl:framebufferRenderbuffer/4 .
?GL_MAX_SAMPLE_MASK_WORDS
: Params
returns one value, the maximum number
of sample mask words.
?GL_MAX_SERVER_WAIT_TIMEOUT
: Params
returns one value, the maximum gl:waitSync/3
timeout interval.
?GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS
: Params
returns a single value, the
maximum number of atomic counters available to tessellation control shaders.
?GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS
: Params
returns a single value,
the maximum number of atomic counters available to tessellation evaluation shaders.
?GL_MAX_TEXTURE_BUFFER_SIZE
: Params
returns one value. The value gives the
maximum number of texels allowed in the texel array of a texture buffer object. Value
must be at least 65536.
?GL_MAX_TEXTURE_IMAGE_UNITS
: Params
returns one value, the maximum supported
texture image units that can be used to access texture maps from the fragment shader.
The value must be at least 16. See gl:activeTexture/1 .
?GL_MAX_TEXTURE_LOD_BIAS
: Params
returns one value, the maximum, absolute
value of the texture level-of-detail bias. The value must be at least 2.0.
?GL_MAX_TEXTURE_SIZE
: Params
returns one value. The value gives a rough
estimate of the largest texture that the GL can handle. The value must be at least 1024.
Use a proxy texture target such as ?GL_PROXY_TEXTURE_1D
or ?GL_PROXY_TEXTURE_2D
to determine if a texture is too large. See gl:texImage1D/8 and gl:texImage2D/9
.
?GL_MAX_UNIFORM_BUFFER_BINDINGS
: Params
returns one value, the maximum number
of uniform buffer binding points on the context, which must be at least 36.
?GL_MAX_UNIFORM_BLOCK_SIZE
: Params
returns one value, the maximum size in
basic machine units of a uniform block, which must be at least 16384.
?GL_MAX_VARYING_COMPONENTS
: Params
returns one value, the number components
for varying variables, which must be at least 60.
?GL_MAX_VARYING_VECTORS
: Params
returns one value, the number 4-vectors
for varying variables, which is equal to the value of ?GL_MAX_VARYING_COMPONENTS
and must be at least 15.
?GL_MAX_VARYING_FLOATS
: Params
returns one value, the maximum number of
interpolators available for processing varying variables used by vertex and fragment shaders.
This value represents the number of individual floating-point values that can be interpolated;
varying variables declared as vectors, matrices, and arrays will all consume multiple
interpolators. The value must be at least 32.
?GL_MAX_VERTEX_ATOMIC_COUNTERS
: Params
returns a single value, the maximum
number of atomic counters available to vertex shaders.
?GL_MAX_VERTEX_ATTRIBS
: Params
returns one value, the maximum number of
4-component generic vertex attributes accessible to a vertex shader. The value must be
at least 16. See gl:vertexAttrib1d/2 .
?GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS
: Params
returns one value, the maximum
supported texture image units that can be used to access texture maps from the vertex
shader. The value may be at least 16. See gl:activeTexture/1 .
?GL_MAX_VERTEX_UNIFORM_COMPONENTS
: Params
returns one value, the maximum
number of individual floating-point, integer, or boolean values that can be held in uniform
variable storage for a vertex shader. The value must be at least 1024. See gl:uniform1f/2
.
?GL_MAX_VERTEX_UNIFORM_VECTORS
: Params
returns one value, the maximum number
of 4-vectors that may be held in uniform variable storage for the vertex shader. The value
of ?GL_MAX_VERTEX_UNIFORM_VECTORS
is equal to the value of ?GL_MAX_VERTEX_UNIFORM_COMPONENTS
and must be at least 256.
?GL_MAX_VERTEX_OUTPUT_COMPONENTS
: Params
returns one value, the maximum
number of components of output written by a vertex shader, which must be at least 64.
?GL_MAX_VERTEX_UNIFORM_BLOCKS
: Params
returns one value, the maximum number
of uniform blocks per vertex shader. The value must be at least 12. See gl:uniformBlockBinding/3
.
?GL_MAX_VIEWPORT_DIMS
: Params
returns two values: the maximum supported
width and height of the viewport. These must be at least as large as the visible dimensions
of the display being rendered to. See gl:viewport/4 .
?GL_MAX_VIEWPORTS
: Params
returns one value, the maximum number of simultaneous
viewports that are supported. The value must be at least 16. See gl:viewportIndexedf/5
.
?GL_MINOR_VERSION
: Params
returns one value, the minor version number of
the OpenGL API supported by the current context.
?GL_NUM_COMPRESSED_TEXTURE_FORMATS
: Params
returns a single integer value
indicating the number of available compressed texture formats. The minimum value is 4.
See gl:compressedTexImage2D/8 .
?GL_NUM_EXTENSIONS
: Params
returns one value, the number of extensions supported
by the GL implementation for the current context. See gl:getString/1 .
?GL_NUM_PROGRAM_BINARY_FORMATS
: Params
returns one value, the number of
program binary formats supported by the implementation.
?GL_NUM_SHADER_BINARY_FORMATS
: Params
returns one value, the number of binary
shader formats supported by the implementation. If this value is greater than zero, then
the implementation supports loading binary shaders. If it is zero, then the loading of
binary shaders by the implementation is not supported.
?GL_PACK_ALIGNMENT
: Params
returns one value, the byte alignment used for
writing pixel data to memory. The initial value is 4. See gl:pixelStoref/2 .
?GL_PACK_IMAGE_HEIGHT
: Params
returns one value, the image height used for
writing pixel data to memory. The initial value is 0. See gl:pixelStoref/2 .
?GL_PACK_LSB_FIRST
: Params
returns a single boolean value indicating whether
single-bit pixels being written to memory are written first to the least significant bit
of each unsigned byte. The initial value is ?GL_FALSE
. See gl:pixelStoref/2 .
?GL_PACK_ROW_LENGTH
: Params
returns one value, the row length used for writing
pixel data to memory. The initial value is 0. See gl:pixelStoref/2 .
?GL_PACK_SKIP_IMAGES
: Params
returns one value, the number of pixel images
skipped before the first pixel is written into memory. The initial value is 0. See gl:pixelStoref/2
.
?GL_PACK_SKIP_PIXELS
: Params
returns one value, the number of pixel locations
skipped before the first pixel is written into memory. The initial value is 0. See gl:pixelStoref/2
.
?GL_PACK_SKIP_ROWS
: Params
returns one value, the number of rows of pixel
locations skipped before the first pixel is written into memory. The initial value is
0. See gl:pixelStoref/2 .
?GL_PACK_SWAP_BYTES
: Params
returns a single boolean value indicating whether
the bytes of two-byte and four-byte pixel indices and components are swapped before being
written to memory. The initial value is ?GL_FALSE
. See gl:pixelStoref/2 .
?GL_PIXEL_PACK_BUFFER_BINDING
: Params
returns a single value, the name of
the buffer object currently bound to the target ?GL_PIXEL_PACK_BUFFER
. If no buffer
object is bound to this target, 0 is returned. The initial value is 0. See gl:bindBuffer/2
.
?GL_PIXEL_UNPACK_BUFFER_BINDING
: Params
returns a single value, the name
of the buffer object currently bound to the target ?GL_PIXEL_UNPACK_BUFFER
. If
no buffer object is bound to this target, 0 is returned. The initial value is 0. See gl:bindBuffer/2
.
?GL_POINT_FADE_THRESHOLD_SIZE
: Params
returns one value, the point size
threshold for determining the point size. See gl:pointParameterf/2 .
?GL_PRIMITIVE_RESTART_INDEX
: Params
returns one value, the current primitive
restart index. The initial value is 0. See gl:primitiveRestartIndex/1 .
?GL_PROGRAM_BINARY_FORMATS
: Params
an array of ?GL_NUM_PROGRAM_BINARY_FORMATS
values, indicating the proram binary formats supported by the implementation.
?GL_PROGRAM_PIPELINE_BINDING
: Params
a single value, the name of the currently
bound program pipeline object, or zero if no program pipeline object is bound. See gl:bindProgramPipeline/1
.
?GL_PROVOKING_VERTEX
: Params
returns one value, the currently selected provoking
vertex convention. The initial value is ?GL_LAST_VERTEX_CONVENTION
. See gl:provokingVertex/1
.
?GL_POINT_SIZE
: Params
returns one value, the point size as specified by gl:pointSize/1
. The initial value is 1.
?GL_POINT_SIZE_GRANULARITY
: Params
returns one value, the size difference
between adjacent supported sizes for antialiased points. See gl:pointSize/1 .
?GL_POINT_SIZE_RANGE
: Params
returns two values: the smallest and largest
supported sizes for antialiased points. The smallest size must be at most 1, and the largest
size must be at least 1. See gl:pointSize/1 .
?GL_POLYGON_OFFSET_FACTOR
: Params
returns one value, the scaling factor
used to determine the variable offset that is added to the depth value of each fragment
generated when a polygon is rasterized. The initial value is 0. See gl:polygonOffset/2
.
?GL_POLYGON_OFFSET_UNITS
: Params
returns one value. This value is multiplied
by an implementation-specific value and then added to the depth value of each fragment
generated when a polygon is rasterized. The initial value is 0. See gl:polygonOffset/2
.
?GL_POLYGON_OFFSET_FILL
: Params
returns a single boolean value indicating
whether polygon offset is enabled for polygons in fill mode. The initial value is ?GL_FALSE
. See gl:polygonOffset/2 .
?GL_POLYGON_OFFSET_LINE
: Params
returns a single boolean value indicating
whether polygon offset is enabled for polygons in line mode. The initial value is ?GL_FALSE
. See gl:polygonOffset/2 .
?GL_POLYGON_OFFSET_POINT
: Params
returns a single boolean value indicating
whether polygon offset is enabled for polygons in point mode. The initial value is ?GL_FALSE
. See gl:polygonOffset/2 .
?GL_POLYGON_SMOOTH
: Params
returns a single boolean value indicating whether
antialiasing of polygons is enabled. The initial value is ?GL_FALSE
. See gl:polygonMode/2
.
?GL_POLYGON_SMOOTH_HINT
: Params
returns one value, a symbolic constant indicating
the mode of the polygon antialiasing hint. The initial value is ?GL_DONT_CARE
.
See gl:hint/2 .
?GL_READ_BUFFER
: Params
returns one value, a symbolic constant indicating
which color buffer is selected for reading. The initial value is ?GL_BACK
if there
is a back buffer, otherwise it is ?GL_FRONT
. See gl:readPixels/7 .
?GL_RENDERBUFFER_BINDING
: Params
returns a single value, the name of the
renderbuffer object currently bound to the target ?GL_RENDERBUFFER
. If no renderbuffer
object is bound to this target, 0 is returned. The initial value is 0. See gl:bindRenderbuffer/2
.
?GL_SAMPLE_BUFFERS
: Params
returns a single integer value indicating the
number of sample buffers associated with the framebuffer. See gl:sampleCoverage/2 .
?GL_SAMPLE_COVERAGE_VALUE
: Params
returns a single positive floating-point
value indicating the current sample coverage value. See gl:sampleCoverage/2 .
?GL_SAMPLE_COVERAGE_INVERT
: Params
returns a single boolean value indicating
if the temporary coverage value should be inverted. See gl:sampleCoverage/2 .
?GL_SAMPLER_BINDING
: Params
returns a single value, the name of the sampler
object currently bound to the active texture unit. The initial value is 0. See gl:bindSampler/2
.
?GL_SAMPLES
: Params
returns a single integer value indicating the coverage
mask size. See gl:sampleCoverage/2 .
?GL_SCISSOR_BOX
: Params
returns four values: the x and y window coordinates
of the scissor box, followed by its width and height. Initially the x and y window
coordinates are both 0 and the width and height are set to the size of the window. See gl:scissor/4
.
?GL_SCISSOR_TEST
: Params
returns a single boolean value indicating whether
scissoring is enabled. The initial value is ?GL_FALSE
. See gl:scissor/4 .
?GL_SHADER_COMPILER
: Params
returns a single boolean value indicating whether
an online shader compiler is present in the implementation. All desktop OpenGL implementations
must support online shader compilations, and therefore the value of ?GL_SHADER_COMPILER
will always be ?GL_TRUE
.
?GL_SMOOTH_LINE_WIDTH_RANGE
: Params
returns a pair of values indicating
the range of widths supported for smooth (antialiased) lines. See gl:lineWidth/1 .
?GL_SMOOTH_LINE_WIDTH_GRANULARITY
: Params
returns a single value indicating
the level of quantization applied to smooth line width parameters.
?GL_STENCIL_BACK_FAIL
: Params
returns one value, a symbolic constant indicating
what action is taken for back-facing polygons when the stencil test fails. The initial
value is ?GL_KEEP
. See gl:stencilOpSeparate/4 .
?GL_STENCIL_BACK_FUNC
: Params
returns one value, a symbolic constant indicating
what function is used for back-facing polygons to compare the stencil reference value
with the stencil buffer value. The initial value is ?GL_ALWAYS
. See gl:stencilFuncSeparate/4
.
?GL_STENCIL_BACK_PASS_DEPTH_FAIL
: Params
returns one value, a symbolic constant
indicating what action is taken for back-facing polygons when the stencil test passes,
but the depth test fails. The initial value is ?GL_KEEP
. See gl:stencilOpSeparate/4
.
?GL_STENCIL_BACK_PASS_DEPTH_PASS
: Params
returns one value, a symbolic constant
indicating what action is taken for back-facing polygons when the stencil test passes
and the depth test passes. The initial value is ?GL_KEEP
. See gl:stencilOpSeparate/4
.
?GL_STENCIL_BACK_REF
: Params
returns one value, the reference value that
is compared with the contents of the stencil buffer for back-facing polygons. The initial
value is 0. See gl:stencilFuncSeparate/4 .
?GL_STENCIL_BACK_VALUE_MASK
: Params
returns one value, the mask that is
used for back-facing polygons to mask both the stencil reference value and the stencil
buffer value before they are compared. The initial value is all 1's. See gl:stencilFuncSeparate/4
.
?GL_STENCIL_BACK_WRITEMASK
: Params
returns one value, the mask that controls
writing of the stencil bitplanes for back-facing polygons. The initial value is all 1's.
See gl:stencilMaskSeparate/2 .
?GL_STENCIL_CLEAR_VALUE
: Params
returns one value, the index to which the
stencil bitplanes are cleared. The initial value is 0. See gl:clearStencil/1 .
?GL_STENCIL_FAIL
: Params
returns one value, a symbolic constant indicating
what action is taken when the stencil test fails. The initial value is ?GL_KEEP
.
See gl:stencilOp/3 . This stencil state only affects non-polygons and front-facing
polygons. Back-facing polygons use separate stencil state. See gl:stencilOpSeparate/4
.
?GL_STENCIL_FUNC
: Params
returns one value, a symbolic constant indicating
what function is used to compare the stencil reference value with the stencil buffer value.
The initial value is ?GL_ALWAYS
. See gl:stencilFunc/3 . This stencil state
only affects non-polygons and front-facing polygons. Back-facing polygons use separate
stencil state. See gl:stencilFuncSeparate/4 .
?GL_STENCIL_PASS_DEPTH_FAIL
: Params
returns one value, a symbolic constant
indicating what action is taken when the stencil test passes, but the depth test fails.
The initial value is ?GL_KEEP
. See gl:stencilOp/3 . This stencil state only
affects non-polygons and front-facing polygons. Back-facing polygons use separate stencil
state. See gl:stencilOpSeparate/4 .
?GL_STENCIL_PASS_DEPTH_PASS
: Params
returns one value, a symbolic constant
indicating what action is taken when the stencil test passes and the depth test passes.
The initial value is ?GL_KEEP
. See gl:stencilOp/3 . This stencil state only
affects non-polygons and front-facing polygons. Back-facing polygons use separate stencil
state. See gl:stencilOpSeparate/4 .
?GL_STENCIL_REF
: Params
returns one value, the reference value that is compared
with the contents of the stencil buffer. The initial value is 0. See gl:stencilFunc/3
. This stencil state only affects non-polygons and front-facing polygons. Back-facing
polygons use separate stencil state. See gl:stencilFuncSeparate/4 .
?GL_STENCIL_TEST
: Params
returns a single boolean value indicating whether
stencil testing of fragments is enabled. The initial value is ?GL_FALSE
. See gl:stencilFunc/3
and gl:stencilOp/3 .
?GL_STENCIL_VALUE_MASK
: Params
returns one value, the mask that is used
to mask both the stencil reference value and the stencil buffer value before they are
compared. The initial value is all 1's. See gl:stencilFunc/3 . This stencil state
only affects non-polygons and front-facing polygons. Back-facing polygons use separate
stencil state. See gl:stencilFuncSeparate/4 .
?GL_STENCIL_WRITEMASK
: Params
returns one value, the mask that controls
writing of the stencil bitplanes. The initial value is all 1's. See gl:stencilMask/1
. This stencil state only affects non-polygons and front-facing polygons. Back-facing
polygons use separate stencil state. See gl:stencilMaskSeparate/2 .
?GL_STEREO
: Params
returns a single boolean value indicating whether stereo
buffers (left and right) are supported.
?GL_SUBPIXEL_BITS
: Params
returns one value, an estimate of the number of
bits of subpixel resolution that are used to position rasterized geometry in window coordinates.
The value must be at least 4.
?GL_TEXTURE_BINDING_1D
: Params
returns a single value, the name of the texture
currently bound to the target ?GL_TEXTURE_1D
. The initial value is 0. See gl:bindTexture/2
.
?GL_TEXTURE_BINDING_1D_ARRAY
: Params
returns a single value, the name of
the texture currently bound to the target ?GL_TEXTURE_1D_ARRAY
. The initial value
is 0. See gl:bindTexture/2 .
?GL_TEXTURE_BINDING_2D
: Params
returns a single value, the name of the texture
currently bound to the target ?GL_TEXTURE_2D
. The initial value is 0. See gl:bindTexture/2
.
?GL_TEXTURE_BINDING_2D_ARRAY
: Params
returns a single value, the name of
the texture currently bound to the target ?GL_TEXTURE_2D_ARRAY
. The initial value
is 0. See gl:bindTexture/2 .
?GL_TEXTURE_BINDING_2D_MULTISAMPLE
: Params
returns a single value, the name
of the texture currently bound to the target ?GL_TEXTURE_2D_MULTISAMPLE
. The initial
value is 0. See gl:bindTexture/2 .
?GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY
: Params
returns a single value,
the name of the texture currently bound to the target ?GL_TEXTURE_2D_MULTISAMPLE_ARRAY
. The initial value is 0. See gl:bindTexture/2 .
?GL_TEXTURE_BINDING_3D
: Params
returns a single value, the name of the texture
currently bound to the target ?GL_TEXTURE_3D
. The initial value is 0. See gl:bindTexture/2
.
?GL_TEXTURE_BINDING_BUFFER
: Params
returns a single value, the name of the
texture currently bound to the target ?GL_TEXTURE_BUFFER
. The initial value is
0. See gl:bindTexture/2 .
?GL_TEXTURE_BINDING_CUBE_MAP
: Params
returns a single value, the name of
the texture currently bound to the target ?GL_TEXTURE_CUBE_MAP
. The initial value
is 0. See gl:bindTexture/2 .
?GL_TEXTURE_BINDING_RECTANGLE
: Params
returns a single value, the name of
the texture currently bound to the target ?GL_TEXTURE_RECTANGLE
. The initial value
is 0. See gl:bindTexture/2 .
?GL_TEXTURE_COMPRESSION_HINT
: Params
returns a single value indicating the
mode of the texture compression hint. The initial value is ?GL_DONT_CARE
.
?GL_TEXTURE_BUFFER_BINDING
: Params
returns a single value, the name of the
texture buffer object currently bound. The initial value is 0. See gl:bindBuffer/2 .
?GL_TIMESTAMP
: Params
returns a single value, the 64-bit value of the current
GL time. See gl:queryCounter/2 .
?GL_TRANSFORM_FEEDBACK_BUFFER_BINDING
: When used with non-indexed variants of gl:get
(such as gl:getIntegerv
), Params
returns a single value, the name of the
buffer object currently bound to the target ?GL_TRANSFORM_FEEDBACK_BUFFER
. If no
buffer object is bound to this target, 0 is returned. When used with indexed variants of gl:get
(such as gl:getIntegeri_v
), Params
returns a single value, the name of the
buffer object bound to the indexed transform feedback attribute stream. The initial value
is 0 for all targets. See gl:bindBuffer/2 , gl:bindBufferBase/3 , and gl:bindBufferRange/5
.
?GL_TRANSFORM_FEEDBACK_BUFFER_START
: When used with indexed variants of gl:get
(such as gl:getInteger64i_v
), Params
returns a single value, the start offset
of the binding range for each transform feedback attribute stream. The initial value is
0 for all streams. See gl:bindBufferRange/5 .
?GL_TRANSFORM_FEEDBACK_BUFFER_SIZE
: When used with indexed variants of gl:get
(such as gl:getInteger64i_v
), Params
returns a single value, the size of
the binding range for each transform feedback attribute stream. The initial value is 0
for all streams. See gl:bindBufferRange/5 .
?GL_UNIFORM_BUFFER_BINDING
: When used with non-indexed variants of gl:get
(such as gl:getIntegerv
), Params
returns a single value, the name of the
buffer object currently bound to the target ?GL_UNIFORM_BUFFER
. If no buffer object
is bound to this target, 0 is returned. When used with indexed variants of gl:get
(such as gl:getIntegeri_v
), Params
returns a single value, the name of the
buffer object bound to the indexed uniform buffer binding point. The initial value is
0 for all targets. See gl:bindBuffer/2 , gl:bindBufferBase/3 , and gl:bindBufferRange/5
.
?GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT
: Params
returns a single value, the
minimum required alignment for uniform buffer sizes and offset. The initial value is 1.
See gl:uniformBlockBinding/3 .
?GL_UNIFORM_BUFFER_SIZE
: When used with indexed variants of gl:get
(such
as gl:getInteger64i_v
), Params
returns a single value, the size of the binding
range for each indexed uniform buffer binding. The initial value is 0 for all bindings.
See gl:bindBufferRange/5 .
?GL_UNIFORM_BUFFER_START
: When used with indexed variants of gl:get
(such
as gl:getInteger64i_v
), Params
returns a single value, the start offset of
the binding range for each indexed uniform buffer binding. The initial value is 0 for
all bindings. See gl:bindBufferRange/5 .
?GL_UNPACK_ALIGNMENT
: Params
returns one value, the byte alignment used
for reading pixel data from memory. The initial value is 4. See gl:pixelStoref/2 .
?GL_UNPACK_IMAGE_HEIGHT
: Params
returns one value, the image height used
for reading pixel data from memory. The initial is 0. See gl:pixelStoref/2 .
?GL_UNPACK_LSB_FIRST
: Params
returns a single boolean value indicating whether
single-bit pixels being read from memory are read first from the least significant bit
of each unsigned byte. The initial value is ?GL_FALSE
. See gl:pixelStoref/2 .
?GL_UNPACK_ROW_LENGTH
: Params
returns one value, the row length used for
reading pixel data from memory. The initial value is 0. See gl:pixelStoref/2 .
?GL_UNPACK_SKIP_IMAGES
: Params
returns one value, the number of pixel images
skipped before the first pixel is read from memory. The initial value is 0. See gl:pixelStoref/2
.
?GL_UNPACK_SKIP_PIXELS
: Params
returns one value, the number of pixel locations
skipped before the first pixel is read from memory. The initial value is 0. See gl:pixelStoref/2
.
?GL_UNPACK_SKIP_ROWS
: Params
returns one value, the number of rows of pixel
locations skipped before the first pixel is read from memory. The initial value is 0.
See gl:pixelStoref/2 .
?GL_UNPACK_SWAP_BYTES
: Params
returns a single boolean value indicating
whether the bytes of two-byte and four-byte pixel indices and components are swapped after
being read from memory. The initial value is ?GL_FALSE
. See gl:pixelStoref/2 .
?GL_VERTEX_PROGRAM_POINT_SIZE
: Params
returns a single boolean value indicating
whether vertex program point size mode is enabled. If enabled, and a vertex shader is
active, then the point size is taken from the shader built-in gl_PointSize. If disabled,
and a vertex shader is active, then the point size is taken from the point state as specified
by gl:pointSize/1 . The initial value is ?GL_FALSE
.
?GL_VIEWPORT
: When used with non-indexed variants of gl:get
(such as gl:getIntegerv
), Params
returns four values: the x and y window coordinates of the viewport,
followed by its width and height. Initially the x and y window coordinates are both
set to 0, and the width and height are set to the width and height of the window into
which the GL will do its rendering. See gl:viewport/4 . When used with indexed
variants of gl:get
(such as gl:getIntegeri_v
), Params
returns four
values: the x and y window coordinates of the indexed viewport, followed by its width
and height. Initially the x and y window coordinates are both set to 0, and the width
and height are set to the width and height of the window into which the GL will do its
rendering. See gl:viewportIndexedf/5 .
?GL_VIEWPORT_BOUNDS_RANGE
: Params
returns two values, the minimum and maximum
viewport bounds range. The minimum range should be at least [-32768, 32767].
?GL_VIEWPORT_INDEX_PROVOKING_VERTEX
: Params
returns one value, the implementation
dependent specifc vertex of a primitive that is used to select the viewport index. If
the value returned is equivalent to ?GL_PROVOKING_VERTEX
, then the vertex selection
follows the convention specified by gl:provokingVertex/1 . If the value returned
is equivalent to ?GL_FIRST_VERTEX_CONVENTION
, then the selection is always taken
from the first vertex in the primitive. If the value returned is equivalent to ?GL_LAST_VERTEX_CONVENTION
, then the selection is always taken from the last vertex in the primitive. If the value
returned is equivalent to ?GL_UNDEFINED_VERTEX
, then the selection is not guaranteed
to be taken from any specific vertex in the primitive.
?GL_VIEWPORT_SUBPIXEL_BITS
: Params
returns a single value, the number of
bits of sub-pixel precision which the GL uses to interpret the floating point viewport
bounds. The minimum value is 0.
Many of the boolean parameters can also be queried more easily using gl:isEnabled/1 .
See
pushAttrib(Mask) -> ok
Mask = integer()
Push and pop the server attribute stack
gl:pushAttrib
takes one argument, a mask that indicates which groups of state variables
to save on the attribute stack. Symbolic constants are used to set bits in the mask. Mask
is typically constructed by specifying the bitwise-or of several of these constants
together. The special mask ?GL_ALL_ATTRIB_BITS
can be used to save all stackable
states.
The symbolic mask constants and their associated GL state are as follows (the second column lists which attributes are saved):
?GL_ACCUM_BUFFER_BIT
Accumulation buffer clear value
?GL_COLOR_BUFFER_BIT
?GL_ALPHA_TEST
enable bit
Alpha test function and reference value
?GL_BLEND
enable bit Blending source and destination functions
Constant blend color
Blending equation
?GL_DITHER
enable bit ?GL_DRAW_BUFFER
setting ?GL_COLOR_LOGIC_OP
enable bit ?GL_INDEX_LOGIC_OP
enable bit Logic op function
Color mode and index mode clear values
Color mode and index mode writemasks
?GL_CURRENT_BIT
Current RGBA color Current color index
Current normal vector
Current texture coordinates
Current raster position
?GL_CURRENT_RASTER_POSITION_VALID
flag RGBA color associated with current raster position
Color index associated with current raster position
Texture coordinates associated with current raster position
?GL_EDGE_FLAG
flag ?GL_DEPTH_BUFFER_BIT
?GL_DEPTH_TEST
enable
bit Depth buffer test function
Depth buffer clear value
?GL_DEPTH_WRITEMASK
enable
bit ?GL_ENABLE_BIT
?GL_ALPHA_TEST
flag ?GL_AUTO_NORMAL
flag ?GL_BLEND
flag
Enable bits for the user-definable clipping planes
?GL_COLOR_MATERIAL
?GL_CULL_FACE
flag ?GL_DEPTH_TEST
flag ?GL_DITHER
flag ?GL_FOG
flag ?GL_LIGHT
i
where ?0
<= i
< ?GL_MAX_LIGHTS
?GL_LIGHTING
flag ?GL_LINE_SMOOTH
flag ?GL_LINE_STIPPLE
flag ?GL_COLOR_LOGIC_OP
flag ?GL_INDEX_LOGIC_OP
flag ?GL_MAP1_
x
where x
is a map type ?GL_MAP2_
x
where x
is a map type ?GL_MULTISAMPLE
flag ?GL_NORMALIZE
flag ?GL_POINT_SMOOTH
flag ?GL_POLYGON_OFFSET_LINE
flag ?GL_POLYGON_OFFSET_FILL
flag ?GL_POLYGON_OFFSET_POINT
flag ?GL_POLYGON_SMOOTH
flag ?GL_POLYGON_STIPPLE
flag ?GL_SAMPLE_ALPHA_TO_COVERAGE
flag ?GL_SAMPLE_ALPHA_TO_ONE
flag ?GL_SAMPLE_COVERAGE
flag ?GL_SCISSOR_TEST
flag ?GL_STENCIL_TEST
flag ?GL_TEXTURE_1D
flag ?GL_TEXTURE_2D
flag ?GL_TEXTURE_3D
flag Flags
?GL_TEXTURE_GEN_
x
where x
is S, T, R, or Q ?GL_EVAL_BIT
?GL_MAP1_
x
enable bits, where x
is a map type ?GL_MAP2_
x
enable bits, where x
is a map type 1D grid endpoints and divisions
2D grid endpoints and divisions
?GL_AUTO_NORMAL
enable bit ?GL_FOG_BIT
?GL_FOG
enable bit Fog color
Fog density
Linear fog start
Linear fog end
Fog index
?GL_FOG_MODE
value
?GL_HINT_BIT
?GL_PERSPECTIVE_CORRECTION_HINT
setting
?GL_POINT_SMOOTH_HINT
setting ?GL_LINE_SMOOTH_HINT
setting ?GL_POLYGON_SMOOTH_HINT
setting ?GL_FOG_HINT
setting ?GL_GENERATE_MIPMAP_HINT
setting ?GL_TEXTURE_COMPRESSION_HINT
setting ?GL_LIGHTING_BIT
?GL_COLOR_MATERIAL
enable bit ?GL_COLOR_MATERIAL_FACE
value Color material parameters that are tracking the current color
Ambient scene color
?GL_LIGHT_MODEL_LOCAL_VIEWER
value ?GL_LIGHT_MODEL_TWO_SIDE
setting ?GL_LIGHTING
enable bit Enable bit for each light
Ambient, diffuse, and specular intensity for each light
Direction, position, exponent, and cutoff angle for each light
Constant, linear, and quadratic attenuation factors for each light
Ambient, diffuse, specular, and emissive color for each material
Ambient, diffuse, and specular color indices for each material
Specular exponent for each material
?GL_SHADE_MODEL
setting
?GL_LINE_BIT
?GL_LINE_SMOOTH
flag ?GL_LINE_STIPPLE
enable bit Line stipple pattern and repeat counter
Line width
?GL_LIST_BIT
?GL_LIST_BASE
setting ?GL_MULTISAMPLE_BIT
?GL_MULTISAMPLE
flag ?GL_SAMPLE_ALPHA_TO_COVERAGE
flag ?GL_SAMPLE_ALPHA_TO_ONE
flag ?GL_SAMPLE_COVERAGE
flag ?GL_SAMPLE_COVERAGE_VALUE
value ?GL_SAMPLE_COVERAGE_INVERT
value ?GL_PIXEL_MODE_BIT
?GL_RED_BIAS
and ?GL_RED_SCALE
settings
?GL_GREEN_BIAS
and ?GL_GREEN_SCALE
values ?GL_BLUE_BIAS
and ?GL_BLUE_SCALE
?GL_ALPHA_BIAS
and ?GL_ALPHA_SCALE
?GL_DEPTH_BIAS
and ?GL_DEPTH_SCALE
?GL_INDEX_OFFSET
and ?GL_INDEX_SHIFT
values
?GL_MAP_COLOR
and ?GL_MAP_STENCIL
flags ?GL_ZOOM_X
and ?GL_ZOOM_Y
factors ?GL_READ_BUFFER
setting ?GL_POINT_BIT
?GL_POINT_SMOOTH
flag
Point size
?GL_POLYGON_BIT
?GL_CULL_FACE
enable bit ?GL_CULL_FACE_MODE
value ?GL_FRONT_FACE
indicator ?GL_POLYGON_MODE
setting ?GL_POLYGON_SMOOTH
flag ?GL_POLYGON_STIPPLE
enable bit ?GL_POLYGON_OFFSET_FILL
flag ?GL_POLYGON_OFFSET_LINE
flag ?GL_POLYGON_OFFSET_POINT
flag ?GL_POLYGON_OFFSET_FACTOR
?GL_POLYGON_OFFSET_UNITS
?GL_POLYGON_STIPPLE_BIT
Polygon stipple image ?GL_SCISSOR_BIT
?GL_SCISSOR_TEST
flag Scissor box
?GL_STENCIL_BUFFER_BIT
?GL_STENCIL_TEST
enable bit Stencil function and reference value
Stencil value mask
Stencil fail, pass, and depth buffer pass actions
Stencil buffer clear value
Stencil buffer writemask
?GL_TEXTURE_BIT
Enable bits for the four texture coordinates Border color for each texture image
Minification function for each texture image
Magnification function for each texture image
Texture coordinates and wrap mode for each texture image
Color and mode for each texture environment
Enable bits
?GL_TEXTURE_GEN_
x
, x
is S, T,
R, and Q ?GL_TEXTURE_GEN_MODE
setting for S, T, R, and
Q gl:texGend/3 plane equations for S, T, R, and Q
Current texture bindings (for example,
?GL_TEXTURE_BINDING_2D
)
?GL_TRANSFORM_BIT
Coefficients of the six clipping planes
Enable bits for the user-definable clipping planes
?GL_MATRIX_MODE
value ?GL_NORMALIZE
flag ?GL_RESCALE_NORMAL
flag ?GL_VIEWPORT_BIT
Depth range (near and far) Viewport origin and extent
gl:pushAttrib/1 restores the values of the state variables saved with the last gl:pushAttrib
command. Those not saved are left unchanged.
It is an error to push attributes onto a full stack or to pop attributes off an empty stack. In either case, the error flag is set and no other change is made to GL state.
Initially, the attribute stack is empty.
See
popAttrib() -> ok
See pushAttrib/1
pushClientAttrib(Mask) -> ok
Mask = integer()
Push and pop the client attribute stack
gl:pushClientAttrib
takes one argument, a mask that indicates which groups of client-state
variables to save on the client attribute stack. Symbolic constants are used to set bits
in the mask. Mask
is typically constructed by specifying the bitwise-or of several
of these constants together. The special mask ?GL_CLIENT_ALL_ATTRIB_BITS
can
be used to save all stackable client state.
The symbolic mask constants and their associated GL client state are as follows (the second column lists which attributes are saved):
?GL_CLIENT_PIXEL_STORE_BIT
Pixel storage modes ?GL_CLIENT_VERTEX_ARRAY_BIT
Vertex arrays (and enables)
gl:pushClientAttrib/1 restores the values of the client-state variables saved with
the last gl:pushClientAttrib
. Those not saved are left unchanged.
It is an error to push attributes onto a full client attribute stack or to pop attributes off an empty stack. In either case, the error flag is set, and no other change is made to GL state.
Initially, the client attribute stack is empty.
See
popClientAttrib() -> ok
renderMode(Mode) -> integer()
Mode = enum()
Set rasterization mode
gl:renderMode
sets the rasterization mode. It takes one argument, Mode
, which
can assume one of three predefined values:
?GL_RENDER
: Render mode. Primitives are rasterized, producing pixel fragments,
which are written into the frame buffer. This is the normal mode and also the default
mode.
?GL_SELECT
: Selection mode. No pixel fragments are produced, and no change to
the frame buffer contents is made. Instead, a record of the names of primitives that would
have been drawn if the render mode had been ?GL_RENDER
is returned in a select
buffer, which must be created (see gl:selectBuffer/2 ) before selection mode is
entered.
?GL_FEEDBACK
: Feedback mode. No pixel fragments are produced, and no change to
the frame buffer contents is made. Instead, the coordinates and attributes of vertices
that would have been drawn if the render mode had been ?GL_RENDER
is returned in
a feedback buffer, which must be created (see gl:feedbackBuffer/3 ) before feedback
mode is entered.
The return value of gl:renderMode
is determined by the render mode at the time gl:renderMode
is called, rather than by Mode
. The values returned for the three render modes
are as follows:
?GL_RENDER
: 0.
?GL_SELECT
: The number of hit records transferred to the select buffer.
?GL_FEEDBACK
: The number of values (not vertices) transferred to the feedback
buffer.
See the gl:selectBuffer/2 and gl:feedbackBuffer/3 reference pages for more details concerning selection and feedback operation.
See
getError() -> enum()
Return error information
gl:getError
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 gl:getError
is called, the
error code is returned, and the flag is reset to ?GL_NO_ERROR
. If a call to gl:getError
returns ?GL_NO_ERROR
, there has been no detectable error since the last call to gl:getError
, 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 gl:getError
is called. If more than one flag has
recorded an error, gl:getError
returns and clears an arbitrary error flag value.
Thus, gl:getError
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_INVALID_FRAMEBUFFER_OPERATION
: The framebuffer object is not complete. 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 gl:getError
itself generates an error, it returns 0.
See
getString(Name) -> string()
Name = enum()
Return a string describing the current GL connection
gl:getString
returns a pointer to a static string describing some aspect of the
current GL connection. 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 a version or release number.
?GL_SHADING_LANGUAGE_VERSION
: Returns a version or release number for the shading
language.
gl:getStringi
returns a pointer to a static string indexed by Index
. Name
can be one of the following:
?GL_EXTENSIONS
: For gl:getStringi
only, returns the extension string supported
by the implementation at Index
.
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.
The ?GL_VERSION
and ?GL_SHADING_LANGUAGE_VERSION
strings begin with a version
number. The version number uses one of these forms:
major_number.minor_number
major_number.minor_number.release_number
Vendor-specific information may follow the version number. Its format depends on the implementation, but a space always separates the version number and the vendor-specific information.
All strings are null-terminated.
See
finish() -> ok
Block until all GL execution is complete
gl:finish
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.
See
flush() -> ok
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. gl:flush
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 gl:flush
whenever they count on having all of
their previously issued commands completed. For example, call gl:flush
before waiting
for user input that depends on the generated image.
See
hint(Target, Mode) -> ok
Target = enum()
Mode = enum()
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_FRAGMENT_SHADER_DERIVATIVE_HINT
: Indicates the accuracy of the derivative
calculation for the GL shading language fragment processing built-in functions: ?dFdx
, ?dFdy
, and ?fwidth
.
?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_POLYGON_SMOOTH_HINT
: Indicates the sampling quality of antialiased polygons.
Hinting ?GL_NICEST
can result in more pixel fragments being generated during rasterization,
if a larger filter function is applied.
?GL_TEXTURE_COMPRESSION_HINT
: Indicates the quality and performance of the compressing
texture images. Hinting ?GL_FASTEST
indicates that texture images should be compressed
as quickly as possible, while ?GL_NICEST
indicates that texture images should be
compressed with as little image quality loss as possible. ?GL_NICEST
should be
selected if the texture is to be retrieved by gl:getCompressedTexImage/3 for reuse.
See
clearDepth(Depth) -> ok
Depth = clamp()
Specify the clear value for the depth buffer
gl:clearDepth
specifies the depth value used by gl:clear/1 to clear the depth
buffer. Values specified by gl:clearDepth
are clamped to the range [0 1].
See
depthFunc(Func) -> ok
Func = enum()
Specify the value used for depth buffer comparisons
gl:depthFunc
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. (See gl:enable/1 and gl:enable/1 of ?GL_DEPTH_TEST
.)
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.
If depth testing is disabled or if no depth buffer exists, it is as if the depth test
always passes.
See
depthMask(Flag) -> ok
Flag = 0 | 1
Enable or disable writing into the depth buffer
gl:depthMask
specifies whether the depth buffer is enabled for writing. If Flag
is ?GL_FALSE
, depth buffer writing is disabled. Otherwise, it is enabled. Initially,
depth buffer writing is enabled.
See
depthRange(Near_val, Far_val) -> ok
Near_val = clamp()
Far_val = clamp()
Specify mapping of depth values from normalized device coordinates to window coordinates
After clipping and division by w
, depth coordinates range from -1 to 1, corresponding
to the near and far clipping planes. gl:depthRange
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 gl:depthRange
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.
See
clearAccum(Red, Green, Blue, Alpha) -> ok
Red = float()
Green = float()
Blue = float()
Alpha = float()
Specify clear values for the accumulation buffer
gl:clearAccum
specifies the red, green, blue, and alpha values used by gl:clear/1
to clear the accumulation buffer.
Values specified by gl:clearAccum
are clamped to the range [-1 1].
See
accum(Op, Value) -> ok
Op = enum()
Value = float()
Operate on the accumulation buffer
The accumulation buffer is an extended-range color buffer. Images are not rendered into it. Rather, images rendered into one of the color buffers are added to the contents of the accumulation buffer after rendering. Effects such as antialiasing (of points, lines, and polygons), motion blur, and depth of field can be created by accumulating images generated with different transformation matrices.
Each pixel in the accumulation buffer consists of red, green, blue, and alpha values.
The number of bits per component in the accumulation buffer depends on the implementation.
You can examine this number by calling gl:getBooleanv/1 four times, with arguments
?GL_ACCUM_RED_BITS
, ?GL_ACCUM_GREEN_BITS
, ?GL_ACCUM_BLUE_BITS
, and ?GL_ACCUM_ALPHA_BITS
. Regardless of the number of bits per component, the range of values stored by each component
is [-1 1]. The accumulation buffer pixels are mapped one-to-one with frame buffer pixels.
gl:accum
operates on the accumulation buffer. The first argument, Op
, is
a symbolic constant that selects an accumulation buffer operation. The second argument, Value
, is a floating-point value to be used in that operation. Five operations are specified: ?GL_ACCUM
, ?GL_LOAD
, ?GL_ADD
, ?GL_MULT
, and ?GL_RETURN
.
All accumulation buffer operations are limited to the area of the current scissor box
and applied identically to the red, green, blue, and alpha components of each pixel. If
a gl:accum
operation results in a value outside the range [-1 1], the contents of an
accumulation buffer pixel component are undefined.
The operations are as follows:
?GL_ACCUM
: Obtains R, G, B, and A values from the buffer currently selected for
reading (see gl:readBuffer/1 ). Each component value is divided by 2 n-1, where
n is the number of bits allocated to each color component in the currently selected buffer.
The result is a floating-point value in the range [0 1], which is multiplied by Value
and added to the corresponding pixel component in the accumulation buffer, thereby updating
the accumulation buffer.
?GL_LOAD
: Similar to ?GL_ACCUM
, except that the current value in the accumulation
buffer is not used in the calculation of the new value. That is, the R, G, B, and A values
from the currently selected buffer are divided by 2 n-1, multiplied by Value
,
and then stored in the corresponding accumulation buffer cell, overwriting the current
value.
?GL_ADD
: Adds Value
to each R, G, B, and A in the accumulation buffer.
?GL_MULT
: Multiplies each R, G, B, and A in the accumulation buffer by Value
and returns the scaled component to its corresponding accumulation buffer location.
?GL_RETURN
: Transfers accumulation buffer values to the color buffer or buffers
currently selected for writing. Each R, G, B, and A component is multiplied by Value
, then multiplied by 2 n-1, clamped to the range [0 2 n-1], and stored in the corresponding
display buffer cell. The only fragment operations that are applied to this transfer are
pixel ownership, scissor, dithering, and color writemasks.
To clear the accumulation buffer, call gl:clearAccum/4 with R, G, B, and A values to set it to, then call gl:clear/1 with the accumulation buffer enabled.
See
matrixMode(Mode) -> ok
Mode = enum()
Specify which matrix is the current matrix
gl:matrixMode
sets the current matrix mode. Mode
can assume one of four values:
?GL_MODELVIEW
: Applies subsequent matrix operations to the modelview matrix stack.
?GL_PROJECTION
: Applies subsequent matrix operations to the projection matrix
stack.
?GL_TEXTURE
: Applies subsequent matrix operations to the texture matrix stack.
?GL_COLOR
: Applies subsequent matrix operations to the color matrix stack.
To find out which matrix stack is currently the target of all matrix operations, call gl:getBooleanv/1
with argument ?GL_MATRIX_MODE
. The initial value is ?GL_MODELVIEW
.
See
ortho(Left, Right, Bottom, Top, Near_val, Far_val) -> ok
Left = float()
Right = float()
Bottom = float()
Top = float()
Near_val = float()
Far_val = float()
Multiply the current matrix with an orthographic matrix
gl:ortho
describes a transformation that produces a parallel projection. The current
matrix (see gl:matrixMode/1 ) is multiplied by this matrix and the result replaces
the current matrix, as if gl:multMatrixd/1 were called with the following matrix
as its argument:
((2/(right-left)) 0 0(t x) 0(2/(top-bottom)) 0(t y) 0 0(-2/(farVal-nearVal))(t z) 0 0 0 1)
where t x=-((right+left)/(right-left)) t y=-((top+bottom)/(top-bottom)) t z=-((farVal+nearVal)/(farVal-nearVal))
Typically, the matrix mode is ?GL_PROJECTION
, and (left bottom-nearVal) and (right top-nearVal) 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). -farVal specifies
the location of the far clipping plane. Both NearVal
and FarVal
can be either
positive or negative.
Use gl:pushMatrix/0 and gl:pushMatrix/0 to save and restore the current matrix stack.
See
frustum(Left, Right, Bottom, Top, Near_val, Far_val) -> ok
Left = float()
Right = float()
Bottom = float()
Top = float()
Near_val = float()
Far_val = float()
Multiply the current matrix by a perspective matrix
gl:frustum
describes a perspective matrix that produces a perspective projection.
The current matrix (see gl:matrixMode/1 ) is multiplied by this matrix and the result
replaces the current matrix, as if gl:multMatrixd/1 were called with the following
matrix as its argument:
[((2 nearVal)/(right-left)) 0 A 0 0((2 nearVal)/(top-bottom)) B 0 0 0 C D 0 0 -1 0]
A=(right+left)/(right-left)
B=(top+bottom)/(top-bottom)
C=-((farVal+nearVal)/(farVal-nearVal))
D=-((2 farVal nearVal)/(farVal-nearVal))
Typically, the matrix mode is ?GL_PROJECTION
, and (left bottom-nearVal) and (right top-nearVal) 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). -farVal specifies the location
of the far clipping plane. Both NearVal
and FarVal
must be positive.
Use gl:pushMatrix/0 and gl:pushMatrix/0 to save and restore the current matrix stack.
See
viewport(X, Y, Width, Height) -> ok
X = integer()
Y = integer()
Width = integer()
Height = integer()
Set the viewport
gl:viewport
specifies the affine transformation of x and y from normalized device
coordinates to window coordinates. Let (x nd y nd) be normalized device coordinates. Then the window
coordinates (x w y w) are computed as follows:
x w=(x nd+1) (width/2)+x
y w=(y nd+1) (height/2)+y
Viewport width and height are silently clamped to a range that depends on the implementation.
To query this range, call gl:getBooleanv/1 with argument ?GL_MAX_VIEWPORT_DIMS
.
See
pushMatrix() -> ok
Push and pop 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 32. In the other modes, ?GL_COLOR
, ?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.
gl:pushMatrix
pushes the current matrix stack down by one, duplicating the current
matrix. That is, after a gl:pushMatrix
call, the matrix on top of the stack is identical
to the one below it.
gl:pushMatrix/0 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.
See
popMatrix() -> ok
See pushMatrix/0
loadIdentity() -> ok
Replace the current matrix with the identity matrix
gl:loadIdentity
replaces the current matrix with the identity matrix. It is semantically
equivalent to calling gl:loadMatrixd/1 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.
See
loadMatrixd(M) -> ok
M = matrix()
Replace the current matrix with the specified matrix
gl:loadMatrix
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 gl:matrixMode/1 ).
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
points to an array of 16 single- or double-precision floating-point values
m={m[0] m[1] ... m[15]}, then the modelview transformation M(v) does the following:
M(v)=(m[0] m[4] m[8] m[12] m[1] m[5] m[9] m[13] m[2] m[6] m[10] m[14] m[3] m[7] m[11] m[15])×(v[0] v[1] v[2] v[3])
Projection and texture transformations are similarly defined.
See
multMatrixd(M) -> ok
M = matrix()
Multiply the current matrix with the specified matrix
gl:multMatrix
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 gl:matrixMode/1 ). It is either the projection matrix, modelview matrix, or the texture matrix.
See
rotated(Angle, X, Y, Z) -> ok
Angle = float()
X = float()
Y = float()
Z = float()
Multiply the current matrix by a rotation matrix
gl:rotate
produces a rotation of Angle
degrees around the vector (x y z). The current
matrix (see gl:matrixMode/1 ) is multiplied by a rotation matrix with the product
replacing the current matrix, as if gl:multMatrixd/1 were called with the following
matrix as its argument:
(x 2(1-c)+c x y(1-c)-z s x z(1-c)+y s 0 y x(1-c)+z s y 2(1-c)+c y z(1-c)-x s 0 x z(1-c)-y s y z(1-c)+x s z 2(1-c)+c 0 0 0 0 1)
Where c=cos(angle), s=sin(angle), and ||(x y z)||=1 (if not, the GL will normalize this vector).
If the matrix mode is either ?GL_MODELVIEW
or ?GL_PROJECTION
, all objects
drawn after gl:rotate
is called are rotated. Use gl:pushMatrix/0 and gl:pushMatrix/0
to save and restore the unrotated coordinate system.
See
scaled(X, Y, Z) -> ok
X = float()
Y = float()
Z = float()
Multiply the current matrix by a general scaling matrix
gl:scale
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 gl:matrixMode/1 ) is multiplied by this scale matrix, and the product replaces the current matrix as if gl:multMatrixd/1 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 gl:scale
is called are scaled.
Use gl:pushMatrix/0 and gl:pushMatrix/0 to save and restore the unscaled coordinate system.
See
translated(X, Y, Z) -> ok
X = float()
Y = float()
Z = float()
Multiply the current matrix by a translation matrix
gl:translate
produces a translation by (x y z). The current matrix (see gl:matrixMode/1
) is multiplied by this translation matrix, with the product replacing the current matrix,
as if gl:multMatrixd/1 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 gl:translate
are translated.
Use gl:pushMatrix/0 and gl:pushMatrix/0 to save and restore the untranslated coordinate system.
See
isList(List) -> 0 | 1
List = integer()
Determine if a name corresponds to a display list
gl:isList
returns ?GL_TRUE
if List
is the name of a display list and
returns ?GL_FALSE
if it is not, or if an error occurs.
A name returned by gl:genLists/1 , but not yet associated with a display list by calling gl:newList/2 , is not the name of a display list.
See
deleteLists(List, Range) -> ok
List = integer()
Range = integer()
Delete a contiguous group of display lists
gl:deleteLists
causes a contiguous group of display lists to be deleted. List
is the name of the first display list to be deleted, and Range
is the number of
display lists to delete. All display lists d with list<= d<= list+range-1 are
deleted.
All storage locations allocated to the specified display lists are freed, and the names
are available for reuse at a later time. Names within the range that do not have an associated
display list are ignored. If Range
is 0, nothing happens.
See
genLists(Range) -> integer()
Range = integer()
Generate a contiguous set of empty display lists
gl:genLists
has one argument, Range
. It returns an integer n
such
that Range
contiguous empty display lists, named n, n+1, ..., n+range-1,
are created. If Range
is 0, if there is no group of Range
contiguous names
available, or if any error is generated, no display lists are generated, and 0 is returned.
See
newList(List, Mode) -> ok
List = integer()
Mode = enum()
Create or replace a display list
Display lists are groups of GL commands that have been stored for subsequent execution.
Display lists are created with gl:newList
. All subsequent commands are placed in
the display list, in the order issued, until gl:endList/0 is called.
gl:newList
has two arguments. The first argument, List
, is a positive integer
that becomes the unique name for the display list. Names can be created and reserved with
gl:genLists/1 and tested for uniqueness with gl:isList/1 . The second argument,
Mode
, is a symbolic constant that can assume one of two values:
?GL_COMPILE
: Commands are merely compiled.
?GL_COMPILE_AND_EXECUTE
: Commands are executed as they are compiled into the display
list.
Certain commands are not compiled into the display list but are executed immediately, regardless of the display-list mode. These commands are gl:areTexturesResident/1 , gl:colorPointer/4 , gl:deleteLists/2 , gl:deleteTextures/1 , gl:enableClientState/1 , gl:edgeFlagPointer/2 , gl:enableClientState/1 , gl:feedbackBuffer/3 , gl:finish/0 , gl:flush/0 , gl:genLists/1 , gl:genTextures/1 , gl:indexPointer/3 , gl:interleavedArrays/3 , gl:isEnabled/1 , gl:isList/1 , gl:isTexture/1 , gl:normalPointer/3 , gl:pushClientAttrib/1 , gl:pixelStoref/2 , gl:pushClientAttrib/1 , gl:readPixels/7 , gl:renderMode/1 , gl:selectBuffer/2 , gl:texCoordPointer/4 , gl:vertexPointer/4 , and all of the gl:getBooleanv/1 commands.
Similarly, gl:texImage1D/8 , gl:texImage2D/9 , and gl:texImage3D/10
are executed immediately and not compiled into the display list when their first argument
is ?GL_PROXY_TEXTURE_1D
, ?GL_PROXY_TEXTURE_1D
, or ?GL_PROXY_TEXTURE_3D
, respectively.
When the ARB_imaging extension is supported, gl:histogram/4 executes immediately
when its argument is ?GL_PROXY_HISTOGRAM
. Similarly, gl:colorTable/6 executes
immediately when its first argument is ?GL_PROXY_COLOR_TABLE
, ?GL_PROXY_POST_CONVOLUTION_COLOR_TABLE
, or ?GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE
.
For OpenGL versions 1.3 and greater, or when the ARB_multitexture extension is supported, gl:clientActiveTexture/1 is not compiled into display lists, but executed immediately.
When gl:endList/0 is encountered, the display-list definition is completed by
associating the list with the unique name List
(specified in the gl:newList
command). If a display list with name List
already exists, it is replaced only
when gl:endList/0 is called.
See
endList() -> ok
glBeginList
See
callList(List) -> ok
List = integer()
Execute a display list
gl:callList
causes the named display list to be executed. The commands saved in
the display list are executed in order, just as if they were called without using a display
list. If List
has not been defined as a display list, gl:callList
is ignored.
gl:callList
can appear inside a display list. To avoid the possibility of infinite
recursion resulting from display lists calling one another, a limit is placed on the nesting
level of display lists during display-list execution. This limit is at least 64, and it
depends on the implementation.
GL state is not saved and restored across a call to gl:callList
. Thus, changes
made to GL state during the execution of a display list remain after execution of the
display list is completed. Use gl:pushAttrib/1 , gl:pushAttrib/1 , gl:pushMatrix/0
, and gl:pushMatrix/0 to preserve GL state across gl:callList
calls.
See
callLists(Lists) -> ok
Lists = [integer()]
Execute a list of display lists
gl:callLists
causes each display list in the list of names passed as Lists
to be executed. As a result, the commands saved in each display list are executed in order,
just as if they were called without using a display list. Names of display lists that
have not been defined are ignored.
gl:callLists
provides an efficient means for executing more than one display list. Type
allows lists with various name formats to be accepted. The formats are as follows:
?GL_BYTE
: Lists
is treated as an array of signed bytes, each in the range
-128 through 127.
?GL_UNSIGNED_BYTE
: Lists
is treated as an array of unsigned bytes, each
in the range 0 through 255.
?GL_SHORT
: Lists
is treated as an array of signed two-byte integers, each
in the range -32768 through 32767.
?GL_UNSIGNED_SHORT
: Lists
is treated as an array of unsigned two-byte integers,
each in the range 0 through 65535.
?GL_INT
: Lists
is treated as an array of signed four-byte integers.
?GL_UNSIGNED_INT
: Lists
is treated as an array of unsigned four-byte integers.
?GL_FLOAT
: Lists
is treated as an array of four-byte floating-point values.
?GL_2_BYTES
: Lists
is treated as an array of unsigned bytes. Each pair of
bytes specifies a single display-list name. The value of the pair is computed as 256 times
the unsigned value of the first byte plus the unsigned value of the second byte.
?GL_3_BYTES
: Lists
is treated as an array of unsigned bytes. Each triplet
of bytes specifies a single display-list name. The value of the triplet is computed as
65536 times the unsigned value of the first byte, plus 256 times the unsigned value of
the second byte, plus the unsigned value of the third byte.
?GL_4_BYTES
: Lists
is treated as an array of unsigned bytes. Each quadruplet
of bytes specifies a single display-list name. The value of the quadruplet is computed
as 16777216 times the unsigned value of the first byte, plus 65536 times the unsigned
value of the second byte, plus 256 times the unsigned value of the third byte, plus the
unsigned value of the fourth byte.
The list of display-list names is not null-terminated. Rather, N
specifies how
many names are to be taken from Lists
.
An additional level of indirection is made available with the gl:listBase/1 command,
which specifies an unsigned offset that is added to each display-list name specified in Lists
before that display list is executed.
gl:callLists
can appear inside a display list. To avoid the possibility of infinite
recursion resulting from display lists calling one another, a limit is placed on the nesting
level of display lists during display-list execution. This limit must be at least 64,
and it depends on the implementation.
GL state is not saved and restored across a call to gl:callLists
. Thus, changes
made to GL state during the execution of the display lists remain after execution is completed.
Use gl:pushAttrib/1 , gl:pushAttrib/1 , gl:pushMatrix/0 , and gl:pushMatrix/0
to preserve GL state across gl:callLists
calls.
See
listBase(Base) -> ok
Base = integer()
set the display-list base for
gl:callLists/1 specifies an array of offsets. Display-list names are generated
by adding Base
to each offset. Names that reference valid display lists are executed;
the others are ignored.
See
begin(Mode) -> ok
Mode = enum()
Delimit the vertices of a primitive or a group of like primitives
gl:'begin
' and gl:'begin'/1 delimit the vertices that define a primitive or a group
of like primitives. gl:'begin
' accepts a single argument that specifies in which of
ten ways the vertices are interpreted. Taking n as an integer count starting at one,
and N as the total number of vertices specified, the interpretations are as follows:
?GL_POINTS
: Treats each vertex as a single point. Vertex n defines point n.
N points are drawn.
?GL_LINES
: Treats each pair of vertices as an independent line segment. Vertices
2 n-1 and 2 n define line n. N/2 lines are drawn.
?GL_LINE_STRIP
: Draws a connected group of line segments from the first vertex
to the last. Vertices n and n+1 define line n. N-1 lines are drawn.
?GL_LINE_LOOP
: Draws a connected group of line segments from the first vertex
to the last, then back to the first. Vertices n and n+1 define line n. The last
line, however, is defined by vertices N and 1. N lines are drawn.
?GL_TRIANGLES
: Treats each triplet of vertices as an independent triangle. Vertices
3 n-2, 3 n-1, and 3 n define triangle n. N/3 triangles are drawn.
?GL_TRIANGLE_STRIP
: Draws a connected group of triangles. One triangle is defined
for each vertex presented after the first two vertices. For odd n, vertices n, n+1,
and n+2 define triangle n. For even n, vertices n+1, n, and n+2 define triangle
n. N-2 triangles are drawn.
?GL_TRIANGLE_FAN
: Draws a connected group of triangles. One triangle is defined
for each vertex presented after the first two vertices. Vertices 1, n+1, and n+2
define triangle n. N-2 triangles are drawn.
?GL_QUADS
: Treats each group of four vertices as an independent quadrilateral.
Vertices 4 n-3, 4 n-2, 4 n-1, and 4 n define quadrilateral n. N/4 quadrilaterals
are drawn.
?GL_QUAD_STRIP
: Draws a connected group of quadrilaterals. One quadrilateral is
defined for each pair of vertices presented after the first pair. Vertices 2 n-1, 2
n, 2 n+2, and 2 n+1 define quadrilateral n. N/2-1 quadrilaterals are drawn. Note
that the order in which vertices are used to construct a quadrilateral from strip data
is different from that used with independent data.
?GL_POLYGON
: Draws a single, convex polygon. Vertices 1 through N define this
polygon.
Only a subset of GL commands can be used between gl:'begin
' and gl:'begin'/1 .
The commands are gl:vertex2d/2 , gl:color3b/3 , gl:secondaryColor3b/3 , gl:indexd/1
, gl:normal3b/3 , gl:fogCoordf/1 , gl:texCoord1d/1 , gl:multiTexCoord1d/2
, gl:vertexAttrib1d/2 , gl:evalCoord1d/1 , gl:evalPoint1/1 , gl:arrayElement/1
, gl:materialf/3 , and gl:edgeFlag/1 . Also, it is acceptable to use gl:callList/1
or gl:callLists/1 to execute display lists that include only the preceding commands.
If any other GL command is executed between gl:'begin
' and gl:'begin'/1 , the error
flag is set and the command is ignored.
Regardless of the value chosen for Mode
, there is no limit to the number of vertices
that can be defined between gl:'begin
' and gl:'begin'/1 . Lines, triangles, quadrilaterals,
and polygons that are incompletely specified are not drawn. Incomplete specification results
when either too few vertices are provided to specify even a single primitive or when an
incorrect multiple of vertices is specified. The incomplete primitive is ignored; the
rest are drawn.
The minimum specification of vertices for each primitive is as follows: 1 for a point,
2 for a line, 3 for a triangle, 4 for a quadrilateral, and 3 for a polygon. Modes that
require a certain multiple of vertices are ?GL_LINES
(2), ?GL_TRIANGLES
(3), ?GL_QUADS
(4), and ?GL_QUAD_STRIP
(2).
See
end() -> ok
See 'begin'/1
vertex2d(X, Y) -> ok
X = float()
Y = float()
Specify a vertex
gl:vertex
commands are used within gl:'begin'/1 / gl:'begin'/1 pairs to specify
point, line, and polygon vertices. The current color, normal, texture coordinates, and
fog coordinate are associated with the vertex when gl:vertex
is called.
When only x and y are specified, z defaults to 0 and w defaults to 1. When x, y, and z are specified, w defaults to 1.
See
vertex4dv(V) -> ok
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to vertex4d(X, Y, Z, W).
vertex4fv(V) -> ok
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to vertex4f(X, Y, Z, W).
vertex4iv(V) -> ok
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertex4i(X, Y, Z, W).
vertex4sv(V) -> ok
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertex4s(X, Y, Z, W).
normal3b(Nx, Ny, Nz) -> ok
Nx = integer()
Ny = integer()
Nz = integer()
Set the current normal vector
The current normal is set to the given coordinates whenever gl:normal
is issued.
Byte, short, or integer arguments are converted to floating-point format 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 gl:normal
need not have unit length. If ?GL_NORMALIZE
is enabled, then normals of any length specified with gl:normal
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 gl:enable/1
and gl:enable/1 with either ?GL_NORMALIZE
or ?GL_RESCALE_NORMAL
.
Normalization is initially disabled.
See
normal3bv(V) -> ok
V = {Nx::integer(), Ny::integer(), Nz::integer()}
Equivalent to normal3b(Nx, Ny, Nz).
normal3iv(V) -> ok
V = {Nx::integer(), Ny::integer(), Nz::integer()}
Equivalent to normal3i(Nx, Ny, Nz).
normal3sv(V) -> ok
V = {Nx::integer(), Ny::integer(), Nz::integer()}
Equivalent to normal3s(Nx, Ny, Nz).
indexd(C) -> ok
C = float()
Set the current color index
gl:index
updates the current (single-valued) color index. It takes one argument,
the new value for the current color index.
The current index is stored as a floating-point value. Integer values are converted directly to floating-point values, with no special mapping. The initial value is 1.
Index values outside the representable range of the color index buffer are not clamped. However, before an index is dithered (if enabled) and written to the frame buffer, it is converted to fixed-point format. Any bits in the integer portion of the resulting fixed-point value that do not correspond to bits in the frame buffer are masked out.
See
color3b(Red, Green, Blue) -> ok
Red = integer()
Green = integer()
Blue = integer()
Set the current color
The GL stores both a current single-valued color index and a current four-valued RGBA
color. gl:color
sets a new four-valued RGBA color. gl:color
has two major
variants: gl:color3
and gl:color4
. gl:color3
variants specify new red,
green, and blue values explicitly and set the current alpha value to 1.0 (full intensity)
implicitly. gl:color4
variants specify all four color components explicitly.
gl:color3b
, gl:color4b
, gl:color3s
, gl:color4s
, gl:color3i
,
and gl:color4i
take three or four signed byte, short, or long integers as arguments.
When v
is appended to the name, the color commands can take a pointer to an array
of such values.
Current color values are stored in floating-point format, with unspecified mantissa and exponent sizes. Unsigned integer color components, when specified, are linearly mapped to floating-point values such that the largest representable value maps to 1.0 (full intensity), and 0 maps to 0.0 (zero intensity). Signed integer color components, when specified, are linearly mapped to floating-point values such that the most positive representable value maps to 1.0, and the most negative representable value maps to -1.0. (Note that this mapping does not convert 0 precisely to 0.0.) Floating-point values are mapped directly.
Neither floating-point nor signed integer 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 a color buffer.
See
color4b(Red, Green, Blue, Alpha) -> ok
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color4d(Red, Green, Blue, Alpha) -> ok
Red = float()
Green = float()
Blue = float()
Alpha = float()
See color3b/3
color4f(Red, Green, Blue, Alpha) -> ok
Red = float()
Green = float()
Blue = float()
Alpha = float()
See color3b/3
color4i(Red, Green, Blue, Alpha) -> ok
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color4s(Red, Green, Blue, Alpha) -> ok
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color4ub(Red, Green, Blue, Alpha) -> ok
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color4ui(Red, Green, Blue, Alpha) -> ok
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color4us(Red, Green, Blue, Alpha) -> ok
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color3bv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3b(Red, Green, Blue).
color3dv(V) -> ok
V = {Red::float(), Green::float(), Blue::float()}
Equivalent to color3d(Red, Green, Blue).
color3fv(V) -> ok
V = {Red::float(), Green::float(), Blue::float()}
Equivalent to color3f(Red, Green, Blue).
color3iv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3i(Red, Green, Blue).
color3sv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3s(Red, Green, Blue).
color3ubv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3ub(Red, Green, Blue).
color3uiv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3ui(Red, Green, Blue).
color3usv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3us(Red, Green, Blue).
color4bv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4b(Red, Green, Blue, Alpha).
color4dv(V) -> ok
V = {Red::float(), Green::float(), Blue::float(), Alpha::float()}
Equivalent to color4d(Red, Green, Blue, Alpha).
color4fv(V) -> ok
V = {Red::float(), Green::float(), Blue::float(), Alpha::float()}
Equivalent to color4f(Red, Green, Blue, Alpha).
color4iv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4i(Red, Green, Blue, Alpha).
color4sv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4s(Red, Green, Blue, Alpha).
color4ubv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4ub(Red, Green, Blue, Alpha).
color4uiv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4ui(Red, Green, Blue, Alpha).
color4usv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4us(Red, Green, Blue, Alpha).
texCoord1d(S) -> ok
S = float()
Set the current texture coordinates
gl:texCoord
specifies texture coordinates in one, two, three, or four dimensions. gl:texCoord1
sets the current texture coordinates to (s 0 0 1); a call to gl:texCoord2
sets them to (s t
0 1).
Similarly, gl:texCoord3
specifies the texture coordinates as (s t r 1), and gl:texCoord4
defines all four components explicitly as (s t r q).
The current texture coordinates are part of the data that is associated with each vertex
and with the current raster position. Initially, the values for s
, t
, r
, and q
are (0, 0, 0, 1).
See
texCoord3iv(V) -> ok
V = {S::integer(), T::integer(), R::integer()}
Equivalent to texCoord3i(S, T, R).
texCoord3sv(V) -> ok
V = {S::integer(), T::integer(), R::integer()}
Equivalent to texCoord3s(S, T, R).
texCoord4dv(V) -> ok
V = {S::float(), T::float(), R::float(), Q::float()}
Equivalent to texCoord4d(S, T, R, Q).
texCoord4fv(V) -> ok
V = {S::float(), T::float(), R::float(), Q::float()}
Equivalent to texCoord4f(S, T, R, Q).
texCoord4iv(V) -> ok
V = {S::integer(), T::integer(), R::integer(), Q::integer()}
Equivalent to texCoord4i(S, T, R, Q).
texCoord4sv(V) -> ok
V = {S::integer(), T::integer(), R::integer(), Q::integer()}
Equivalent to texCoord4s(S, T, R, Q).
rasterPos2d(X, Y) -> ok
X = float()
Y = float()
Specify the raster position for pixel operations
The GL maintains a 3D position in window coordinates. This position, called the raster position, is used to position pixel and bitmap write operations. It is maintained with subpixel accuracy. See gl:bitmap/7 , gl:drawPixels/5 , and gl:copyPixels/5 .
The current raster position consists of three window coordinates ( x, y, z), a clip
coordinate value ( w), an eye coordinate distance, a valid bit, and associated color
data and texture coordinates. The w coordinate is a clip coordinate, because w is
not projected to window coordinates. gl:rasterPos4
specifies object coordinates x,
y, z, and w explicitly. gl:rasterPos3
specifies object coordinate x, y, and
z explicitly, while w is implicitly set to 1. gl:rasterPos2
uses the argument
values for x and y while implicitly setting z and w to 0 and 1.
The object coordinates presented by gl:rasterPos
are treated just like those of a gl:vertex2d/2
command: They are transformed by the current modelview and projection matrices and passed
to the clipping stage. If the vertex is not culled, then it is projected and scaled to
window coordinates, which become the new current raster position, and the ?GL_CURRENT_RASTER_POSITION_VALID
flag is set. If the vertex is
culled, then the valid bit is cleared and the current
raster position and associated color and texture coordinates are undefined.
The current raster position also includes some associated color data and texture coordinates.
If lighting is enabled, then ?GL_CURRENT_RASTER_COLOR
(in RGBA mode) or ?GL_CURRENT_RASTER_INDEX
(in color index mode) is set to the color produced by the lighting calculation (see gl:lightf/3
, gl:lightModelf/2 , and gl:shadeModel/1 ). If lighting is disabled, current
color (in RGBA mode, state variable ?GL_CURRENT_COLOR
) or color index (in color
index mode, state variable ?GL_CURRENT_INDEX
) is used to update the current raster
color. ?GL_CURRENT_RASTER_SECONDARY_COLOR
(in RGBA mode) is likewise updated.
Likewise, ?GL_CURRENT_RASTER_TEXTURE_COORDS
is updated as a function of ?GL_CURRENT_TEXTURE_COORDS
, based on the texture matrix and the texture generation functions (see gl:texGend/3 ).
Finally, the distance from the origin of the eye coordinate system to the vertex as transformed
by only the modelview matrix replaces ?GL_CURRENT_RASTER_DISTANCE
.
Initially, the current raster position is (0, 0, 0, 1), the current raster distance is
0, the valid bit is set, the associated RGBA color is (1, 1, 1, 1), the associated color
index is 1, and the associated texture coordinates are (0, 0, 0, 1). In RGBA mode, ?GL_CURRENT_RASTER_INDEX
is always 1; in color index mode, the current raster RGBA color always maintains its
initial value.
See
rasterPos4i(X, Y, Z, W) -> ok
X = integer()
Y = integer()
Z = integer()
W = integer()
See rasterPos2d/2
rasterPos4s(X, Y, Z, W) -> ok
X = integer()
Y = integer()
Z = integer()
W = integer()
See rasterPos2d/2
rasterPos3iv(V) -> ok
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to rasterPos3i(X, Y, Z).
rasterPos3sv(V) -> ok
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to rasterPos3s(X, Y, Z).
rasterPos4dv(V) -> ok
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to rasterPos4d(X, Y, Z, W).
rasterPos4fv(V) -> ok
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to rasterPos4f(X, Y, Z, W).
rasterPos4iv(V) -> ok
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to rasterPos4i(X, Y, Z, W).
rasterPos4sv(V) -> ok
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to rasterPos4s(X, Y, Z, W).
rectd(X1, Y1, X2, Y2) -> ok
X1 = float()
Y1 = float()
X2 = float()
Y2 = float()
Draw a rectangle
gl:rect
supports efficient specification of rectangles as two corner points. Each
rectangle command takes four arguments, organized either as two consecutive pairs of (x y)
coordinates or as two pointers to arrays, each containing an (x y) pair. The resulting rectangle
is defined in the z=0 plane.
gl:rect
( X1
, Y1
, X2
, Y2
) is exactly equivalent to the
following sequence: glBegin(?GL_POLYGON
); glVertex2( X1
, Y1
); glVertex2(
X2
, Y1
); glVertex2( X2
, Y2
); glVertex2( X1
, Y2
);
glEnd(); Note that if the second vertex is above and to the right of the first vertex,
the rectangle is constructed with a counterclockwise winding.
See
vertexPointer(Size, Type, Stride, Ptr) -> ok
Size = integer()
Type = enum()
Stride = integer()
Ptr = offset() | mem()
Define an array of vertex data
gl:vertexPointer
specifies the location and data format of an array of vertex coordinates
to use when rendering. Size
specifies the number of coordinates per vertex, and
must be 2, 3, or 4. Type
specifies the data type of each coordinate, and 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; see gl:interleavedArrays/3 .)
If a non-zero named buffer object is bound to the ?GL_ARRAY_BUFFER
target (see gl:bindBuffer/2
) while a vertex array is specified, Pointer
is treated as a byte offset into the
buffer object's data store. Also, the buffer object binding (?GL_ARRAY_BUFFER_BINDING
) is saved as vertex array client-side state (?GL_VERTEX_ARRAY_BUFFER_BINDING
).
When a vertex array is specified, Size
, Type
, Stride
, and Pointer
are saved as client-side state, in addition to the current vertex array buffer object
binding.
To enable and disable the vertex array, call gl:enableClientState/1 and gl:enableClientState/1
with the argument ?GL_VERTEX_ARRAY
. If enabled, the vertex array is used when gl:arrayElement/1
, gl:drawArrays/3 , gl:multiDrawArrays/3 , gl:drawElements/4 , see glMultiDrawElements
, or gl:drawRangeElements/6 is called.
See
normalPointer(Type, Stride, Ptr) -> ok
Type = enum()
Stride = integer()
Ptr = offset() | mem()
Define an array of normals
gl:normalPointer
specifies the location and data format of an array of normals to
use when rendering. Type
specifies the data type of each normal coordinate, and Stride
specifies 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; see gl:interleavedArrays/3 .)
If a non-zero named buffer object is bound to the ?GL_ARRAY_BUFFER
target (see gl:bindBuffer/2
) while a normal array is specified, Pointer
is treated as a byte offset into the
buffer object's data store. Also, the buffer object binding (?GL_ARRAY_BUFFER_BINDING
) is saved as normal vertex array client-side state (?GL_NORMAL_ARRAY_BUFFER_BINDING
).
When a normal array is specified, Type
, Stride
, and Pointer
are
saved as client-side state, in addition to the current vertex array buffer object binding.
To enable and disable the normal array, call gl:enableClientState/1 and gl:enableClientState/1
with the argument ?GL_NORMAL_ARRAY
. If enabled, the normal array is used when gl:drawArrays/3
, gl:multiDrawArrays/3 , gl:drawElements/4 , see glMultiDrawElements
, gl:drawRangeElements/6
, or gl:arrayElement/1 is called.
See
colorPointer(Size, Type, Stride, Ptr) -> ok
Size = integer()
Type = enum()
Stride = integer()
Ptr = offset() | mem()
Define an array of colors
gl:colorPointer
specifies the location and data format of an array of color components
to use when rendering. Size
specifies the number of components per color, and must
be 3 or 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; see gl:interleavedArrays/3 .)
If a non-zero named buffer object is bound to the ?GL_ARRAY_BUFFER
target (see gl:bindBuffer/2
) while a color array is specified, Pointer
is treated as a byte offset into the
buffer object's data store. Also, the buffer object binding (?GL_ARRAY_BUFFER_BINDING
) is saved as color vertex array client-side state (?GL_COLOR_ARRAY_BUFFER_BINDING
).
When a color array is specified, Size
, Type
, Stride
, and Pointer
are saved as client-side state, in addition to the current vertex array buffer object
binding.
To enable and disable the color array, call gl:enableClientState/1 and gl:enableClientState/1
with the argument ?GL_COLOR_ARRAY
. If enabled, the color array is used when gl:drawArrays/3
, gl:multiDrawArrays/3 , gl:drawElements/4 , see glMultiDrawElements
, gl:drawRangeElements/6
, or gl:arrayElement/1 is called.
See
indexPointer(Type, Stride, Ptr) -> ok
Type = enum()
Stride = integer()
Ptr = offset() | mem()
Define an array of color indexes
gl:indexPointer
specifies the location and data format of an array of color indexes
to use when rendering. Type
specifies the data type of each color index and Stride
specifies the byte stride from one color index to the next, allowing vertices and attributes
to be packed into a single array or stored in separate arrays.
If a non-zero named buffer object is bound to the ?GL_ARRAY_BUFFER
target (see gl:bindBuffer/2
) while a color index array is specified, Pointer
is treated as a byte offset into
the buffer object's data store. Also, the buffer object binding (?GL_ARRAY_BUFFER_BINDING
) is saved as color index vertex array client-side state (?GL_INDEX_ARRAY_BUFFER_BINDING
).
When a color index array is specified, Type
, Stride
, and Pointer
are saved as client-side state, in addition to the current vertex array buffer object
binding.
To enable and disable the color index array, call gl:enableClientState/1 and gl:enableClientState/1
with the argument ?GL_INDEX_ARRAY
. If enabled, the color index array is used when
gl:drawArrays/3 , gl:multiDrawArrays/3 , gl:drawElements/4 , see glMultiDrawElements
, gl:drawRangeElements/6 , or gl:arrayElement/1 is called.
See
texCoordPointer(Size, Type, Stride, Ptr) -> ok
Size = integer()
Type = enum()
Stride = integer()
Ptr = offset() | mem()
Define an array of texture coordinates
gl:texCoordPointer
specifies the location and data format of an array of texture
coordinates to use when rendering. Size
specifies the number of coordinates per
texture coordinate set, and must be 1, 2, 3, or 4. Type
specifies the data type
of each texture coordinate, and Stride
specifies the byte stride from one texture
coordinate set 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; see gl:interleavedArrays/3 .)
If a non-zero named buffer object is bound to the ?GL_ARRAY_BUFFER
target (see gl:bindBuffer/2
) while a texture coordinate array is specified, Pointer
is treated as a byte offset
into the buffer object's data store. Also, the buffer object binding (?GL_ARRAY_BUFFER_BINDING
) is saved as texture coordinate vertex array client-side state (?GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING
).
When a texture coordinate array is specified, Size
, Type
, Stride
,
and Pointer
are saved as client-side state, in addition to the current vertex array
buffer object binding.
To enable and disable a texture coordinate array, call gl:enableClientState/1
and gl:enableClientState/1 with the argument ?GL_TEXTURE_COORD_ARRAY
. If
enabled, the texture coordinate array is used when gl:arrayElement/1 , gl:drawArrays/3
, gl:multiDrawArrays/3 , gl:drawElements/4 , see glMultiDrawElements
,
or gl:drawRangeElements/6 is called.
See
edgeFlagPointer(Stride, Ptr) -> ok
Stride = integer()
Ptr = offset() | mem()
Define an array of edge flags
gl:edgeFlagPointer
specifies the location and data format of an array of boolean
edge flags to use when rendering. Stride
specifies the byte stride from one edge
flag to the next, allowing vertices and attributes to be packed into a single array or
stored in separate arrays.
If a non-zero named buffer object is bound to the ?GL_ARRAY_BUFFER
target (see gl:bindBuffer/2
) while an edge flag array is specified, Pointer
is treated as a byte offset into
the buffer object's data store. Also, the buffer object binding (?GL_ARRAY_BUFFER_BINDING
) is saved as edge flag vertex array client-side state (?GL_EDGE_FLAG_ARRAY_BUFFER_BINDING
).
When an edge flag array is specified, Stride
and Pointer
are saved as client-side
state, in addition to the current vertex array buffer object binding.
To enable and disable the edge flag array, call gl:enableClientState/1 and gl:enableClientState/1
with the argument ?GL_EDGE_FLAG_ARRAY
. If enabled, the edge flag array is used
when gl:drawArrays/3 , gl:multiDrawArrays/3 , gl:drawElements/4 , see glMultiDrawElements
, gl:drawRangeElements/6 , or gl:arrayElement/1 is called.
See
arrayElement(I) -> ok
I = integer()
Render a vertex using the specified vertex array element
gl:arrayElement
commands are used within gl:'begin'/1 / gl:'begin'/1 pairs
to specify vertex and attribute data for point, line, and polygon primitives. If ?GL_VERTEX_ARRAY
is enabled when gl:arrayElement
is called, a single vertex is drawn, using vertex
and attribute data taken from location I
of the enabled arrays. If ?GL_VERTEX_ARRAY
is not enabled, no drawing occurs but the attributes corresponding to the enabled arrays
are modified.
Use gl:arrayElement
to construct primitives by indexing vertex data, rather than
by streaming through arrays of data in first-to-last order. Because each call specifies
only a single vertex, it is possible to explicitly specify per-primitive attributes such
as a single normal for each triangle.
Changes made to array data between the execution of gl:'begin'/1 and the corresponding
execution of gl:'begin'/1 may affect calls to gl:arrayElement
that are made within
the same gl:'begin'/1 / gl:'begin'/1 period in nonsequential ways. That is, a call
to gl:arrayElement
that precedes a change to array data may access the changed data,
and a call that follows a change to array data may access original data.
See
drawArrays(Mode, First, Count) -> ok
Mode = enum()
First = integer()
Count = integer()
Render primitives from array data
gl:drawArrays
specifies multiple geometric primitives with very few subroutine calls.
Instead of calling a GL procedure to pass each individual vertex, normal, texture coordinate,
edge flag, or color, you can prespecify separate arrays of vertices, normals, and colors
and use them to construct a sequence of primitives with a single call to gl:drawArrays
.
When gl:drawArrays
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.
Vertex attributes that are modified by gl:drawArrays
have an unspecified value
after gl:drawArrays
returns. Attributes that aren't modified remain well defined.
See
drawElements(Mode, Count, Type, Indices) -> ok
Mode = enum()
Count = integer()
Type = enum()
Indices = offset() | mem()
Render primitives from array data
gl:drawElements
specifies multiple geometric primitives with very few subroutine
calls. Instead of calling a GL function to pass each individual vertex, normal, texture
coordinate, edge flag, or color, you can prespecify separate arrays of vertices, normals,
and so on, and use them to construct a sequence of primitives with a single call to gl:drawElements
.
When gl:drawElements
is called, it uses Count
sequential elements from an
enabled array, starting at Indices
to construct a sequence of geometric primitives.
Mode
specifies what kind of primitives are constructed and how the array elements
construct these primitives. If more than one array is enabled, each is used.
Vertex attributes that are modified by gl:drawElements
have an unspecified value
after gl:drawElements
returns. Attributes that aren't modified maintain their previous
values.
See
interleavedArrays(Format, Stride, Pointer) -> ok
Format = enum()
Stride = integer()
Pointer = offset() | mem()
Simultaneously specify and enable several interleaved arrays
gl:interleavedArrays
lets you specify and enable individual color, normal, texture
and vertex arrays whose elements are part of a larger aggregate array element. For some
implementations, this is more efficient than specifying the arrays separately.
If Stride
is 0, the aggregate elements are stored consecutively. Otherwise, Stride
bytes occur between the beginning of one aggregate array element and the beginning of
the next aggregate array element.
Format
serves as a key
describing the extraction of individual arrays from
the aggregate array. If Format
contains a T, then texture coordinates are extracted
from the interleaved array. If C is present, color values are extracted. If N is present,
normal coordinates are extracted. Vertex coordinates are always extracted.
The digits 2, 3, and 4 denote how many values are extracted. F indicates that values are extracted as floating-point values. Colors may also be extracted as 4 unsigned bytes if 4UB follows the C. If a color is extracted as 4 unsigned bytes, the vertex array element which follows is located at the first possible floating-point aligned address.
See
shadeModel(Mode) -> ok
Mode = enum()
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 when gl:'begin'/1 is issued 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 the vertex listed in the following table. This is the last vertex to specify the polygon in all cases except single polygons, where the first vertex specifies the flat-shaded color.
Primitive Type of Polygon
iVertex
Single polygon ( i== 1) 1
Triangle strip i+2
Triangle fan i+2
Independent triangle 3 i
Quad strip 2 i+2
Independent quad 4 i
Flat and smooth shading are specified by gl:shadeModel
with Mode
set to ?GL_FLAT
and ?GL_SMOOTH
, respectively.
See
lightf(Light, Pname, Param) -> ok
Light = enum()
Pname = enum()
Param = float()
Set light source parameters
gl:light
sets the values of individual light source parameters. Light
names
the light and is a symbolic name of the form ?GL_LIGHT
i, where i ranges from 0
to the value of ?GL_MAX_LIGHTS
- 1. Pname
specifies one of ten light source
parameters, again by symbolic name. Params
is either a single value or a pointer
to an array that contains the new values.
To enable and disable lighting calculation, call gl:enable/1 and gl:enable/1
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 gl:enable/1 and gl:enable/1 with argument ?GL_LIGHT
i.
The ten light parameters are as follows:
?GL_AMBIENT
: Params
contains four integer or floating-point values that
specify the ambient RGBA intensity of the light. Integer values are mapped linearly such
that the most positive representable value maps to 1.0, and the most negative representable
value maps to -1.0. Floating-point values are mapped directly. Neither integer nor floating-point
values are clamped. The initial ambient light intensity is (0, 0, 0, 1).
?GL_DIFFUSE
: Params
contains four integer or floating-point values that
specify the diffuse RGBA intensity of the light. Integer values are mapped linearly such
that the most positive representable value maps to 1.0, and the most negative representable
value maps to -1.0. Floating-point values are mapped directly. Neither integer 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, 1).
?GL_SPECULAR
: Params
contains four integer or floating-point values that
specify the specular RGBA intensity of the light. Integer values are mapped linearly such
that the most positive representable value maps to 1.0, and the most negative representable
value maps to -1.0. Floating-point values are mapped directly. Neither integer 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, 1).
?GL_POSITION
: Params
contains four integer or floating-point values that
specify the position of the light in homogeneous object coordinates. Both integer and
floating-point values are mapped directly. Neither integer nor floating-point values are
clamped.
The position is transformed by the modelview matrix when gl:light
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 integer or floating-point values
that specify the direction of the light in homogeneous object coordinates. Both integer
and floating-point values are mapped directly. Neither integer nor floating-point values
are clamped.
The spot direction is transformed by the upper 3x3 of the modelview matrix when gl:light
is called, 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 integer or floating-point value that
specifies the intensity distribution of the light. Integer 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 integer or floating-point value that
specifies the maximum spread angle of a light source. Integer 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.
?GL_CONSTANT_ATTENUATION
?GL_LINEAR_ATTENUATION
?GL_QUADRATIC_ATTENUATION
: Params
is a single integer or floating-point
value that specifies one of the three light attenuation factors. Integer 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.
See
getLightfv(Light, Pname) -> {float(), float(), float(), float()}
Light = enum()
Pname = enum()
Return light source parameter values
gl:getLight
returns in Params
the value or values of a light source parameter.
Light
names the light and is a symbolic name of the form ?GL_LIGHT
i where
i ranges from 0 to the value of ?GL_MAX_LIGHTS
- 1. ?GL_MAX_LIGHTS
is an
implementation dependent constant that is greater than or equal to eight. Pname
specifies one of ten light source parameters, again by symbolic name.
The following parameters are defined:
?GL_AMBIENT
: Params
returns four integer or floating-point values representing
the ambient intensity of the light source. Integer values, when requested, are linearly
mapped from the internal floating-point representation such that 1.0 maps to the most
positive representable integer value, and -1.0 maps to the most negative representable
integer value. If the internal value is outside the range [-1 1], the corresponding integer
return value is undefined. The initial value is (0, 0, 0, 1).
?GL_DIFFUSE
: Params
returns four integer or floating-point values representing
the diffuse intensity of the light source. Integer values, when requested, are linearly
mapped from the internal floating-point representation such that 1.0 maps to the most
positive representable integer value, and -1.0 maps to the most negative representable
integer value. If the internal value is outside the range [-1 1], the corresponding integer
return value is undefined. 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
returns four integer or floating-point values representing
the specular intensity of the light source. Integer values, when requested, are linearly
mapped from the internal floating-point representation such that 1.0 maps to the most
positive representable integer value, and -1.0 maps to the most negative representable
integer value. If the internal value is outside the range [-1 1], the corresponding integer
return value is undefined. The initial value for ?GL_LIGHT0
is (1, 1, 1, 1); for
other lights, the initial value is (0, 0, 0, 0).
?GL_POSITION
: Params
returns four integer or floating-point values representing
the position of the light source. Integer values, when requested, are computed by rounding
the internal floating-point values to the nearest integer value. The returned values are
those maintained in eye coordinates. They will not be equal to the values specified using
gl:lightf/3 , unless the modelview matrix was identity at the time gl:lightf/3
was called. The initial value is (0, 0, 1, 0).
?GL_SPOT_DIRECTION
: Params
returns three integer or floating-point values
representing the direction of the light source. Integer values, when requested, are computed
by rounding the internal floating-point values to the nearest integer value. The returned
values are those maintained in eye coordinates. They will not be equal to the values specified
using gl:lightf/3 , unless the modelview matrix was identity at the time gl:lightf/3
was called. Although spot direction is normalized before being used in the lighting equation,
the returned values are the transformed versions of the specified values prior to normalization.
The initial value is (0 0 -1).
?GL_SPOT_EXPONENT
: Params
returns a single integer or floating-point value
representing the spot exponent of the light. An integer value, when requested, is computed
by rounding the internal floating-point representation to the nearest integer. The initial
value is 0.
?GL_SPOT_CUTOFF
: Params
returns a single integer or floating-point value
representing the spot cutoff angle of the light. An integer value, when requested, is
computed by rounding the internal floating-point representation to the nearest integer.
The initial value is 180.
?GL_CONSTANT_ATTENUATION
: Params
returns a single integer or floating-point
value representing the constant (not distance-related) attenuation of the light. An integer
value, when requested, is computed by rounding the internal floating-point representation
to the nearest integer. The initial value is 1.
?GL_LINEAR_ATTENUATION
: Params
returns a single integer or floating-point
value representing the linear attenuation of the light. An integer value, when requested,
is computed by rounding the internal floating-point representation to the nearest integer.
The initial value is 0.
?GL_QUADRATIC_ATTENUATION
: Params
returns a single integer or floating-point
value representing the quadratic attenuation of the light. An integer value, when requested,
is computed by rounding the internal floating-point representation to the nearest integer.
The initial value is 0.
See
getLightiv(Light, Pname) -> {integer(), integer(), integer(), integer()}
Light = enum()
Pname = enum()
See getLightfv/2
lightModelf(Pname, Param) -> ok
Pname = enum()
Param = float()
Set the lighting model parameters
gl:lightModel
sets the lighting model parameter. Pname
names a parameter
and Params
gives the new value. There are three lighting model parameters:
?GL_LIGHT_MODEL_AMBIENT
: Params
contains four integer or floating-point
values that specify the ambient RGBA intensity of the entire scene. Integer values are
mapped linearly such that the most positive representable value maps to 1.0, and the most
negative representable value maps to -1.0. Floating-point values are mapped directly.
Neither integer nor floating-point values are clamped. The initial ambient scene intensity
is (0.2, 0.2, 0.2, 1.0).
?GL_LIGHT_MODEL_COLOR_CONTROL
: Params
must be either ?GL_SEPARATE_SPECULAR_COLOR
or ?GL_SINGLE_COLOR
. ?GL_SINGLE_COLOR
specifies that a single color is
generated from the lighting computation for a vertex. ?GL_SEPARATE_SPECULAR_COLOR
specifies that the specular color computation of lighting be stored separately from the
remainder of the lighting computation. The specular color is summed into the generated
fragment's color after the application of texture mapping (if enabled). The initial value
is ?GL_SINGLE_COLOR
.
?GL_LIGHT_MODEL_LOCAL_VIEWER
: Params
is a single integer or floating-point
value that specifies how specular reflection angles are computed. If Params
is
0 (or 0.0), specular reflection angles take the view direction to be parallel to and in
the direction of the -z
axis, regardless of the location of the vertex in eye coordinates.
Otherwise, specular reflections are computed from the origin of the eye coordinate system.
The initial value is 0.
?GL_LIGHT_MODEL_TWO_SIDE
: Params
is a single integer or floating-point 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
is 0 (or 0.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.
In RGBA mode, 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.
In color index mode, the value of the lighted index of a vertex ranges from the ambient
to the specular values passed to gl:materialf/3 using ?GL_COLOR_INDEXES
.
Diffuse and specular coefficients, computed with a (.30, .59, .11) weighting of the lights'
colors, the shininess of the material, and the same reflection and attenuation equations
as in the RGBA case, determine how much above ambient the resulting index is.
See
materialf(Face, Pname, Param) -> ok
Face = enum()
Pname = enum()
Param = float()
Specify material parameters for the lighting model
gl:material
assigns values to material parameters. There are two matched sets of
material parameters. One, the front-facing
set, is used to shade points, lines,
bitmaps, 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 gl:lightModelf/2
reference page for details concerning one- and two-sided lighting calculations.
gl:material
takes three arguments. The first, Face
, specifies whether the ?GL_FRONT
materials, the ?GL_BACK
materials, or both ?GL_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 gl:lightModelf/2 reference page. The parameters
that can be specified using gl:material
, and their interpretations by the lighting
equation, are as follows:
?GL_AMBIENT
: Params
contains four integer or floating-point values that
specify the ambient RGBA reflectance of the material. Integer values are mapped linearly
such that the most positive representable value maps to 1.0, and the most negative representable
value maps to -1.0. Floating-point values are mapped directly. Neither integer nor floating-point
values are clamped. The initial ambient reflectance for both front- and back-facing materials
is (0.2, 0.2, 0.2, 1.0).
?GL_DIFFUSE
: Params
contains four integer or floating-point values that
specify the diffuse RGBA reflectance of the material. Integer values are mapped linearly
such that the most positive representable value maps to 1.0, and the most negative representable
value maps to -1.0. Floating-point values are mapped directly. Neither integer nor floating-point
values are clamped. The initial diffuse reflectance for both front- and back-facing materials
is (0.8, 0.8, 0.8, 1.0).
?GL_SPECULAR
: Params
contains four integer or floating-point values that
specify the specular RGBA reflectance of the material. Integer values are mapped linearly
such that the most positive representable value maps to 1.0, and the most negative representable
value maps to -1.0. Floating-point values are mapped directly. Neither integer nor floating-point
values are clamped. The initial specular reflectance for both front- and back-facing materials
is (0, 0, 0, 1).
?GL_EMISSION
: Params
contains four integer or floating-point values that
specify the RGBA emitted light intensity of the material. Integer values are mapped linearly
such that the most positive representable value maps to 1.0, and the most negative representable
value maps to -1.0. Floating-point values are mapped directly. Neither integer nor floating-point
values are clamped. The initial emission intensity for both front- and back-facing materials
is (0, 0, 0, 1).
?GL_SHININESS
: Params
is a single integer or floating-point value that specifies
the RGBA specular exponent of the material. Integer and floating-point values are mapped
directly. Only values in the range [0 128] are accepted. The initial specular exponent for both
front- and back-facing materials is 0.
?GL_AMBIENT_AND_DIFFUSE
: Equivalent to calling gl:material
twice with the
same parameter values, once with ?GL_AMBIENT
and once with ?GL_DIFFUSE
.
?GL_COLOR_INDEXES
: Params
contains three integer or floating-point values
specifying the color indices for ambient, diffuse, and specular lighting. These three
values, and ?GL_SHININESS
, are the only material values used by the color index
mode lighting equation. Refer to the gl:lightModelf/2 reference page for a discussion
of color index lighting.
See
materialiv(Face, Pname, Params) -> ok
Face = enum()
Pname = enum()
Params = {integer()}
See materialf/3
getMaterialfv(Face, Pname) -> {float(), float(), float(), float()}
Face = enum()
Pname = enum()
Return material parameters
gl:getMaterial
returns in Params
the value or values of parameter Pname
of material Face
. Six parameters are defined:
?GL_AMBIENT
: Params
returns four integer or floating-point values representing
the ambient reflectance of the material. Integer values, when requested, are linearly
mapped from the internal floating-point representation such that 1.0 maps to the most
positive representable integer value, and -1.0 maps to the most negative representable
integer value. If the internal value is outside the range [-1 1], the corresponding integer
return value is undefined. The initial value is (0.2, 0.2, 0.2, 1.0)
?GL_DIFFUSE
: Params
returns four integer or floating-point values representing
the diffuse reflectance of the material. Integer values, when requested, are linearly
mapped from the internal floating-point representation such that 1.0 maps to the most
positive representable integer value, and -1.0 maps to the most negative representable
integer value. If the internal value is outside the range [-1 1], the corresponding integer
return value is undefined. The initial value is (0.8, 0.8, 0.8, 1.0).
?GL_SPECULAR
: Params
returns four integer or floating-point values representing
the specular reflectance of the material. Integer values, when requested, are linearly
mapped from the internal floating-point representation such that 1.0 maps to the most
positive representable integer value, and -1.0 maps to the most negative representable
integer value. If the internal value is outside the range [-1 1], the corresponding integer
return value is undefined. The initial value is (0, 0, 0, 1).
?GL_EMISSION
: Params
returns four integer or floating-point values representing
the emitted light intensity of the material. Integer values, when requested, are linearly
mapped from the internal floating-point representation such that 1.0 maps to the most
positive representable integer value, and -1.0 maps to the most negative representable
integer value. If the internal value is outside the range [-1 1], the corresponding integer
return value is undefined. The initial value is (0, 0, 0, 1).
?GL_SHININESS
: Params
returns one integer or floating-point value representing
the specular exponent of the material. Integer values, when requested, are computed by
rounding the internal floating-point value to the nearest integer value. The initial value
is 0.
?GL_COLOR_INDEXES
: Params
returns three integer or floating-point values
representing the ambient, diffuse, and specular indices of the material. These indices
are used only for color index lighting. (All the other parameters are used only for RGBA
lighting.) Integer values, when requested, are computed by rounding the internal floating-point
values to the nearest integer values.
See
getMaterialiv(Face, Pname) -> {integer(), integer(), integer(), integer()}
Face = enum()
Pname = enum()
See getMaterialfv/2
colorMaterial(Face, Mode) -> ok
Face = enum()
Mode = enum()
Cause a material color to track the current color
gl:colorMaterial
specifies which material parameters track the current color. When ?GL_COLOR_MATERIAL
is enabled, the material parameter or parameters specified by Mode
, of the material
or materials specified by Face
, track the current color at all times.
To enable and disable ?GL_COLOR_MATERIAL
, call gl:enable/1 and gl:enable/1
with argument ?GL_COLOR_MATERIAL
. ?GL_COLOR_MATERIAL
is initially disabled.
See
pixelZoom(Xfactor, Yfactor) -> ok
Xfactor = float()
Yfactor = float()
Specify the pixel zoom factors
gl:pixelZoom
specifies values for the x and y zoom factors. During the execution
of gl:drawPixels/5 or gl:copyPixels/5 , if ( xr, yr) is the current raster
position, and a given element is in the mth row and nth column of the pixel rectangle,
then pixels whose centers are in the rectangle with corners at
( xr+n. xfactor, yr+m. yfactor)
( xr+(n+1). xfactor, yr+(m+1). yfactor)
are candidates for replacement. Any pixel whose center lies on the bottom or left edge of this rectangular region is also modified.
Pixel zoom factors are not limited to positive values. Negative zoom factors reflect the resulting image about the current raster position.
See
pixelStoref(Pname, Param) -> ok
Pname = enum()
Param = float()
Set pixel storage modes
gl:pixelStore
sets pixel storage modes that affect the operation of subsequent gl:readPixels/7
as well as the unpacking of texture patterns (see gl:texImage1D/8 , gl:texImage2D/9
, gl:texImage3D/10 , gl:texSubImage1D/7 , gl:texSubImage1D/7 , gl:texSubImage1D/7
), gl:compressedTexImage1D/7 , gl:compressedTexImage2D/8 , gl:compressedTexImage3D/9
, gl:compressedTexSubImage1D/7 , gl:compressedTexSubImage2D/9 or gl:compressedTexSubImage1D/7
.
Pname
is a symbolic constant indicating the parameter to be set, and Param
is the new value. Six of the twelve storage parameters affect how pixel data is returned
to client memory. They are as follows:
?GL_PACK_SWAP_BYTES
: If true, byte ordering for multibyte color components, depth
components, or stencil indices is reversed. That is, if a four-byte component consists
of bytes b 0, b 1, b 2, b 3, it is stored in memory as b 3, b 2, b 1, b 0 if ?GL_PACK_SWAP_BYTES
is true. ?GL_PACK_SWAP_BYTES
has no effect on the memory order of components within
a pixel, only on the order of bytes within components or indices. For example, the three
components of a ?GL_RGB
format pixel are always stored with red first, green second,
and blue third, regardless of the value of ?GL_PACK_SWAP_BYTES
.
?GL_PACK_LSB_FIRST
: If true, bits are ordered within a byte from least significant
to most significant; otherwise, the first bit in each byte is the most significant one.
?GL_PACK_ROW_LENGTH
: If greater than 0, ?GL_PACK_ROW_LENGTH
defines the
number of pixels in a row. If the first pixel of a row is placed at location p in memory,
then the location of the first pixel of the next row is obtained by skipping
k={n l(a/s) |(s n l)/a| s>= a s< a)
components or indices, where n is the number of components or indices in a pixel, l
is the number of pixels in a row (?GL_PACK_ROW_LENGTH
if it is greater than 0,
the width argument to the pixel routine otherwise), a is the value of ?GL_PACK_ALIGNMENT
, and s is the size, in bytes, of a single component (if a< s, then it is as if a=
s). In the case of 1-bit values, the location of the next row is obtained by skipping
k=8 a |(n l)/(8 a)|
components or indices.
The word component
in this description refers to the nonindex values red, green,
blue, alpha, and depth. Storage format ?GL_RGB
, for example, has three components
per pixel: first red, then green, and finally blue.
?GL_PACK_IMAGE_HEIGHT
: If greater than 0, ?GL_PACK_IMAGE_HEIGHT
defines
the number of pixels in an image three-dimensional texture volume, where image
is
defined by all pixels sharing the same third dimension index. If the first pixel of a
row is placed at location p in memory, then the location of the first pixel of the next
row is obtained by skipping
k={n l h(a/s) |(s n l h)/a| s>= a s< a)
components or indices, where n is the number of components or indices in a pixel, l
is the number of pixels in a row (?GL_PACK_ROW_LENGTH
if it is greater than 0,
the width argument to gl:texImage3D/10 otherwise), h is the number of rows in
a pixel image (?GL_PACK_IMAGE_HEIGHT
if it is greater than 0, the height argument
to the gl:texImage3D/10 routine otherwise), a is the value of ?GL_PACK_ALIGNMENT
, and s is the size, in bytes, of a single component (if a< s, then it is as if
a=s).
The word component
in this description refers to the nonindex values red, green,
blue, alpha, and depth. Storage format ?GL_RGB
, for example, has three components
per pixel: first red, then green, and finally blue.
?GL_PACK_SKIP_PIXELS
, ?GL_PACK_SKIP_ROWS
, and ?GL_PACK_SKIP_IMAGES
These values are provided as a convenience to the programmer; they provide no functionality
that cannot be duplicated simply by incrementing the pointer passed to gl:readPixels/7
. Setting ?GL_PACK_SKIP_PIXELS
to i is equivalent to incrementing the pointer
by i n components or indices, where n is the number of components or indices in each
pixel. Setting ?GL_PACK_SKIP_ROWS
to j is equivalent to incrementing the pointer
by j m components or indices, where m is the number of components or indices per
row, as just computed in the ?GL_PACK_ROW_LENGTH
section. Setting ?GL_PACK_SKIP_IMAGES
to k is equivalent to incrementing the pointer by k p, where p is the number of
components or indices per image, as computed in the ?GL_PACK_IMAGE_HEIGHT
section.
?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 other six of the twelve storage parameters affect how pixel data is read from client memory. These values are significant for gl:texImage1D/8 , gl:texImage2D/9 , gl:texImage3D/10 , gl:texSubImage1D/7 , gl:texSubImage1D/7 , and gl:texSubImage1D/7
They are as follows:
?GL_UNPACK_SWAP_BYTES
: If true, byte ordering for multibyte color components,
depth components, or stencil indices is reversed. That is, if a four-byte component consists
of bytes b 0, b 1, b 2, b 3, it is taken from memory as b 3, b 2, b 1, b 0 if ?GL_UNPACK_SWAP_BYTES
is true. ?GL_UNPACK_SWAP_BYTES
has no effect on the memory order of components
within a pixel, only on the order of bytes within components or indices. For example,
the three components of a ?GL_RGB
format pixel are always stored with red first,
green second, and blue third, regardless of the value of ?GL_UNPACK_SWAP_BYTES
.
?GL_UNPACK_LSB_FIRST
: If true, bits are ordered within a byte from least significant
to most significant; otherwise, the first bit in each byte is the most significant one.
?GL_UNPACK_ROW_LENGTH
: If greater than 0, ?GL_UNPACK_ROW_LENGTH
defines
the number of pixels in a row. If the first pixel of a row is placed at location p in
memory, then the location of the first pixel of the next row is obtained by skipping
k={n l(a/s) |(s n l)/a| s>= a s< a)
components or indices, where n is the number of components or indices in a pixel, l
is the number of pixels in a row (?GL_UNPACK_ROW_LENGTH
if it is greater than 0,
the width argument to the pixel routine otherwise), a is the value of ?GL_UNPACK_ALIGNMENT
, and s is the size, in bytes, of a single component (if a< s, then it is as if a=
s). In the case of 1-bit values, the location of the next row is obtained by skipping
k=8 a |(n l)/(8 a)|
components or indices.
The word component
in this description refers to the nonindex values red, green,
blue, alpha, and depth. Storage format ?GL_RGB
, for example, has three components
per pixel: first red, then green, and finally blue.
?GL_UNPACK_IMAGE_HEIGHT
: If greater than 0, ?GL_UNPACK_IMAGE_HEIGHT
defines
the number of pixels in an image of a three-dimensional texture volume. Where image
is defined by all pixel sharing the same third dimension index. If the first pixel of
a row is placed at location p in memory, then the location of the first pixel of the
next row is obtained by skipping
k={n l h(a/s) |(s n l h)/a| s>= a s< a)
components or indices, where n is the number of components or indices in a pixel, l
is the number of pixels in a row (?GL_UNPACK_ROW_LENGTH
if it is greater than 0,
the width argument to gl:texImage3D/10 otherwise), h is the number of rows in
an image (?GL_UNPACK_IMAGE_HEIGHT
if it is greater than 0, the height argument
to gl:texImage3D/10 otherwise), a is the value of ?GL_UNPACK_ALIGNMENT
,
and s is the size, in bytes, of a single component (if a< s, then it is as if a=s).
The word component
in this description refers to the nonindex values red, green,
blue, alpha, and depth. Storage format ?GL_RGB
, for example, has three components
per pixel: first red, then green, and finally blue.
?GL_UNPACK_SKIP_PIXELS
and ?GL_UNPACK_SKIP_ROWS
These values are provided as a convenience to the programmer; they provide no functionality
that cannot be duplicated by incrementing the pointer passed to gl:texImage1D/8 , gl:texImage2D/9
, gl:texSubImage1D/7 or gl:texSubImage1D/7 . Setting ?GL_UNPACK_SKIP_PIXELS
to i is equivalent to incrementing the pointer by i n components or indices, where
n is the number of components or indices in each pixel. Setting ?GL_UNPACK_SKIP_ROWS
to j is equivalent to incrementing the pointer by j k components or indices, where
k is the number of components or indices per row, as just computed in the ?GL_UNPACK_ROW_LENGTH
section.
?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 following table gives the type, initial value, and range of valid values for each
storage parameter that can be set with gl:pixelStore
.
Pname
Type
Initial Value
Valid Range
?GL_PACK_SWAP_BYTES
boolean false true or false ?GL_PACK_LSB_FIRST
boolean false true or false ?GL_PACK_ROW_LENGTH
integer 0 [0)?GL_PACK_IMAGE_HEIGHT
integer 0 [0)?GL_PACK_SKIP_ROWS
integer 0 [0)?GL_PACK_SKIP_PIXELS
integer
0 [0)?GL_PACK_SKIP_IMAGES
integer
0 [0)?GL_PACK_ALIGNMENT
integer 4
1, 2, 4, or 8 ?GL_UNPACK_SWAP_BYTES
boolean
false true or false ?GL_UNPACK_LSB_FIRST
boolean false true or false ?GL_UNPACK_ROW_LENGTH
integer 0 [0)?GL_UNPACK_IMAGE_HEIGHT
integer 0 [0)?GL_UNPACK_SKIP_ROWS
integer 0 [0)?GL_UNPACK_SKIP_PIXELS
integer 0 [0)?GL_UNPACK_SKIP_IMAGES
integer 0 [0)?GL_UNPACK_ALIGNMENT
integer
4 1, 2, 4, or 8 gl:pixelStoref
can be used to set any pixel store parameter. If the parameter type
is boolean, then if Param
is 0, the parameter is false; otherwise it is set to
true. If Pname
is a integer type parameter, Param
is rounded to the nearest
integer.
Likewise, gl:pixelStorei
can also be used to set any of the pixel store parameters.
Boolean parameters are set to false if Param
is 0 and true otherwise.
See
pixelTransferf(Pname, Param) -> ok
Pname = enum()
Param = float()
Set pixel transfer modes
gl:pixelTransfer
sets pixel transfer modes that affect the operation of subsequent gl:copyPixels/5
, gl:copyTexImage1D/7 , gl:copyTexImage2D/8 , gl:copyTexSubImage1D/6 , gl:copyTexSubImage2D/8
, gl:copyTexSubImage3D/9 , gl:drawPixels/5 , gl:readPixels/7 , gl:texImage1D/8
, gl:texImage2D/9 , gl:texImage3D/10 , gl:texSubImage1D/7 , gl:texSubImage1D/7
, and gl:texSubImage1D/7 commands. Additionally, if the ARB_imaging subset is supported,
the routines gl:colorTable/6 , gl:colorSubTable/6 , gl:convolutionFilter1D/6
, gl:convolutionFilter2D/7 , gl:histogram/4 , gl:minmax/3 , and gl:separableFilter2D/8
are also affected. The algorithms that are specified by pixel transfer modes operate
on pixels after they are read from the frame buffer ( gl:copyPixels/5 gl:copyTexImage1D/7
, gl:copyTexImage2D/8 , gl:copyTexSubImage1D/6 , gl:copyTexSubImage2D/8 ,
gl:copyTexSubImage3D/9 , and gl:readPixels/7 ), or unpacked from client memory
( gl:drawPixels/5 , gl:texImage1D/8 , gl:texImage2D/9 , gl:texImage3D/10
, gl:texSubImage1D/7 , gl:texSubImage1D/7 , and gl:texSubImage1D/7 ).
Pixel transfer operations happen in the same order, and in the same manner, regardless
of the command that resulted in the pixel operation. Pixel storage modes (see gl:pixelStoref/2
) control the unpacking of pixels being read from client memory and the packing of pixels
being written back into client memory.
Pixel transfer operations handle four fundamental pixel types: color
, color index
, depth
, and stencil
. Color
pixels consist of four floating-point
values with unspecified mantissa and exponent sizes, scaled such that 0 represents zero
intensity and 1 represents full intensity. Color indices
comprise a single fixed-point
value, with unspecified precision to the right of the binary point. Depth
pixels
comprise a single floating-point value, with unspecified mantissa and exponent sizes,
scaled such that 0.0 represents the minimum depth buffer value, and 1.0 represents the
maximum depth buffer value. Finally, stencil
pixels comprise a single fixed-point
value, with unspecified precision to the right of the binary point.
The pixel transfer operations performed on the four basic pixel types are as follows:
Color
: Each of the four color components is multiplied by a scale factor, then
added to a bias factor. That is, the red component is multiplied by ?GL_RED_SCALE
,
then added to ?GL_RED_BIAS
; the green component is multiplied by ?GL_GREEN_SCALE
, then added to ?GL_GREEN_BIAS
; the blue component is multiplied by ?GL_BLUE_SCALE
, then added to ?GL_BLUE_BIAS
; and the alpha component is multiplied by ?GL_ALPHA_SCALE
, then added to ?GL_ALPHA_BIAS
. After all four color components are scaled and
biased, each is clamped to the range [0 1]. All color, scale, and bias values are specified
with gl:pixelTransfer
.
If ?GL_MAP_COLOR
is true, each color component is scaled by the size of the corresponding
color-to-color map, then replaced by the contents of that map indexed by the scaled component.
That is, the red component is scaled by ?GL_PIXEL_MAP_R_TO_R_SIZE
, then replaced
by the contents of ?GL_PIXEL_MAP_R_TO_R
indexed by itself. The green component
is scaled by ?GL_PIXEL_MAP_G_TO_G_SIZE
, then replaced by the contents of ?GL_PIXEL_MAP_G_TO_G
indexed by itself. The blue component is scaled by ?GL_PIXEL_MAP_B_TO_B_SIZE
,
then replaced by the contents of ?GL_PIXEL_MAP_B_TO_B
indexed by itself. And the
alpha component is scaled by ?GL_PIXEL_MAP_A_TO_A_SIZE
, then replaced by the contents
of ?GL_PIXEL_MAP_A_TO_A
indexed by itself. All components taken from the maps are
then clamped to the range [0 1]. ?GL_MAP_COLOR
is specified with gl:pixelTransfer
.
The contents of the various maps are specified with gl:pixelMapfv/3 .
If the ARB_imaging extension is supported, each of the four color components may be scaled
and biased after transformation by the color matrix. That is, the red component is multiplied
by ?GL_POST_COLOR_MATRIX_RED_SCALE
, then added to ?GL_POST_COLOR_MATRIX_RED_BIAS
; the green component is multiplied by ?GL_POST_COLOR_MATRIX_GREEN_SCALE
, then
added to ?GL_POST_COLOR_MATRIX_GREEN_BIAS
; the blue component is multiplied by ?GL_POST_COLOR_MATRIX_BLUE_SCALE
, then added to ?GL_POST_COLOR_MATRIX_BLUE_BIAS
; and the alpha component is multiplied
by ?GL_POST_COLOR_MATRIX_ALPHA_SCALE
, then added to ?GL_POST_COLOR_MATRIX_ALPHA_BIAS
. After all four color components are scaled and biased, each is clamped to the range [0
1].
Similarly, if the ARB_imaging extension is supported, each of the four color components
may be scaled and biased after processing by the enabled convolution filter. That is,
the red component is multiplied by ?GL_POST_CONVOLUTION_RED_SCALE
, then added to ?GL_POST_CONVOLUTION_RED_BIAS
; the green component is multiplied by ?GL_POST_CONVOLUTION_GREEN_SCALE
, then added
to ?GL_POST_CONVOLUTION_GREEN_BIAS
; the blue component is multiplied by ?GL_POST_CONVOLUTION_BLUE_SCALE
, then added to ?GL_POST_CONVOLUTION_BLUE_BIAS
; and the alpha component is multiplied
by ?GL_POST_CONVOLUTION_ALPHA_SCALE
, then added to ?GL_POST_CONVOLUTION_ALPHA_BIAS
. After all four color components are scaled and biased, each is clamped to the range [0
1].
Color index
: Each color index is shifted left by ?GL_INDEX_SHIFT
bits;
any bits beyond the number of fraction bits carried by the fixed-point index are filled
with zeros. If ?GL_INDEX_SHIFT
is negative, the shift is to the right, again zero
filled. Then ?GL_INDEX_OFFSET
is added to the index. ?GL_INDEX_SHIFT
and ?GL_INDEX_OFFSET
are specified with gl:pixelTransfer
.
From this point, operation diverges depending on the required format of the resulting
pixels. If the resulting pixels are to be written to a color index buffer, or if they
are being read back to client memory in ?GL_COLOR_INDEX
format, the pixels continue
to be treated as indices. If ?GL_MAP_COLOR
is true, each index is masked by 2 n-1
, where n is ?GL_PIXEL_MAP_I_TO_I_SIZE
, then replaced by the contents of ?GL_PIXEL_MAP_I_TO_I
indexed by the masked value. ?GL_MAP_COLOR
is specified with gl:pixelTransfer
. The contents of the index map is specified with gl:pixelMapfv/3 .
If the resulting pixels are to be written to an RGBA color buffer, or if they are read
back to client memory in a format other than ?GL_COLOR_INDEX
, the pixels are converted
from indices to colors by referencing the four maps ?GL_PIXEL_MAP_I_TO_R
, ?GL_PIXEL_MAP_I_TO_G
, ?GL_PIXEL_MAP_I_TO_B
, and ?GL_PIXEL_MAP_I_TO_A
. Before being dereferenced,
the index is masked by 2 n-1, where n is ?GL_PIXEL_MAP_I_TO_R_SIZE
for the
red map, ?GL_PIXEL_MAP_I_TO_G_SIZE
for the green map, ?GL_PIXEL_MAP_I_TO_B_SIZE
for the blue map, and ?GL_PIXEL_MAP_I_TO_A_SIZE
for the alpha map. All components
taken from the maps are then clamped to the range [0 1]. The contents of the four maps is
specified with gl:pixelMapfv/3 .
Depth
: Each depth value is multiplied by ?GL_DEPTH_SCALE
, added to ?GL_DEPTH_BIAS
, then clamped to the range [0 1].
Stencil
: Each index is shifted ?GL_INDEX_SHIFT
bits just as a color index
is, then added to ?GL_INDEX_OFFSET
. If ?GL_MAP_STENCIL
is true, each index
is masked by 2 n-1, where n is ?GL_PIXEL_MAP_S_TO_S_SIZE
, then replaced by
the contents of ?GL_PIXEL_MAP_S_TO_S
indexed by the masked value.
The following table gives the type, initial value, and range of valid values for each
of the pixel transfer parameters that are set with gl:pixelTransfer
.
Pname
Type
Initial Value
Valid Range
?GL_MAP_COLOR
boolean false true/false ?GL_MAP_STENCIL
boolean false true/false ?GL_INDEX_SHIFT
integer 0 (-)?GL_INDEX_OFFSET
integer
0 (-)?GL_RED_SCALE
float 1
(-)?GL_GREEN_SCALE
float 1 (-)?GL_BLUE_SCALE
float 1 (-)?GL_ALPHA_SCALE
float 1 (-)?GL_DEPTH_SCALE
float 1 (-)?GL_RED_BIAS
float
0 (-)?GL_GREEN_BIAS
float 0 (-)
?GL_BLUE_BIAS
float 0 (-)?GL_ALPHA_BIAS
float 0 (-)?GL_DEPTH_BIAS
float 0 (-)?GL_POST_COLOR_MATRIX_RED_SCALE
float 1 (-)?GL_POST_COLOR_MATRIX_GREEN_SCALE
float 1 (-)?GL_POST_COLOR_MATRIX_BLUE_SCALE
float 1 (-)?GL_POST_COLOR_MATRIX_ALPHA_SCALE
float 1 (-)?GL_POST_COLOR_MATRIX_RED_BIAS
float 0 (-)?GL_POST_COLOR_MATRIX_GREEN_BIAS
float 0 (-)?GL_POST_COLOR_MATRIX_BLUE_BIAS
float 0 (-)?GL_POST_COLOR_MATRIX_ALPHA_BIAS
float 0 (-)?GL_POST_CONVOLUTION_RED_SCALE
float 1 (-)?GL_POST_CONVOLUTION_GREEN_SCALE
float 1 (-)?GL_POST_CONVOLUTION_BLUE_SCALE
float 1 (-)?GL_POST_CONVOLUTION_ALPHA_SCALE
float 1 (-)?GL_POST_CONVOLUTION_RED_BIAS
float 0 (-)?GL_POST_CONVOLUTION_GREEN_BIAS
float 0 (-)?GL_POST_CONVOLUTION_BLUE_BIAS
float 0 (-)?GL_POST_CONVOLUTION_ALPHA_BIAS
float 0 (-)gl:pixelTransferf
can be used to set any pixel transfer parameter. If the parameter
type is boolean, 0 implies false and any other value implies true. If Pname
is
an integer parameter, Param
is rounded to the nearest integer.
Likewise, gl:pixelTransferi
can be used to set any of the pixel transfer parameters.
Boolean parameters are set to false if Param
is 0 and to true otherwise. Param
is converted to floating point before being assigned to real-valued parameters.
See
pixelMapfv(Map, Mapsize, Values) -> ok
Map = enum()
Mapsize = integer()
Values = binary()
Set up pixel transfer maps
gl:pixelMap
sets up translation tables, or maps
, used by gl:copyPixels/5
, gl:copyTexImage1D/7 , gl:copyTexImage2D/8 , gl:copyTexSubImage1D/6 , gl:copyTexSubImage2D/8
, gl:copyTexSubImage3D/9 , gl:drawPixels/5 , gl:readPixels/7 , gl:texImage1D/8
, gl:texImage2D/9 , gl:texImage3D/10 , gl:texSubImage1D/7 , gl:texSubImage1D/7
, and gl:texSubImage1D/7 . Additionally, if the ARB_imaging subset is supported,
the routines gl:colorTable/6 , gl:colorSubTable/6 , gl:convolutionFilter1D/6
, gl:convolutionFilter2D/7 , gl:histogram/4 , gl:minmax/3 , and gl:separableFilter2D/8
. Use of these maps is described completely in the gl:pixelTransferf/2 reference
page, and partly in the reference pages for the pixel and texture image commands. Only
the specification of the maps is described in this reference page.
Map
is a symbolic map name, indicating one of ten maps to set. Mapsize
specifies
the number of entries in the map, and Values
is a pointer to an array of Mapsize
map values.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a pixel transfer map is specified, Values
is
treated as a byte offset into the buffer object's data store.
The ten maps are as follows:
?GL_PIXEL_MAP_I_TO_I
: Maps color indices to color indices.
?GL_PIXEL_MAP_S_TO_S
: Maps stencil indices to stencil indices.
?GL_PIXEL_MAP_I_TO_R
: Maps color indices to red components.
?GL_PIXEL_MAP_I_TO_G
: Maps color indices to green components.
?GL_PIXEL_MAP_I_TO_B
: Maps color indices to blue components.
?GL_PIXEL_MAP_I_TO_A
: Maps color indices to alpha components.
?GL_PIXEL_MAP_R_TO_R
: Maps red components to red components.
?GL_PIXEL_MAP_G_TO_G
: Maps green components to green components.
?GL_PIXEL_MAP_B_TO_B
: Maps blue components to blue components.
?GL_PIXEL_MAP_A_TO_A
: Maps alpha components to alpha components.
The entries in a map can be specified as single-precision floating-point numbers, unsigned
short integers, or unsigned int integers. Maps that store color component values (all
but ?GL_PIXEL_MAP_I_TO_I
and ?GL_PIXEL_MAP_S_TO_S
) retain their values in
floating-point format, with unspecified mantissa and exponent sizes. Floating-point values
specified by gl:pixelMapfv
are converted directly to the internal floating-point
format of these maps, then clamped to the range [0,1]. Unsigned integer values specified
by gl:pixelMapusv
and gl:pixelMapuiv
are converted linearly such that the
largest representable integer maps to 1.0, and 0 maps to 0.0.
Maps that store indices, ?GL_PIXEL_MAP_I_TO_I
and ?GL_PIXEL_MAP_S_TO_S
,
retain their values in fixed-point format, with an unspecified number of bits to the right
of the binary point. Floating-point values specified by gl:pixelMapfv
are converted
directly to the internal fixed-point format of these maps. Unsigned integer values specified
by gl:pixelMapusv
and gl:pixelMapuiv
specify integer values, with all 0's
to the right of the binary point.
The following table shows the initial sizes and values for each of the maps. Maps that
are indexed by either color or stencil indices must have Mapsize
= 2 n for some
n or the results are undefined. The maximum allowable size for each map depends on the
implementation and can be determined by calling gl:getBooleanv/1 with argument ?GL_MAX_PIXEL_MAP_TABLE
. The single maximum applies to all maps; it is at least 32.
Map
Lookup Index
Lookup Value
Initial Size
Initial Value
?GL_PIXEL_MAP_I_TO_I
color index color index 1 0 ?GL_PIXEL_MAP_S_TO_S
stencil index stencil index 1 0 ?GL_PIXEL_MAP_I_TO_R
color index R 1 0
?GL_PIXEL_MAP_I_TO_G
color index G 1
0 ?GL_PIXEL_MAP_I_TO_B
color index B
1 0 ?GL_PIXEL_MAP_I_TO_A
color index
A 1 0 ?GL_PIXEL_MAP_R_TO_R
R
R 1 0 ?GL_PIXEL_MAP_G_TO_G
G
G 1 0 ?GL_PIXEL_MAP_B_TO_B
B
B 1 0 ?GL_PIXEL_MAP_A_TO_A
A
A 1 0 See
pixelMapuiv(Map, Mapsize, Values) -> ok
Map = enum()
Mapsize = integer()
Values = binary()
See pixelMapfv/3
pixelMapusv(Map, Mapsize, Values) -> ok
Map = enum()
Mapsize = integer()
Values = binary()
See pixelMapfv/3
getPixelMapfv(Map, Values) -> ok
Map = enum()
Values = mem()
Return the specified pixel map
See the gl:pixelMapfv/3 reference page for a description of the acceptable values
for the Map
parameter. gl:getPixelMap
returns in Data
the contents
of the pixel map specified in Map
. Pixel maps are used during the execution of gl:readPixels/7
, gl:drawPixels/5 , gl:copyPixels/5 , gl:texImage1D/8 , gl:texImage2D/9
, gl:texImage3D/10 , gl:texSubImage1D/7 , gl:texSubImage1D/7 , gl:texSubImage1D/7
, gl:copyTexImage1D/7 , gl:copyTexImage2D/8 , gl:copyTexSubImage1D/6 , gl:copyTexSubImage2D/8
, and gl:copyTexSubImage3D/9 . to map color indices, stencil indices, color components,
and depth components to other values.
If a non-zero named buffer object is bound to the ?GL_PIXEL_PACK_BUFFER
target
(see gl:bindBuffer/2 ) while a pixel map is requested, Data
is treated as
a byte offset into the buffer object's data store.
Unsigned integer values, if requested, are linearly mapped from the internal fixed or floating-point representation such that 1.0 maps to the largest representable integer value, and 0.0 maps to 0. Return unsigned integer values are undefined if the map value was not in the range [0,1].
To determine the required size of Map
, call gl:getBooleanv/1 with the appropriate
symbolic constant.
See
bitmap(Width, Height, Xorig, Yorig, Xmove, Ymove, Bitmap) -> ok
Width = integer()
Height = integer()
Xorig = float()
Yorig = float()
Xmove = float()
Ymove = float()
Bitmap = offset() | mem()
Draw a bitmap
A bitmap is a binary image. When drawn, the bitmap is positioned relative to the current raster position, and frame buffer pixels corresponding to 1's in the bitmap are written using the current raster color or index. Frame buffer pixels corresponding to 0's in the bitmap are not modified.
gl:bitmap
takes seven arguments. The first pair specifies the width and height of
the bitmap image. The second pair specifies the location of the bitmap origin relative
to the lower left corner of the bitmap image. The third pair of arguments specifies x
and y
offsets to be added to the current raster position after the bitmap has
been drawn. The final argument is a pointer to the bitmap image itself.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a bitmap image is specified, Bitmap
is treated
as a byte offset into the buffer object's data store.
The bitmap image is interpreted like image data for the gl:drawPixels/5 command,
with Width
and Height
corresponding to the width and height arguments of
that command, and with type
set to ?GL_BITMAP
and format
set to ?GL_COLOR_INDEX
. Modes specified using gl:pixelStoref/2 affect the interpretation of bitmap image
data; modes specified using gl:pixelTransferf/2 do not.
If the current raster position is invalid, gl:bitmap
is ignored. Otherwise, the
lower left corner of the bitmap image is positioned at the window coordinates
x w=|x r-x o|
y w=|y r-y o|
where (x r y r) is the raster position and (x o y o) is the bitmap origin. Fragments are then generated
for each pixel corresponding to a 1 (one) in the bitmap image. These fragments are generated
using the current raster z
coordinate, color or color index, and current raster
texture coordinates. They are then treated just as if they had been generated by a point,
line, or polygon, including texture mapping, fogging, and all per-fragment operations
such as alpha and depth testing.
After the bitmap has been drawn, the x
and y
coordinates of the current
raster position are offset by Xmove
and Ymove
. No change is made to the z
coordinate of the current raster position, or to the current raster color, texture coordinates,
or index.
See
readPixels(X, Y, Width, Height, Format, Type, Pixels) -> ok
X = integer()
Y = integer()
Width = integer()
Height = integer()
Format = enum()
Type = enum()
Pixels = mem()
Read a block of pixels from the frame buffer
gl:readPixels
returns pixel data from the frame buffer, starting with the pixel
whose lower left corner is at location ( X
, Y
), into client memory starting
at location Data
. Several parameters control the processing of the pixel data before
it is placed into client memory. These parameters are set with gl:pixelStoref/2 .
This reference page describes the effects on gl:readPixels
of most, but not all
of the parameters specified by these three commands.
If a non-zero named buffer object is bound to the ?GL_PIXEL_PACK_BUFFER
target
(see gl:bindBuffer/2 ) while a block of pixels is requested, Data
is treated
as a byte offset into the buffer object's data store rather than a pointer to client memory.
gl:readPixels
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 for the returned pixel values; accepted values are:
?GL_STENCIL_INDEX
: Stencil values are read from the stencil buffer. Each index
is converted to fixed point, shifted left or right depending on the value and sign of ?GL_INDEX_SHIFT
, and added to ?GL_INDEX_OFFSET
. If ?GL_MAP_STENCIL
is ?GL_TRUE
,
indices are replaced by their mappings in the table ?GL_PIXEL_MAP_S_TO_S
.
?GL_DEPTH_COMPONENT
: Depth values are read from the depth buffer. Each component
is converted to floating point such that the minimum depth value maps to 0 and the maximum
value maps to 1. Each component is then multiplied by ?GL_DEPTH_SCALE
, added to ?GL_DEPTH_BIAS
, and finally clamped to the range [0 1].
?GL_DEPTH_STENCIL
: Values are taken from both the depth and stencil buffers. The Type
parameter must be ?GL_UNSIGNED_INT_24_8
or ?GL_FLOAT_32_UNSIGNED_INT_24_8_REV
.
?GL_RED
?GL_GREEN
?GL_BLUE
?GL_RGB
?GL_BGR
?GL_RGBA
?GL_BGRA
: Finally, the indices or components are converted to the proper format,
as specified by Type
. If Format
is ?GL_STENCIL_INDEX
and Type
is not ?GL_FLOAT
, each index is masked with the mask value given in the following
table. If Type
is ?GL_FLOAT
, then each integer index is converted to single-precision
floating-point format.
If Format
is ?GL_RED
, ?GL_GREEN
, ?GL_BLUE
, ?GL_RGB
, ?GL_BGR
, ?GL_RGBA
, or ?GL_BGRA
and Type
is not ?GL_FLOAT
, each component
is multiplied by the multiplier shown in the following table. If type is ?GL_FLOAT
,
then each component is passed as is (or converted to the client's single-precision floating-point
format if it is different from the one used by the GL).
Type
Index Mask
Component Conversion
?GL_UNSIGNED_BYTE
2 8-1(2 8-1) c?GL_BYTE
2 7-1((2 8-1) c-1)/2?GL_UNSIGNED_SHORT
2 16-1(2 16-1) c?GL_SHORT
2 15-1((2
16-1)
c-1)/2
?GL_UNSIGNED_INT
2 32-1(2 32-1) c?GL_INT
2 31-1((2 32-1) c-1)/2?GL_HALF_FLOAT
none
c?GL_FLOAT
none c?GL_UNSIGNED_BYTE_3_3_2
2 N-1(2 N-1) c?GL_UNSIGNED_BYTE_2_3_3_REV
2 N-1(2 N-1) c?GL_UNSIGNED_SHORT_5_6_5
2 N-1
(2 N-1) c?GL_UNSIGNED_SHORT_5_6_5_REV
2 N-1(2 N-1) c?GL_UNSIGNED_SHORT_4_4_4_4
2 N-1(2 N-1) c?GL_UNSIGNED_SHORT_4_4_4_4_REV
2 N-1(2 N-1) c?GL_UNSIGNED_SHORT_5_5_5_1
2
N-1(2 N-1) c?GL_UNSIGNED_SHORT_1_5_5_5_REV
2 N-1
(2 N-1) c?GL_UNSIGNED_INT_8_8_8_8
2 N-1(2 N-1) c?GL_UNSIGNED_INT_8_8_8_8_REV
2 N-1(2 N-1) c?GL_UNSIGNED_INT_10_10_10_2
2 N-1(2 N-1) c?GL_UNSIGNED_INT_2_10_10_10_REV
2 N-1(2 N-1) c?GL_UNSIGNED_INT_24_8
2 N-1(2
N-1)
c?GL_UNSIGNED_INT_10F_11F_11F_REV
-- Special
?GL_UNSIGNED_INT_5_9_9_9_REV
-- Special ?GL_FLOAT_32_UNSIGNED_INT_24_8_REV
none c (Depth Only)
Return values are placed in memory as follows. If Format
is ?GL_STENCIL_INDEX
, ?GL_DEPTH_COMPONENT
, ?GL_RED
, ?GL_GREEN
, or ?GL_BLUE
, 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
and ?GL_BGR
return three values, ?GL_RGBA
and ?GL_BGRA
return four values for each pixel, with all values corresponding
to a single pixel occupying contiguous space in Data
. Storage parameters set by gl:pixelStoref/2
, such as ?GL_PACK_LSB_FIRST
and ?GL_PACK_SWAP_BYTES
, affect the way that
data is written into memory. See gl:pixelStoref/2 for a description.
See
drawPixels(Width, Height, Format, Type, Pixels) -> ok
Width = integer()
Height = integer()
Format = enum()
Type = enum()
Pixels = offset() | mem()
Write a block of pixels to the frame buffer
gl:drawPixels
reads pixel data from memory and writes it into the frame buffer relative
to the current raster position, provided that the raster position is valid. Use gl:rasterPos2d/2
or gl:windowPos2d/2 to set the current raster position; use gl:getBooleanv/1 with
argument ?GL_CURRENT_RASTER_POSITION_VALID
to determine if the specified raster
position is valid, and gl:getBooleanv/1 with argument ?GL_CURRENT_RASTER_POSITION
to query the raster position.
Several parameters define the encoding of pixel data in memory and control the processing
of the pixel data before it is placed in the frame buffer. These parameters are set with
four commands: gl:pixelStoref/2 , gl:pixelTransferf/2 , gl:pixelMapfv/3 ,
and gl:pixelZoom/2 . This reference page describes the effects on gl:drawPixels
of many, but not all, of the parameters specified by these four commands.
Data is read from Data
as a sequence of signed or unsigned bytes, signed or unsigned
shorts, signed or unsigned integers, or single-precision floating-point values, depending
on Type
. When Type
is one of ?GL_UNSIGNED_BYTE
, ?GL_BYTE
, ?GL_UNSIGNED_SHORT
, ?GL_SHORT
, ?GL_UNSIGNED_INT
, ?GL_INT
, or ?GL_FLOAT
each
of these bytes, shorts, integers, or floating-point values is interpreted as one color
or depth component, or one index, depending on Format
. When Type
is one of ?GL_UNSIGNED_BYTE_3_3_2
, ?GL_UNSIGNED_SHORT_5_6_5
, ?GL_UNSIGNED_SHORT_4_4_4_4
, ?GL_UNSIGNED_SHORT_5_5_5_1
, ?GL_UNSIGNED_INT_8_8_8_8
, or ?GL_UNSIGNED_INT_10_10_10_2
, each unsigned
value is interpreted as containing all the components for a single pixel, with the color
components arranged according to Format
. When Type
is one of ?GL_UNSIGNED_BYTE_2_3_3_REV
, ?GL_UNSIGNED_SHORT_5_6_5_REV
, ?GL_UNSIGNED_SHORT_4_4_4_4_REV
, ?GL_UNSIGNED_SHORT_1_5_5_5_REV
, ?GL_UNSIGNED_INT_8_8_8_8_REV
, or ?GL_UNSIGNED_INT_2_10_10_10_REV
, each
unsigned value is interpreted as containing all color components, specified by Format
, for a single pixel in a reversed order. Indices are always treated individually. Color
components are treated as groups of one, two, three, or four values, again based on Format
. Both individual indices and groups of components are referred to as pixels. If Type
is ?GL_BITMAP
, the data must be unsigned bytes, and Format
must be either ?GL_COLOR_INDEX
or ?GL_STENCIL_INDEX
. Each unsigned byte is treated as eight 1-bit pixels, with
bit ordering determined by ?GL_UNPACK_LSB_FIRST
(see gl:pixelStoref/2 ).
width×height pixels are read from memory, starting at location Data
. By default,
these 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 gl:pixelStoref/2 with argument ?GL_UNPACK_ALIGNMENT
, and it can be set to one, two, four, or eight bytes. Other pixel store parameters specify
different read pointer advancements, both before the first pixel is read and after all Width
pixels are read. See the gl:pixelStoref/2 reference page for details on these options.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a block of pixels is specified, Data
is treated
as a byte offset into the buffer object's data store.
The width×height pixels that are read from memory are each operated on in the same
way, based on the values of several parameters specified by gl:pixelTransferf/2
and gl:pixelMapfv/3 . The details of these operations, as well as the target buffer
into which the pixels are drawn, are specific to the format of the pixels, as specified
by Format
. Format
can assume one of 13 symbolic values:
?GL_COLOR_INDEX
: Each pixel is a single value, a color index. It is converted
to fixed-point format, with an unspecified number of bits to the right of the binary point,
regardless of the memory data type. Floating-point values convert to true fixed-point
values. Signed and unsigned integer data is converted with all fraction bits set to 0.
Bitmap data convert to either 0 or 1.
Each fixed-point index is then shifted left by ?GL_INDEX_SHIFT
bits and added to ?GL_INDEX_OFFSET
. If ?GL_INDEX_SHIFT
is negative, the shift is to the right. In either case, zero
bits fill otherwise unspecified bit locations in the result.
If the GL is in RGBA mode, the resulting index is converted to an RGBA pixel with the
help of the ?GL_PIXEL_MAP_I_TO_R
, ?GL_PIXEL_MAP_I_TO_G
, ?GL_PIXEL_MAP_I_TO_B
, and ?GL_PIXEL_MAP_I_TO_A
tables. If the GL is in color index mode, and if ?GL_MAP_COLOR
is true, the index is replaced with the value that it references in lookup table ?GL_PIXEL_MAP_I_TO_I
. Whether the lookup replacement of the index is done or not, the integer part of the
index is then ANDed with 2 b-1, where b is the number of bits in a color index buffer.
The GL then converts the resulting indices or RGBA colors to fragments by attaching the
current raster position z
coordinate and texture coordinates to each pixel, then
assigning x and y window coordinates to the nth fragment such that x n=x r+n% width
y n=y r+|n/width|
where (x r y r) is the current raster position. These pixel fragments are then treated just like the fragments generated by rasterizing points, lines, or polygons. Texture mapping, fog, and all the fragment operations are applied before the fragments are written to the frame buffer.
?GL_STENCIL_INDEX
: Each pixel is a single value, a stencil index. It is converted
to fixed-point format, with an unspecified number of bits to the right of the binary point,
regardless of the memory data type. Floating-point values convert to true fixed-point
values. Signed and unsigned integer data is converted with all fraction bits set to 0.
Bitmap data convert to either 0 or 1.
Each fixed-point index is then shifted left by ?GL_INDEX_SHIFT
bits, and added
to ?GL_INDEX_OFFSET
. If ?GL_INDEX_SHIFT
is negative, the shift is to the
right. In either case, zero bits fill otherwise unspecified bit locations in the result.
If ?GL_MAP_STENCIL
is true, the index is replaced with the value that it references
in lookup table ?GL_PIXEL_MAP_S_TO_S
. Whether the lookup replacement of the index
is done or not, the integer part of the index is then ANDed with 2 b-1, where b is
the number of bits in the stencil buffer. The resulting stencil indices are then written
to the stencil buffer such that the nth index is written to location
x n=x r+n% width
y n=y r+|n/width|
where (x r y r) is the current raster position. Only the pixel ownership test, the scissor test, and the stencil writemask affect these write operations.
?GL_DEPTH_COMPONENT
: Each pixel is a single-depth component. Floating-point data
is converted directly to an internal floating-point format with unspecified precision.
Signed integer data is mapped linearly to the internal floating-point format such that
the most positive representable integer value maps to 1.0, and the most negative representable
value maps to -1.0. Unsigned integer data is mapped similarly: the largest integer value
maps to 1.0, and 0 maps to 0.0. The resulting floating-point depth value is then multiplied
by ?GL_DEPTH_SCALE
and added to ?GL_DEPTH_BIAS
. The result is clamped to
the range [0 1].
The GL then converts the resulting depth components to fragments by attaching the current raster position color or color index and texture coordinates to each pixel, then assigning x and y window coordinates to the nth fragment such that
x n=x r+n% width
y n=y r+|n/width|
where (x r y r) is the current raster position. These pixel fragments are then treated just like the fragments generated by rasterizing points, lines, or polygons. Texture mapping, fog, and all the fragment operations are applied before the fragments are written to the frame buffer.
?GL_RGBA
?GL_BGRA
: Each pixel is a four-component group: For ?GL_RGBA
, the red component
is first, followed by green, followed by blue, followed by alpha; for ?GL_BGRA
the order is blue, green, red and then alpha. Floating-point values are converted directly
to an internal floating-point format with unspecified precision. Signed integer values
are mapped linearly to the internal floating-point format such that the most positive
representable integer value maps to 1.0, and the most negative representable value maps
to -1.0. (Note that this mapping does not convert 0 precisely to 0.0.) Unsigned integer
data is mapped similarly: The largest integer value maps to 1.0, and 0 maps to 0.0. The
resulting floating-point color values are then multiplied by ?GL_c_SCALE
and added
to ?GL_c_BIAS
, where c
is RED, GREEN, BLUE, and ALPHA for the respective
color components. The results are clamped to the range [0 1].
If ?GL_MAP_COLOR
is true, each color component is scaled by the size of lookup
table ?GL_PIXEL_MAP_c_TO_c
, then replaced by the value that it references in that
table. c
is R, G, B, or A respectively.
The GL then converts the resulting RGBA colors to fragments by attaching the current
raster position z
coordinate and texture coordinates to each pixel, then assigning
x and y window coordinates to the nth fragment such that
x n=x r+n% width
y n=y r+|n/width|
where (x r y r) is the current raster position. These pixel fragments are then treated just like the fragments generated by rasterizing points, lines, or polygons. Texture mapping, fog, and all the fragment operations are applied before the fragments are written to the frame buffer.
?GL_RED
: Each pixel is a single red component. This component is converted to
the internal floating-point format in the same way the red component of an RGBA pixel
is. It is then converted to an RGBA pixel with green and blue set to 0, and alpha set
to 1. After this conversion, the pixel is treated as if it had been read as an RGBA pixel.
?GL_GREEN
: Each pixel is a single green component. This component is converted
to the internal floating-point format in the same way the green component of an RGBA pixel
is. It is then converted to an RGBA pixel with red and blue set to 0, and alpha set to
1. After this conversion, the pixel is treated as if it had been read as an RGBA pixel.
?GL_BLUE
: Each pixel is a single blue component. This component is converted to
the internal floating-point format in the same way the blue component of an RGBA pixel
is. It is then converted to an RGBA pixel with red and green set to 0, and alpha set to
1. After this conversion, the pixel is treated as if it had been read as an RGBA pixel.
?GL_ALPHA
: Each pixel is a single alpha component. This component is converted
to the internal floating-point format in the same way the alpha component of an RGBA pixel
is. It is then converted to an RGBA pixel with red, green, and blue set to 0. After this
conversion, the pixel is treated as if it had been read as an RGBA pixel.
?GL_RGB
?GL_BGR
: Each pixel is a three-component group: red first, followed by green,
followed by blue; for ?GL_BGR
, the first component is blue, followed by green and
then red. Each component is converted to the internal floating-point format in the same
way the red, green, and blue components of an RGBA pixel are. The color triple is converted
to an RGBA pixel with alpha set to 1. After this conversion, the pixel is treated as if
it had been read as an RGBA pixel.
?GL_LUMINANCE
: Each pixel is a single luminance component. This component is converted
to the internal floating-point format in the same way the red component of an RGBA pixel
is. It is then converted to an RGBA pixel with red, green, and blue set to the converted
luminance value, and alpha set to 1. After this conversion, the pixel is treated as if
it had been read as an RGBA pixel.
?GL_LUMINANCE_ALPHA
: Each pixel is a two-component group: luminance first, followed
by alpha. The two components are converted to the internal floating-point format in the
same way the red component of an RGBA pixel is. They are then converted to an RGBA pixel
with red, green, and blue set to the converted luminance value, and alpha set to the converted
alpha value. After this conversion, the pixel is treated as if it had been read as an
RGBA pixel.
The following table summarizes the meaning of the valid constants for the type
parameter:
Type
Corresponding Type
?GL_UNSIGNED_BYTE
unsigned 8-bit integer ?GL_BYTE
signed 8-bit integer ?GL_BITMAP
single bits
in unsigned 8-bit integers ?GL_UNSIGNED_SHORT
unsigned
16-bit integer ?GL_SHORT
signed 16-bit integer ?GL_UNSIGNED_INT
unsigned 32-bit integer ?GL_INT
32-bit integer ?GL_FLOAT
single-precision
floating-point ?GL_UNSIGNED_BYTE_3_3_2
unsigned 8-bit
integer ?GL_UNSIGNED_BYTE_2_3_3_REV
unsigned 8-bit
integer with reversed component ordering ?GL_UNSIGNED_SHORT_5_6_5
unsigned 16-bit integer ?GL_UNSIGNED_SHORT_5_6_5_REV
unsigned 16-bit integer with reversed component ordering ?GL_UNSIGNED_SHORT_4_4_4_4
unsigned 16-bit integer ?GL_UNSIGNED_SHORT_4_4_4_4_REV
unsigned 16-bit integer with reversed component ordering ?GL_UNSIGNED_SHORT_5_5_5_1
unsigned 16-bit integer ?GL_UNSIGNED_SHORT_1_5_5_5_REV
unsigned 16-bit integer with reversed component ordering ?GL_UNSIGNED_INT_8_8_8_8
unsigned 32-bit integer ?GL_UNSIGNED_INT_8_8_8_8_REV
unsigned 32-bit integer with reversed component ordering ?GL_UNSIGNED_INT_10_10_10_2
unsigned 32-bit integer ?GL_UNSIGNED_INT_2_10_10_10_REV
unsigned 32-bit integer with reversed component ordering The rasterization described so far assumes pixel zoom factors of 1. If gl:pixelZoom/2 is used to change the x and y pixel zoom factors, pixels are converted to fragments as follows. If (x r y r) is the current raster position, and a given pixel is in the nth column and mth row of the pixel rectangle, then fragments are generated for pixels whose centers are in the rectangle with corners at
(x r+(zoom x) n y r+(zoom y) m)
(x r+(zoom x)(n+1) y r+(zoom y)(m+1))
where zoom x is the value of ?GL_ZOOM_X
and zoom y is the value of ?GL_ZOOM_Y
.
See
copyPixels(X, Y, Width, Height, Type) -> ok
X = integer()
Y = integer()
Width = integer()
Height = integer()
Type = enum()
Copy pixels in the frame buffer
gl:copyPixels
copies a screen-aligned rectangle of pixels from the specified frame
buffer location to a region relative to the current raster position. Its operation is
well defined only if the entire pixel source region is within the exposed portion of the
window. Results of copies from outside the window, or from regions of the window that
are not exposed, are hardware dependent and undefined.
X
and Y
specify the window coordinates of the lower left corner of the rectangular
region to be copied. Width
and Height
specify the dimensions of the rectangular
region to be copied. Both Width
and Height
must not be negative.
Several parameters control the processing of the pixel data while it is being copied.
These parameters are set with three commands: gl:pixelTransferf/2 , gl:pixelMapfv/3
, and gl:pixelZoom/2 . This reference page describes the effects on gl:copyPixels
of most, but not all, of the parameters specified by these three commands.
gl:copyPixels
copies values from each pixel with the lower left-hand 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 copied in row order from the lowest to the highest
row, left to right in each row.
Type
specifies whether color, depth, or stencil data is to be copied. The details
of the transfer for each data type are as follows:
?GL_COLOR
: Indices or RGBA colors are read from the buffer currently specified
as the read source buffer (see gl:readBuffer/1 ). If the GL is in color index mode,
each index that is read from this buffer is converted to a fixed-point format with an
unspecified number of bits to the right of the binary point. Each index is then shifted
left by ?GL_INDEX_SHIFT
bits, and added to ?GL_INDEX_OFFSET
. If ?GL_INDEX_SHIFT
is negative, the shift is to the right. In either case, zero bits fill otherwise unspecified
bit locations in the result. If ?GL_MAP_COLOR
is true, the index is replaced with
the value that it references in lookup table ?GL_PIXEL_MAP_I_TO_I
. Whether the
lookup replacement of the index is done or not, the integer part of the index is then
ANDed with 2 b-1, where b is the number of bits in a color index buffer.
If the GL is in RGBA mode, the red, green, blue, and alpha components of each pixel that
is read are converted to an internal 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 resulting floating-point color values are then multiplied by ?GL_c_SCALE
and added to ?GL_c_BIAS
, where c
is RED, GREEN, BLUE, and ALPHA for the
respective color components. The results are clamped to the range [0,1]. If ?GL_MAP_COLOR
is true, each color component is scaled by the size of lookup table ?GL_PIXEL_MAP_c_TO_c
, then replaced by the value that it references in that table. c
is R, G, B, or
A.
If the ARB_imaging extension is supported, the color values may be additionally processed by color-table lookups, color-matrix transformations, and convolution filters.
The GL then converts the resulting indices or RGBA colors to fragments by attaching the
current raster position z
coordinate and texture coordinates to each pixel, then
assigning window coordinates (x r+i y r+j), where (x r y r) is the current raster position, and the pixel was
the ith pixel in the jth row. These pixel fragments are then treated just like the
fragments generated by rasterizing points, lines, or polygons. Texture mapping, fog, and
all the fragment operations are applied before the fragments are written to the frame
buffer.
?GL_DEPTH
: Depth values are read from the depth buffer and converted directly
to an internal floating-point format with unspecified precision. The resulting floating-point
depth value is then multiplied by ?GL_DEPTH_SCALE
and added to ?GL_DEPTH_BIAS
. The result is clamped to the range [0,1].
The GL then converts the resulting depth components to fragments by attaching the current raster position color or color index and texture coordinates to each pixel, then assigning window coordinates (x r+i y r+j), where (x r y r) is the current raster position, and the pixel was the ith pixel in the jth row. These pixel fragments are then treated just like the fragments generated by rasterizing points, lines, or polygons. Texture mapping, fog, and all the fragment operations are applied before the fragments are written to the frame buffer.
?GL_STENCIL
: Stencil indices are read from the stencil buffer and converted to
an internal fixed-point format with an unspecified number of bits to the right of the
binary point. Each fixed-point index is then shifted left by ?GL_INDEX_SHIFT
bits,
and added to ?GL_INDEX_OFFSET
. If ?GL_INDEX_SHIFT
is negative, the shift
is to the right. In either case, zero bits fill otherwise unspecified bit locations in
the result. If ?GL_MAP_STENCIL
is true, the index is replaced with the value that
it references in lookup table ?GL_PIXEL_MAP_S_TO_S
. Whether the lookup replacement
of the index is done or not, the integer part of the index is then ANDed with 2 b-1,
where b is the number of bits in the stencil buffer. The resulting stencil indices are
then written to the stencil buffer such that the index read from the ith location of
the jth row is written to location (x r+i y r+j), where (x r y r) is the current raster position. Only the
pixel ownership test, the scissor test, and the stencil writemask affect these write operations.
The rasterization described thus far assumes pixel zoom factors of 1.0. If gl:pixelZoom/2 is used to change the x and y pixel zoom factors, pixels are converted to fragments as follows. If (x r y r) is the current raster position, and a given pixel is in the ith location in the jth row of the source pixel rectangle, then fragments are generated for pixels whose centers are in the rectangle with corners at
(x r+(zoom x) i y r+(zoom y) j)
and
(x r+(zoom x)(i+1) y r+(zoom y)(j+1))
where zoom x is the value of ?GL_ZOOM_X
and zoom y is the value of ?GL_ZOOM_Y
.
See
stencilFunc(Func, Ref, Mask) -> ok
Func = enum()
Ref = integer()
Mask = integer()
Set front and back function and reference value for stencil testing
Stenciling, like depth-buffering, enables and disables drawing on a per-pixel basis. Stencil planes are first drawn into using GL drawing primitives, then geometry and images are rendered 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
the test, call gl:enable/1 and gl:enable/1 with argument ?GL_STENCIL_TEST
. To specify actions based on the outcome of the stencil test, call gl:stencilOp/3
or gl:stencilOpSeparate/4 .
There can be two separate sets of Func
, Ref
, and Mask
parameters;
one affects back-facing polygons, and the other affects front-facing polygons as well
as other non-polygon primitives. gl:stencilFunc/3 sets both front and back stencil
state to the same values. Use gl:stencilFuncSeparate/4 to set front and back stencil
state to different values.
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 gl:stencilOp/3 ). 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.
See
stencilMask(Mask) -> ok
Mask = integer()
Control the front and back writing of individual bits in the stencil planes
gl:stencilMask
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.
There can be two separate Mask
writemasks; one affects back-facing polygons, and
the other affects front-facing polygons as well as other non-polygon primitives. gl:stencilMask/1
sets both front and back stencil writemasks to the same values. Use gl:stencilMaskSeparate/2
to set front and back stencil writemasks to different values.
See
stencilOp(Fail, Zfail, Zpass) -> ok
Fail = enum()
Zfail = enum()
Zpass = enum()
Set front and back 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 the
test, call gl:enable/1 and gl:enable/1 with argument ?GL_STENCIL_TEST
; to control it, call gl:stencilFunc/3 or gl:stencilFuncSeparate/4 .
There can be two separate sets of Sfail
, Dpfail
, and Dppass
parameters;
one affects back-facing polygons, and the other affects front-facing polygons as well
as other non-polygon primitives. gl:stencilOp/3 sets both front and back stencil
state to the same values. Use gl:stencilOpSeparate/4 to set front and back stencil
state to different values.
gl:stencilOp
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 Sfail
specifies what happens to the stencil
buffer contents. The following eight 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 gl:stencilFunc/3
.
?GL_INCR
: Increments the current stencil buffer value. Clamps to the maximum representable
unsigned value.
?GL_INCR_WRAP
: Increments the current stencil buffer value. Wraps stencil buffer
value to zero when incrementing the maximum representable unsigned value.
?GL_DECR
: Decrements the current stencil buffer value. Clamps to 0.
?GL_DECR_WRAP
: Decrements the current stencil buffer value. Wraps stencil buffer
value to the maximum representable unsigned value when decrementing a stencil buffer value
of zero.
?GL_INVERT
: Bitwise inverts the current stencil buffer 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 gl:stencilOp
specify stencil buffer actions that depend
on whether subsequent depth buffer tests succeed ( Dppass
) or fail ( Dpfail
)
(see gl:depthFunc/1 ). The actions are specified using the same eight symbolic constants
as Sfail
. Note that Dpfail
is ignored when there is no depth buffer, or
when the depth buffer is not enabled. In these cases, Sfail
and Dppass
specify
stencil action when the stencil test fails and passes, respectively.
See
clearStencil(S) -> ok
S = integer()
Specify the clear value for the stencil buffer
gl:clearStencil
specifies the index used by gl:clear/1 to clear the stencil
buffer. S
is masked with 2 m-1, where m is the number of bits in the stencil
buffer.
See
texGend(Coord, Pname, Param) -> ok
Coord = enum()
Pname = enum()
Param = float()
Control the generation of texture coordinates
gl:texGen
selects a texture-coordinate generation function or supplies coefficients
for one of the functions. Coord
names one of the (s
, t
, r
, q
) texture coordinates; it must be one of the symbols ?GL_S
, ?GL_T
, ?GL_R
, or ?GL_Q
. Pname
must be one of three symbolic constants: ?GL_TEXTURE_GEN_MODE
, ?GL_OBJECT_PLANE
, or ?GL_EYE_PLANE
. If Pname
is ?GL_TEXTURE_GEN_MODE
, then Params
chooses a mode, one of ?GL_OBJECT_LINEAR
, ?GL_EYE_LINEAR
, ?GL_SPHERE_MAP
, ?GL_NORMAL_MAP
, or ?GL_REFLECTION_MAP
. If Pname
is either ?GL_OBJECT_PLANE
or ?GL_EYE_PLANE
, Params
contains coefficients
for the corresponding texture generation function.
If the texture generation function is ?GL_OBJECT_LINEAR
, the function
g=p 1×x o+p 2×y o+p 3×z o+p 4×w o
is used, where g is the value computed for the coordinate named in Coord
, p 1,
p 2, p 3, and p 4 are the four values supplied in Params
, and x o, y o, z o,
and w o are the object coordinates of the vertex. This function can be used, for example,
to texture-map terrain using sea level as a reference plane (defined by p 1, p 2, p
3, and p 4). The altitude of a terrain vertex is computed by the ?GL_OBJECT_LINEAR
coordinate generation function as its distance from sea level; that altitude can then
be used to index the texture image to map white snow onto peaks and green grass onto foothills.
If the texture generation function is ?GL_EYE_LINEAR
, the function
g=(p 1)"×x e+(p 2)"×y e+(p 3)"×z e+(p 4)"×w e
is used, where
((p 1)" (p 2)" (p 3)" (p 4)")=(p 1 p 2 p 3 p 4) M -1
and x e, y e, z e, and w e are the eye coordinates of the vertex, p 1, p 2, p 3,
and p 4 are the values supplied in Params
, and M is the modelview matrix when gl:texGen
is invoked. If M is poorly conditioned or singular, texture coordinates generated by
the resulting function may be inaccurate or undefined.
Note that the values in Params
define a reference plane in eye coordinates. The
modelview matrix that is applied to them may not be the same one in effect when the polygon
vertices are transformed. This function establishes a field of texture coordinates that
can produce dynamic contour lines on moving objects.
If the texture generation function is ?GL_SPHERE_MAP
and Coord
is either ?GL_S
or ?GL_T
, s and t texture coordinates are generated as follows. Let u
be the unit vector pointing from the origin to the polygon vertex (in eye coordinates).
Let n
sup prime be the current normal, after transformation to eye coordinates.
Let
f=(f x f y f z) T be the reflection vector such that
f=u-2 n" (n") T u
Finally, let m=2 ((f x) 2+(f y) 2+(f z+1) 2). Then the values assigned to the s and t texture coordinates are
s=f x/m+1/2
t=f y/m+1/2
To enable or disable a texture-coordinate generation function, call gl:enable/1
or gl:enable/1 with one of the symbolic texture-coordinate names (?GL_TEXTURE_GEN_S
, ?GL_TEXTURE_GEN_T
, ?GL_TEXTURE_GEN_R
, or ?GL_TEXTURE_GEN_Q
) as
the argument. When enabled, the specified texture coordinate is computed according to
the generating function associated with that coordinate. When disabled, subsequent vertices
take the specified texture coordinate from the current set of texture coordinates. Initially,
all texture generation functions are set to ?GL_EYE_LINEAR
and are disabled. Both
s plane equations are (1, 0, 0, 0), both t plane equations are (0, 1, 0, 0), and all
r and q plane equations are (0, 0, 0, 0).
When the ARB_multitexture extension is supported, gl:texGen
sets the texture generation
parameters for the currently active texture unit, selected with gl:activeTexture/1 .
See
getTexGendv(Coord, Pname) -> {float(), float(), float(), float()}
Coord = enum()
Pname = enum()
Return texture coordinate generation parameters
gl:getTexGen
returns in Params
selected parameters of a texture coordinate
generation function that was specified using gl:texGend/3 . Coord
names one
of the (s
, t
, r
, q
) texture coordinates, using the symbolic
constant ?GL_S
, ?GL_T
, ?GL_R
, or ?GL_Q
.
Pname
specifies one of three symbolic names:
?GL_TEXTURE_GEN_MODE
: Params
returns the single-valued texture generation
function, a symbolic constant. The initial value is ?GL_EYE_LINEAR
.
?GL_OBJECT_PLANE
: Params
returns the four plane equation coefficients that
specify object linear-coordinate generation. Integer values, when requested, are mapped
directly from the internal floating-point representation.
?GL_EYE_PLANE
: Params
returns the four plane equation coefficients that
specify eye linear-coordinate generation. Integer values, when requested, are mapped directly
from the internal floating-point representation. The returned values are those maintained
in eye coordinates. They are not equal to the values specified using gl:texGend/3 ,
unless the modelview matrix was identity when gl:texGend/3 was called.
See
getTexGenfv(Coord, Pname) -> {float(), float(), float(), float()}
Coord = enum()
Pname = enum()
See getTexGendv/2
getTexGeniv(Coord, Pname) -> {integer(), integer(), integer(), integer()}
Coord = enum()
Pname = enum()
See getTexGendv/2
texEnvf(Target, Pname, Param) -> ok
Target = enum()
Pname = enum()
Param = float()
glTexEnvf
See
texEnvi(Target, Pname, Param) -> ok
Target = enum()
Pname = enum()
Param = integer()
glTexEnvi
See
texEnvfv(Target, Pname, Params) -> ok
Target = enum()
Pname = enum()
Params = {float()}
Set texture environment parameters
A texture environment specifies how texture values are interpreted when a fragment is
textured. When Target
is ?GL_TEXTURE_FILTER_CONTROL
, Pname
must be ?GL_TEXTURE_LOD_BIAS
. When Target
is ?GL_TEXTURE_ENV
, Pname
can be ?GL_TEXTURE_ENV_MODE
, ?GL_TEXTURE_ENV_COLOR
, ?GL_COMBINE_RGB
, ?GL_COMBINE_ALPHA
, ?GL_RGB_SCALE
, ?GL_ALPHA_SCALE
, ?GL_SRC0_RGB
, ?GL_SRC1_RGB
, ?GL_SRC2_RGB
, ?GL_SRC0_ALPHA
, ?GL_SRC1_ALPHA
, or ?GL_SRC2_ALPHA
.
If Pname
is ?GL_TEXTURE_ENV_MODE
, then Params
is (or points to)
the symbolic name of a texture function. Six texture functions may be specified: ?GL_ADD
, ?GL_MODULATE
, ?GL_DECAL
, ?GL_BLEND
, ?GL_REPLACE
, or ?GL_COMBINE
.
The following table shows the correspondence of filtered texture values R t, G t, B t, A t, L t, I t to texture source components. C s and A s are used by the texture functions described below.
Texture Base Internal Format C s A s?GL_ALPHA
(0, 0, 0) A t?GL_LUMINANCE
( L t, L t, L t ) 1 ?GL_LUMINANCE_ALPHA
( L t, L t, L t ) A t?GL_INTENSITY
(
I t, I t, I t ) I t?GL_RGB
( R t, G t, B
t ) 1 ?GL_RGBA
( R t, G t, B t )
A tA texture function acts on the fragment to be textured using the texture image value that applies to the fragment (see gl:texParameterf/3 ) and produces an RGBA color for that fragment. The following table shows how the RGBA color is produced for each of the first five 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 p refers to the color computed from the previous texture stage (or the incoming fragment if processing texture stage 0), the subscript s to the texture source color, the subscript c to the texture environment color, and the subscript v indicates a value produced by the texture function.
Texture Base Internal Format?Value
?GL_REPLACE
Function ?GL_MODULATE
Function ?GL_DECAL
Function
?GL_BLEND
Function ?GL_ADD
Function ?GL_ALPHA
C v= C p C p undefined C p
C pA v= A s A p A s A v=A p A s A p A s
?GL_LUMINANCE
C v=
C s C p C s undefined C p (1-C s)+C c C s C p+C s(or 1) A v= A p A p A p A p
?GL_LUMINANCE_ALPHA
C v= C s C p C
s undefined C p (1-C s)+C c C s C p+C s(or 2) A v= A s A p A s A p A s A p A s
?GL_INTENSITY
C v= C s C p C s
undefined C p (1-C s)+C c C s C p+C sA v= A s A p A s A p (1-A s)+A c A s A p+A s
?GL_RGB
C v= C s C p C s C s C p (1-C s)+C c C s
C p+C s(or 3) A v= A p A p A p A p A p
?GL_RGBA
C v= C s
C p C s C p (1-A s)+C s A s C p (1-C s)+C c C s C p+C s(or 4) A v= A s A p A s A p A p A s A p A s
If Pname
is ?GL_TEXTURE_ENV_MODE
, and Params
is ?GL_COMBINE
,
the form of the texture function depends on the values of ?GL_COMBINE_RGB
and ?GL_COMBINE_ALPHA
.
The following describes how the texture sources, as specified by ?GL_SRC0_RGB
, ?GL_SRC1_RGB
, ?GL_SRC2_RGB
, ?GL_SRC0_ALPHA
, ?GL_SRC1_ALPHA
, and ?GL_SRC2_ALPHA
, are combined to produce a final texture color. In the following tables, ?GL_SRC0_c
is represented by Arg0, ?GL_SRC1_c
is represented by Arg1, and ?GL_SRC2_c
is represented by Arg2.
?GL_COMBINE_RGB
accepts any of ?GL_REPLACE
, ?GL_MODULATE
, ?GL_ADD
, ?GL_ADD_SIGNED
, ?GL_INTERPOLATE
, ?GL_SUBTRACT
, ?GL_DOT3_RGB
,
or ?GL_DOT3_RGBA
.
?GL_COMBINE_RGB
Texture Function
?GL_REPLACE
Arg0?GL_MODULATE
Arg0×Arg1?GL_ADD
Arg0+Arg1?GL_ADD_SIGNED
Arg0+Arg1-0.5?GL_INTERPOLATE
Arg0×Arg2+Arg1×(1-
Arg2)
?GL_SUBTRACT
Arg0-Arg1?GL_DOT3_RGB
or ?GL_DOT3_RGBA
4×((((Arg0 r)-0.5)×((Arg1 r)-0.5))+(((Arg0 g)-0.5)×((Arg1 g)-0.5))+(((Arg0 b)-0.5)×((Arg1 b)-0.5)))The scalar results for ?GL_DOT3_RGB
and ?GL_DOT3_RGBA
are placed into each
of the 3 (RGB) or 4 (RGBA) components on output.
Likewise, ?GL_COMBINE_ALPHA
accepts any of ?GL_REPLACE
, ?GL_MODULATE
,
?GL_ADD
, ?GL_ADD_SIGNED
, ?GL_INTERPOLATE
, or ?GL_SUBTRACT
.
The following table describes how alpha values are combined:
?GL_COMBINE_ALPHA
Texture Function
?GL_REPLACE
Arg0?GL_MODULATE
Arg0×Arg1?GL_ADD
Arg0+Arg1?GL_ADD_SIGNED
Arg0+Arg1-0.5?GL_INTERPOLATE
Arg0×Arg2+Arg1×(1-
Arg2)
?GL_SUBTRACT
Arg0-Arg1In the following tables, the value C s represents the color sampled from the currently bound texture, C c represents the constant texture-environment color, C f represents the primary color of the incoming fragment, and C p represents the color computed from the previous texture stage or C f if processing texture stage 0. Likewise, A s, A c, A f, and A p represent the respective alpha values.
The following table describes the values assigned to Arg0, Arg1, and Arg2 based upon the RGB sources and operands:
?GL_SRCn_RGB
?GL_OPERANDn_RGB
Argument Value
?GL_TEXTURE
?GL_SRC_COLOR
(C
s)
?GL_ONE_MINUS_SRC_COLOR
1-(C s)?GL_SRC_ALPHA
(A s)?GL_ONE_MINUS_SRC_ALPHA
1-(A s)?GL_TEXTUREn
?GL_SRC_COLOR
(C s)?GL_ONE_MINUS_SRC_COLOR
1-(C s)?GL_SRC_ALPHA
(A s)?GL_ONE_MINUS_SRC_ALPHA
1-(A s)?GL_CONSTANT
?GL_SRC_COLOR
(C c)?GL_ONE_MINUS_SRC_COLOR
1-(C c)?GL_SRC_ALPHA
(A c)?GL_ONE_MINUS_SRC_ALPHA
1-(A c)?GL_PRIMARY_COLOR
?GL_SRC_COLOR
(C f)?GL_ONE_MINUS_SRC_COLOR
1-(C f)?GL_SRC_ALPHA
(A f)?GL_ONE_MINUS_SRC_ALPHA
1-(A f)?GL_PREVIOUS
?GL_SRC_COLOR
(C p)?GL_ONE_MINUS_SRC_COLOR
1-(C p)?GL_SRC_ALPHA
(A p)?GL_ONE_MINUS_SRC_ALPHA
1-(A p)For ?GL_TEXTUREn
sources, C s and A s represent the color and alpha, respectively,
produced from texture stage n.
The follow table describes the values assigned to Arg0, Arg1, and Arg2 based upon the alpha sources and operands:
?GL_SRCn_ALPHA
?GL_OPERANDn_ALPHA
Argument Value
?GL_TEXTURE
?GL_SRC_ALPHA
(A
s)
?GL_ONE_MINUS_SRC_ALPHA
1-(A s)?GL_TEXTUREn
?GL_SRC_ALPHA
(A s)?GL_ONE_MINUS_SRC_ALPHA
1-(A s)?GL_CONSTANT
?GL_SRC_ALPHA
(A
c)
?GL_ONE_MINUS_SRC_ALPHA
1-(A c)?GL_PRIMARY_COLOR
?GL_SRC_ALPHA
(A f)?GL_ONE_MINUS_SRC_ALPHA
1-(A f)?GL_PREVIOUS
?GL_SRC_ALPHA
(A
p)
?GL_ONE_MINUS_SRC_ALPHA
1-(A p)The RGB and alpha results of the texture function are multipled by the values of ?GL_RGB_SCALE
and ?GL_ALPHA_SCALE
, respectively, and clamped to the range [0 1].
If Pname
is ?GL_TEXTURE_ENV_COLOR
, Params
is a pointer to an array
that holds an RGBA color consisting of four values. Integer color components are interpreted
linearly such that the most positive integer maps to 1.0, and the most negative integer
maps to -1.0. The values are clamped to the range [0,1] when they are specified. C c
takes these four values.
If Pname
is ?GL_TEXTURE_LOD_BIAS
, the value specified is added to the texture
level-of-detail parameter, that selects which mipmap, or mipmaps depending upon the selected
?GL_TEXTURE_MIN_FILTER
, will be sampled.
?GL_TEXTURE_ENV_MODE
defaults to ?GL_MODULATE
and ?GL_TEXTURE_ENV_COLOR
defaults to (0, 0, 0, 0).
If Target
is ?GL_POINT_SPRITE
and Pname
is ?GL_COORD_REPLACE
,
the boolean value specified is used to either enable or disable point sprite texture coordinate
replacement. The default value is ?GL_FALSE
.
See
texEnviv(Target, Pname, Params) -> ok
Target = enum()
Pname = enum()
Params = {integer()}
See texEnvfv/3
getTexEnvfv(Target, Pname) -> {float(), float(), float(), float()}
Target = enum()
Pname = enum()
Return texture environment parameters
gl:getTexEnv
returns in Params
selected values of a texture environment that
was specified with gl:texEnvfv/3 . Target
specifies a texture environment.
When Target
is ?GL_TEXTURE_FILTER_CONTROL
, Pname
must be ?GL_TEXTURE_LOD_BIAS
. When Target
is ?GL_POINT_SPRITE
, Pname
must be ?GL_COORD_REPLACE
. When Target
is ?GL_TEXTURE_ENV
, Pname
can be ?GL_TEXTURE_ENV_MODE
, ?GL_TEXTURE_ENV_COLOR
, ?GL_COMBINE_RGB
, ?GL_COMBINE_ALPHA
, ?GL_RGB_SCALE
, ?GL_ALPHA_SCALE
, ?GL_SRC0_RGB
, ?GL_SRC1_RGB
, ?GL_SRC2_RGB
,
?GL_SRC0_ALPHA
, ?GL_SRC1_ALPHA
, or ?GL_SRC2_ALPHA
.
Pname
names a specific texture environment parameter, as follows:
?GL_TEXTURE_ENV_MODE
: Params
returns the single-valued texture environment
mode, a symbolic constant. The initial value is ?GL_MODULATE
.
?GL_TEXTURE_ENV_COLOR
: Params
returns four integer or floating-point values
that are the texture environment color. Integer values, when requested, are linearly mapped
from the internal floating-point representation such that 1.0 maps to the most positive
representable integer, and -1.0 maps to the most negative representable integer. The
initial value is (0, 0, 0, 0).
?GL_TEXTURE_LOD_BIAS
: Params
returns a single floating-point value that
is the texture level-of-detail bias. The initial value is 0.
?GL_COMBINE_RGB
: Params
returns a single symbolic constant value representing
the current RGB combine mode. The initial value is ?GL_MODULATE
.
?GL_COMBINE_ALPHA
: Params
returns a single symbolic constant value representing
the current alpha combine mode. The initial value is ?GL_MODULATE
.
?GL_SRC0_RGB
: Params
returns a single symbolic constant value representing
the texture combiner zero's RGB source. The initial value is ?GL_TEXTURE
.
?GL_SRC1_RGB
: Params
returns a single symbolic constant value representing
the texture combiner one's RGB source. The initial value is ?GL_PREVIOUS
.
?GL_SRC2_RGB
: Params
returns a single symbolic constant value representing
the texture combiner two's RGB source. The initial value is ?GL_CONSTANT
.
?GL_SRC0_ALPHA
: Params
returns a single symbolic constant value representing
the texture combiner zero's alpha source. The initial value is ?GL_TEXTURE
.
?GL_SRC1_ALPHA
: Params
returns a single symbolic constant value representing
the texture combiner one's alpha source. The initial value is ?GL_PREVIOUS
.
?GL_SRC2_ALPHA
: Params
returns a single symbolic constant value representing
the texture combiner two's alpha source. The initial value is ?GL_CONSTANT
.
?GL_OPERAND0_RGB
: Params
returns a single symbolic constant value representing
the texture combiner zero's RGB operand. The initial value is ?GL_SRC_COLOR
.
?GL_OPERAND1_RGB
: Params
returns a single symbolic constant value representing
the texture combiner one's RGB operand. The initial value is ?GL_SRC_COLOR
.
?GL_OPERAND2_RGB
: Params
returns a single symbolic constant value representing
the texture combiner two's RGB operand. The initial value is ?GL_SRC_ALPHA
.
?GL_OPERAND0_ALPHA
: Params
returns a single symbolic constant value representing
the texture combiner zero's alpha operand. The initial value is ?GL_SRC_ALPHA
.
?GL_OPERAND1_ALPHA
: Params
returns a single symbolic constant value representing
the texture combiner one's alpha operand. The initial value is ?GL_SRC_ALPHA
.
?GL_OPERAND2_ALPHA
: Params
returns a single symbolic constant value representing
the texture combiner two's alpha operand. The initial value is ?GL_SRC_ALPHA
.
?GL_RGB_SCALE
: Params
returns a single floating-point value representing
the current RGB texture combiner scaling factor. The initial value is 1.0.
?GL_ALPHA_SCALE
: Params
returns a single floating-point value representing
the current alpha texture combiner scaling factor. The initial value is 1.0.
?GL_COORD_REPLACE
: Params
returns a single boolean value representing the
current point sprite texture coordinate replacement enable state. The initial value is ?GL_FALSE
.
See
getTexEnviv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Target = enum()
Pname = enum()
See getTexEnvfv/2
texParameterf(Target, Pname, Param) -> ok
Target = enum()
Pname = enum()
Param = float()
Set texture parameters
gl:texParameter
assigns the value or values in Params
to the texture parameter
specified as Pname
. Target
defines the target texture, either ?GL_TEXTURE_1D
, ?GL_TEXTURE_2D
, ?GL_TEXTURE_1D_ARRAY
, ?GL_TEXTURE_2D_ARRAY
, ?GL_TEXTURE_RECTANGLE
, or ?GL_TEXTURE_3D
. The following symbols are accepted in Pname
:
?GL_TEXTURE_BASE_LEVEL
: Specifies the index of the lowest defined mipmap level.
This is an integer value. The initial value is 0.
?GL_TEXTURE_BORDER_COLOR
: The data in Params
specifies four values that
define the border values that should be used for border texels. If a texel is sampled
from the border of the texture, the values of ?GL_TEXTURE_BORDER_COLOR
are interpreted
as an RGBA color to match the texture's internal format and substituted for the non-existent
texel data. If the texture contains depth components, the first component of ?GL_TEXTURE_BORDER_COLOR
is interpreted as a depth value. The initial value is ( 0.0, 0.0, 0.0, 0.0 ).
If the values for ?GL_TEXTURE_BORDER_COLOR
are specified with gl:texParameterIiv
or gl:texParameterIuiv
, the values are stored unmodified with an internal data
type of integer. If specified with gl:texParameteriv
, they are converted to floating
point with the following equation: f=2 c+1 2 b-/1. If specified with gl:texParameterfv
, they are stored unmodified as floating-point values.
?GL_TEXTURE_COMPARE_FUNC
: Specifies the comparison operator used when ?GL_TEXTURE_COMPARE_MODE
is set to ?GL_COMPARE_REF_TO_TEXTURE
. Permissible values are:
Texture Comparison Function
Computed result
?GL_LEQUAL
result={1.0 0.0 r<=(D t) r>(D t))?GL_GEQUAL
result={1.0 0.0 r>=(D t) r<(D t))?GL_LESS
result={1.0 0.0 r<(D t) r>=(D t))?GL_GREATER
result={1.0 0.0 r>(D t) r<=(D t))?GL_EQUAL
result={1.0 0.0 r=(D t) r≠
(D t))?GL_NOTEQUAL
result={1.0 0.0 r≠(D t) r=(D t))?GL_ALWAYS
result=1.0?GL_NEVER
result=0.0where r is the current interpolated texture coordinate, and D t is the depth texture value sampled from the currently bound depth texture. result is assigned to the the red channel.
?GL_TEXTURE_COMPARE_MODE
: Specifies the texture comparison mode for currently
bound depth textures. That is, a texture whose internal format is ?GL_DEPTH_COMPONENT_*
; see gl:texImage2D/9 ) Permissible values are:
?GL_COMPARE_REF_TO_TEXTURE
: Specifies that the interpolated and clamped r texture
coordinate should be compared to the value in the currently bound depth texture. See the
discussion of ?GL_TEXTURE_COMPARE_FUNC
for details of how the comparison is evaluated.
The result of the comparison is assigned to the red channel.
?GL_NONE
: Specifies that the red channel should be assigned the appropriate value
from the currently bound depth texture.
?GL_TEXTURE_LOD_BIAS
: Params
specifies a fixed bias value that is to be
added to the level-of-detail parameter for the texture before texture sampling. The specified
value is added to the shader-supplied bias value (if any) and subsequently clamped into
the implementation-defined range [( - bias max)(bias max)], where bias max is the value of the implementation
defined constant ?GL_MAX_TEXTURE_LOD_BIAS
. The initial value is 0.0.
?GL_TEXTURE_MIN_FILTER
: The texture minifying function is used whenever the level-of-detail
function used when sampling from the texture determines that the texture should be minified.
There are six defined minifying functions. Two of them use either the nearest texture
elements or a weighted average of multiple 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 gl:texImage1D/8
, gl:texImage2D/9 , gl:texImage3D/10 , gl:copyTexImage1D/7 , or gl:copyTexImage2D/8
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.
Params
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 specified texture coordinates.
?GL_LINEAR
: Returns the weighted average of the four texture elements that are
closest to the specified texture coordinates. These can include items wrapped or repeated
from other parts of a texture, 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
closest to the specified texture coordinates) 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 specified texture coordinates) 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 closest to the specified texture coordinates ) 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 texture elements that are closest to the specified texture coordinates)
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 multiple 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 whenever the
level-of-detail function used when sampling from the texture determines that the texture
should be magified. 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 specified texture coordinates.
?GL_LINEAR
: Returns the weighted average of the texture elements that are closest
to the specified texture coordinates. These can include items wrapped or repeated from
other parts of a texture, depending on the values of ?GL_TEXTURE_WRAP_S
and ?GL_TEXTURE_WRAP_T
, and on the exact mapping.
?GL_TEXTURE_MIN_LOD
: Sets the minimum level-of-detail parameter. This floating-point
value limits the selection of highest resolution mipmap (lowest mipmap level). The initial
value is -1000.
?GL_TEXTURE_MAX_LOD
: Sets the maximum level-of-detail parameter. This floating-point
value limits the selection of the lowest resolution mipmap (highest mipmap level). The
initial value is 1000.
?GL_TEXTURE_MAX_LEVEL
: Sets the index of the highest defined mipmap level. This
is an integer value. The initial value is 1000.
?GL_TEXTURE_SWIZZLE_R
: Sets the swizzle that will be applied to the r component
of a texel before it is returned to the shader. Valid values for Param
are ?GL_RED
, ?GL_GREEN
, ?GL_BLUE
, ?GL_ALPHA
, ?GL_ZERO
and ?GL_ONE
.
If ?GL_TEXTURE_SWIZZLE_R
is ?GL_RED
, the value for r will be taken from
the first channel of the fetched texel. If ?GL_TEXTURE_SWIZZLE_R
is ?GL_GREEN
, the value for r will be taken from the second channel of the fetched texel. If ?GL_TEXTURE_SWIZZLE_R
is ?GL_BLUE
, the value for r will be taken from the third channel of the fetched
texel. If ?GL_TEXTURE_SWIZZLE_R
is ?GL_ALPHA
, the value for r will be taken
from the fourth channel of the fetched texel. If ?GL_TEXTURE_SWIZZLE_R
is ?GL_ZERO
, the value for r will be subtituted with 0.0. If ?GL_TEXTURE_SWIZZLE_R
is ?GL_ONE
, the value for r will be subtituted with 1.0. The initial value is ?GL_RED
.
?GL_TEXTURE_SWIZZLE_G
: Sets the swizzle that will be applied to the g component
of a texel before it is returned to the shader. Valid values for Param
and their
effects are similar to those of ?GL_TEXTURE_SWIZZLE_R
. The initial value is ?GL_GREEN
.
?GL_TEXTURE_SWIZZLE_B
: Sets the swizzle that will be applied to the b component
of a texel before it is returned to the shader. Valid values for Param
and their
effects are similar to those of ?GL_TEXTURE_SWIZZLE_R
. The initial value is ?GL_BLUE
.
?GL_TEXTURE_SWIZZLE_A
: Sets the swizzle that will be applied to the a component
of a texel before it is returned to the shader. Valid values for Param
and their
effects are similar to those of ?GL_TEXTURE_SWIZZLE_R
. The initial value is ?GL_ALPHA
.
?GL_TEXTURE_SWIZZLE_RGBA
: Sets the swizzles that will be applied to the r, g,
b, and a components of a texel before they are returned to the shader. Valid values for Params
and their effects are similar to those of ?GL_TEXTURE_SWIZZLE_R
, except that all
channels are specified simultaneously. Setting the value of ?GL_TEXTURE_SWIZZLE_RGBA
is equivalent (assuming no errors are generated) to setting the parameters of each of ?GL_TEXTURE_SWIZZLE_R
, ?GL_TEXTURE_SWIZZLE_G
, ?GL_TEXTURE_SWIZZLE_B
, and ?GL_TEXTURE_SWIZZLE_A
successively.
?GL_TEXTURE_WRAP_S
: Sets the wrap parameter for texture coordinate s to either ?GL_CLAMP_TO_EDGE
, ?GL_CLAMP_TO_BORDER
, ?GL_MIRRORED_REPEAT
, or ?GL_REPEAT
. ?GL_CLAMP_TO_EDGE
causes s coordinates to be clamped to the range [(1 2/N) 1-(1 2/N)], where N is the size of the texture
in the direction of clamping. ?GL_CLAMP_TO_BORDER
evaluates s coordinates in a
similar manner to ?GL_CLAMP_TO_EDGE
. However, in cases where clamping would have
occurred in ?GL_CLAMP_TO_EDGE
mode, the fetched texel data is substituted with
the values specified by ?GL_TEXTURE_BORDER_COLOR
. ?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. ?GL_MIRRORED_REPEAT
causes the s coordinate
to be set to the fractional part of the texture coordinate if the integer part of s
is even; if the integer part of s is odd, then the s texture coordinate is set to 1-
frac(s), where frac(s) represents the fractional part of s. 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_TO_EDGE
, ?GL_CLAMP_TO_BORDER
, ?GL_MIRRORED_REPEAT
, or ?GL_REPEAT
. See the
discussion under ?GL_TEXTURE_WRAP_S
. Initially, ?GL_TEXTURE_WRAP_T
is set
to ?GL_REPEAT
.
?GL_TEXTURE_WRAP_R
: Sets the wrap parameter for texture coordinate r to either ?GL_CLAMP_TO_EDGE
, ?GL_CLAMP_TO_BORDER
, ?GL_MIRRORED_REPEAT
, or ?GL_REPEAT
. See the
discussion under ?GL_TEXTURE_WRAP_S
. Initially, ?GL_TEXTURE_WRAP_R
is set
to ?GL_REPEAT
.
See
texParameteri(Target, Pname, Param) -> ok
Target = enum()
Pname = enum()
Param = integer()
See texParameterf/3
texParameterfv(Target, Pname, Params) -> ok
Target = enum()
Pname = enum()
Params = {float()}
See texParameterf/3
texParameteriv(Target, Pname, Params) -> ok
Target = enum()
Pname = enum()
Params = {integer()}
See texParameterf/3
getTexParameterfv(Target, Pname) -> {float(), float(), float(), float()}
Target = enum()
Pname = enum()
Return texture parameter values
gl:getTexParameter
returns in Params
the value or values of the texture parameter
specified as Pname
. Target
defines the target texture. ?GL_TEXTURE_1D
,
?GL_TEXTURE_2D
, ?GL_TEXTURE_3D
, ?GL_TEXTURE_1D_ARRAY
, ?GL_TEXTURE_2D_ARRAY
, ?GL_TEXTURE_RECTANGLE
, ?GL_TEXTURE_CUBE_MAP
, ?GL_TEXTURE_CUBE_MAP_ARRAY
specify one-, two-, or three-dimensional, one-dimensional array, two-dimensional array,
rectangle, cube-mapped or cube-mapped array texturing, respectively. Pname
accepts
the same symbols as gl:texParameterf/3 , with the same interpretations:
?GL_TEXTURE_MAG_FILTER
: Returns the single-valued texture magnification filter,
a symbolic constant. The initial value is ?GL_LINEAR
.
?GL_TEXTURE_MIN_FILTER
: Returns the single-valued texture minification filter,
a symbolic constant. The initial value is ?GL_NEAREST_MIPMAP_LINEAR
.
?GL_TEXTURE_MIN_LOD
: Returns the single-valued texture minimum level-of-detail
value. The initial value is -1000.
?GL_TEXTURE_MAX_LOD
: Returns the single-valued texture maximum level-of-detail
value. The initial value is 1000.
?GL_TEXTURE_BASE_LEVEL
: Returns the single-valued base texture mipmap level. The
initial value is 0.
?GL_TEXTURE_MAX_LEVEL
: Returns the single-valued maximum texture mipmap array
level. The initial value is 1000.
?GL_TEXTURE_SWIZZLE_R
: Returns the red component swizzle. The initial value is ?GL_RED
.
?GL_TEXTURE_SWIZZLE_G
: Returns the green component swizzle. The initial value is ?GL_GREEN
.
?GL_TEXTURE_SWIZZLE_B
: Returns the blue component swizzle. The initial value is ?GL_BLUE
.
?GL_TEXTURE_SWIZZLE_A
: Returns the alpha component swizzle. The initial value is ?GL_ALPHA
.
?GL_TEXTURE_SWIZZLE_RGBA
: Returns the component swizzle for all channels in a
single query.
?GL_TEXTURE_WRAP_S
: Returns the single-valued wrapping function for texture coordinate
s, a symbolic constant. The initial value is ?GL_REPEAT
.
?GL_TEXTURE_WRAP_T
: Returns the single-valued wrapping function for texture coordinate
t, a symbolic constant. The initial value is ?GL_REPEAT
.
?GL_TEXTURE_WRAP_R
: Returns the single-valued wrapping function for texture coordinate
r, a symbolic constant. The initial value is ?GL_REPEAT
.
?GL_TEXTURE_BORDER_COLOR
: Returns four integer or floating-point numbers that
comprise the RGBA color of the texture border. Floating-point values are returned in the
range [0 1]. Integer values are returned as a linear mapping of the internal floating-point
representation such that 1.0 maps to the most positive representable integer and -1.0
maps to the most negative representable integer. The initial value is (0, 0, 0, 0).
?GL_TEXTURE_COMPARE_MODE
: Returns a single-valued texture comparison mode, a symbolic
constant. The initial value is ?GL_NONE
. See gl:texParameterf/3 .
?GL_TEXTURE_COMPARE_FUNC
: Returns a single-valued texture comparison function,
a symbolic constant. The initial value is ?GL_LEQUAL
. See gl:texParameterf/3 .
In addition to the parameters that may be set with gl:texParameterf/3 , gl:getTexParameter
accepts the following read-only parameters:
?GL_TEXTURE_IMMUTABLE_FORMAT
: Returns non-zero if the texture has an immutable
format. Textures become immutable if their storage is specified with gl:texStorage1D/4
, gl:texStorage2D/5 or gl:texStorage3D/6 . The initial value is ?GL_FALSE
.
See
getTexParameteriv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Target = enum()
Pname = enum()
getTexLevelParameterfv(Target, Level, Pname) -> {float()}
Target = enum()
Level = integer()
Pname = enum()
Return texture parameter values for a specific level of detail
gl:getTexLevelParameter
returns in Params
texture parameter values for a
specific level-of-detail value, specified as Level
. Target
defines the target
texture, either ?GL_TEXTURE_1D
, ?GL_TEXTURE_2D
, ?GL_TEXTURE_3D
, ?GL_PROXY_TEXTURE_1D
, ?GL_PROXY_TEXTURE_2D
, ?GL_PROXY_TEXTURE_3D
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_X
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_X
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_Y
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_Z
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
, or ?GL_PROXY_TEXTURE_CUBE_MAP
.
?GL_MAX_TEXTURE_SIZE
, and ?GL_MAX_3D_TEXTURE_SIZE
are not really descriptive
enough. It has to report the largest square texture image that can be accommodated with
mipmaps and borders, but a long skinny texture, or a texture without mipmaps and borders,
may easily fit in texture memory. The proxy targets allow the user to more accurately
query whether the GL can accommodate a texture of a given configuration. If the texture
cannot be accommodated, the texture state variables, which may be queried with gl:getTexLevelParameter
, are set to 0. If the texture can be accommodated, the texture state values will be set
as they would be set for a non-proxy target.
Pname
specifies the texture parameter whose value or values will be returned.
The accepted parameter names are as follows:
?GL_TEXTURE_WIDTH
: Params
returns a single value, the width of the texture
image. This value includes the border of the texture image. The initial value is 0.
?GL_TEXTURE_HEIGHT
: Params
returns a single value, the height of the texture
image. This value includes the border of the texture image. The initial value is 0.
?GL_TEXTURE_DEPTH
: Params
returns a single value, the depth of the texture
image. This value includes the border of the texture image. The initial value is 0.
?GL_TEXTURE_INTERNAL_FORMAT
: Params
returns a single value, the internal
format of the texture image.
?GL_TEXTURE_RED_TYPE
,
?GL_TEXTURE_GREEN_TYPE
,
?GL_TEXTURE_BLUE_TYPE
,
?GL_TEXTURE_ALPHA_TYPE
,
?GL_TEXTURE_DEPTH_TYPE
: The data type used to store the component. The types ?GL_NONE
, ?GL_SIGNED_NORMALIZED
, ?GL_UNSIGNED_NORMALIZED
, ?GL_FLOAT
, ?GL_INT
, and ?GL_UNSIGNED_INT
may be returned to indicate signed normalized fixed-point,
unsigned normalized fixed-point, floating-point, integer unnormalized, and unsigned integer
unnormalized components, respectively.
?GL_TEXTURE_RED_SIZE
,
?GL_TEXTURE_GREEN_SIZE
,
?GL_TEXTURE_BLUE_SIZE
,
?GL_TEXTURE_ALPHA_SIZE
,
?GL_TEXTURE_DEPTH_SIZE
: The internal storage resolution of an individual component.
The resolution chosen by the GL will be a close match for the resolution requested by
the user with the component argument of gl:texImage1D/8 , gl:texImage2D/9 , gl:texImage3D/10
, gl:copyTexImage1D/7 , and gl:copyTexImage2D/8 . The initial value is 0.
?GL_TEXTURE_COMPRESSED
: Params
returns a single boolean value indicating
if the texture image is stored in a compressed internal format. The initiali value is ?GL_FALSE
.
?GL_TEXTURE_COMPRESSED_IMAGE_SIZE
: Params
returns a single integer value,
the number of unsigned bytes of the compressed texture image that would be returned from gl:getCompressedTexImage/3
.
See
getTexLevelParameteriv(Target, Level, Pname) -> {integer()}
Target = enum()
Level = integer()
Pname = enum()
texImage1D(Target, Level, InternalFormat, Width, Border, Format, Type, Pixels) -> ok
Target = enum()
Level = integer()
InternalFormat = integer()
Width = integer()
Border = integer()
Format = enum()
Type = enum()
Pixels = offset() | mem()
Specify a one-dimensional texture image
Texturing maps a portion of a specified texture image onto each graphical primitive for
which texturing is enabled. To enable and disable one-dimensional texturing, call gl:enable/1
and gl:enable/1 with argument ?GL_TEXTURE_1D
.
Texture images are defined with gl:texImage1D
. The arguments describe the parameters
of the texture image, such as width, width of the border, level-of-detail number (see gl:texParameterf/3
), and the internal resolution and format used to store the image. The last three arguments
describe how the image is represented in memory.
If Target
is ?GL_PROXY_TEXTURE_1D
, no data is read from Data
, but
all of the texture image state is recalculated, checked for consistency, and checked against
the implementation's capabilities. If the implementation cannot handle a texture of the
requested texture size, it sets all of the image state to 0, but does not generate an
error (see gl:getError/0 ). To query for an entire mipmap array, use an image array
level greater than or equal to 1.
If Target
is ?GL_TEXTURE_1D
, data is read from Data
as a sequence
of signed or unsigned bytes, shorts, or longs, or single-precision floating-point values,
depending on Type
. These values are grouped into sets of one, two, three, or four
values, depending on Format
, to form elements. Each data byte is treated as eight
1-bit elements, with bit ordering determined by ?GL_UNPACK_LSB_FIRST
(see gl:pixelStoref/2
).
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is specified, Data
is treated
as a byte offset into the buffer object's data store.
The first element corresponds to the left end of the texture array. Subsequent elements progress left-to-right through the remaining texels in the texture array. The final element corresponds to the right end of the texture array.
Format
determines the composition of each element in Data
. It can assume
one of these symbolic values:
?GL_RED
: Each element is a single red component. The GL converts it to floating
point and assembles it into an RGBA element by attaching 0 for green and blue, and 1 for
alpha. Each component is then multiplied by the signed scale factor ?GL_c_SCALE
,
added to the signed bias ?GL_c_BIAS
, and clamped to the range [0,1].
?GL_RG
: Each element is a single red/green double The GL converts it to floating
point and assembles it into an RGBA element by attaching 0 for blue, and 1 for alpha.
Each component is then multiplied by the signed scale factor ?GL_c_SCALE
, added
to the signed bias ?GL_c_BIAS
, and clamped to the range [0,1].
?GL_RGB
?GL_BGR
: 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. Each component is then multiplied
by the signed scale factor ?GL_c_SCALE
, added to the signed bias ?GL_c_BIAS
,
and clamped to the range [0,1].
?GL_RGBA
?GL_BGRA
: Each element contains all four components. Each component is multiplied
by the signed scale factor ?GL_c_SCALE
, added to the signed bias ?GL_c_BIAS
,
and clamped to the range [0,1].
?GL_DEPTH_COMPONENT
: Each element is a single depth value. The GL converts it
to floating point, multiplies by the signed scale factor ?GL_DEPTH_SCALE
, adds
the signed bias ?GL_DEPTH_BIAS
, and clamps to the range [0,1].
If an application wants to store the texture at a certain resolution or in a certain
format, it can request the resolution and format with InternalFormat
. The GL will
choose an internal representation that closely approximates that requested by InternalFormat
, but it may not match exactly. (The representations specified by ?GL_RED
, ?GL_RG
, ?GL_RGB
and ?GL_RGBA
must match exactly.)
InternalFormat
may be one of the base internal formats shown in Table 1, below
InternalFormat
may also be one of the sized internal formats shown in Table 2,
below
Finally, InternalFormat
may also be one of the generic or compressed compressed
texture formats shown in Table 3 below
If the InternalFormat
parameter is one of the generic compressed formats, ?GL_COMPRESSED_RED
, ?GL_COMPRESSED_RG
, ?GL_COMPRESSED_RGB
, or ?GL_COMPRESSED_RGBA
,
the GL will replace the internal format with the symbolic constant for a specific internal
format and compress the texture before storage. If no corresponding internal format is
available, or the GL can not compress that image for any reason, the internal format is
instead replaced with a corresponding base internal format.
If the InternalFormat
parameter is ?GL_SRGB
, ?GL_SRGB8
, ?GL_SRGB_ALPHA
or ?GL_SRGB8_ALPHA8
, the texture is treated as if the red, green, or blue components
are encoded in the sRGB color space. Any alpha component is left unchanged. The conversion
from the sRGB encoded component c s to a linear component c l is:
c l={ c s/12.92if c s≤ 0.04045( c s+0.055/1.055) 2.4if c s> 0.04045
Assume c s is the sRGB component in the range [0,1].
Use the ?GL_PROXY_TEXTURE_1D
target to try out a resolution and format. The implementation
will update and recompute its best match for the requested storage resolution and format.
To then query this state, call gl:getTexLevelParameterfv/3 . If the texture cannot
be accommodated, texture state is set to 0.
A one-component texture image uses only the red component of the RGBA color from Data
. A two-component image uses the R and A values. A three-component image uses the R, G,
and B values. A four-component image uses all of the RGBA components.
Image-based shadowing can be enabled by comparing texture r coordinates to depth texture values to generate a boolean result. See gl:texParameterf/3 for details on texture comparison.
See
texImage2D(Target, Level, InternalFormat, Width, Height, Border, Format, Type, Pixels) -> ok
Target = enum()
Level = integer()
InternalFormat = integer()
Width = integer()
Height = integer()
Border = integer()
Format = enum()
Type = enum()
Pixels = offset() | mem()
Specify a two-dimensional texture image
Texturing allows elements of an image array to be read by shaders.
To define texture images, call gl:texImage2D
. The arguments describe the parameters
of the texture image, such as height, width, width of the border, level-of-detail number
(see gl:texParameterf/3 ), and number of color components provided. The last three
arguments describe how the image is represented in memory.
If Target
is ?GL_PROXY_TEXTURE_2D
, ?GL_PROXY_TEXTURE_1D_ARRAY
, ?GL_PROXY_TEXTURE_CUBE_MAP
, or ?GL_PROXY_TEXTURE_RECTANGLE
, no data is read from Data
, but all of
the texture image state is recalculated, checked for consistency, and checked against
the implementation's capabilities. If the implementation cannot handle a texture of the
requested texture size, it sets all of the image state to 0, but does not generate an
error (see gl:getError/0 ). To query for an entire mipmap array, use an image array
level greater than or equal to 1.
If Target
is ?GL_TEXTURE_2D
, ?GL_TEXTURE_RECTANGLE
or one of the ?GL_TEXTURE_CUBE_MAP
targets, data is read from Data
as a sequence of signed or unsigned bytes, shorts,
or longs, or single-precision floating-point values, depending on Type
. These values
are grouped into sets of one, two, three, or four values, depending on Format
,
to form elements. Each data byte is treated as eight 1-bit elements, with bit ordering
determined by ?GL_UNPACK_LSB_FIRST
(see gl:pixelStoref/2 ).
If Target
is ?GL_TEXTURE_1D_ARRAY
, data is interpreted as an array of one-dimensional
images.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is specified, Data
is treated
as a byte offset into the buffer object's data store.
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.
Format
determines the composition of each element in Data
. It can assume
one of these symbolic values:
?GL_RED
: Each element is a single red component. The GL converts it to floating
point and assembles it into an RGBA element by attaching 0 for green and blue, and 1 for
alpha. Each component is then multiplied by the signed scale factor ?GL_c_SCALE
,
added to the signed bias ?GL_c_BIAS
, and clamped to the range [0,1].
?GL_RG
: Each element is a red/green double. The GL converts it to floating point
and assembles it into an RGBA element by attaching 0 for blue, and 1 for alpha. Each component
is then multiplied by the signed scale factor ?GL_c_SCALE
, added to the signed
bias ?GL_c_BIAS
, and clamped to the range [0,1].
?GL_RGB
?GL_BGR
: 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. Each component is then multiplied
by the signed scale factor ?GL_c_SCALE
, added to the signed bias ?GL_c_BIAS
,
and clamped to the range [0,1].
?GL_RGBA
?GL_BGRA
: Each element contains all four components. Each component is multiplied
by the signed scale factor ?GL_c_SCALE
, added to the signed bias ?GL_c_BIAS
,
and clamped to the range [0,1].
?GL_DEPTH_COMPONENT
: Each element is a single depth value. The GL converts it
to floating point, multiplies by the signed scale factor ?GL_DEPTH_SCALE
, adds
the signed bias ?GL_DEPTH_BIAS
, and clamps to the range [0,1].
?GL_DEPTH_STENCIL
: Each element is a pair of depth and stencil values. The depth
component of the pair is interpreted as in ?GL_DEPTH_COMPONENT
. The stencil component
is interpreted based on specified the depth + stencil internal format.
If an application wants to store the texture at a certain resolution or in a certain
format, it can request the resolution and format with InternalFormat
. The GL will
choose an internal representation that closely approximates that requested by InternalFormat
, but it may not match exactly. (The representations specified by ?GL_RED
, ?GL_RG
, ?GL_RGB
, and ?GL_RGBA
must match exactly.)
InternalFormat
may be one of the base internal formats shown in Table 1, below
InternalFormat
may also be one of the sized internal formats shown in Table 2,
below
Finally, InternalFormat
may also be one of the generic or compressed compressed
texture formats shown in Table 3 below
If the InternalFormat
parameter is one of the generic compressed formats, ?GL_COMPRESSED_RED
, ?GL_COMPRESSED_RG
, ?GL_COMPRESSED_RGB
, or ?GL_COMPRESSED_RGBA
,
the GL will replace the internal format with the symbolic constant for a specific internal
format and compress the texture before storage. If no corresponding internal format is
available, or the GL can not compress that image for any reason, the internal format is
instead replaced with a corresponding base internal format.
If the InternalFormat
parameter is ?GL_SRGB
, ?GL_SRGB8
, ?GL_SRGB_ALPHA
, or ?GL_SRGB8_ALPHA8
, the texture is treated as if the red, green, or blue components
are encoded in the sRGB color space. Any alpha component is left unchanged. The conversion
from the sRGB encoded component c s to a linear component c l is:
c l={ c s/12.92if c s≤ 0.04045( c s+0.055/1.055) 2.4if c s> 0.04045
Assume c s is the sRGB component in the range [0,1].
Use the ?GL_PROXY_TEXTURE_2D
, ?GL_PROXY_TEXTURE_1D_ARRAY
, ?GL_PROXY_TEXTURE_RECTANGLE
, or ?GL_PROXY_TEXTURE_CUBE_MAP
target to try out a resolution and format. The
implementation will update and recompute its best match for the requested storage resolution
and format. To then query this state, call gl:getTexLevelParameterfv/3 . If the texture
cannot be accommodated, texture state is set to 0.
A one-component texture image uses only the red component of the RGBA color extracted
from Data
. A two-component image uses the R and G values. A three-component image
uses the R, G, and B values. A four-component image uses all of the RGBA components.
Image-based shadowing can be enabled by comparing texture r coordinates to depth texture values to generate a boolean result. See gl:texParameterf/3 for details on texture comparison.
See
getTexImage(Target, Level, Format, Type, Pixels) -> ok
Target = enum()
Level = integer()
Format = enum()
Type = enum()
Pixels = mem()
Return a texture image
gl:getTexImage
returns a texture image into Img
. Target
specifies
whether the desired texture image is one specified by gl:texImage1D/8 (?GL_TEXTURE_1D
), gl:texImage2D/9 (?GL_TEXTURE_1D_ARRAY
, ?GL_TEXTURE_RECTANGLE
, ?GL_TEXTURE_2D
or any of ?GL_TEXTURE_CUBE_MAP_*
), or gl:texImage3D/10 (?GL_TEXTURE_2D_ARRAY
, ?GL_TEXTURE_3D
). Level
specifies the level-of-detail number of the desired
image. Format
and Type
specify the format and type of the desired image
array. See the reference page for gl:texImage1D/8 for a description of the acceptable
values for the Format
and Type
parameters, respectively.
If a non-zero named buffer object is bound to the ?GL_PIXEL_PACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is requested, Img
is treated
as a byte offset into the buffer object's data store.
To understand the operation of gl:getTexImage
, consider the selected internal four-component
texture image to be an RGBA color buffer the size of the image. The semantics of gl:getTexImage
are then identical to those of gl:readPixels/7 , with the exception that no pixel
transfer operations are performed, when called with the same Format
and Type
,
with x
and y
set to 0, width
set to the width of the texture image
and height
set to 1 for 1D images, or to the height of the texture image for 2D
images.
If the selected texture image does not contain four components, the following mappings are applied. Single-component textures are treated as RGBA buffers with red set to the single-component value, green set to 0, blue set to 0, and alpha set to 1. Two-component textures are treated as RGBA buffers with red set to the value of component zero, alpha set to the value of component one, and green and blue set to 0. Finally, three-component textures are treated as RGBA buffers with red set to component zero, green set to component one, blue set to component two, and alpha set to 1.
To determine the required size of Img
, use gl:getTexLevelParameterfv/3 to
determine the dimensions of the internal texture image, then scale the required number
of pixels by the storage required for each pixel, based on Format
and Type
.
Be sure to take the pixel storage parameters into account, especially ?GL_PACK_ALIGNMENT
.
See
genTextures(N) -> [integer()]
N = integer()
Generate texture names
gl:genTextures
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 gl:genTextures
.
The generated textures have no dimensionality; they assume the dimensionality of the texture target to which they are first bound (see gl:bindTexture/2 ).
Texture names returned by a call to gl:genTextures
are not returned by subsequent
calls, unless they are first deleted with gl:deleteTextures/1 .
See
deleteTextures(Textures) -> ok
Textures = [integer()]
Delete named textures
gl:deleteTextures
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 gl:genTextures/1 ). If a texture that is currently bound
is deleted, the binding reverts to 0 (the default texture).
gl:deleteTextures
silently ignores 0's and names that do not correspond to existing
textures.
See
bindTexture(Target, Texture) -> ok
Target = enum()
Texture = integer()
Bind a named texture to a texturing target
gl:bindTexture
lets you create or use a named texture. Calling gl:bindTexture
with Target
set to ?GL_TEXTURE_1D
, ?GL_TEXTURE_2D
, ?GL_TEXTURE_3D
, or ?GL_TEXTURE_1D_ARRAY
, ?GL_TEXTURE_2D_ARRAY
, ?GL_TEXTURE_RECTANGLE
, ?GL_TEXTURE_CUBE_MAP
, ?GL_TEXTURE_2D_MULTISAMPLE
or ?GL_TEXTURE_2D_MULTISAMPLE_ARRAY
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 zero is reserved to represent the default texture for each texture target. Texture names and the corresponding texture contents are local to the shared object space of the current GL rendering context; two rendering contexts share texture names only if they explicitly enable sharing between contexts through the appropriate GL windows interfaces functions.
You must use gl:genTextures/1 to generate a set of new texture names.
When a texture is first bound, it assumes the specified target: A texture first bound
to ?GL_TEXTURE_1D
becomes one-dimensional texture, a texture first bound to ?GL_TEXTURE_2D
becomes two-dimensional texture, a texture first bound to ?GL_TEXTURE_3D
becomes
three-dimensional texture, a texture first bound to ?GL_TEXTURE_1D_ARRAY
becomes
one-dimensional array texture, a texture first bound to ?GL_TEXTURE_2D_ARRAY
becomes
two-dimensional arary texture, a texture first bound to ?GL_TEXTURE_RECTANGLE
becomes
rectangle texture, a, texture first bound to ?GL_TEXTURE_CUBE_MAP
becomes a cube-mapped
texture, a texture first bound to ?GL_TEXTURE_2D_MULTISAMPLE
becomes a two-dimensional
multisampled texture, and a texture first bound to ?GL_TEXTURE_2D_MULTISAMPLE_ARRAY
becomes a two-dimensional multisampled array texture. The state of a one-dimensional texture
immediately after it is first bound is equivalent to the state of the default ?GL_TEXTURE_1D
at GL initialization, and similarly for the other texture types.
While a texture is bound, GL operations on the target to which it is bound affect the bound texture, and queries of the target to which it is bound return state from the bound texture. In effect, the texture targets become aliases for the textures currently bound to them, and the texture name zero refers to the default textures that were bound to them at initialization.
A texture binding created with gl:bindTexture
remains active until a different
texture is bound to the same target, or until the bound texture is deleted with gl:deleteTextures/1
.
Once created, a named texture may be re-bound to its same original target as often as
needed. It is usually much faster to use gl:bindTexture
to bind an existing named
texture to one of the texture targets than it is to reload the texture image using gl:texImage1D/8
, gl:texImage2D/9 , gl:texImage3D/10 or another similar function.
See
prioritizeTextures(Textures, Priorities) -> ok
Textures = [integer()]
Priorities = [clamp()]
Set texture residence priority
gl:prioritizeTextures
assigns the N
texture priorities given in Priorities
to the N
textures named in Textures
.
The GL establishes a working set
of textures that are resident in texture memory.
These textures may be bound to a texture target much more efficiently than textures that
are not resident. By specifying a priority for each texture, gl:prioritizeTextures
allows applications to guide the GL implementation in determining which textures should
be resident.
The priorities given in Priorities
are clamped to the range [0 1] before they are
assigned. 0 indicates the lowest priority; textures with priority 0 are least likely to
be resident. 1 indicates the highest priority; textures with priority 1 are most likely
to be resident. However, textures are not guaranteed to be resident until they are used.
gl:prioritizeTextures
silently ignores attempts to prioritize texture 0 or any texture
name that does not correspond to an existing texture.
gl:prioritizeTextures
does not require that any of the textures named by Textures
be bound to a texture target. gl:texParameterf/3 may also be used to set a texture's
priority, but only if the texture is currently bound. This is the only way to set the
priority of a default texture.
See
areTexturesResident(Textures) -> {0 | 1, Residences::[0 | 1]}
Textures = [integer()]
Determine if textures are loaded in texture memory
GL establishes a working set
of textures that are resident in texture memory. These
textures can be bound to a texture target much more efficiently than textures that are
not resident.
gl:areTexturesResident
queries the texture residence status of the N
textures
named by the elements of Textures
. If all the named textures are resident, gl:areTexturesResident
returns ?GL_TRUE
, and the contents of Residences
are undisturbed. If not
all the named textures are resident, gl:areTexturesResident
returns ?GL_FALSE
,
and detailed status is returned in the N
elements of Residences
. If an element
of Residences
is ?GL_TRUE
, then the texture named by the corresponding element
of Textures
is resident.
The residence status of a single bound texture may also be queried by calling gl:getTexParameterfv/2
with the target
argument set to the target to which the texture is bound, and
the pname
argument set to ?GL_TEXTURE_RESIDENT
. This is the only way that
the residence status of a default texture can be queried.
See
isTexture(Texture) -> 0 | 1
Texture = integer()
Determine if a name corresponds to a texture
gl:isTexture
returns ?GL_TRUE
if Texture
is currently the name of
a texture. If Texture
is zero, or is a non-zero value that is not currently the
name of a texture, or if an error occurs, gl:isTexture
returns ?GL_FALSE
.
A name returned by gl:genTextures/1 , but not yet associated with a texture by calling gl:bindTexture/2 , is not the name of a texture.
See
texSubImage1D(Target, Level, Xoffset, Width, Format, Type, Pixels) -> ok
Target = enum()
Level = integer()
Xoffset = integer()
Width = integer()
Format = enum()
Type = enum()
Pixels = offset() | mem()
glTexSubImage
See
texSubImage2D(Target, Level, Xoffset, Yoffset, Width, Height, Format, Type, Pixels) -> ok
Target = enum()
Level = integer()
Xoffset = integer()
Yoffset = integer()
Width = integer()
Height = integer()
Format = enum()
Type = enum()
Pixels = offset() | mem()
glTexSubImage
See
copyTexImage1D(Target, Level, Internalformat, X, Y, Width, Border) -> ok
Target = enum()
Level = integer()
Internalformat = enum()
X = integer()
Y = integer()
Width = integer()
Border = integer()
Copy pixels into a 1D texture image
gl:copyTexImage1D
defines a one-dimensional texture image with pixels from the current
?GL_READ_BUFFER
.
The screen-aligned pixel row with left corner at (x y) and with a length of width+2(border) defines
the texture array at the mipmap level specified by Level
. Internalformat
specifies the internal format of the texture array.
The pixels in the row are processed exactly as if gl:readPixels/7 had been called, but the process stops just before final conversion. At this point all pixel component values are clamped to the range [0 1] and then converted to the texture's internal format for storage in the texel array.
Pixel ordering is such that lower x screen coordinates correspond to lower texture coordinates.
If any of the pixels within the specified row of the current ?GL_READ_BUFFER
are
outside the window associated with the current rendering context, then the values obtained
for those pixels are undefined.
gl:copyTexImage1D
defines a one-dimensional texture image with pixels from the current
?GL_READ_BUFFER
.
When Internalformat
is one of the sRGB types, the GL does not automatically convert
the source pixels to the sRGB color space. In this case, the gl:pixelMap
function
can be used to accomplish the conversion.
See
copyTexImage2D(Target, Level, Internalformat, X, Y, Width, Height, Border) -> ok
Target = enum()
Level = integer()
Internalformat = enum()
X = integer()
Y = integer()
Width = integer()
Height = integer()
Border = integer()
Copy pixels into a 2D texture image
gl:copyTexImage2D
defines a two-dimensional texture image, or cube-map texture image
with pixels from the current ?GL_READ_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 internal format of
the texture array.
The pixels in the rectangle are processed exactly as if gl:readPixels/7 had been called, but the process stops just before final conversion. At this point all pixel component values are clamped to the range [0 1] and then converted to the texture's internal format for storage in the texel array.
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 current ?GL_READ_BUFFER
are outside the window associated with the current rendering context, then the values
obtained for those pixels are undefined.
When Internalformat
is one of the sRGB types, the GL does not automatically convert
the source pixels to the sRGB color space. In this case, the gl:pixelMap
function
can be used to accomplish the conversion.
See
copyTexSubImage1D(Target, Level, Xoffset, X, Y, Width) -> ok
Target = enum()
Level = integer()
Xoffset = integer()
X = integer()
Y = integer()
Width = integer()
Copy a one-dimensional texture subimage
gl:copyTexSubImage1D
replaces a portion of a one-dimensional texture image with
pixels from the current ?GL_READ_BUFFER
(rather than from main memory, as is the
case for gl:texSubImage1D/7 ).
The screen-aligned pixel row with left corner at ( X
, Y
), and with length Width
replaces the portion of the texture array with x indices Xoffset
through xoffset
+width-1, inclusive. The destination in the texture array may not include any texels outside
the texture array as it was originally specified.
The pixels in the row are processed exactly as if gl:readPixels/7 had been called, but the process stops just before final conversion. At this point, all pixel component values are clamped to the range [0 1] and then converted to the texture's internal format for storage in the texel array.
It is not an error to specify a subtexture with zero width, but such a specification
has no effect. If any of the pixels within the specified row of the current ?GL_READ_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
, or border
parameters
of the specified texture array or to texel values outside the specified subregion.
See
copyTexSubImage2D(Target, Level, Xoffset, Yoffset, X, Y, Width, Height) -> ok
Target = enum()
Level = integer()
Xoffset = integer()
Yoffset = integer()
X = integer()
Y = integer()
Width = integer()
Height = integer()
Copy a two-dimensional texture subimage
gl:copyTexSubImage2D
replaces a rectangular portion of a two-dimensional texture
image or cube-map texture image with pixels from the current ?GL_READ_BUFFER
(rather
than from main memory, as is the case for gl:texSubImage1D/7 ).
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 exactly as if gl:readPixels/7 had been called, but the process stops just before final conversion. At this point, all pixel component values are clamped to the range [0 1] and then converted to the texture's internal format for storage in the texel array.
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 ?GL_READ_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.
See
map1d(Target, U1, U2, Stride, Order, Points) -> ok
Target = enum()
U1 = float()
U2 = float()
Stride = integer()
Order = integer()
Points = binary()
glMap
See
map1f(Target, U1, U2, Stride, Order, Points) -> ok
Target = enum()
U1 = float()
U2 = float()
Stride = integer()
Order = integer()
Points = binary()
glMap
See
map2d(Target, U1, U2, Ustride, Uorder, V1, V2, Vstride, Vorder, Points) -> ok
Target = enum()
U1 = float()
U2 = float()
Ustride = integer()
Uorder = integer()
V1 = float()
V2 = float()
Vstride = integer()
Vorder = integer()
Points = binary()
glMap
See
map2f(Target, U1, U2, Ustride, Uorder, V1, V2, Vstride, Vorder, Points) -> ok
Target = enum()
U1 = float()
U2 = float()
Ustride = integer()
Uorder = integer()
V1 = float()
V2 = float()
Vstride = integer()
Vorder = integer()
Points = binary()
glMap
See
getMapdv(Target, Query, V) -> ok
Target = enum()
Query = enum()
V = mem()
Return evaluator parameters
gl:map1d/6 and gl:map1d/6 define evaluators. gl:getMap
returns evaluator
parameters. Target
chooses a map, Query
selects a specific parameter, and V
points to storage where the values will be returned.
The acceptable values for the Target
parameter are described in the gl:map1d/6
and gl:map1d/6 reference pages.
Query
can assume the following values:
?GL_COEFF
: V
returns the control points for the evaluator function. One-dimensional
evaluators return order control points, and two-dimensional evaluators return uorder×vorder
control points. Each control point consists of one, two, three, or four integer, single-precision
floating-point, or double-precision floating-point values, depending on the type of the
evaluator. The GL returns two-dimensional control points in row-major order, incrementing
the uorder index quickly and the vorder index after each row. Integer values, when
requested, are computed by rounding the internal floating-point values to the nearest
integer values.
?GL_ORDER
: V
returns the order of the evaluator function. One-dimensional
evaluators return a single value, order. The initial value is 1. Two-dimensional evaluators
return two values, uorder and vorder. The initial value is 1,1.
?GL_DOMAIN
: V
returns the linear u and v mapping parameters. One-dimensional
evaluators return two values, u1 and u2, as specified by gl:map1d/6 . Two-dimensional
evaluators return four values ( u1, u2, v1, and v2) as specified by gl:map1d/6 .
Integer values, when requested, are computed by rounding the internal floating-point values
to the nearest integer values.
See
evalCoord1d(U) -> ok
U = float()
Evaluate enabled one- and two-dimensional maps
gl:evalCoord1
evaluates enabled one-dimensional maps at argument U
. gl:evalCoord2
does the same for two-dimensional maps using two domain values, U
and V
.
To define a map, call gl:map1d/6 and gl:map1d/6 ; to enable and disable it,
call gl:enable/1 and gl:enable/1 .
When one of the gl:evalCoord
commands is issued, all currently enabled maps of
the indicated dimension are evaluated. Then, for each enabled map, it is as if the corresponding
GL command had been issued with the computed value. That is, if ?GL_MAP1_INDEX
or ?GL_MAP2_INDEX
is enabled, a gl:indexd/1 command is simulated. If ?GL_MAP1_COLOR_4
or ?GL_MAP2_COLOR_4
is enabled, a gl:color3b/3 command is simulated. If ?GL_MAP1_NORMAL
or ?GL_MAP2_NORMAL
is enabled, a normal vector is produced, and if any of ?GL_MAP1_TEXTURE_COORD_1
, ?GL_MAP1_TEXTURE_COORD_2
, ?GL_MAP1_TEXTURE_COORD_3
, ?GL_MAP1_TEXTURE_COORD_4
, ?GL_MAP2_TEXTURE_COORD_1
, ?GL_MAP2_TEXTURE_COORD_2
, ?GL_MAP2_TEXTURE_COORD_3
, or ?GL_MAP2_TEXTURE_COORD_4
is enabled, then an appropriate gl:texCoord1d/1 command is simulated.
For color, color index, normal, and texture coordinates the GL uses evaluated values
instead of current values for those evaluations that are enabled, and current values otherwise,
However, the evaluated values do not update the current values. Thus, if gl:vertex2d/2
commands are interspersed with gl:evalCoord
commands, the color, normal, and texture
coordinates associated with the gl:vertex2d/2 commands are not affected by the values
generated by the gl:evalCoord
commands, but only by the most recent gl:color3b/3
, gl:indexd/1 , gl:normal3b/3 , and gl:texCoord1d/1 commands.
No commands are issued for maps that are not enabled. If more than one texture evaluation
is enabled for a particular dimension (for example, ?GL_MAP2_TEXTURE_COORD_1
and ?GL_MAP2_TEXTURE_COORD_2
), then only the evaluation of the map that produces the larger number of coordinates
(in this case, ?GL_MAP2_TEXTURE_COORD_2
) is carried out. ?GL_MAP1_VERTEX_4
overrides ?GL_MAP1_VERTEX_3
, and ?GL_MAP2_VERTEX_4
overrides ?GL_MAP2_VERTEX_3
, in the same manner. If neither a three- nor a four-component vertex map is enabled for
the specified dimension, the gl:evalCoord
command is ignored.
If you have enabled automatic normal generation, by calling gl:enable/1 with argument
?GL_AUTO_NORMAL
, gl:evalCoord2
generates surface normals analytically, regardless
of the contents or enabling of the ?GL_MAP2_NORMAL
map. Let
m=((∂ p)/(∂ u))×((∂ p)/(∂ v))
Then the generated normal n is n=m/(||m||)
If automatic normal generation is disabled, the corresponding normal map ?GL_MAP2_NORMAL
, if enabled, is used to produce a normal. If neither automatic normal generation nor
a normal map is enabled, no normal is generated for gl:evalCoord2
commands.
See
mapGrid1d(Un, U1, U2) -> ok
Un = integer()
U1 = float()
U2 = float()
Define a one- or two-dimensional mesh
gl:mapGrid
and gl:evalMesh1/3 are used together to efficiently generate and
evaluate a series of evenly-spaced map domain values. gl:evalMesh1/3 steps through
the integer domain of a one- or two-dimensional grid, whose range is the domain of the
evaluation maps specified by gl:map1d/6 and gl:map1d/6 .
gl:mapGrid1
and gl:mapGrid2
specify the linear grid mappings between the i
(or i and j) integer grid coordinates, to the u (or u and v) floating-point
evaluation map coordinates. See gl:map1d/6 and gl:map1d/6 for details of how
u and v coordinates are evaluated.
gl:mapGrid1
specifies a single linear mapping such that integer grid coordinate
0 maps exactly to U1
, and integer grid coordinate Un
maps exactly to U2
. All other integer grid coordinates i are mapped so that
u=i(u2-u1)/un+u1
gl:mapGrid2
specifies two such linear mappings. One maps integer grid coordinate
i=0 exactly to U1
, and integer grid coordinate i=un exactly to U2
. The
other maps integer grid coordinate j=0 exactly to V1
, and integer grid coordinate
j=vn exactly to V2
. Other integer grid coordinates i and j are mapped such
that
u=i(u2-u1)/un+u1
v=j(v2-v1)/vn+v1
The mappings specified by gl:mapGrid
are used identically by gl:evalMesh1/3
and gl:evalPoint1/1 .
See
mapGrid2d(Un, U1, U2, Vn, V1, V2) -> ok
Un = integer()
U1 = float()
U2 = float()
Vn = integer()
V1 = float()
V2 = float()
See mapGrid1d/3
mapGrid2f(Un, U1, U2, Vn, V1, V2) -> ok
Un = integer()
U1 = float()
U2 = float()
Vn = integer()
V1 = float()
V2 = float()
See mapGrid1d/3
evalPoint1(I) -> ok
I = integer()
Generate and evaluate a single point in a mesh
gl:mapGrid1d/3 and gl:evalMesh1/3 are used in tandem to efficiently generate
and evaluate a series of evenly spaced map domain values. gl:evalPoint
can be used
to evaluate a single grid point in the same gridspace that is traversed by gl:evalMesh1/3
. Calling gl:evalPoint1
is equivalent to calling glEvalCoord1( i.Δ u+u
1 ); where Δ u=(u 2-u 1)/n
and n, u 1, and u 2 are the arguments to the most recent gl:mapGrid1d/3 command. The one absolute numeric requirement is that if i=n, then the value computed from i.Δ u+u 1 is exactly u 2.
In the two-dimensional case, gl:evalPoint2
, let
Δ u=(u 2-u 1)/n
Δ v=(v 2-v 1)/m
where n, u 1, u 2, m, v 1, and v 2 are the arguments to the most recent gl:mapGrid1d/3
command. Then the gl:evalPoint2
command is equivalent to calling glEvalCoord2( i.
Δ u+u 1, j.Δ v+v 1 ); The only absolute numeric requirements are
that if i=n, then the value computed from i.Δ u+u 1 is exactly u 2, and
if j=m, then the value computed from j.Δ v+v 1 is exactly v 2.
See
evalMesh1(Mode, I1, I2) -> ok
Mode = enum()
I1 = integer()
I2 = integer()
Compute a one- or two-dimensional grid of points or lines
gl:mapGrid1d/3 and gl:evalMesh
are used in tandem to efficiently generate and
evaluate a series of evenly-spaced map domain values. gl:evalMesh
steps through
the integer domain of a one- or two-dimensional grid, whose range is the domain of the
evaluation maps specified by gl:map1d/6 and gl:map1d/6 . Mode
determines
whether the resulting vertices are connected as points, lines, or filled polygons.
In the one-dimensional case, gl:evalMesh1
, the mesh is generated as if the following
code fragment were executed:
glBegin( Type
); for ( i = I1
; i <= I2
; i += 1 ) glEvalCoord1(
i.Δ u+u 1 ); glEnd(); where
Δ u=(u 2-u 1)/n
and n, u 1, and u 2 are the arguments to the most recent gl:mapGrid1d/3 command.
type
is ?GL_POINTS
if Mode
is ?GL_POINT
, or ?GL_LINES
if Mode
is ?GL_LINE
.
The one absolute numeric requirement is that if i=n, then the value computed from i.Δ u+u 1 is exactly u 2.
In the two-dimensional case, gl:evalMesh2
, let .cp Δ u=(u 2-u 1)/n
Δ v=(v 2-v 1)/m
where n, u 1, u 2, m, v 1, and v 2 are the arguments to the most recent gl:mapGrid1d/3
command. Then, if Mode
is ?GL_FILL
, the gl:evalMesh2
command is equivalent
to:
for ( j = J1
; j < J2
; j += 1 ) { glBegin( GL_QUAD_STRIP ); for ( i = I1
; i <= I2
; i += 1 ) { glEvalCoord2( i.Δ u+u 1, j.Δ v+v 1
); glEvalCoord2( i.Δ u+u 1,(j+1).Δ v+v 1 ); } glEnd(); }
If Mode
is ?GL_LINE
, then a call to gl:evalMesh2
is equivalent to:
for ( j = J1
; j <= J2
; j += 1 ) { glBegin( GL_LINE_STRIP ); for ( i = I1
; i <= I2
; i += 1 ) glEvalCoord2( i.Δ u+u 1, j.Δ v+v 1
); glEnd(); } for ( i = I1
; i <= I2
; i += 1 ) { glBegin( GL_LINE_STRIP
); for ( j = J1
; j <= J1
; j += 1 ) glEvalCoord2( i.Δ u+u 1, j.
Δ v+v 1 ); glEnd(); }
And finally, if Mode
is ?GL_POINT
, then a call to gl:evalMesh2
is
equivalent to:
glBegin( GL_POINTS ); for ( j = J1
; j <= J2
; j += 1 ) for ( i = I1
; i <= I2
; i += 1 ) glEvalCoord2( i.Δ u+u 1, j.Δ v+v 1
); glEnd();
In all three cases, the only absolute numeric requirements are that if i=n, then the value computed from i.Δ u+u 1 is exactly u 2, and if j=m, then the value computed from j.Δ v+v 1 is exactly v 2.
See
evalMesh2(Mode, I1, I2, J1, J2) -> ok
Mode = enum()
I1 = integer()
I2 = integer()
J1 = integer()
J2 = integer()
See evalMesh1/3
fogf(Pname, Param) -> ok
Pname = enum()
Param = float()
Specify fog parameters
Fog is initially disabled. While enabled, fog affects rasterized geometry, bitmaps, and
pixel blocks, but not buffer clear operations. To enable and disable fog, call gl:enable/1
and gl:enable/1 with argument ?GL_FOG
.
gl:fog
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
is a single integer or floating-point 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
is a single integer or floating-point 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
is a single integer or floating-point value that specifies
start, the near distance used in the linear fog equation. The initial near distance
is 0.
?GL_FOG_END
: Params
is a single integer or floating-point value that specifies
end, the far distance used in the linear fog equation. The initial far distance is 1.
?GL_FOG_INDEX
: Params
is a single integer or floating-point value that specifies
i f, the fog color index. The initial fog index is 0.
?GL_FOG_COLOR
: Params
contains four integer or floating-point values that
specify C f, the fog color. Integer values are mapped linearly such that the most positive
representable value maps to 1.0, and the most negative representable value maps to -1.0.
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).
?GL_FOG_COORD_SRC
: Params
contains either of the following symbolic constants:
?GL_FOG_COORD
or ?GL_FRAGMENT_DEPTH
. ?GL_FOG_COORD
specifies that
the current fog coordinate should be used as distance value in the fog color computation.
?GL_FRAGMENT_DEPTH
specifies that the current fragment depth should be used as
distance value in the fog computation.
Fog blends a fog color with each rasterized pixel fragment's post-texturing color using
a blending factor f. Factor f is computed in one of three ways, depending on the fog
mode. Let c be either the distance in eye coordinate from the origin (in the case that
the ?GL_FOG_COORD_SRC
is ?GL_FRAGMENT_DEPTH
) or the current fog coordinate
(in the case that ?GL_FOG_COORD_SRC
is ?GL_FOG_COORD
). The equation for ?GL_LINEAR
fog is f=(end-c)/(end-start)
The equation for ?GL_EXP
fog is f=e(-(density. c))
The equation for ?GL_EXP2
fog is f=e(-(density. c)) 2
Regardless of the fog mode, f is clamped to the range [0 1] after it is computed. Then, if the GL is in RGBA color mode, the fragment's red, green, and blue colors, represented by C r, are replaced by
(C r)"=f×C r+(1-f)×C f
Fog does not affect a fragment's alpha component.
In color index mode, the fragment's color index i r is replaced by
(i r)"=i r+(1-f)×i f
See
feedbackBuffer(Size, Type, Buffer) -> ok
Size = integer()
Type = enum()
Buffer = mem()
Controls feedback mode
The gl:feedbackBuffer
function controls feedback. Feedback, like selection, is
a GL mode. The mode is selected by calling gl:renderMode/1 with ?GL_FEEDBACK
.
When the GL is in feedback mode, no pixels are produced by rasterization. Instead, information
about primitives that would have been rasterized is fed back to the application using
the GL.
gl:feedbackBuffer
has three arguments: Buffer
is a pointer to an array of
floating-point values into which feedback information is placed. Size
indicates
the size of the array. Type
is a symbolic constant describing the information that
is fed back for each vertex. gl:feedbackBuffer
must be issued before feedback mode
is enabled (by calling gl:renderMode/1 with argument ?GL_FEEDBACK
). Setting
?GL_FEEDBACK
without establishing the feedback buffer, or calling gl:feedbackBuffer
while the GL is in feedback mode, is an error.
When gl:renderMode/1 is called while in feedback mode, it returns the number of
entries placed in the feedback array and resets the feedback array pointer to the base
of the feedback buffer. The returned value never exceeds Size
. If the feedback
data required more room than was available in Buffer
, gl:renderMode/1 returns
a negative value. To take the GL out of feedback mode, call gl:renderMode/1 with
a parameter value other than ?GL_FEEDBACK
.
While in feedback mode, each primitive, bitmap, or pixel rectangle that would be rasterized generates a block of values that are copied into the feedback array. If doing so would cause the number of entries to exceed the maximum, the block is partially written so as to fill the array (if there is any room left at all), and an overflow flag is set. Each block begins with a code indicating the primitive type, followed by values that describe the primitive's vertices and associated data. Entries are also written for bitmaps and pixel rectangles. Feedback occurs after polygon culling and gl:polygonMode/2 interpretation of polygons has taken place, so polygons that are culled are not returned in the feedback buffer. It can also occur after polygons with more than three edges are broken up into triangles, if the GL implementation renders polygons by performing this decomposition.
The gl:passThrough/1 command can be used to insert a marker into the feedback buffer. See gl:passThrough/1 .
Following is the grammar for the blocks of values written into the feedback buffer. Each
primitive is indicated with a unique identifying value followed by some number of vertices.
Polygon entries include an integer value indicating how many vertices follow. A vertex
is fed back as some number of floating-point values, as determined by Type
. Colors
are fed back as four values in RGBA mode and one value in color index mode.
feedbackList ← feedbackItem feedbackList | feedbackItem
feedbackItem ← point | lineSegment | polygon | bitmap | pixelRectangle | passThru
point ←?GL_POINT_TOKEN
vertex
lineSegment ←?GL_LINE_TOKEN
vertex vertex | ?GL_LINE_RESET_TOKEN
vertex
vertex
polygon ←?GL_POLYGON_TOKEN
n polySpec
polySpec ← polySpec vertex | vertex vertex vertex
bitmap ←?GL_BITMAP_TOKEN
vertex
pixelRectangle ←?GL_DRAW_PIXEL_TOKEN
vertex | ?GL_COPY_PIXEL_TOKEN
vertex
passThru ←?GL_PASS_THROUGH_TOKEN
value
vertex ← 2d | 3d | 3dColor | 3dColorTexture | 4dColorTexture
2d ← value value
3d ← value value value
3dColor ← value value value color
3dColorTexture ← value value value color tex
4dColorTexture ← value value value value color tex
color ← rgba | index
rgba ← value value value value
index ← value
tex ← value value value value
value
is a floating-point number, and n
is a floating-point integer giving
the number of vertices in the polygon. ?GL_POINT_TOKEN
, ?GL_LINE_TOKEN
, ?GL_LINE_RESET_TOKEN
, ?GL_POLYGON_TOKEN
, ?GL_BITMAP_TOKEN
, ?GL_DRAW_PIXEL_TOKEN
, ?GL_COPY_PIXEL_TOKEN
and ?GL_PASS_THROUGH_TOKEN
are symbolic floating-point constants. ?GL_LINE_RESET_TOKEN
is returned whenever the line stipple pattern is reset. The data returned as a vertex
depends on the feedback Type
.
The following table gives the correspondence between Type
and the number of values
per vertex. k
is 1 in color index mode and 4 in RGBA mode.
Type
Coordinates
Color
Texture
Total Number of Values
?GL_2D
x
, y
2 ?GL_3D
x
, y
, z
3 ?GL_3D_COLOR
x
, y
, z
k 3+k?GL_3D_COLOR_TEXTURE
x
, y
, z
k 4 7+k?GL_4D_COLOR_TEXTURE
x
, y
, z
, w
k
4 8+kFeedback vertex coordinates are in window coordinates, except w
, which is in clip
coordinates. Feedback colors are lighted, if lighting is enabled. Feedback texture coordinates
are generated, if texture coordinate generation is enabled. They are always transformed
by the texture matrix.
See
passThrough(Token) -> ok
Token = float()
Place a marker in the feedback buffer
Feedback is a GL render mode. The mode is selected by calling gl:renderMode/1
with ?GL_FEEDBACK
. When the GL is in feedback mode, no pixels are produced by rasterization.
Instead, information about primitives that would have been rasterized is fed back to the
application using the GL. See the gl:feedbackBuffer/3 reference page for a description
of the feedback buffer and the values in it.
gl:passThrough
inserts a user-defined marker in the feedback buffer when it is executed
in feedback mode. Token
is returned as if it were a primitive; it is indicated
with its own unique identifying value: ?GL_PASS_THROUGH_TOKEN
. The order of gl:passThrough
commands with respect to the specification of graphics primitives is maintained.
See
selectBuffer(Size, Buffer) -> ok
Size = integer()
Buffer = mem()
Establish a buffer for selection mode values
gl:selectBuffer
has two arguments: Buffer
is a pointer to an array of unsigned
integers, and Size
indicates the size of the array. Buffer
returns values
from the name stack (see gl:initNames/0 , gl:loadName/1 , gl:pushName/1 )
when the rendering mode is ?GL_SELECT
(see gl:renderMode/1 ). gl:selectBuffer
must be issued before selection mode is enabled, and it must not be issued while the
rendering mode is ?GL_SELECT
.
A programmer can use selection to determine which primitives are drawn into some region of a window. The region is defined by the current modelview and perspective matrices.
In selection mode, no pixel fragments are produced from rasterization. Instead, if a
primitive or a raster position intersects the clipping volume defined by the viewing frustum
and the user-defined clipping planes, this primitive causes a selection hit. (With polygons,
no hit occurs if the polygon is culled.) When a change is made to the name stack, or when
gl:renderMode/1 is called, a hit record is copied to Buffer
if any hits
have occurred since the last such event (name stack change or gl:renderMode/1 call).
The hit record consists of the number of names in the name stack at the time of the event,
followed by the minimum and maximum depth values of all vertices that hit since the previous
event, followed by the name stack contents, bottom name first.
Depth values (which are in the range [0,1]) are multiplied by 2 32-1, before being placed in the hit record.
An internal index into Buffer
is reset to 0 whenever selection mode is entered.
Each time a hit record is copied into Buffer
, the index is incremented to point
to the cell just past the end of the block of names(emthat is, to the next available cell
If the hit record is larger than the number of remaining locations in Buffer
, as
much data as can fit is copied, and the overflow flag is set. If the name stack is empty
when a hit record is copied, that record consists of 0 followed by the minimum and maximum
depth values.
To exit selection mode, call gl:renderMode/1 with an argument other than ?GL_SELECT
. Whenever gl:renderMode/1 is called while the render mode is ?GL_SELECT
,
it returns the number of hit records copied to Buffer
, resets the overflow flag
and the selection buffer pointer, and initializes the name stack to be empty. If the overflow
bit was set when gl:renderMode/1 was called, a negative hit record count is returned.
See
initNames() -> ok
Initialize the name stack
The name stack is used during selection mode to allow sets of rendering commands to be
uniquely identified. It consists of an ordered set of unsigned integers. gl:initNames
causes the name stack to be initialized to its default empty state.
The name stack is always empty while the render mode is not ?GL_SELECT
. Calls to gl:initNames
while the render mode is not ?GL_SELECT
are ignored.
See
loadName(Name) -> ok
Name = integer()
Load a name onto the name stack
The name stack is used during selection mode to allow sets of rendering commands to be uniquely identified. It consists of an ordered set of unsigned integers and is initially empty.
gl:loadName
causes Name
to replace the value on the top of the name stack.
The name stack is always empty while the render mode is not ?GL_SELECT
. Calls to gl:loadName
while the render mode is not ?GL_SELECT
are ignored.
See
pushName(Name) -> ok
Name = integer()
Push and pop the name stack
The name stack is used during selection mode to allow sets of rendering commands to be uniquely identified. It consists of an ordered set of unsigned integers and is initially empty.
gl:pushName
causes Name
to be pushed onto the name stack. gl:pushName/1
pops one name off the top of the stack.
The maximum name stack depth is implementation-dependent; call ?GL_MAX_NAME_STACK_DEPTH
to find out the value for a particular implementation. It is an error to push a name
onto a full stack or to pop a name off an empty stack. It is also an error to manipulate
the name stack between the execution of gl:'begin'/1 and the corresponding execution
of gl:'begin'/1 . In any of these cases, the error flag is set and no other change is
made to GL state.
The name stack is always empty while the render mode is not ?GL_SELECT
. Calls to gl:pushName
or gl:pushName/1 while the render mode is not ?GL_SELECT
are ignored.
See
popName() -> ok
See pushName/1
blendColor(Red, Green, Blue, Alpha) -> ok
Red = clamp()
Green = clamp()
Blue = clamp()
Alpha = clamp()
Set the blend color
The ?GL_BLEND_COLOR
may be used to calculate the source and destination blending
factors. The color components are clamped to the range [0 1] before being stored. See gl:blendFunc/2
for a complete description of the blending operations. Initially the ?GL_BLEND_COLOR
is set to (0, 0, 0, 0).
See
blendEquation(Mode) -> ok
Mode = enum()
Specify the equation used for both the RGB blend equation and the Alpha blend equation
The blend equations determine how a new pixel (the ''source'' color) is combined with
a pixel already in the framebuffer (the ''destination'' color). This function sets both
the RGB blend equation and the alpha blend equation to a single equation. gl:blendEquationi
specifies the blend equation for a single draw buffer whereas gl:blendEquation
sets the blend equation for all draw buffers.
These equations use the source and destination blend factors specified by either gl:blendFunc/2 or gl:blendFuncSeparate/4 . See gl:blendFunc/2 or gl:blendFuncSeparate/4 for a description of the various blend factors.
In the equations that follow, source and destination color components are referred to as (R s G s B s A s) and (R d G d B d A d), respectively. The result color is referred to as (R r G r B r A r). The source and destination blend factors are denoted (s R s G s B s A) and (d R d G d B d A), respectively. For these equations all color components are understood to have values in the range [0 1].
Mode
RGB Components
Alpha Component
?GL_FUNC_ADD
Rr=R s s R+R d d R Gr=G s s G+G d d G Br=B s s B+B d d B Ar=A s
s A+A d d A?GL_FUNC_SUBTRACT
Rr=R s s R-R d d R Gr=G
s s G-G d d G Br=B s s B-B d d B Ar=A s s A-A d d A?GL_FUNC_REVERSE_SUBTRACT
Rr=R d d R-R s s R Gr=G d d G-G s s G Br=B d d B-B s s B Ar=A d
d A-A s s A?GL_MIN
Rr=min(R s R d) Gr=min(G s G d) Br=min(B s B d) Ar=min
(A s A d)?GL_MAX
Rr=max(R s R d) Gr=max(G s G d) Br=max(B s B d) Ar=max(A s A d)The results of these equations are clamped to the range [0 1].
The ?GL_MIN
and ?GL_MAX
equations are useful for applications that analyze
image data (image thresholding against a constant color, for example). The ?GL_FUNC_ADD
equation is useful for antialiasing and transparency, among other things.
Initially, both the RGB blend equation and the alpha blend equation are set to ?GL_FUNC_ADD
.
See
drawRangeElements(Mode, Start, End, Count, Type, Indices) -> ok
Mode = enum()
Start = integer()
End = integer()
Count = integer()
Type = enum()
Indices = offset() | mem()
Render primitives from array data
gl:drawRangeElements
is a restricted form of gl:drawElements/4 . Mode
,
Start
, End
, and Count
match the corresponding arguments to gl:drawElements/4
, with the additional constraint that all values in the arrays Count
must lie between
Start
and End
, inclusive.
Implementations denote recommended maximum amounts of vertex and index data, which may
be queried by calling gl:getBooleanv/1 with argument ?GL_MAX_ELEMENTS_VERTICES
and ?GL_MAX_ELEMENTS_INDICES
. If end-start+1 is greater than the value of ?GL_MAX_ELEMENTS_VERTICES
, or if Count
is greater than the value of ?GL_MAX_ELEMENTS_INDICES
, then the call may operate
at reduced performance. There is no requirement that all vertices in the range [start end] be referenced.
However, the implementation may partially process unused vertices, reducing performance
from what could be achieved with an optimal index set.
When gl:drawRangeElements
is called, it uses Count
sequential elements from
an enabled array, starting at Start
to construct a sequence of geometric primitives.
Mode
specifies what kind of primitives are constructed, and how the array elements
construct these primitives. If more than one array is enabled, each is used.
Vertex attributes that are modified by gl:drawRangeElements
have an unspecified
value after gl:drawRangeElements
returns. Attributes that aren't modified maintain
their previous values.
See
texImage3D(Target, Level, InternalFormat, Width, Height, Depth, Border, Format, Type, Pixels) -> ok
Target = enum()
Level = integer()
InternalFormat = integer()
Width = integer()
Height = integer()
Depth = integer()
Border = integer()
Format = enum()
Type = enum()
Pixels = offset() | mem()
Specify a three-dimensional texture image
Texturing maps a portion of a specified texture image onto each graphical primitive for
which texturing is enabled. To enable and disable three-dimensional texturing, call gl:enable/1
and gl:enable/1 with argument ?GL_TEXTURE_3D
.
To define texture images, call gl:texImage3D
. The arguments describe the parameters
of the texture image, such as height, width, depth, width of the border, level-of-detail
number (see gl:texParameterf/3 ), and number of color components provided. The last
three arguments describe how the image is represented in memory.
If Target
is ?GL_PROXY_TEXTURE_3D
, no data is read from Data
, but
all of the texture image state is recalculated, checked for consistency, and checked against
the implementation's capabilities. If the implementation cannot handle a texture of the
requested texture size, it sets all of the image state to 0, but does not generate an
error (see gl:getError/0 ). To query for an entire mipmap array, use an image array
level greater than or equal to 1.
If Target
is ?GL_TEXTURE_3D
, data is read from Data
as a sequence
of signed or unsigned bytes, shorts, or longs, or single-precision floating-point values,
depending on Type
. These values are grouped into sets of one, two, three, or four
values, depending on Format
, to form elements. Each data byte is treated as eight
1-bit elements, with bit ordering determined by ?GL_UNPACK_LSB_FIRST
(see gl:pixelStoref/2
).
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is specified, Data
is treated
as a byte offset into the buffer object's data store.
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.
Format
determines the composition of each element in Data
. It can assume
one of these symbolic values:
?GL_RED
: Each element is a single red component. The GL converts it to floating
point and assembles it into an RGBA element by attaching 0 for green and blue, and 1 for
alpha. Each component is then multiplied by the signed scale factor ?GL_c_SCALE
,
added to the signed bias ?GL_c_BIAS
, and clamped to the range [0,1].
?GL_RG
: Each element is a red and green pair. The GL converts each to floating
point and assembles it into an RGBA element by attaching 0 for blue, and 1 for alpha.
Each component is then multiplied by the signed scale factor ?GL_c_SCALE
, added
to the signed bias ?GL_c_BIAS
, and clamped to the range [0,1].
?GL_RGB
?GL_BGR
: 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. Each component is then multiplied
by the signed scale factor ?GL_c_SCALE
, added to the signed bias ?GL_c_BIAS
,
and clamped to the range [0,1].
?GL_RGBA
?GL_BGRA
: Each element contains all four components. Each component is multiplied
by the signed scale factor ?GL_c_SCALE
, added to the signed bias ?GL_c_BIAS
,
and clamped to the range [0,1].
If an application wants to store the texture at a certain resolution or in a certain
format, it can request the resolution and format with InternalFormat
. The GL will
choose an internal representation that closely approximates that requested by InternalFormat
, but it may not match exactly. (The representations specified by ?GL_RED
, ?GL_RG
, ?GL_RGB
, and ?GL_RGBA
must match exactly.)
InternalFormat
may be one of the base internal formats shown in Table 1, below
InternalFormat
may also be one of the sized internal formats shown in Table 2,
below
Finally, InternalFormat
may also be one of the generic or compressed compressed
texture formats shown in Table 3 below
If the InternalFormat
parameter is one of the generic compressed formats, ?GL_COMPRESSED_RED
, ?GL_COMPRESSED_RG
, ?GL_COMPRESSED_RGB
, or ?GL_COMPRESSED_RGBA
,
the GL will replace the internal format with the symbolic constant for a specific internal
format and compress the texture before storage. If no corresponding internal format is
available, or the GL can not compress that image for any reason, the internal format is
instead replaced with a corresponding base internal format.
If the InternalFormat
parameter is ?GL_SRGB
, ?GL_SRGB8
, ?GL_SRGB_ALPHA
, or ?GL_SRGB8_ALPHA8
, the texture is treated as if the red, green, blue, or
luminance components are encoded in the sRGB color space. Any alpha component is left
unchanged. The conversion from the sRGB encoded component c s to a linear component
c l is:
c l={ c s/12.92if c s≤ 0.04045( c s+0.055/1.055) 2.4if c s> 0.04045
Assume c s is the sRGB component in the range [0,1].
Use the ?GL_PROXY_TEXTURE_3D
target to try out a resolution and format. The implementation
will update and recompute its best match for the requested storage resolution and format.
To then query this state, call gl:getTexLevelParameterfv/3 . If the texture cannot
be accommodated, texture state is set to 0.
A one-component texture image uses only the red component of the RGBA color extracted
from Data
. A two-component image uses the R and A values. A three-component image
uses the R, G, and B values. A four-component image uses all of the RGBA components.
See
texSubImage3D(Target, Level, Xoffset, Yoffset, Zoffset, Width, Height, Depth, Format, Type, Pixels) -> ok
Target = enum()
Level = integer()
Xoffset = integer()
Yoffset = integer()
Zoffset = integer()
Width = integer()
Height = integer()
Depth = integer()
Format = enum()
Type = enum()
Pixels = offset() | mem()
glTexSubImage
See
copyTexSubImage3D(Target, Level, Xoffset, Yoffset, Zoffset, X, Y, Width, Height) -> ok
Target = enum()
Level = integer()
Xoffset = integer()
Yoffset = integer()
Zoffset = integer()
X = integer()
Y = integer()
Width = integer()
Height = integer()
Copy a three-dimensional texture subimage
gl:copyTexSubImage3D
replaces a rectangular portion of a three-dimensional texture
image with pixels from the current ?GL_READ_BUFFER
(rather than from main memory,
as is the case for gl:texSubImage1D/7 ).
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 z index Zoffset
and at the mipmap level
specified by Level
.
The pixels in the rectangle are processed exactly as if gl:readPixels/7 had been called, but the process stops just before final conversion. At this point, all pixel component values are clamped to the range [0 1] and then converted to the texture's internal format for storage in the texel array.
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 ?GL_READ_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
, depth
,
or border
parameters of the specified texture array or to texel values outside
the specified subregion.
See
colorTable(Target, Internalformat, Width, Format, Type, Table) -> ok
Target = enum()
Internalformat = enum()
Width = integer()
Format = enum()
Type = enum()
Table = offset() | mem()
Define a color lookup table
gl:colorTable
may be used in two ways: to test the actual size and color resolution
of a lookup table given a particular set of parameters, or to load the contents of a color
lookup table. Use the targets ?GL_PROXY_*
for the first case and the other targets
for the second case.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a color table is specified, Data
is treated
as a byte offset into the buffer object's data store.
If Target
is ?GL_COLOR_TABLE
, ?GL_POST_CONVOLUTION_COLOR_TABLE
, or ?GL_POST_COLOR_MATRIX_COLOR_TABLE
, gl:colorTable
builds a color lookup table from an array of pixels. The pixel array
specified by Width
, Format
, Type
, and Data
is extracted from
memory and processed just as if gl:drawPixels/5 were called, but processing stops
after the final expansion to RGBA is completed.
The four scale parameters and the four bias parameters that are defined for the table
are then used to scale and bias the R, G, B, and A components of each pixel. (Use gl:colorTableParameter
to set these scale and bias parameters.)
Next, the R, G, B, and A values are clamped to the range [0 1]. Each pixel is then converted
to the internal format specified by Internalformat
. This conversion simply maps
the component values of the pixel (R, G, B, and A) to the values included in the internal
format (red, green, blue, alpha, luminance, and intensity). The mapping is as follows:
Internal Format
Red
Green
Blue
Alpha
Luminance
Intensity
?GL_ALPHA
A
?GL_LUMINANCE
R ?GL_LUMINANCE_ALPHA
A R ?GL_INTENSITY
R ?GL_RGB
R G
B ?GL_RGBA
R
G B A Finally, the red, green, blue, alpha, luminance, and/or intensity components of the resulting pixels are stored in the color table. They form a one-dimensional table with indices in the range [0 width-1].
If Target
is ?GL_PROXY_*
, gl:colorTable
recomputes and stores the
values of the proxy color table's state variables ?GL_COLOR_TABLE_FORMAT
, ?GL_COLOR_TABLE_WIDTH
, ?GL_COLOR_TABLE_RED_SIZE
, ?GL_COLOR_TABLE_GREEN_SIZE
, ?GL_COLOR_TABLE_BLUE_SIZE
, ?GL_COLOR_TABLE_ALPHA_SIZE
, ?GL_COLOR_TABLE_LUMINANCE_SIZE
, and ?GL_COLOR_TABLE_INTENSITY_SIZE
. There is no effect on the image or state of any actual color table. If the specified
color table is too large to be supported, then all the proxy state variables listed above
are set to zero. Otherwise, the color table could be supported by gl:colorTable
using the corresponding non-proxy target, and the proxy state variables are set as if
that target were being defined.
The proxy state variables can be retrieved by calling gl:getColorTableParameterfv/2
with a target of ?GL_PROXY_*
. This allows the application to decide if a particular
gl:colorTable
command would succeed, and to determine what the resulting color table
attributes would be.
If a color table is enabled, and its width is non-zero, then its contents are used to replace a subset of the components of each RGBA pixel group, based on the internal format of the table.
Each pixel group has color components (R, G, B, A) that are in the range [0.0 1.0]. The color components are rescaled to the size of the color lookup table to form an index. Then a subset of the components based on the internal format of the table are replaced by the table entry selected by that index. If the color components and contents of the table are represented as follows:
Representation
Meaning
r Table index computed from R
g Table index computed from G
b Table index computed from B
a Table index computed from A
L[i] Luminance value at table index i
I[i] Intensity value at table index i
R[i] Red value at table index i
G[i] Green value at table index i
B[i] Blue value at table index i
A[i] Alpha value at table index i
then the result of color table lookup is as follows:
Resulting Texture Components
Table Internal Format
R
G
B
A
?GL_ALPHA
RGBA[a]?GL_LUMINANCE
L[r]L[g]L[b]At?GL_LUMINANCE_ALPHA
L[r]L[g]L[b]A[a]?GL_INTENSITY
I[r]I[g]I[b]I[a]?GL_RGB
R[r]
G[g]B[b]A?GL_RGBA
R[r]
G[g]B[b]A[a]When ?GL_COLOR_TABLE
is enabled, the colors resulting from the pixel map operation
(if it is enabled) are mapped by the color lookup table before being passed to the convolution
operation. The colors resulting from the convolution operation are modified by the post
convolution color lookup table when ?GL_POST_CONVOLUTION_COLOR_TABLE
is enabled.
These modified colors are then sent to the color matrix operation. Finally, if ?GL_POST_COLOR_MATRIX_COLOR_TABLE
is enabled, the colors resulting from the color matrix operation are mapped by the post
color matrix color lookup table before being used by the histogram operation.
See
colorTableParameterfv(Target, Pname, Params) -> ok
Target = enum()
Pname = enum()
Params = {float(), float(), float(), float()}
Set color lookup table parameters
gl:colorTableParameter
is used to specify the scale factors and bias terms applied
to color components when they are loaded into a color table. Target
indicates which
color table the scale and bias terms apply to; it must be set to ?GL_COLOR_TABLE
, ?GL_POST_CONVOLUTION_COLOR_TABLE
, or ?GL_POST_COLOR_MATRIX_COLOR_TABLE
.
Pname
must be ?GL_COLOR_TABLE_SCALE
to set the scale factors. In this case,
Params
points to an array of four values, which are the scale factors for red,
green, blue, and alpha, in that order.
Pname
must be ?GL_COLOR_TABLE_BIAS
to set the bias terms. In this case, Params
points to an array of four values, which are the bias terms for red, green, blue, and
alpha, in that order.
The color tables themselves are specified by calling gl:colorTable/6 .
See
colorTableParameteriv(Target, Pname, Params) -> ok
Target = enum()
Pname = enum()
Params = {integer(), integer(), integer(), integer()}
copyColorTable(Target, Internalformat, X, Y, Width) -> ok
Target = enum()
Internalformat = enum()
X = integer()
Y = integer()
Width = integer()
Copy pixels into a color table
gl:copyColorTable
loads a color table with pixels from the current ?GL_READ_BUFFER
(rather than from main memory, as is the case for gl:colorTable/6 ).
The screen-aligned pixel rectangle with lower-left corner at ( X
, Y
) having
width Width
and height 1 is loaded into the color table. If any pixels within this
region are outside the window that is associated with the GL context, the values obtained
for those pixels are undefined.
The pixels in the rectangle are processed just as if gl:readPixels/7 were called,
with Internalformat
set to RGBA, but processing stops after the final conversion
to RGBA.
The four scale parameters and the four bias parameters that are defined for the table are then used to scale and bias the R, G, B, and A components of each pixel. The scale and bias parameters are set by calling gl:colorTableParameterfv/3 .
Next, the R, G, B, and A values are clamped to the range [0 1]. Each pixel is then converted
to the internal format specified by Internalformat
. This conversion simply maps
the component values of the pixel (R, G, B, and A) to the values included in the internal
format (red, green, blue, alpha, luminance, and intensity). The mapping is as follows:
Internal Format
Red
Green
Blue
Alpha
Luminance
Intensity
?GL_ALPHA
A
?GL_LUMINANCE
R ?GL_LUMINANCE_ALPHA
A R ?GL_INTENSITY
R ?GL_RGB
R G
B ?GL_RGBA
R
G B A Finally, the red, green, blue, alpha, luminance, and/or intensity components of the resulting pixels are stored in the color table. They form a one-dimensional table with indices in the range [0 width-1].
See
getColorTable(Target, Format, Type, Table) -> ok
Target = enum()
Format = enum()
Type = enum()
Table = mem()
Retrieve contents of a color lookup table
gl:getColorTable
returns in Table
the contents of the color table specified
by Target
. No pixel transfer operations are performed, but pixel storage modes
that are applicable to gl:readPixels/7 are performed.
If a non-zero named buffer object is bound to the ?GL_PIXEL_PACK_BUFFER
target
(see gl:bindBuffer/2 ) while a histogram table is requested, Table
is treated
as a byte offset into the buffer object's data store.
Color components that are requested in the specified Format
, but which are not
included in the internal format of the color lookup table, are returned as zero. The assignments
of internal color components to the components requested by Format
are
Internal Component
Resulting Component
Red Red
Green Green
Blue Blue
Alpha Alpha
Luminance Red
Intensity Red
See
getColorTableParameterfv(Target, Pname) -> {float(), float(), float(), float()}
Target = enum()
Pname = enum()
Get color lookup table parameters
Returns parameters specific to color table Target
.
When Pname
is set to ?GL_COLOR_TABLE_SCALE
or ?GL_COLOR_TABLE_BIAS
,
gl:getColorTableParameter
returns the color table scale or bias parameters for the
table specified by Target
. For these queries, Target
must be set to ?GL_COLOR_TABLE
, ?GL_POST_CONVOLUTION_COLOR_TABLE
, or ?GL_POST_COLOR_MATRIX_COLOR_TABLE
and Params
points to an array of four elements, which receive the scale or bias
factors for red, green, blue, and alpha, in that order.
gl:getColorTableParameter
can also be used to retrieve the format and size parameters
for a color table. For these queries, set Target
to either the color table target
or the proxy color table target. The format and size parameters are set by gl:colorTable/6
.
The following table lists the format and size parameters that may be queried. For each
symbolic constant listed below for Pname
, Params
must point to an array
of the given length and receive the values indicated.
Parameter
N
Meaning
?GL_COLOR_TABLE_FORMAT
1 Internal format
(e.g., ?GL_RGBA
) ?GL_COLOR_TABLE_WIDTH
1
Number of elements in table ?GL_COLOR_TABLE_RED_SIZE
1 Size of red component, in bits ?GL_COLOR_TABLE_GREEN_SIZE
1 Size of green component ?GL_COLOR_TABLE_BLUE_SIZE
1 Size of blue component ?GL_COLOR_TABLE_ALPHA_SIZE
1 Size of alpha component ?GL_COLOR_TABLE_LUMINANCE_SIZE
1 Size of luminance component ?GL_COLOR_TABLE_INTENSITY_SIZE
1 Size of intensity component See
getColorTableParameteriv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Target = enum()
Pname = enum()
colorSubTable(Target, Start, Count, Format, Type, Data) -> ok
Target = enum()
Start = integer()
Count = integer()
Format = enum()
Type = enum()
Data = offset() | mem()
Respecify a portion of a color table
gl:colorSubTable
is used to respecify a contiguous portion of a color table previously
defined using gl:colorTable/6 . The pixels referenced by Data
replace the
portion of the existing table from indices Start
to start+count-1, inclusive.
This region may not include any entries outside the range of the color table as it was
originally specified. It is not an error to specify a subtexture with width of 0, but
such a specification has no effect.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a portion of a color table is respecified, Data
is treated as a byte offset into the buffer object's data store.
See
copyColorSubTable(Target, Start, X, Y, Width) -> ok
Target = enum()
Start = integer()
X = integer()
Y = integer()
Width = integer()
Respecify a portion of a color table
gl:copyColorSubTable
is used to respecify a contiguous portion of a color table
previously defined using gl:colorTable/6 . The pixels copied from the framebuffer
replace the portion of the existing table from indices Start
to start+x-1, inclusive.
This region may not include any entries outside the range of the color table, as was originally
specified. It is not an error to specify a subtexture with width of 0, but such a specification
has no effect.
See
convolutionFilter1D(Target, Internalformat, Width, Format, Type, Image) -> ok
Target = enum()
Internalformat = enum()
Width = integer()
Format = enum()
Type = enum()
Image = offset() | mem()
Define a one-dimensional convolution filter
gl:convolutionFilter1D
builds a one-dimensional convolution filter kernel from an
array of pixels.
The pixel array specified by Width
, Format
, Type
, and Data
is extracted from memory and processed just as if gl:drawPixels/5 were called,
but processing stops after the final expansion to RGBA is completed.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a convolution filter is specified, Data
is
treated as a byte offset into the buffer object's data store.
The R, G, B, and A components of each pixel are next scaled by the four 1D ?GL_CONVOLUTION_FILTER_SCALE
parameters and biased by the four 1D ?GL_CONVOLUTION_FILTER_BIAS
parameters. (The
scale and bias parameters are set by gl:convolutionParameterf/3 using the ?GL_CONVOLUTION_1D
target and the names ?GL_CONVOLUTION_FILTER_SCALE
and ?GL_CONVOLUTION_FILTER_BIAS
. The parameters themselves are vectors of four values that are applied to red, green,
blue, and alpha, in that order.) The R, G, B, and A values are not clamped to [0,1] at
any time during this process.
Each pixel is then converted to the internal format specified by Internalformat
.
This conversion simply maps the component values of the pixel (R, G, B, and A) to the
values included in the internal format (red, green, blue, alpha, luminance, and intensity).
The mapping is as follows:
Internal Format
Red
Green
Blue
Alpha
Luminance
Intensity
?GL_ALPHA
A
?GL_LUMINANCE
R ?GL_LUMINANCE_ALPHA
A R ?GL_INTENSITY
R ?GL_RGB
R G
B ?GL_RGBA
R
G B A The red, green, blue, alpha, luminance, and/or intensity components of the resulting
pixels are stored in floating-point rather than integer format. They form a one-dimensional
filter kernel image indexed with coordinate i
such that i
starts at 0 and
increases from left to right. Kernel location i
is derived from the i
th
pixel, counting from 0.
Note that after a convolution is performed, the resulting color components are also scaled
by their corresponding ?GL_POST_CONVOLUTION_c_SCALE
parameters and biased by their
corresponding ?GL_POST_CONVOLUTION_c_BIAS
parameters (where c
takes on the
values RED
, GREEN
, BLUE
, and ALPHA
). These parameters are
set by gl:pixelTransferf/2 .
See
convolutionFilter2D(Target, Internalformat, Width, Height, Format, Type, Image) -> ok
Target = enum()
Internalformat = enum()
Width = integer()
Height = integer()
Format = enum()
Type = enum()
Image = offset() | mem()
Define a two-dimensional convolution filter
gl:convolutionFilter2D
builds a two-dimensional convolution filter kernel from an
array of pixels.
The pixel array specified by Width
, Height
, Format
, Type
,
and Data
is extracted from memory and processed just as if gl:drawPixels/5
were called, but processing stops after the final expansion to RGBA is completed.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a convolution filter is specified, Data
is
treated as a byte offset into the buffer object's data store.
The R, G, B, and A components of each pixel are next scaled by the four 2D ?GL_CONVOLUTION_FILTER_SCALE
parameters and biased by the four 2D ?GL_CONVOLUTION_FILTER_BIAS
parameters. (The
scale and bias parameters are set by gl:convolutionParameterf/3 using the ?GL_CONVOLUTION_2D
target and the names ?GL_CONVOLUTION_FILTER_SCALE
and ?GL_CONVOLUTION_FILTER_BIAS
. The parameters themselves are vectors of four values that are applied to red, green,
blue, and alpha, in that order.) The R, G, B, and A values are not clamped to [0,1] at
any time during this process.
Each pixel is then converted to the internal format specified by Internalformat
.
This conversion simply maps the component values of the pixel (R, G, B, and A) to the
values included in the internal format (red, green, blue, alpha, luminance, and intensity).
The mapping is as follows:
Internal Format
Red
Green
Blue
Alpha
Luminance
Intensity
?GL_ALPHA
A
?GL_LUMINANCE
R ?GL_LUMINANCE_ALPHA
A R ?GL_INTENSITY
R ?GL_RGB
R G
B ?GL_RGBA
R
G B A The red, green, blue, alpha, luminance, and/or intensity components of the resulting
pixels are stored in floating-point rather than integer format. They form a two-dimensional
filter kernel image indexed with coordinates i
and j
such that i
starts at zero and increases from left to right, and j
starts at zero and increases
from bottom to top. Kernel location i,j
is derived from the N
th pixel, where
N
is i
+j
* Width
.
Note that after a convolution is performed, the resulting color components are also scaled
by their corresponding ?GL_POST_CONVOLUTION_c_SCALE
parameters and biased by their
corresponding ?GL_POST_CONVOLUTION_c_BIAS
parameters (where c
takes on the
values RED
, GREEN
, BLUE
, and ALPHA
). These parameters are
set by gl:pixelTransferf/2 .
See
convolutionParameterf(Target, Pname, Params) -> ok
Target = enum()
Pname = enum()
Params = {float()}
Set convolution parameters
gl:convolutionParameter
sets the value of a convolution parameter.
Target
selects the convolution filter to be affected: ?GL_CONVOLUTION_1D
, ?GL_CONVOLUTION_2D
, or ?GL_SEPARABLE_2D
for the 1D, 2D, or separable 2D filter, respectively.
Pname
selects the parameter to be changed. ?GL_CONVOLUTION_FILTER_SCALE
and ?GL_CONVOLUTION_FILTER_BIAS
affect the definition of the convolution filter
kernel; see gl:convolutionFilter1D/6 , gl:convolutionFilter2D/7 , and gl:separableFilter2D/8
for details. In these cases, Params
v is an array of four values to be applied
to red, green, blue, and alpha values, respectively. The initial value for ?GL_CONVOLUTION_FILTER_SCALE
is (1, 1, 1, 1), and the initial value for ?GL_CONVOLUTION_FILTER_BIAS
is (0,
0, 0, 0).
A Pname
value of ?GL_CONVOLUTION_BORDER_MODE
controls the convolution border
mode. The accepted modes are:
?GL_REDUCE
: The image resulting from convolution is smaller than the source image.
If the filter width is Wf and height is Hf, and the source image width is Ws and
height is Hs, then the convolved image width will be Ws-Wf+1 and height will be Hs-Hf
+1. (If this reduction would generate an image with zero or negative width and/or height,
the output is simply null, with no error generated.) The coordinates of the image resulting
from convolution are zero through Ws-Wf in width and zero through Hs-Hf in height.
?GL_CONSTANT_BORDER
: The image resulting from convolution is the same size as
the source image, and processed as if the source image were surrounded by pixels with
their color specified by the ?GL_CONVOLUTION_BORDER_COLOR
.
?GL_REPLICATE_BORDER
: The image resulting from convolution is the same size as
the source image, and processed as if the outermost pixel on the border of the source
image were replicated.
See
convolutionParameterfv(Target::enum(), Pname::enum(), Params) -> ok
Params = {Params::{float()}}
Equivalent to convolutionParameterf(Target, Pname, Params).
convolutionParameteri(Target, Pname, Params) -> ok
Target = enum()
Pname = enum()
Params = {integer()}
convolutionParameteriv(Target::enum(), Pname::enum(), Params) -> ok
Params = {Params::{integer()}}
Equivalent to convolutionParameteri(Target, Pname, Params).
copyConvolutionFilter1D(Target, Internalformat, X, Y, Width) -> ok
Target = enum()
Internalformat = enum()
X = integer()
Y = integer()
Width = integer()
Copy pixels into a one-dimensional convolution filter
gl:copyConvolutionFilter1D
defines a one-dimensional convolution filter kernel with
pixels from the current ?GL_READ_BUFFER
(rather than from main memory, as is the
case for gl:convolutionFilter1D/6 ).
The screen-aligned pixel rectangle with lower-left corner at ( X
, Y
), width
Width
and height 1 is used to define the convolution filter. If any pixels within
this region are outside the window that is associated with the GL context, the values
obtained for those pixels are undefined.
The pixels in the rectangle are processed exactly as if gl:readPixels/7 had been
called with format
set to RGBA, but the process stops just before final conversion.
The R, G, B, and A components of each pixel are next scaled by the four 1D ?GL_CONVOLUTION_FILTER_SCALE
parameters and biased by the four 1D ?GL_CONVOLUTION_FILTER_BIAS
parameters. (The
scale and bias parameters are set by gl:convolutionParameterf/3 using the ?GL_CONVOLUTION_1D
target and the names ?GL_CONVOLUTION_FILTER_SCALE
and ?GL_CONVOLUTION_FILTER_BIAS
. The parameters themselves are vectors of four values that are applied to red, green,
blue, and alpha, in that order.) The R, G, B, and A values are not clamped to [0,1] at
any time during this process.
Each pixel is then converted to the internal format specified by Internalformat
.
This conversion simply maps the component values of the pixel (R, G, B, and A) to the
values included in the internal format (red, green, blue, alpha, luminance, and intensity).
The mapping is as follows:
Internal Format
Red
Green
Blue
Alpha
Luminance
Intensity
?GL_ALPHA
A
?GL_LUMINANCE
R ?GL_LUMINANCE_ALPHA
A R ?GL_INTENSITY
R ?GL_RGB
R G
B ?GL_RGBA
R
G B A The red, green, blue, alpha, luminance, and/or intensity components of the resulting pixels are stored in floating-point rather than integer format.
Pixel ordering is such that lower x screen coordinates correspond to lower i
filter
image coordinates.
Note that after a convolution is performed, the resulting color components are also scaled
by their corresponding ?GL_POST_CONVOLUTION_c_SCALE
parameters and biased by their
corresponding ?GL_POST_CONVOLUTION_c_BIAS
parameters (where c
takes on the
values RED
, GREEN
, BLUE
, and ALPHA
). These parameters are
set by gl:pixelTransferf/2 .
See
copyConvolutionFilter2D(Target, Internalformat, X, Y, Width, Height) -> ok
Target = enum()
Internalformat = enum()
X = integer()
Y = integer()
Width = integer()
Height = integer()
Copy pixels into a two-dimensional convolution filter
gl:copyConvolutionFilter2D
defines a two-dimensional convolution filter kernel with
pixels from the current ?GL_READ_BUFFER
(rather than from main memory, as is the
case for gl:convolutionFilter2D/7 ).
The screen-aligned pixel rectangle with lower-left corner at ( X
, Y
), width
Width
and height Height
is used to define the convolution filter. If any
pixels within this region are outside the window that is associated with the GL context,
the values obtained for those pixels are undefined.
The pixels in the rectangle are processed exactly as if gl:readPixels/7 had been
called with format
set to RGBA, but the process stops just before final conversion.
The R, G, B, and A components of each pixel are next scaled by the four 2D ?GL_CONVOLUTION_FILTER_SCALE
parameters and biased by the four 2D ?GL_CONVOLUTION_FILTER_BIAS
parameters. (The
scale and bias parameters are set by gl:convolutionParameterf/3 using the ?GL_CONVOLUTION_2D
target and the names ?GL_CONVOLUTION_FILTER_SCALE
and ?GL_CONVOLUTION_FILTER_BIAS
. The parameters themselves are vectors of four values that are applied to red, green,
blue, and alpha, in that order.) The R, G, B, and A values are not clamped to [0,1] at
any time during this process.
Each pixel is then converted to the internal format specified by Internalformat
.
This conversion simply maps the component values of the pixel (R, G, B, and A) to the
values included in the internal format (red, green, blue, alpha, luminance, and intensity).
The mapping is as follows:
Internal Format
Red
Green
Blue
Alpha
Luminance
Intensity
?GL_ALPHA
A
?GL_LUMINANCE
R ?GL_LUMINANCE_ALPHA
A R ?GL_INTENSITY
R ?GL_RGB
R G
B ?GL_RGBA
R
G B A The red, green, blue, alpha, luminance, and/or intensity components of the resulting pixels are stored in floating-point rather than integer format.
Pixel ordering is such that lower x screen coordinates correspond to lower i
filter
image coordinates, and lower y screen coordinates correspond to lower j
filter
image coordinates.
Note that after a convolution is performed, the resulting color components are also scaled
by their corresponding ?GL_POST_CONVOLUTION_c_SCALE
parameters and biased by their
corresponding ?GL_POST_CONVOLUTION_c_BIAS
parameters (where c
takes on the
values RED
, GREEN
, BLUE
, and ALPHA
). These parameters are
set by gl:pixelTransferf/2 .
See
getConvolutionFilter(Target, Format, Type, Image) -> ok
Target = enum()
Format = enum()
Type = enum()
Image = mem()
Get current 1D or 2D convolution filter kernel
gl:getConvolutionFilter
returns the current 1D or 2D convolution filter kernel as
an image. The one- or two-dimensional image is placed in Image
according to the
specifications in Format
and Type
. No pixel transfer operations are performed
on this image, but the relevant pixel storage modes are applied.
If a non-zero named buffer object is bound to the ?GL_PIXEL_PACK_BUFFER
target
(see gl:bindBuffer/2 ) while a convolution filter is requested, Image
is
treated as a byte offset into the buffer object's data store.
Color components that are present in Format
but not included in the internal format
of the filter are returned as zero. The assignments of internal color components to the
components of Format
are as follows.
Internal Component
Resulting Component
Red Red
Green Green
Blue Blue
Alpha Alpha
Luminance Red
Intensity Red
See
getConvolutionParameterfv(Target, Pname) -> {float(), float(), float(), float()}
Target = enum()
Pname = enum()
Get convolution parameters
gl:getConvolutionParameter
retrieves convolution parameters. Target
determines
which convolution filter is queried. Pname
determines which parameter is returned:
?GL_CONVOLUTION_BORDER_MODE
: The convolution border mode. See gl:convolutionParameterf/3
for a list of border modes.
?GL_CONVOLUTION_BORDER_COLOR
: The current convolution border color. Params
must be a pointer to an array of four elements, which will receive the red, green, blue,
and alpha border colors.
?GL_CONVOLUTION_FILTER_SCALE
: The current filter scale factors. Params
must be a pointer to an array of four elements, which will receive the red, green, blue,
and alpha filter scale factors in that order.
?GL_CONVOLUTION_FILTER_BIAS
: The current filter bias factors. Params
must
be a pointer to an array of four elements, which will receive the red, green, blue, and
alpha filter bias terms in that order.
?GL_CONVOLUTION_FORMAT
: The current internal format. See gl:convolutionFilter1D/6
, gl:convolutionFilter2D/7 , and gl:separableFilter2D/8 for lists of allowable
formats.
?GL_CONVOLUTION_WIDTH
: The current filter image width.
?GL_CONVOLUTION_HEIGHT
: The current filter image height.
?GL_MAX_CONVOLUTION_WIDTH
: The maximum acceptable filter image width.
?GL_MAX_CONVOLUTION_HEIGHT
: The maximum acceptable filter image height.
See
getConvolutionParameteriv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Target = enum()
Pname = enum()
separableFilter2D(Target, Internalformat, Width, Height, Format, Type, Row, Column) -> ok
Target = enum()
Internalformat = enum()
Width = integer()
Height = integer()
Format = enum()
Type = enum()
Row = offset() | mem()
Column = offset() | mem()
Define a separable two-dimensional convolution filter
gl:separableFilter2D
builds a two-dimensional separable convolution filter kernel
from two arrays of pixels.
The pixel arrays specified by ( Width
, Format
, Type
, Row
)
and ( Height
, Format
, Type
, Column
) are processed just as if
they had been passed to gl:drawPixels/5 , but processing stops after the final expansion
to RGBA is completed.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a convolution filter is specified, Row
and Column
are treated as byte offsets into the buffer object's data store.
Next, the R, G, B, and A components of all pixels in both arrays are scaled by the four
separable 2D ?GL_CONVOLUTION_FILTER_SCALE
parameters and biased by the four separable
2D ?GL_CONVOLUTION_FILTER_BIAS
parameters. (The scale and bias parameters are set
by gl:convolutionParameterf/3 using the ?GL_SEPARABLE_2D
target and the names
?GL_CONVOLUTION_FILTER_SCALE
and ?GL_CONVOLUTION_FILTER_BIAS
. The parameters
themselves are vectors of four values that are applied to red, green, blue, and alpha,
in that order.) The R, G, B, and A values are not clamped to [0,1] at any time during
this process.
Each pixel is then converted to the internal format specified by Internalformat
.
This conversion simply maps the component values of the pixel (R, G, B, and A) to the
values included in the internal format (red, green, blue, alpha, luminance, and intensity).
The mapping is as follows:
Internal Format
Red
Green
Blue
Alpha
Luminance
Intensity
?GL_LUMINANCE
R ?GL_LUMINANCE_ALPHA
A R ?GL_INTENSITY
R ?GL_RGB
R G B ?GL_RGBA
R G B A The red, green, blue, alpha, luminance, and/or intensity components of the resulting
pixels are stored in floating-point rather than integer format. They form two one-dimensional
filter kernel images. The row image is indexed by coordinate i
starting at zero
and increasing from left to right. Each location in the row image is derived from element
i
of Row
. The column image is indexed by coordinate j
starting at
zero and increasing from bottom to top. Each location in the column image is derived from
element j
of Column
.
Note that after a convolution is performed, the resulting color components are also scaled
by their corresponding ?GL_POST_CONVOLUTION_c_SCALE
parameters and biased by their
corresponding ?GL_POST_CONVOLUTION_c_BIAS
parameters (where c
takes on the
values RED
, GREEN
, BLUE
, and ALPHA
). These parameters are
set by gl:pixelTransferf/2 .
See
getHistogram(Target, Reset, Format, Type, Values) -> ok
Target = enum()
Reset = 0 | 1
Format = enum()
Type = enum()
Values = mem()
Get histogram table
gl:getHistogram
returns the current histogram table as a one-dimensional image with
the same width as the histogram. No pixel transfer operations are performed on this image,
but pixel storage modes that are applicable to 1D images are honored.
If a non-zero named buffer object is bound to the ?GL_PIXEL_PACK_BUFFER
target
(see gl:bindBuffer/2 ) while a histogram table is requested, Values
is treated
as a byte offset into the buffer object's data store.
Color components that are requested in the specified Format
, but which are not
included in the internal format of the histogram, are returned as zero. The assignments
of internal color components to the components requested by Format
are:
Internal Component
Resulting Component
Red Red
Green Green
Blue Blue
Alpha Alpha
Luminance Red
See
getHistogramParameterfv(Target, Pname) -> {float()}
Target = enum()
Pname = enum()
Get histogram parameters
gl:getHistogramParameter
is used to query parameter values for the current histogram
or for a proxy. The histogram state information may be queried by calling gl:getHistogramParameter
with a Target
of ?GL_HISTOGRAM
(to obtain information for the current histogram
table) or ?GL_PROXY_HISTOGRAM
(to obtain information from the most recent proxy
request) and one of the following values for the Pname
argument:
Parameter
Description
?GL_HISTOGRAM_WIDTH
Histogram table width ?GL_HISTOGRAM_FORMAT
Internal format ?GL_HISTOGRAM_RED_SIZE
Red
component counter size, in bits ?GL_HISTOGRAM_GREEN_SIZE
Green component counter size, in bits ?GL_HISTOGRAM_BLUE_SIZE
Blue component counter size, in bits ?GL_HISTOGRAM_ALPHA_SIZE
Alpha component counter size, in bits ?GL_HISTOGRAM_LUMINANCE_SIZE
Luminance component counter size, in bits ?GL_HISTOGRAM_SINK
Value of the sink
parameter See
getHistogramParameteriv(Target, Pname) -> {integer()}
Target = enum()
Pname = enum()
getMinmax(Target, Reset, Format, Types, Values) -> ok
Target = enum()
Reset = 0 | 1
Format = enum()
Types = enum()
Values = mem()
Get minimum and maximum pixel values
gl:getMinmax
returns the accumulated minimum and maximum pixel values (computed
on a per-component basis) in a one-dimensional image of width 2. The first set of return
values are the minima, and the second set of return values are the maxima. The format
of the return values is determined by Format
, and their type is determined by Types
.
If a non-zero named buffer object is bound to the ?GL_PIXEL_PACK_BUFFER
target
(see gl:bindBuffer/2 ) while minimum and maximum pixel values are requested, Values
is treated as a byte offset into the buffer object's data store.
No pixel transfer operations are performed on the return values, but pixel storage modes
that are applicable to one-dimensional images are performed. Color components that are
requested in the specified Format
, but that are not included in the internal format
of the minmax table, are returned as zero. The assignment of internal color components
to the components requested by Format
are as follows:
Internal Component
Resulting Component
Red Red
Green Green
Blue Blue
Alpha Alpha
Luminance Red
If Reset
is ?GL_TRUE
, the minmax table entries corresponding to the return
values are reset to their initial values. Minimum and maximum values that are not returned
are not modified, even if Reset
is ?GL_TRUE
.
See
getMinmaxParameterfv(Target, Pname) -> {float()}
Target = enum()
Pname = enum()
Get minmax parameters
gl:getMinmaxParameter
retrieves parameters for the current minmax table by setting Pname
to one of the following values:
Parameter
Description
?GL_MINMAX_FORMAT
Internal format of minmax table ?GL_MINMAX_SINK
Value of the sink
parameter See
getMinmaxParameteriv(Target, Pname) -> {integer()}
Target = enum()
Pname = enum()
histogram(Target, Width, Internalformat, Sink) -> ok
Target = enum()
Width = integer()
Internalformat = enum()
Sink = 0 | 1
Define histogram table
When ?GL_HISTOGRAM
is enabled, RGBA color components are converted to histogram
table indices by clamping to the range [0,1], multiplying by the width of the histogram
table, and rounding to the nearest integer. The table entries selected by the RGBA indices
are then incremented. (If the internal format of the histogram table includes luminance,
then the index derived from the R color component determines the luminance table entry
to be incremented.) If a histogram table entry is incremented beyond its maximum value,
then its value becomes undefined. (This is not an error.)
Histogramming is performed only for RGBA pixels (though these may be specified originally as color indices and converted to RGBA by index table lookup). Histogramming is enabled with gl:enable/1 and disabled with gl:enable/1 .
When Target
is ?GL_HISTOGRAM
, gl:histogram
redefines the current
histogram table to have Width
entries of the format specified by Internalformat
. The entries are indexed 0 through width-1, and all entries are initialized to zero.
The values in the previous histogram table, if any, are lost. If Sink
is ?GL_TRUE
, then pixels are discarded after histogramming; no further processing of the pixels takes
place, and no drawing, texture loading, or pixel readback will result.
When Target
is ?GL_PROXY_HISTOGRAM
, gl:histogram
computes all state
information as if the histogram table were to be redefined, but does not actually define
the new table. If the requested histogram table is too large to be supported, then the
state information will be set to zero. This provides a way to determine if a histogram
table with the given parameters can be supported.
See
minmax(Target, Internalformat, Sink) -> ok
Target = enum()
Internalformat = enum()
Sink = 0 | 1
Define minmax table
When ?GL_MINMAX
is enabled, the RGBA components of incoming pixels are compared
to the minimum and maximum values for each component, which are stored in the two-element
minmax table. (The first element stores the minima, and the second element stores the
maxima.) If a pixel component is greater than the corresponding component in the maximum
element, then the maximum element is updated with the pixel component value. If a pixel
component is less than the corresponding component in the minimum element, then the minimum
element is updated with the pixel component value. (In both cases, if the internal format
of the minmax table includes luminance, then the R color component of incoming pixels
is used for comparison.) The contents of the minmax table may be retrieved at a later
time by calling gl:getMinmax/5 . The minmax operation is enabled or disabled by
calling gl:enable/1 or gl:enable/1 , respectively, with an argument of ?GL_MINMAX
.
gl:minmax
redefines the current minmax table to have entries of the format specified
by Internalformat
. The maximum element is initialized with the smallest possible
component values, and the minimum element is initialized with the largest possible component
values. The values in the previous minmax table, if any, are lost. If Sink
is ?GL_TRUE
, then pixels are discarded after minmax; no further processing of the pixels takes place,
and no drawing, texture loading, or pixel readback will result.
See
resetHistogram(Target) -> ok
Target = enum()
Reset histogram table entries to zero
gl:resetHistogram
resets all the elements of the current histogram table to zero.
See
resetMinmax(Target) -> ok
Target = enum()
Reset minmax table entries to initial values
gl:resetMinmax
resets the elements of the current minmax table to their initial
values: the maximum
element receives the minimum possible component values, and the
minimum
element receives the maximum possible component values.
See
activeTexture(Texture) -> ok
Texture = enum()
Select active texture unit
gl:activeTexture
selects which texture unit subsequent texture state calls will
affect. The number of texture units an implementation supports is implementation dependent,
but must be at least 80.
See
sampleCoverage(Value, Invert) -> ok
Value = clamp()
Invert = 0 | 1
Specify multisample coverage parameters
Multisampling samples a pixel multiple times at various implementation-dependent subpixel locations to generate antialiasing effects. Multisampling transparently antialiases points, lines, polygons, and images if it is enabled.
Value
is used in constructing a temporary mask used in determining which samples
will be used in resolving the final fragment color. This mask is bitwise-anded with the
coverage mask generated from the multisampling computation. If the Invert
flag
is set, the temporary mask is inverted (all bits flipped) and then the bitwise-and is
computed.
If an implementation does not have any multisample buffers available, or multisampling is disabled, rasterization occurs with only a single sample computing a pixel's final RGB color.
Provided an implementation supports multisample buffers, and multisampling is enabled, then a pixel's final color is generated by combining several samples per pixel. Each sample contains color, depth, and stencil information, allowing those operations to be performed on each sample.
See
compressedTexImage3D(Target, Level, Internalformat, Width, Height, Depth, Border, ImageSize, Data) -> ok
Target = enum()
Level = integer()
Internalformat = enum()
Width = integer()
Height = integer()
Depth = integer()
Border = integer()
ImageSize = integer()
Data = offset() | mem()
Specify a three-dimensional texture image in a compressed format
Texturing allows elements of an image array to be read by shaders.
gl:compressedTexImage3D
loads a previously defined, and retrieved, compressed three-dimensional
texture image if Target
is ?GL_TEXTURE_3D
(see gl:texImage3D/10 ).
If Target
is ?GL_TEXTURE_2D_ARRAY
, Data
is treated as an array of
compressed 2D textures.
If Target
is ?GL_PROXY_TEXTURE_3D
or ?GL_PROXY_TEXTURE_2D_ARRAY
,
no data is read from Data
, but all of the texture image state is recalculated,
checked for consistency, and checked against the implementation's capabilities. If the
implementation cannot handle a texture of the requested texture size, it sets all of the
image state to 0, but does not generate an error (see gl:getError/0 ). To query
for an entire mipmap array, use an image array level greater than or equal to 1.
Internalformat
must be a known compressed image format (such as ?GL_RGTC
)
or an extension-specified compressed-texture format. When a texture is loaded with gl:texImage2D/9
using a generic compressed texture format (e.g., ?GL_COMPRESSED_RGB
), the GL selects
from one of its extensions supporting compressed textures. In order to load the compressed
texture image using gl:compressedTexImage3D
, query the compressed texture image's
size and format using gl:getTexLevelParameterfv/3 .
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is specified, Data
is treated
as a byte offset into the buffer object's data store.
If the compressed data are arranged into fixed-size blocks of texels, the pixel storage
modes can be used to select a sub-rectangle from a larger containing rectangle. These
pixel storage modes operate in the same way as they do for gl:texImage1D/8 . In
the following description, denote by b s, b w, b h, and b d, the values of pixel storage
modes ?GL_UNPACK_COMPRESSED_BLOCK_SIZE
, ?GL_UNPACK_COMPRESSED_BLOCK_WIDTH
, ?GL_UNPACK_COMPRESSED_BLOCK_HEIGHT
, and ?GL_UNPACK_COMPRESSED_BLOCK_DEPTH
, respectively. b s is the compressed block
size in bytes; b w, b h, and b d are the compressed block width, height, and depth
in pixels.
By default the pixel storage modes ?GL_UNPACK_ROW_LENGTH
, ?GL_UNPACK_SKIP_ROWS
, ?GL_UNPACK_SKIP_PIXELS
, ?GL_UNPACK_IMAGE_HEIGHT
and ?GL_UNPACK_SKIP_IMAGES
are ignored for compressed images. To enable ?GL_UNPACK_SKIP_PIXELS
and ?GL_UNPACK_ROW_LENGTH
, b s and b w must both be non-zero. To also enable ?GL_UNPACK_SKIP_ROWS
and ?GL_UNPACK_IMAGE_HEIGHT
, b h must be non-zero. To also enable ?GL_UNPACK_SKIP_IMAGES
, b d must be non-zero.
All parameters must be consistent with the compressed format to produce the desired results.
When selecting a sub-rectangle from a compressed image: the value of ?GL_UNPACK_SKIP_PIXELS
must be a multiple of b w;the value of ?GL_UNPACK_SKIP_ROWS
must be a multiple
of b w;the value of ?GL_UNPACK_SKIP_IMAGES
must be a multiple of b w.
ImageSize
must be equal to:
b s×|width b/w|×|height b/h|×|depth b/d|
See
compressedTexImage2D(Target, Level, Internalformat, Width, Height, Border, ImageSize, Data) -> ok
Target = enum()
Level = integer()
Internalformat = enum()
Width = integer()
Height = integer()
Border = integer()
ImageSize = integer()
Data = offset() | mem()
Specify a two-dimensional texture image in a compressed format
Texturing allows elements of an image array to be read by shaders.
gl:compressedTexImage2D
loads a previously defined, and retrieved, compressed two-dimensional
texture image if Target
is ?GL_TEXTURE_2D
, or one of the cube map faces
such as ?GL_TEXTURE_CUBE_MAP_POSITIVE_X
. (see gl:texImage2D/9 ).
If Target
is ?GL_TEXTURE_1D_ARRAY
, Data
is treated as an array of
compressed 1D textures.
If Target
is ?GL_PROXY_TEXTURE_2D
, ?GL_PROXY_TEXTURE_1D_ARRAY
or ?GL_PROXY_CUBE_MAP
, no data is read from Data
, but all of the texture image state is recalculated,
checked for consistency, and checked against the implementation's capabilities. If the
implementation cannot handle a texture of the requested texture size, it sets all of the
image state to 0, but does not generate an error (see gl:getError/0 ). To query
for an entire mipmap array, use an image array level greater than or equal to 1.
Internalformat
must be a known compressed image format (such as ?GL_RGTC
)
or an extension-specified compressed-texture format. When a texture is loaded with gl:texImage2D/9
using a generic compressed texture format (e.g., ?GL_COMPRESSED_RGB
), the GL selects
from one of its extensions supporting compressed textures. In order to load the compressed
texture image using gl:compressedTexImage2D
, query the compressed texture image's
size and format using gl:getTexLevelParameterfv/3 .
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is specified, Data
is treated
as a byte offset into the buffer object's data store.
If the compressed data are arranged into fixed-size blocks of texels, the pixel storage
modes can be used to select a sub-rectangle from a larger containing rectangle. These
pixel storage modes operate in the same way as they do for gl:texImage2D/9 . In
the following description, denote by b s, b w, b h, and b d, the values of pixel storage
modes ?GL_UNPACK_COMPRESSED_BLOCK_SIZE
, ?GL_UNPACK_COMPRESSED_BLOCK_WIDTH
, ?GL_UNPACK_COMPRESSED_BLOCK_HEIGHT
, and ?GL_UNPACK_COMPRESSED_BLOCK_DEPTH
, respectively. b s is the compressed block
size in bytes; b w, b h, and b d are the compressed block width, height, and depth
in pixels.
By default the pixel storage modes ?GL_UNPACK_ROW_LENGTH
, ?GL_UNPACK_SKIP_ROWS
, ?GL_UNPACK_SKIP_PIXELS
, ?GL_UNPACK_IMAGE_HEIGHT
and ?GL_UNPACK_SKIP_IMAGES
are ignored for compressed images. To enable ?GL_UNPACK_SKIP_PIXELS
and ?GL_UNPACK_ROW_LENGTH
, b s and b w must both be non-zero. To also enable ?GL_UNPACK_SKIP_ROWS
and ?GL_UNPACK_IMAGE_HEIGHT
, b h must be non-zero. To also enable ?GL_UNPACK_SKIP_IMAGES
, b d must be non-zero.
All parameters must be consistent with the compressed format to produce the desired results.
When selecting a sub-rectangle from a compressed image: the value of ?GL_UNPACK_SKIP_PIXELS
must be a multiple of b w;the value of ?GL_UNPACK_SKIP_ROWS
must be a multiple
of b w.
ImageSize
must be equal to:
b s×|width b/w|×|height b/h|
See
compressedTexImage1D(Target, Level, Internalformat, Width, Border, ImageSize, Data) -> ok
Target = enum()
Level = integer()
Internalformat = enum()
Width = integer()
Border = integer()
ImageSize = integer()
Data = offset() | mem()
Specify a one-dimensional texture image in a compressed format
Texturing allows elements of an image array to be read by shaders.
gl:compressedTexImage1D
loads a previously defined, and retrieved, compressed one-dimensional
texture image if Target
is ?GL_TEXTURE_1D
(see gl:texImage1D/8 ).
If Target
is ?GL_PROXY_TEXTURE_1D
, no data is read from Data
, but
all of the texture image state is recalculated, checked for consistency, and checked against
the implementation's capabilities. If the implementation cannot handle a texture of the
requested texture size, it sets all of the image state to 0, but does not generate an
error (see gl:getError/0 ). To query for an entire mipmap array, use an image array
level greater than or equal to 1.
Internalformat
must be an extension-specified compressed-texture format. When a
texture is loaded with gl:texImage1D/8 using a generic compressed texture format
(e.g., ?GL_COMPRESSED_RGB
) the GL selects from one of its extensions supporting
compressed textures. In order to load the compressed texture image using gl:compressedTexImage1D
, query the compressed texture image's size and format using gl:getTexLevelParameterfv/3
.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is specified, Data
is treated
as a byte offset into the buffer object's data store.
If the compressed data are arranged into fixed-size blocks of texels, the pixel storage
modes can be used to select a sub-rectangle from a larger containing rectangle. These
pixel storage modes operate in the same way as they do for gl:texImage1D/8 . In
the following description, denote by b s, b w, b h, and b d, the values of pixel storage
modes ?GL_UNPACK_COMPRESSED_BLOCK_SIZE
, ?GL_UNPACK_COMPRESSED_BLOCK_WIDTH
, ?GL_UNPACK_COMPRESSED_BLOCK_HEIGHT
, and ?GL_UNPACK_COMPRESSED_BLOCK_DEPTH
, respectively. b s is the compressed block
size in bytes; b w, b h, and b d are the compressed block width, height, and depth
in pixels.
By default the pixel storage modes ?GL_UNPACK_ROW_LENGTH
, ?GL_UNPACK_SKIP_ROWS
, ?GL_UNPACK_SKIP_PIXELS
, ?GL_UNPACK_IMAGE_HEIGHT
and ?GL_UNPACK_SKIP_IMAGES
are ignored for compressed images. To enable ?GL_UNPACK_SKIP_PIXELS
and ?GL_UNPACK_ROW_LENGTH
, b s and b w must both be non-zero. To also enable ?GL_UNPACK_SKIP_ROWS
and ?GL_UNPACK_IMAGE_HEIGHT
, b h must be non-zero. To also enable ?GL_UNPACK_SKIP_IMAGES
, b d must be non-zero.
All parameters must be consistent with the compressed format to produce the desired results.
When selecting a sub-rectangle from a compressed image: the value of ?GL_UNPACK_SKIP_PIXELS
must be a multiple of b w;
ImageSize
must be equal to:
b s×|width b/w|
See
compressedTexSubImage3D(Target, Level, Xoffset, Yoffset, Zoffset, Width, Height, Depth, Format, ImageSize, Data) -> ok
Target = enum()
Level = integer()
Xoffset = integer()
Yoffset = integer()
Zoffset = integer()
Width = integer()
Height = integer()
Depth = integer()
Format = enum()
ImageSize = integer()
Data = offset() | mem()
Specify a three-dimensional texture subimage in a compressed format
Texturing allows elements of an image array to be read by shaders.
gl:compressedTexSubImage3D
redefines a contiguous subregion of an existing three-dimensional
texture image. The texels referenced by Data
replace the portion of the existing
texture array with x indices Xoffset
and xoffset+width-1, and the y indices Yoffset
and yoffset+height-1, and the z indices Zoffset
and zoffset+depth-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 width of 0, but
such a specification has no effect.
Internalformat
must be a known compressed image format (such as ?GL_RGTC
)
or an extension-specified compressed-texture format. The Format
of the compressed
texture image is selected by the GL implementation that compressed it (see gl:texImage3D/10
) and should be queried at the time the texture was compressed with gl:getTexLevelParameterfv/3
.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is specified, Data
is treated
as a byte offset into the buffer object's data store.
See
compressedTexSubImage2D(Target, Level, Xoffset, Yoffset, Width, Height, Format, ImageSize, Data) -> ok
Target = enum()
Level = integer()
Xoffset = integer()
Yoffset = integer()
Width = integer()
Height = integer()
Format = enum()
ImageSize = integer()
Data = offset() | mem()
Specify a two-dimensional texture subimage in a compressed format
Texturing allows elements of an image array to be read by shaders.
gl:compressedTexSubImage2D
redefines a contiguous subregion of an existing two-dimensional
texture image. The texels referenced by Data
replace the portion of the existing
texture array with x indices Xoffset
and xoffset+width-1, and the 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 width of 0, but such a specification has no effect.
Internalformat
must be a known compressed image format (such as ?GL_RGTC
)
or an extension-specified compressed-texture format. The Format
of the compressed
texture image is selected by the GL implementation that compressed it (see gl:texImage2D/9
) and should be queried at the time the texture was compressed with gl:getTexLevelParameterfv/3
.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is specified, Data
is treated
as a byte offset into the buffer object's data store.
See
compressedTexSubImage1D(Target, Level, Xoffset, Width, Format, ImageSize, Data) -> ok
Target = enum()
Level = integer()
Xoffset = integer()
Width = integer()
Format = enum()
ImageSize = integer()
Data = offset() | mem()
Specify a one-dimensional texture subimage in a compressed format
Texturing allows elements of an image array to be read by shaders.
gl:compressedTexSubImage1D
redefines a contiguous subregion of an existing one-dimensional
texture image. The texels referenced by Data
replace the portion of the existing
texture array with x indices Xoffset
and xoffset+width-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 width of 0, but such a specification
has no effect.
Internalformat
must be a known compressed image format (such as ?GL_RGTC
)
or an extension-specified compressed-texture format. The Format
of the compressed
texture image is selected by the GL implementation that compressed it (see gl:texImage1D/8
), and should be queried at the time the texture was compressed with gl:getTexLevelParameterfv/3
.
If a non-zero named buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is specified, Data
is treated
as a byte offset into the buffer object's data store.
See
getCompressedTexImage(Target, Lod, Img) -> ok
Target = enum()
Lod = integer()
Img = mem()
Return a compressed texture image
gl:getCompressedTexImage
returns the compressed texture image associated with Target
and Lod
into Img
. Img
should be an array of ?GL_TEXTURE_COMPRESSED_IMAGE_SIZE
bytes. Target
specifies whether the desired texture image was one specified by gl:texImage1D/8
(?GL_TEXTURE_1D
), gl:texImage2D/9 (?GL_TEXTURE_2D
or any of ?GL_TEXTURE_CUBE_MAP_*
), or gl:texImage3D/10 (?GL_TEXTURE_3D
). Lod
specifies the level-of-detail
number of the desired image.
If a non-zero named buffer object is bound to the ?GL_PIXEL_PACK_BUFFER
target
(see gl:bindBuffer/2 ) while a texture image is requested, Img
is treated
as a byte offset into the buffer object's data store.
To minimize errors, first verify that the texture is compressed by calling gl:getTexLevelParameterfv/3
with argument ?GL_TEXTURE_COMPRESSED
. If the texture is compressed, then determine
the amount of memory required to store the compressed texture by calling gl:getTexLevelParameterfv/3
with argument ?GL_TEXTURE_COMPRESSED_IMAGE_SIZE
. Finally, retrieve the internal
format of the texture by calling gl:getTexLevelParameterfv/3 with argument ?GL_TEXTURE_INTERNAL_FORMAT
. To store the texture for later use, associate the internal format and size with the
retrieved texture image. These data can be used by the respective texture or subtexture
loading routine used for loading Target
textures.
See
clientActiveTexture(Texture) -> ok
Texture = enum()
Select active texture unit
gl:clientActiveTexture
selects the vertex array client state parameters to be modified
by gl:texCoordPointer/4 , and enabled or disabled with gl:enableClientState/1
or gl:enableClientState/1 , respectively, when called with a parameter of ?GL_TEXTURE_COORD_ARRAY
.
See
multiTexCoord1d(Target, S) -> ok
Target = enum()
S = float()
Set the current texture coordinates
gl:multiTexCoord
specifies texture coordinates in one, two, three, or four dimensions.
gl:multiTexCoord1
sets the current texture coordinates to (s 0 0 1); a call to gl:multiTexCoord2
sets them to (s t 0 1). Similarly, gl:multiTexCoord3
specifies the texture coordinates as (s
t r 1),
and gl:multiTexCoord4
defines all four components explicitly as (s t r q).
The current texture coordinates are part of the data that is associated with each vertex and with the current raster position. Initially, the values for (s t r q) are (0 0 0 1).
See
multiTexCoord1dv(Target::enum(), V) -> ok
V = {S::float()}
Equivalent to multiTexCoord1d(Target, S).
multiTexCoord1fv(Target::enum(), V) -> ok
V = {S::float()}
Equivalent to multiTexCoord1f(Target, S).
multiTexCoord1iv(Target::enum(), V) -> ok
V = {S::integer()}
Equivalent to multiTexCoord1i(Target, S).
multiTexCoord1sv(Target::enum(), V) -> ok
V = {S::integer()}
Equivalent to multiTexCoord1s(Target, S).
multiTexCoord2dv(Target::enum(), V) -> ok
V = {S::float(), T::float()}
Equivalent to multiTexCoord2d(Target, S, T).
multiTexCoord2fv(Target::enum(), V) -> ok
V = {S::float(), T::float()}
Equivalent to multiTexCoord2f(Target, S, T).
multiTexCoord2iv(Target::enum(), V) -> ok
V = {S::integer(), T::integer()}
Equivalent to multiTexCoord2i(Target, S, T).
multiTexCoord2sv(Target::enum(), V) -> ok
V = {S::integer(), T::integer()}
Equivalent to multiTexCoord2s(Target, S, T).
multiTexCoord3d(Target, S, T, R) -> ok
Target = enum()
S = float()
T = float()
R = float()
multiTexCoord3dv(Target::enum(), V) -> ok
V = {S::float(), T::float(), R::float()}
Equivalent to multiTexCoord3d(Target, S, T, R).
multiTexCoord3f(Target, S, T, R) -> ok
Target = enum()
S = float()
T = float()
R = float()
multiTexCoord3fv(Target::enum(), V) -> ok
V = {S::float(), T::float(), R::float()}
Equivalent to multiTexCoord3f(Target, S, T, R).
multiTexCoord3i(Target, S, T, R) -> ok
Target = enum()
S = integer()
T = integer()
R = integer()
multiTexCoord3iv(Target::enum(), V) -> ok
V = {S::integer(), T::integer(), R::integer()}
Equivalent to multiTexCoord3i(Target, S, T, R).
multiTexCoord3s(Target, S, T, R) -> ok
Target = enum()
S = integer()
T = integer()
R = integer()
multiTexCoord3sv(Target::enum(), V) -> ok
V = {S::integer(), T::integer(), R::integer()}
Equivalent to multiTexCoord3s(Target, S, T, R).
multiTexCoord4d(Target, S, T, R, Q) -> ok
Target = enum()
S = float()
T = float()
R = float()
Q = float()
multiTexCoord4dv(Target::enum(), V) -> ok
V = {S::float(), T::float(), R::float(), Q::float()}
Equivalent to multiTexCoord4d(Target, S, T, R, Q).
multiTexCoord4f(Target, S, T, R, Q) -> ok
Target = enum()
S = float()
T = float()
R = float()
Q = float()
multiTexCoord4fv(Target::enum(), V) -> ok
V = {S::float(), T::float(), R::float(), Q::float()}
Equivalent to multiTexCoord4f(Target, S, T, R, Q).
multiTexCoord4i(Target, S, T, R, Q) -> ok
Target = enum()
S = integer()
T = integer()
R = integer()
Q = integer()
multiTexCoord4iv(Target::enum(), V) -> ok
V = {S::integer(), T::integer(), R::integer(), Q::integer()}
Equivalent to multiTexCoord4i(Target, S, T, R, Q).
multiTexCoord4s(Target, S, T, R, Q) -> ok
Target = enum()
S = integer()
T = integer()
R = integer()
Q = integer()
multiTexCoord4sv(Target::enum(), V) -> ok
V = {S::integer(), T::integer(), R::integer(), Q::integer()}
Equivalent to multiTexCoord4s(Target, S, T, R, Q).
loadTransposeMatrixf(M) -> ok
M = matrix()
Replace the current matrix with the specified row-major ordered matrix
gl:loadTransposeMatrix
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 gl:matrixMode/1 ).
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
points to an array of 16 single- or double-precision floating-point values
m={m[0] m[1] ... m[15]}, then the modelview transformation M(v) does the following:
M(v)=(m[0] m[1] m[2] m[3] m[4] m[5] m[6] m[7] m[8] m[9] m[10] m[11] m[12] m[13] m[14] m[15])×(v[0] v[1] v[2] v[3])
Projection and texture transformations are similarly defined.
Calling gl:loadTransposeMatrix
with matrix M is identical in operation to gl:loadMatrixd/1
with M T, where T represents the transpose.
See
multTransposeMatrixf(M) -> ok
M = matrix()
Multiply the current matrix with the specified row-major ordered matrix
gl:multTransposeMatrix
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 gl:matrixMode/1 ). It is either the projection matrix, modelview matrix, or the texture matrix.
See
blendFuncSeparate(SfactorRGB, DfactorRGB, SfactorAlpha, DfactorAlpha) -> ok
SfactorRGB = enum()
DfactorRGB = enum()
SfactorAlpha = enum()
DfactorAlpha = enum()
Specify pixel arithmetic for RGB and alpha components separately
Pixels can be drawn using a function that blends the incoming (source) RGBA values with
the RGBA values that are already in the frame buffer (the destination values). Blending
is initially disabled. Use gl:enable/1 and gl:enable/1 with argument ?GL_BLEND
to enable and disable blending.
gl:blendFuncSeparate
defines the operation of blending for all draw buffers when
it is enabled. gl:blendFuncSeparatei
defines the operation of blending for a single
draw buffer specified by Buf
when enabled for that draw buffer. SrcRGB
specifies
which method is used to scale the source RGB-color components. DstRGB
specifies
which method is used to scale the destination RGB-color components. Likewise, SrcAlpha
specifies which method is used to scale the source alpha color component, and DstAlpha
specifies which method is used to scale the destination alpha component. The 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, first source, second source and destination color components are referred to as (R s0 G s0 B s0 A s0), (R s1 G s1 B s1 A s1), and (R d G d B d A d), respectively. The color specified by gl:blendColor/4 is referred to as (R c G c B c A c). They are understood to have integer values between 0 and (k R k G k B k A), where
k c=2(m c)-1
and (m R m G m B m A) is the number of red, green, blue, and alpha bitplanes.
Source and destination scale factors are referred to as (s R s G s B s A) and (d R d G d B d A). All scale factors have range [0 1].
Parameter
RGB Factor
Alpha Factor
?GL_ZERO
(0 0 0) 0?GL_ONE
(1 1 1) 1?GL_SRC_COLOR
(R s0 k/R G s0 k/G B s0
k/B) A s0 k/A
?GL_ONE_MINUS_SRC_COLOR
(1 1 1 1)-(R s0 k/R G s0 k/G B s0 k/B) 1-A s0 k/A?GL_DST_COLOR
(R d k/R G d k/G B d k/B) A d k/A?GL_ONE_MINUS_DST_COLOR
(1 1 1)-(R d k/R G d k/G B d k/B) 1-A d k/A?GL_SRC_ALPHA
(A s0 k/A A s0
k/A A s0 k/A) A
s0 k/A?GL_ONE_MINUS_SRC_ALPHA
(1 1 1)-(A s0 k/A A s0 k/A A s0 k/A
) 1-A s0 k/A?GL_DST_ALPHA
(A d k/A A d k/A A d k/A) A d k/A?GL_ONE_MINUS_DST_ALPHA
(1 1 1)-(A d k/A A d k/A A d k/A) 1-A d k/A?GL_CONSTANT_COLOR
(R c G c
B c)
A c?GL_ONE_MINUS_CONSTANT_COLOR
(1 1 1)-(R c G c B c) 1-A c?GL_CONSTANT_ALPHA
(A c A c A c) A c?GL_ONE_MINUS_CONSTANT_ALPHA
(1 1 1)-(A c A c A c) 1-A c?GL_SRC_ALPHA_SATURATE
(i i i)
1?GL_SRC1_COLOR
(R s1 k/R G s1 k/G B s1 k/B) A s1 k/A?GL_ONE_MINUS_SRC_COLOR
(1 1 1 1)-(R s1 k/R G s1 k/G B s1 k/B) 1-A s1 k/A?GL_SRC1_ALPHA
(A s1 k/A A
s1 k/A A s1 k/A) A
s1 k/A?GL_ONE_MINUS_SRC_ALPHA
(1 1 1)-(A s1 k/A A s1 k/A A s1 k/A
) 1-A s1 k/AIn the table,
i=min(A s 1-(A d))
To determine the blended RGBA values of a pixel, the system uses the following equations:
R d=min(k R R s s R+R d d R) G d=min(k G G s s G+G d d G) B d=min(k B B s s B+B d d B) A d=min(k A A s s A+A d d A)
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 SrcRGB
is ?GL_SRC_ALPHA
, DstRGB
is ?GL_ONE_MINUS_SRC_ALPHA
, and A s is equal to k A, the equations
reduce to simple replacement:
R d=R s G d=G s B d=B s A d=A s
See
multiDrawArrays(Mode, First, Count) -> ok
Mode = enum()
First = [integer()]
Count = [integer()]
Render multiple sets of primitives from array data
gl:multiDrawArrays
specifies multiple sets of geometric primitives with very few
subroutine calls. Instead of calling a GL procedure to pass each individual vertex, normal,
texture coordinate, edge flag, or color, you can prespecify separate arrays of vertices,
normals, and colors and use them to construct a sequence of primitives with a single call
to gl:multiDrawArrays
.
gl:multiDrawArrays
behaves identically to gl:drawArrays/3 except that Primcount
separate ranges of elements are specified instead.
When gl:multiDrawArrays
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.
Vertex attributes that are modified by gl:multiDrawArrays
have an unspecified value
after gl:multiDrawArrays
returns. Attributes that aren't modified remain well defined.
See
pointParameterf(Pname, Param) -> ok
Pname = enum()
Param = float()
Specify point parameters
The following values are accepted for Pname
:
?GL_POINT_FADE_THRESHOLD_SIZE
: Params
is a single floating-point value that
specifies the threshold value to which point sizes are clamped if they exceed the specified
value. The default value is 1.0.
?GL_POINT_SPRITE_COORD_ORIGIN
: Params
is a single enum specifying the point
sprite texture coordinate origin, either ?GL_LOWER_LEFT
or ?GL_UPPER_LEFT
.
The default value is ?GL_UPPER_LEFT
.
See
fogCoordf(Coord) -> ok
Coord = float()
Set the current fog coordinates
gl:fogCoord
specifies the fog coordinate that is associated with each vertex and
the current raster position. The value specified is interpolated and used in computing
the fog color (see gl:fogf/2 ).
See
fogCoordPointer(Type, Stride, Pointer) -> ok
Type = enum()
Stride = integer()
Pointer = offset() | mem()
Define an array of fog coordinates
gl:fogCoordPointer
specifies the location and data format of an array of fog coordinates
to use when rendering. Type
specifies the data type of each fog coordinate, and Stride
specifies the byte stride from one fog coordinate to the next, allowing vertices and
attributes to be packed into a single array or stored in separate arrays.
If a non-zero named buffer object is bound to the ?GL_ARRAY_BUFFER
target (see gl:bindBuffer/2
) while a fog coordinate array is specified, Pointer
is treated as a byte offset
into the buffer object's data store. Also, the buffer object binding (?GL_ARRAY_BUFFER_BINDING
) is saved as fog coordinate vertex array client-side state (?GL_FOG_COORD_ARRAY_BUFFER_BINDING
).
When a fog coordinate array is specified, Type
, Stride
, and Pointer
are saved as client-side state, in addition to the current vertex array buffer object
binding.
To enable and disable the fog coordinate array, call gl:enableClientState/1 and gl:enableClientState/1
with the argument ?GL_FOG_COORD_ARRAY
. If enabled, the fog coordinate array is
used when gl:drawArrays/3 , gl:multiDrawArrays/3 , gl:drawElements/4 , see glMultiDrawElements
, gl:drawRangeElements/6 , or gl:arrayElement/1 is called.
See
secondaryColor3b(Red, Green, Blue) -> ok
Red = integer()
Green = integer()
Blue = integer()
Set the current secondary color
The GL stores both a primary four-valued RGBA color and a secondary four-valued RGBA color (where alpha is always set to 0.0) that is associated with every vertex.
The secondary color is interpolated and applied to each fragment during rasterization
when ?GL_COLOR_SUM
is enabled. When lighting is enabled, and ?GL_SEPARATE_SPECULAR_COLOR
is specified, the value of the secondary color is assigned the value computed from the
specular term of the lighting computation. Both the primary and secondary current colors
are applied to each fragment, regardless of the state of ?GL_COLOR_SUM
, under such
conditions. When ?GL_SEPARATE_SPECULAR_COLOR
is specified, the value returned from
querying the current secondary color is undefined.
gl:secondaryColor3b
, gl:secondaryColor3s
, and gl:secondaryColor3i
take
three signed byte, short, or long integers as arguments. When v
is appended to
the name, the color commands can take a pointer to an array of such values.
Color values are stored in floating-point format, with unspecified mantissa and exponent sizes. Unsigned integer color components, when specified, are linearly mapped to floating-point values such that the largest representable value maps to 1.0 (full intensity), and 0 maps to 0.0 (zero intensity). Signed integer color components, when specified, are linearly mapped to floating-point values such that the most positive representable value maps to 1.0, and the most negative representable value maps to -1.0. (Note that this mapping does not convert 0 precisely to 0.0). Floating-point values are mapped directly.
Neither floating-point nor signed integer 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 a color buffer.
See
secondaryColor3bv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3b(Red, Green, Blue).
secondaryColor3d(Red, Green, Blue) -> ok
Red = float()
Green = float()
Blue = float()
secondaryColor3dv(V) -> ok
V = {Red::float(), Green::float(), Blue::float()}
Equivalent to secondaryColor3d(Red, Green, Blue).
secondaryColor3f(Red, Green, Blue) -> ok
Red = float()
Green = float()
Blue = float()
secondaryColor3fv(V) -> ok
V = {Red::float(), Green::float(), Blue::float()}
Equivalent to secondaryColor3f(Red, Green, Blue).
secondaryColor3i(Red, Green, Blue) -> ok
Red = integer()
Green = integer()
Blue = integer()
secondaryColor3iv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3i(Red, Green, Blue).
secondaryColor3s(Red, Green, Blue) -> ok
Red = integer()
Green = integer()
Blue = integer()
secondaryColor3sv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3s(Red, Green, Blue).
secondaryColor3ub(Red, Green, Blue) -> ok
Red = integer()
Green = integer()
Blue = integer()
secondaryColor3ubv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3ub(Red, Green, Blue).
secondaryColor3ui(Red, Green, Blue) -> ok
Red = integer()
Green = integer()
Blue = integer()
secondaryColor3uiv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3ui(Red, Green, Blue).
secondaryColor3us(Red, Green, Blue) -> ok
Red = integer()
Green = integer()
Blue = integer()
secondaryColor3usv(V) -> ok
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3us(Red, Green, Blue).
secondaryColorPointer(Size, Type, Stride, Pointer) -> ok
Size = integer()
Type = enum()
Stride = integer()
Pointer = offset() | mem()
Define an array of secondary colors
gl:secondaryColorPointer
specifies the location and data format of an array of color
components to use when rendering. Size
specifies the number of components per color,
and must be 3. 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.
If a non-zero named buffer object is bound to the ?GL_ARRAY_BUFFER
target (see gl:bindBuffer/2
) while a secondary color array is specified, Pointer
is treated as a byte offset
into the buffer object's data store. Also, the buffer object binding (?GL_ARRAY_BUFFER_BINDING
) is saved as secondary color vertex array client-side state (?GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING
).
When a secondary color array is specified, Size
, Type
, Stride
, and Pointer
are saved as client-side state, in addition to the current vertex array buffer object
binding.
To enable and disable the secondary color array, call gl:enableClientState/1 and gl:enableClientState/1
with the argument ?GL_SECONDARY_COLOR_ARRAY
. If enabled, the secondary color array
is used when gl:arrayElement/1 , gl:drawArrays/3 , gl:multiDrawArrays/3 ,
gl:drawElements/4 , see glMultiDrawElements
, or gl:drawRangeElements/6
is called.
See
windowPos2d(X, Y) -> ok
X = float()
Y = float()
Specify the raster position in window coordinates for pixel operations
The GL maintains a 3D position in window coordinates. This position, called the raster position, is used to position pixel and bitmap write operations. It is maintained with subpixel accuracy. See gl:bitmap/7 , gl:drawPixels/5 , and gl:copyPixels/5 .
gl:windowPos2
specifies the x and y coordinates, while z is implicitly set
to 0. gl:windowPos3
specifies all three coordinates. The w coordinate of the current
raster position is always set to 1.0.
gl:windowPos
directly updates the x and y coordinates of the current raster
position with the values specified. That is, the values are neither transformed by the
current modelview and projection matrices, nor by the viewport-to-window transform. The
z coordinate of the current raster position is updated in the following manner:
z={n f(n+z×(f-n)) if z<= 0 if z>= 1(otherwise))
where n is ?GL_DEPTH_RANGE
's near value, and f is ?GL_DEPTH_RANGE
's
far value. See gl:depthRange/2 .
The specified coordinates are not clip-tested, causing the raster position to always be valid.
The current raster position also includes some associated color data and texture coordinates.
If lighting is enabled, then ?GL_CURRENT_RASTER_COLOR
(in RGBA mode) or ?GL_CURRENT_RASTER_INDEX
(in color index mode) is set to the color produced by the lighting calculation (see gl:lightf/3
, gl:lightModelf/2 , and gl:shadeModel/1 ). If lighting is disabled, current
color (in RGBA mode, state variable ?GL_CURRENT_COLOR
) or color index (in color
index mode, state variable ?GL_CURRENT_INDEX
) is used to update the current raster
color. ?GL_CURRENT_RASTER_SECONDARY_COLOR
(in RGBA mode) is likewise updated.
Likewise, ?GL_CURRENT_RASTER_TEXTURE_COORDS
is updated as a function of ?GL_CURRENT_TEXTURE_COORDS
, based on the texture matrix and the texture generation functions (see gl:texGend/3 ).
The ?GL_CURRENT_RASTER_DISTANCE
is set to the ?GL_CURRENT_FOG_COORD
.
See
windowPos3iv(V) -> ok
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to windowPos3i(X, Y, Z).
windowPos3sv(V) -> ok
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to windowPos3s(X, Y, Z).
genQueries(N) -> [integer()]
N = integer()
Generate query object names
gl:genQueries
returns N
query object names in Ids
. 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 gl:genQueries
.
Query object names returned by a call to gl:genQueries
are not returned by subsequent
calls, unless they are first deleted with gl:deleteQueries/1 .
No query objects are associated with the returned query object names until they are first used by calling gl:beginQuery/2 .
See
deleteQueries(Ids) -> ok
Ids = [integer()]
Delete named query objects
gl:deleteQueries
deletes N
query objects named by the elements of the array Ids
. After a query object is deleted, it has no contents, and its name is free for reuse
(for example by gl:genQueries/1 ).
gl:deleteQueries
silently ignores 0's and names that do not correspond to existing
query objects.
See
isQuery(Id) -> 0 | 1
Id = integer()
Determine if a name corresponds to a query object
gl:isQuery
returns ?GL_TRUE
if Id
is currently the name of a query
object. If Id
is zero, or is a non-zero value that is not currently the name of
a query object, or if an error occurs, gl:isQuery
returns ?GL_FALSE
.
A name returned by gl:genQueries/1 , but not yet associated with a query object by calling gl:beginQuery/2 , is not the name of a query object.
See
beginQuery(Target, Id) -> ok
Target = enum()
Id = integer()
Delimit the boundaries of a query object
gl:beginQuery
and gl:beginQuery/2 delimit the boundaries of a query object. Query
must be a name previously returned from a call to gl:genQueries/1 . If a query
object with name Id
does not yet exist it is created with the type determined by Target
. Target
must be one of ?GL_SAMPLES_PASSED
, ?GL_ANY_SAMPLES_PASSED
, ?GL_PRIMITIVES_GENERATED
, ?GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
, or ?GL_TIME_ELAPSED
. The behavior
of the query object depends on its type and is as follows.
If Target
is ?GL_SAMPLES_PASSED
, Id
must be an unused name, or the
name of an existing occlusion query object. When gl:beginQuery
is executed, the
query object's samples-passed counter is reset to 0. Subsequent rendering will increment
the counter for every sample that passes the depth test. If the value of ?GL_SAMPLE_BUFFERS
is 0, then the samples-passed count is incremented by 1 for each fragment. If the value
of ?GL_SAMPLE_BUFFERS
is 1, then the samples-passed count is incremented by the
number of samples whose coverage bit is set. However, implementations, at their discression
may instead increase the samples-passed count by the value of ?GL_SAMPLES
if any
sample in the fragment is covered. When gl:endQuery
is executed, the samples-passed
counter is assigned to the query object's result value. This value can be queried by calling
gl:getQueryObjectiv/2 with Pname
?GL_QUERY_RESULT
.
If Target
is ?GL_ANY_SAMPLES_PASSED
, Id
must be an unused name,
or the name of an existing boolean occlusion query object. When gl:beginQuery
is
executed, the query object's samples-passed flag is reset to ?GL_FALSE
. Subsequent
rendering causes the flag to be set to ?GL_TRUE
if any sample passes the depth
test. When gl:endQuery
is executed, the samples-passed flag is assigned to the query
object's result value. This value can be queried by calling gl:getQueryObjectiv/2
with Pname
?GL_QUERY_RESULT
.
If Target
is ?GL_PRIMITIVES_GENERATED
, Id
must be an unused name,
or the name of an existing primitive query object previously bound to the ?GL_PRIMITIVES_GENERATED
query binding. When gl:beginQuery
is executed, the query object's primitives-generated
counter is reset to 0. Subsequent rendering will increment the counter once for every
vertex that is emitted from the geometry shader, or from the vertex shader if no geometry
shader is present. When gl:endQuery
is executed, the primitives-generated counter
is assigned to the query object's result value. This value can be queried by calling gl:getQueryObjectiv/2
with Pname
?GL_QUERY_RESULT
.
If Target
is ?GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
, Id
must
be an unused name, or the name of an existing primitive query object previously bound
to the ?GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
query binding. When gl:beginQuery
is executed, the query object's primitives-written counter is reset to 0. Subsequent
rendering will increment the counter once for every vertex that is written into the bound
transform feedback buffer(s). If transform feedback mode is not activated between the
call to gl:beginQuery
and gl:endQuery
, the counter will not be incremented.
When gl:endQuery
is executed, the primitives-written counter is assigned to the
query object's result value. This value can be queried by calling gl:getQueryObjectiv/2
with Pname
?GL_QUERY_RESULT
.
If Target
is ?GL_TIME_ELAPSED
, Id
must be an unused name, or the
name of an existing timer query object previously bound to the ?GL_TIME_ELAPSED
query binding. When gl:beginQuery
is executed, the query object's time counter is
reset to 0. When gl:endQuery
is executed, the elapsed server time that has passed
since the call to gl:beginQuery
is written into the query object's time counter.
This value can be queried by calling gl:getQueryObjectiv/2 with Pname
?GL_QUERY_RESULT
.
Querying the ?GL_QUERY_RESULT
implicitly flushes the GL pipeline until the rendering
delimited by the query object has completed and the result is available. ?GL_QUERY_RESULT_AVAILABLE
can be queried to determine if the result is immediately available or if the rendering
is not yet complete.
See
getQueryiv(Target, Pname) -> integer()
Target = enum()
Pname = enum()
glGetQuery
See
getQueryObjectiv(Id, Pname) -> integer()
Id = integer()
Pname = enum()
Return parameters of a query object
gl:getQueryObject
returns in Params
a selected parameter of the query object
specified by Id
.
Pname
names a specific query object parameter. Pname
can be as follows:
?GL_QUERY_RESULT
: Params
returns the value of the query object's passed
samples counter. The initial value is 0.
?GL_QUERY_RESULT_AVAILABLE
: Params
returns whether the passed samples counter
is immediately available. If a delay would occur waiting for the query result, ?GL_FALSE
is returned. Otherwise, ?GL_TRUE
is returned, which also indicates that the results
of all previous queries are available as well.
See
bindBuffer(Target, Buffer) -> ok
Target = enum()
Buffer = integer()
Bind a named buffer object
gl:bindBuffer
binds a buffer object to the specified buffer binding point. Calling gl:bindBuffer
with Target
set to one of the accepted symbolic constants and Buffer
set
to the name of a buffer object binds that buffer object name to the target. If no buffer
object with name Buffer
exists, one is created with that name. When a buffer object
is bound to a target, the previous binding for that target is automatically broken.
Buffer object names are unsigned integers. The value zero is reserved, but there is no
default buffer object for each buffer object target. Instead, Buffer
set to zero
effectively unbinds any buffer object previously bound, and restores client memory usage
for that buffer object target (if supported for that target). Buffer object names and
the corresponding buffer object contents are local to the shared object space of the current
GL rendering context; two rendering contexts share buffer object names only if they explicitly
enable sharing between contexts through the appropriate GL windows interfaces functions.
gl:genBuffers/1 must be used to generate a set of unused buffer object names.
The state of a buffer object immediately after it is first bound is an unmapped zero-sized
memory buffer with ?GL_READ_WRITE
access and ?GL_STATIC_DRAW
usage.
While a non-zero buffer object name is bound, GL operations on the target to which it
is bound affect the bound buffer object, and queries of the target to which it is bound
return state from the bound buffer object. While buffer object name zero is bound, as
in the initial state, attempts to modify or query state on the target to which it is bound
generates an ?GL_INVALID_OPERATION
error.
When a non-zero buffer object is bound to the ?GL_ARRAY_BUFFER
target, the vertex
array pointer parameter is interpreted as an offset within the buffer object measured
in basic machine units.
When a non-zero buffer object is bound to the ?GL_DRAW_INDIRECT_BUFFER
target,
parameters for draws issued through gl:drawArraysIndirect/2 and gl:drawElementsIndirect/3
are sourced from that buffer object.
While a non-zero buffer object is bound to the ?GL_ELEMENT_ARRAY_BUFFER
target,
the indices parameter of gl:drawElements/4 , gl:drawElementsInstanced/5 , gl:drawElementsBaseVertex/5
, gl:drawRangeElements/6 , gl:drawRangeElementsBaseVertex/7 , see glMultiDrawElements
, or see glMultiDrawElementsBaseVertex
is interpreted as an offset within the
buffer object measured in basic machine units.
While a non-zero buffer object is bound to the ?GL_PIXEL_PACK_BUFFER
target,
the following commands are affected: gl:getCompressedTexImage/3 , gl:getTexImage/5
, and gl:readPixels/7 . The pointer parameter is interpreted as an offset within
the buffer object measured in basic machine units.
While a non-zero buffer object is bound to the ?GL_PIXEL_UNPACK_BUFFER
target,
the following commands are affected: gl:compressedTexImage1D/7 , gl:compressedTexImage2D/8
, gl:compressedTexImage3D/9 , gl:compressedTexSubImage1D/7 , gl:compressedTexSubImage2D/9
, gl:compressedTexSubImage3D/11 , gl:texImage1D/8 , gl:texImage2D/9 , gl:texImage3D/10
, gl:texSubImage1D/7 , gl:texSubImage1D/7 , and gl:texSubImage1D/7 .
The pointer parameter is interpreted as an offset within the buffer object measured in
basic machine units.
The buffer targets ?GL_COPY_READ_BUFFER
and ?GL_COPY_WRITE_BUFFER
are provided
to allow gl:copyBufferSubData/5 to be used without disturbing the state of other
bindings. However, gl:copyBufferSubData/5 may be used with any pair of buffer binding
points.
The ?GL_TRANSFORM_FEEDBACK_BUFFER
buffer binding point may be passed to gl:bindBuffer
, but will not directly affect transform feedback state. Instead, the indexed ?GL_TRANSFORM_FEEDBACK_BUFFER
bindings must be used through a call to gl:bindBufferBase/3 or gl:bindBufferRange/5
. This will affect the generic ?GL_TRANSFORM_FEEDABCK_BUFFER
binding.
Likewise, the ?GL_UNIFORM_BUFFER
and ?GL_ATOMIC_COUNTER_BUFFER
buffer binding
points may be used, but do not directly affect uniform buffer or atomic counter buffer
state, respectively. gl:bindBufferBase/3 or gl:bindBufferRange/5 must be
used to bind a buffer to an indexed uniform buffer or atomic counter buffer binding point.
A buffer object binding created with gl:bindBuffer
remains active until a different
buffer object name is bound to the same target, or until the bound buffer object is deleted
with gl:deleteBuffers/1 .
Once created, a named buffer object may be re-bound to any target as often as needed. However, the GL implementation may make choices about how to optimize the storage of a buffer object based on its initial binding target.
See
deleteBuffers(Buffers) -> ok
Buffers = [integer()]
Delete named buffer objects
gl:deleteBuffers
deletes N
buffer objects named by the elements of the array
Buffers
. After a buffer object is deleted, it has no contents, and its name is
free for reuse (for example by gl:genBuffers/1 ). If a buffer object that is currently
bound is deleted, the binding reverts to 0 (the absence of any buffer object).
gl:deleteBuffers
silently ignores 0's and names that do not correspond to existing
buffer objects.
See
genBuffers(N) -> [integer()]
N = integer()
Generate buffer object names
gl:genBuffers
returns N
buffer object names in Buffers
. 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 gl:genBuffers
.
Buffer object names returned by a call to gl:genBuffers
are not returned by subsequent
calls, unless they are first deleted with gl:deleteBuffers/1 .
No buffer objects are associated with the returned buffer object names until they are first bound by calling gl:bindBuffer/2 .
See
isBuffer(Buffer) -> 0 | 1
Buffer = integer()
Determine if a name corresponds to a buffer object
gl:isBuffer
returns ?GL_TRUE
if Buffer
is currently the name of a
buffer object. If Buffer
is zero, or is a non-zero value that is not currently
the name of a buffer object, or if an error occurs, gl:isBuffer
returns ?GL_FALSE
.
A name returned by gl:genBuffers/1 , but not yet associated with a buffer object by calling gl:bindBuffer/2 , is not the name of a buffer object.
See
bufferData(Target, Size, Data, Usage) -> ok
Target = enum()
Size = integer()
Data = offset() | mem()
Usage = enum()
Creates and initializes a buffer object's data store
gl:bufferData
creates a new data store for the buffer object currently bound to Target
. Any pre-existing data store is deleted. The new data store is created with the specified
Size
in bytes and Usage
. If Data
is not ?NULL
, the data store
is initialized with data from this pointer. In its initial state, the new data store
is not mapped, it has a ?NULL
mapped pointer, and its mapped access is ?GL_READ_WRITE
.
Usage
is a hint to the GL implementation as to how a buffer object's data store
will be accessed. This enables the GL implementation to make more intelligent decisions
that may significantly impact buffer object performance. It does not, however, constrain
the actual usage of the data store. Usage
can be broken down into two parts: first,
the frequency of access (modification and usage), and second, the nature of that access.
The frequency of access may be one of these:
STREAM: The data store contents will be modified once and used at most a few times.
STATIC: The data store contents will be modified once and used many times.
DYNAMIC: The data store contents will be modified repeatedly and used many times.
The nature of access may be one of these:
DRAW: The data store contents are modified by the application, and used as the source for GL drawing and image specification commands.
READ: The data store contents are modified by reading data from the GL, and used to return that data when queried by the application.
COPY: The data store contents are modified by reading data from the GL, and used as the source for GL drawing and image specification commands.
See
bufferSubData(Target, Offset, Size, Data) -> ok
Target = enum()
Offset = integer()
Size = integer()
Data = offset() | mem()
Updates a subset of a buffer object's data store
gl:bufferSubData
redefines some or all of the data store for the buffer object currently
bound to Target
. Data starting at byte offset Offset
and extending for Size
bytes is copied to the data store from the memory pointed to by Data
. An error
is thrown if Offset
and Size
together define a range beyond the bounds of
the buffer object's data store.
See
getBufferSubData(Target, Offset, Size, Data) -> ok
Target = enum()
Offset = integer()
Size = integer()
Data = mem()
Returns a subset of a buffer object's data store
gl:getBufferSubData
returns some or all of the data from the buffer object currently
bound to Target
. Data starting at byte offset Offset
and extending for Size
bytes is copied from the data store to the memory pointed to by Data
. An error
is thrown if the buffer object is currently mapped, or if Offset
and Size
together define a range beyond the bounds of the buffer object's data store.
See
getBufferParameteriv(Target, Pname) -> integer()
Target = enum()
Pname = enum()
Return parameters of a buffer object
gl:getBufferParameteriv
returns in Data
a selected parameter of the buffer
object specified by Target
.
Value
names a specific buffer object parameter, as follows:
?GL_BUFFER_ACCESS
: Params
returns the access policy set while mapping the
buffer object. The initial value is ?GL_READ_WRITE
.
?GL_BUFFER_MAPPED
: Params
returns a flag indicating whether the buffer object
is currently mapped. The initial value is ?GL_FALSE
.
?GL_BUFFER_SIZE
: Params
returns the size of the buffer object, measured
in bytes. The initial value is 0.
?GL_BUFFER_USAGE
: Params
returns the buffer object's usage pattern. The
initial value is ?GL_STATIC_DRAW
.
See
blendEquationSeparate(ModeRGB, ModeAlpha) -> ok
ModeRGB = enum()
ModeAlpha = enum()
Set the RGB blend equation and the alpha blend equation separately
The blend equations determines how a new pixel (the ''source'' color) is combined with
a pixel already in the framebuffer (the ''destination'' color). These functions specifie
one blend equation for the RGB-color components and one blend equation for the alpha
component. gl:blendEquationSeparatei
specifies the blend equations for a single
draw buffer whereas gl:blendEquationSeparate
sets the blend equations for all draw
buffers.
The blend equations use the source and destination blend factors specified by either gl:blendFunc/2 or gl:blendFuncSeparate/4 . See gl:blendFunc/2 or gl:blendFuncSeparate/4 for a description of the various blend factors.
In the equations that follow, source and destination color components are referred to as (R s G s B s A s) and (R d G d B d A d), respectively. The result color is referred to as (R r G r B r A r). The source and destination blend factors are denoted (s R s G s B s A) and (d R d G d B d A), respectively. For these equations all color components are understood to have values in the range [0 1].
Mode
RGB Components
Alpha Component
?GL_FUNC_ADD
Rr=R s s R+R d d R Gr=G s s G+G d d G Br=B s s B+B d d B Ar=A s
s A+A d d A?GL_FUNC_SUBTRACT
Rr=R s s R-R d d R Gr=G
s s G-G d d G Br=B s s B-B d d B Ar=A s s A-A d d A?GL_FUNC_REVERSE_SUBTRACT
Rr=R d d R-R s s R Gr=G d d G-G s s G Br=B d d B-B s s B Ar=A d
d A-A s s A?GL_MIN
Rr=min(R s R d) Gr=min(G s G d) Br=min(B s B d) Ar=min
(A s A d)?GL_MAX
Rr=max(R s R d) Gr=max(G s G d) Br=max(B s B d) Ar=max(A s A d)The results of these equations are clamped to the range [0 1].
The ?GL_MIN
and ?GL_MAX
equations are useful for applications that analyze
image data (image thresholding against a constant color, for example). The ?GL_FUNC_ADD
equation is useful for antialiasing and transparency, among other things.
Initially, both the RGB blend equation and the alpha blend equation are set to ?GL_FUNC_ADD
.
See
drawBuffers(Bufs) -> ok
Bufs = [enum()]
Specifies a list of color buffers to be drawn into
gl:drawBuffers
defines an array of buffers into which outputs from the fragment
shader data will be written. If a fragment shader writes a value to one or more user defined
output variables, then the value of each variable will be written into the buffer specified
at a location within Bufs
corresponding to the location assigned to that user defined
output. The draw buffer used for user defined outputs assigned to locations greater than
or equal to N
is implicitly set to ?GL_NONE
and any data written to such
an output is discarded.
The symbolic constants contained in Bufs
may be any of the following:
?GL_NONE
: The fragment shader output value is not written into any color buffer.
?GL_FRONT_LEFT
: The fragment shader output value is written into the front left
color buffer.
?GL_FRONT_RIGHT
: The fragment shader output value is written into the front right
color buffer.
?GL_BACK_LEFT
: The fragment shader output value is written into the back left color
buffer.
?GL_BACK_RIGHT
: The fragment shader output value is written into the back right
color buffer.
?GL_COLOR_ATTACHMENT
n
: The fragment shader output value is written into
the n
th color attachment of the current framebuffer. n
may range from 0
to the value of ?GL_MAX_COLOR_ATTACHMENTS
.
Except for ?GL_NONE
, the preceding symbolic constants may not appear more than
once in Bufs
. The maximum number of draw buffers supported is implementation dependent
and can be queried by calling gl:getBooleanv/1 with the argument ?GL_MAX_DRAW_BUFFERS
.
See
stencilOpSeparate(Face, Sfail, Dpfail, Dppass) -> ok
Face = enum()
Sfail = enum()
Dpfail = enum()
Dppass = enum()
Set front and/or back 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 the
test, call gl:enable/1 and gl:enable/1 with argument ?GL_STENCIL_TEST
; to control it, call gl:stencilFunc/3 or gl:stencilFuncSeparate/4 .
There can be two separate sets of Sfail
, Dpfail
, and Dppass
parameters;
one affects back-facing polygons, and the other affects front-facing polygons as well
as other non-polygon primitives. gl:stencilOp/3 sets both front and back stencil
state to the same values, as if gl:stencilOpSeparate/4 were called with Face
set to ?GL_FRONT_AND_BACK
.
gl:stencilOpSeparate
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 Sfail
specifies what happens to the
stencil buffer contents. The following eight 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 gl:stencilFunc/3
.
?GL_INCR
: Increments the current stencil buffer value. Clamps to the maximum representable
unsigned value.
?GL_INCR_WRAP
: Increments the current stencil buffer value. Wraps stencil buffer
value to zero when incrementing the maximum representable unsigned value.
?GL_DECR
: Decrements the current stencil buffer value. Clamps to 0.
?GL_DECR_WRAP
: Decrements the current stencil buffer value. Wraps stencil buffer
value to the maximum representable unsigned value when decrementing a stencil buffer value
of zero.
?GL_INVERT
: Bitwise inverts the current stencil buffer 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 gl:stencilOpSeparate
specify stencil buffer actions
that depend on whether subsequent depth buffer tests succeed ( Dppass
) or fail ( Dpfail
) (see gl:depthFunc/1 ). The actions are specified using the same eight symbolic
constants as Sfail
. Note that Dpfail
is ignored when there is no depth buffer,
or when the depth buffer is not enabled. In these cases, Sfail
and Dppass
specify stencil action when the stencil test fails and passes, respectively.
See
stencilFuncSeparate(Face, Func, Ref, Mask) -> ok
Face = enum()
Func = enum()
Ref = integer()
Mask = integer()
Set front and/or back 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
the test, call gl:enable/1 and gl:enable/1 with argument ?GL_STENCIL_TEST
. To specify actions based on the outcome of the stencil test, call gl:stencilOp/3
or gl:stencilOpSeparate/4 .
There can be two separate sets of Func
, Ref
, and Mask
parameters;
one affects back-facing polygons, and the other affects front-facing polygons as well
as other non-polygon primitives. gl:stencilFunc/3 sets both front and back stencil
state to the same values, as if gl:stencilFuncSeparate/4 were called with Face
set to ?GL_FRONT_AND_BACK
.
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 gl:stencilOp/3 ). 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.
See
stencilMaskSeparate(Face, Mask) -> ok
Face = enum()
Mask = integer()
Control the front and/or back writing of individual bits in the stencil planes
gl:stencilMaskSeparate
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.
There can be two separate Mask
writemasks; one affects back-facing polygons, and
the other affects front-facing polygons as well as other non-polygon primitives. gl:stencilMask/1
sets both front and back stencil writemasks to the same values, as if gl:stencilMaskSeparate/2
were called with Face
set to ?GL_FRONT_AND_BACK
.
See
attachShader(Program, Shader) -> ok
Program = integer()
Shader = integer()
Attaches a shader object to a program object
In order to create a complete shader program, there must be a way to specify the list
of things that will be linked together. Program objects provide this mechanism. Shaders
that are to be linked together in a program object must first be attached to that program
object. gl:attachShader
attaches the shader object specified by Shader
to
the program object specified by Program
. This indicates that Shader
will
be included in link operations that will be performed on Program
.
All operations that can be performed on a shader object are valid whether or not the shader object is attached to a program object. It is permissible to attach a shader object to a program object before source code has been loaded into the shader object or before the shader object has been compiled. It is permissible to attach multiple shader objects of the same type because each may contain a portion of the complete shader. It is also permissible to attach a shader object to more than one program object. If a shader object is deleted while it is attached to a program object, it will be flagged for deletion, and deletion will not occur until gl:detachShader/2 is called to detach it from all program objects to which it is attached.
See
bindAttribLocation(Program, Index, Name) -> ok
Program = integer()
Index = integer()
Name = string()
Associates a generic vertex attribute index with a named attribute variable
gl:bindAttribLocation
is used to associate a user-defined attribute variable in
the program object specified by Program
with a generic vertex attribute index.
The name of the user-defined attribute variable is passed as a null terminated string in Name
. The generic vertex attribute index to be bound to this variable is specified by Index
. When Program
is made part of current state, values provided via the generic vertex
attribute Index
will modify the value of the user-defined attribute variable specified
by Name
.
If Name
refers to a matrix attribute variable, Index
refers to the first
column of the matrix. Other matrix columns are then automatically bound to locations Index+1
for a matrix of type mat2
; Index+1
and Index+2
for a matrix of type
mat3
; and Index+1
, Index+2
, and Index+3
for a matrix of type mat4
.
This command makes it possible for vertex shaders to use descriptive names for attribute
variables rather than generic variables that are numbered from 0 to ?GL_MAX_VERTEX_ATTRIBS
-1. The values sent to each generic attribute index are part of current state. If a different
program object is made current by calling gl:useProgram/1 , the generic vertex attributes
are tracked in such a way that the same values will be observed by attributes in the new
program object that are also bound to Index
.
Attribute variable name-to-generic attribute index bindings for a program object can be
explicitly assigned at any time by calling gl:bindAttribLocation
. Attribute bindings
do not go into effect until gl:linkProgram/1 is called. After a program object
has been linked successfully, the index values for generic attributes remain fixed (and
their values can be queried) until the next link command occurs.
Any attribute binding that occurs after the program object has been linked will not take effect until the next time the program object is linked.
See
compileShader(Shader) -> ok
Shader = integer()
Compiles a shader object
gl:compileShader
compiles the source code strings that have been stored in the shader
object specified by Shader
.
The compilation status will be stored as part of the shader object's state. This value
will be set to ?GL_TRUE
if the shader was compiled without errors and is ready
for use, and ?GL_FALSE
otherwise. It can be queried by calling gl:getShaderiv/2
with arguments Shader
and ?GL_COMPILE_STATUS
.
Compilation of a shader can fail for a number of reasons as specified by the OpenGL Shading Language Specification. Whether or not the compilation was successful, information about the compilation can be obtained from the shader object's information log by calling gl:getShaderInfoLog/2 .
See
createProgram() -> integer()
Creates a program object
gl:createProgram
creates an empty program object and returns a non-zero value by
which it can be referenced. A program object is an object to which shader objects can
be attached. This provides a mechanism to specify the shader objects that will be linked
to create a program. It also provides a means for checking the compatibility of the
shaders that will be used to create a program (for instance, checking the compatibility
between a vertex shader and a fragment shader). When no longer needed as part of a program
object, shader objects can be detached.
One or more executables are created in a program object by successfully attaching shader objects to it with gl:attachShader/2 , successfully compiling the shader objects with gl:compileShader/1 , and successfully linking the program object with gl:linkProgram/1 . These executables are made part of current state when gl:useProgram/1 is called. Program objects can be deleted by calling gl:deleteProgram/1 . The memory associated with the program object will be deleted when it is no longer part of current rendering state for any context.
See
createShader(Type) -> integer()
Type = enum()
Creates a shader object
gl:createShader
creates an empty shader object and returns a non-zero value by
which it can be referenced. A shader object is used to maintain the source code strings
that define a shader. ShaderType
indicates the type of shader to be created. Five
types of shader are supported. A shader of type ?GL_VERTEX_SHADER
is a shader
that is intended to run on the programmable vertex processor. A shader of type ?GL_TESS_CONTROL_SHADER
is a shader that is intended to run on the programmable tessellation processor in the
control stage. A shader of type ?GL_TESS_EVALUATION_SHADER
is a shader that is
intended to run on the programmable tessellation processor in the evaluation stage. A
shader of type ?GL_GEOMETRY_SHADER
is a shader that is intended to run on the
programmable geometry processor. A shader of type ?GL_FRAGMENT_SHADER
is a shader
that is intended to run on the programmable fragment processor.
When created, a shader object's ?GL_SHADER_TYPE
parameter is set to either ?GL_VERTEX_SHADER
, ?GL_TESS_CONTROL_SHADER
, ?GL_TESS_EVALUATION_SHADER
, ?GL_GEOMETRY_SHADER
or ?GL_FRAGMENT_SHADER
, depending on the value of ShaderType
.
See
deleteProgram(Program) -> ok
Program = integer()
Deletes a program object
gl:deleteProgram
frees the memory and invalidates the name associated with the program
object specified by Program.
This command effectively undoes the effects of a call
to gl:createProgram/0 .
If a program object is in use as part of current rendering state, it will be flagged for
deletion, but it will not be deleted until it is no longer part of current state for any
rendering context. If a program object to be deleted has shader objects attached to it,
those shader objects will be automatically detached but not deleted unless they have already
been flagged for deletion by a previous call to gl:deleteShader/1 . A value of 0
for Program
will be silently ignored.
To determine whether a program object has been flagged for deletion, call gl:getProgramiv/2
with arguments Program
and ?GL_DELETE_STATUS
.
See
deleteShader(Shader) -> ok
Shader = integer()
Deletes a shader object
gl:deleteShader
frees the memory and invalidates the name associated with the shader
object specified by Shader
. This command effectively undoes the effects of a call
to gl:createShader/1 .
If a shader object to be deleted is attached to a program object, it will be flagged for
deletion, but it will not be deleted until it is no longer attached to any program object,
for any rendering context (i.e., it must be detached from wherever it was attached before
it will be deleted). A value of 0 for Shader
will be silently ignored.
To determine whether an object has been flagged for deletion, call gl:getShaderiv/2
with arguments Shader
and ?GL_DELETE_STATUS
.
See
detachShader(Program, Shader) -> ok
Program = integer()
Shader = integer()
Detaches a shader object from a program object to which it is attached
gl:detachShader
detaches the shader object specified by Shader
from the program
object specified by Program
. This command can be used to undo the effect of the
command gl:attachShader/2 .
If Shader
has already been flagged for deletion by a call to gl:deleteShader/1
and it is not attached to any other program object, it will be deleted after it has been
detached.
See
disableVertexAttribArray(Index) -> ok
Index = integer()
Enable or disable a generic vertex attribute array
gl:enableVertexAttribArray
enables the generic vertex attribute array specified by Index
. gl:disableVertexAttribArray
disables the generic vertex attribute array specified
by Index
. By default, all client-side capabilities are disabled, including all
generic vertex attribute arrays. If enabled, the values in the generic vertex attribute
array will be accessed and used for rendering when calls are made to vertex array commands
such as gl:drawArrays/3 , gl:drawElements/4 , gl:drawRangeElements/6 , see glMultiDrawElements
, or gl:multiDrawArrays/3 .
See
getActiveAttrib(Program, Index, BufSize) -> {Size::integer(), Type::enum(), Name::string()}
Program = integer()
Index = integer()
BufSize = integer()
Returns information about an active attribute variable for the specified program object
gl:getActiveAttrib
returns information about an active attribute variable in the
program object specified by Program
. The number of active attributes can be obtained
by calling gl:getProgramiv/2 with the value ?GL_ACTIVE_ATTRIBUTES
. A value
of 0 for Index
selects the first active attribute variable. Permissible values
for Index
range from 0 to the number of active attribute variables minus 1.
A vertex shader may use either built-in attribute variables, user-defined attribute variables,
or both. Built-in attribute variables have a prefix of "gl_" and reference conventional
OpenGL vertex attribtes (e.g., Gl_Vertex
, Gl_Normal
, etc., see the OpenGL
Shading Language specification for a complete list.) User-defined attribute variables
have arbitrary names and obtain their values through numbered generic vertex attributes.
An attribute variable (either built-in or user-defined) is considered active if it is
determined during the link operation that it may be accessed during program execution.
Therefore, Program
should have previously been the target of a call to gl:linkProgram/1
, but it is not necessary for it to have been linked successfully.
The size of the character buffer required to store the longest attribute variable name
in Program
can be obtained by calling gl:getProgramiv/2 with the value ?GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
. This value should be used to allocate a buffer of sufficient size to store the returned
attribute name. The size of this character buffer is passed in BufSize
, and a pointer
to this character buffer is passed in Name
.
gl:getActiveAttrib
returns the name of the attribute variable indicated by Index
, storing it in the character buffer specified by Name
. The string returned will
be null terminated. The actual number of characters written into this buffer is returned
in Length
, and this count does not include the null termination character. If the
length of the returned string is not required, a value of ?NULL
can be passed in
the Length
argument.
The Type
argument specifies a pointer to a variable into which the attribute variable's
data type will be written. The symbolic constants ?GL_FLOAT
, ?GL_FLOAT_VEC2
,
?GL_FLOAT_VEC3
, ?GL_FLOAT_VEC4
, ?GL_FLOAT_MAT2
, ?GL_FLOAT_MAT3
,
?GL_FLOAT_MAT4
, ?GL_FLOAT_MAT2x3
, ?GL_FLOAT_MAT2x4
, ?GL_FLOAT_MAT3x2
, ?GL_FLOAT_MAT3x4
, ?GL_FLOAT_MAT4x2
, ?GL_FLOAT_MAT4x3
, ?GL_INT
, ?GL_INT_VEC2
, ?GL_INT_VEC3
, ?GL_INT_VEC4
, ?GL_UNSIGNED_INT_VEC
, ?GL_UNSIGNED_INT_VEC2
, ?GL_UNSIGNED_INT_VEC3
, ?GL_UNSIGNED_INT_VEC4
,
?DOUBLE
, ?DOUBLE_VEC2
, ?DOUBLE_VEC3
, ?DOUBLE_VEC4
, ?DOUBLE_MAT2
, ?DOUBLE_MAT3
, ?DOUBLE_MAT4
, ?DOUBLE_MAT2x3
, ?DOUBLE_MAT2x4
,
?DOUBLE_MAT3x2
, ?DOUBLE_MAT3x4
, ?DOUBLE_MAT4x2
, or ?DOUBLE_MAT4x3
may be returned. The Size
argument will return the size of the attribute, in units
of the type returned in Type
.
The list of active attribute variables may include both built-in attribute variables (which begin with the prefix "gl_") as well as user-defined attribute variable names.
This function will return as much information as it can about the specified active attribute
variable. If no information is available, Length
will be 0, and Name
will
be an empty string. This situation could occur if this function is called after a link
operation that failed. If an error occurs, the return values Length
, Size
, Type
, and Name
will be unmodified.
See
getActiveUniform(Program, Index, BufSize) -> {Size::integer(), Type::enum(), Name::string()}
Program = integer()
Index = integer()
BufSize = integer()
Returns information about an active uniform variable for the specified program object
gl:getActiveUniform
returns information about an active uniform variable in the
program object specified by Program
. The number of active uniform variables can
be obtained by calling gl:getProgramiv/2 with the value ?GL_ACTIVE_UNIFORMS
.
A value of 0 for Index
selects the first active uniform variable. Permissible values
for Index
range from 0 to the number of active uniform variables minus 1.
Shaders may use either built-in uniform variables, user-defined uniform variables, or
both. Built-in uniform variables have a prefix of "gl_" and reference existing OpenGL
state or values derived from such state (e.g., Gl_DepthRangeParameters
, see the
OpenGL Shading Language specification for a complete list.) User-defined uniform variables
have arbitrary names and obtain their values from the application through calls to gl:uniform1f/2
. A uniform variable (either built-in or user-defined) is considered active if it is determined
during the link operation that it may be accessed during program execution. Therefore, Program
should have previously been the target of a call to gl:linkProgram/1 , but it is
not necessary for it to have been linked successfully.
The size of the character buffer required to store the longest uniform variable name in Program
can be obtained by calling gl:getProgramiv/2 with the value ?GL_ACTIVE_UNIFORM_MAX_LENGTH
. This value should be used to allocate a buffer of sufficient size to store the returned
uniform variable name. The size of this character buffer is passed in BufSize
,
and a pointer to this character buffer is passed in Name.
gl:getActiveUniform
returns the name of the uniform variable indicated by Index
, storing it in the character buffer specified by Name
. The string returned will
be null terminated. The actual number of characters written into this buffer is returned
in Length
, and this count does not include the null termination character. If the
length of the returned string is not required, a value of ?NULL
can be passed in
the Length
argument.
The Type
argument will return a pointer to the uniform variable's data type. The
symbolic constants returned for uniform types are shown in the table below.
Returned Symbolic Contant
Shader Uniform Type
?GL_FLOAT
?float
?GL_FLOAT_VEC2
?vec2
?GL_FLOAT_VEC3
?vec3
?GL_FLOAT_VEC4
?vec4
?GL_DOUBLE
?double
?GL_DOUBLE_VEC2
?dvec2
?GL_DOUBLE_VEC3
?dvec3
?GL_DOUBLE_VEC4
?dvec4
?GL_INT
?int
?GL_INT_VEC2
?ivec2
?GL_INT_VEC3
?ivec3
?GL_INT_VEC4
?ivec4
?GL_UNSIGNED_INT
?unsigned int
?GL_UNSIGNED_INT_VEC2
?uvec2
?GL_UNSIGNED_INT_VEC3
?uvec3
?GL_UNSIGNED_INT_VEC4
?uvec4
?GL_BOOL
?bool
?GL_BOOL_VEC2
?bvec2
?GL_BOOL_VEC3
?bvec3
?GL_BOOL_VEC4
?bvec4
?GL_FLOAT_MAT2
?mat2
?GL_FLOAT_MAT3
?mat3
?GL_FLOAT_MAT4
?mat4
?GL_FLOAT_MAT2x3
?mat2x3
?GL_FLOAT_MAT2x4
?mat2x4
?GL_FLOAT_MAT3x2
?mat3x2
?GL_FLOAT_MAT3x4
?mat3x4
?GL_FLOAT_MAT4x2
?mat4x2
?GL_FLOAT_MAT4x3
?mat4x3
?GL_DOUBLE_MAT2
?dmat2
?GL_DOUBLE_MAT3
?dmat3
?GL_DOUBLE_MAT4
?dmat4
?GL_DOUBLE_MAT2x3
?dmat2x3
?GL_DOUBLE_MAT2x4
?dmat2x4
?GL_DOUBLE_MAT3x2
?dmat3x2
?GL_DOUBLE_MAT3x4
?dmat3x4
?GL_DOUBLE_MAT4x2
?dmat4x2
?GL_DOUBLE_MAT4x3
?dmat4x3
?GL_SAMPLER_1D
?sampler1D
?GL_SAMPLER_2D
?sampler2D
?GL_SAMPLER_3D
?sampler3D
?GL_SAMPLER_CUBE
?samplerCube
?GL_SAMPLER_1D_SHADOW
?sampler1DShadow
?GL_SAMPLER_2D_SHADOW
?sampler2DShadow
?GL_SAMPLER_1D_ARRAY
?sampler1DArray
?GL_SAMPLER_2D_ARRAY
?sampler2DArray
?GL_SAMPLER_1D_ARRAY_SHADOW
?sampler1DArrayShadow
?GL_SAMPLER_2D_ARRAY_SHADOW
?sampler2DArrayShadow
?GL_SAMPLER_2D_MULTISAMPLE
?sampler2DMS
?GL_SAMPLER_2D_MULTISAMPLE_ARRAY
?sampler2DMSArray
?GL_SAMPLER_CUBE_SHADOW
?samplerCubeShadow
?GL_SAMPLER_BUFFER
?samplerBuffer
?GL_SAMPLER_2D_RECT
?sampler2DRect
?GL_SAMPLER_2D_RECT_SHADOW
?sampler2DRectShadow
?GL_INT_SAMPLER_1D
?isampler1D
?GL_INT_SAMPLER_2D
?isampler2D
?GL_INT_SAMPLER_3D
?isampler3D
?GL_INT_SAMPLER_CUBE
?isamplerCube
?GL_INT_SAMPLER_1D_ARRAY
?isampler1DArray
?GL_INT_SAMPLER_2D_ARRAY
?isampler2DArray
?GL_INT_SAMPLER_2D_MULTISAMPLE
?isampler2DMS
?GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
?isampler2DMSArray
?GL_INT_SAMPLER_BUFFER
?isamplerBuffer
?GL_INT_SAMPLER_2D_RECT
?isampler2DRect
?GL_UNSIGNED_INT_SAMPLER_1D
?usampler1D
?GL_UNSIGNED_INT_SAMPLER_2D
?usampler2D
?GL_UNSIGNED_INT_SAMPLER_3D
?usampler3D
?GL_UNSIGNED_INT_SAMPLER_CUBE
?usamplerCube
?GL_UNSIGNED_INT_SAMPLER_1D_ARRAY
?usampler2DArray
?GL_UNSIGNED_INT_SAMPLER_2D_ARRAY
?usampler2DArray
?GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE
?usampler2DMS
?GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
?usampler2DMSArray
?GL_UNSIGNED_INT_SAMPLER_BUFFER
?usamplerBuffer
?GL_UNSIGNED_INT_SAMPLER_2D_RECT
?usampler2DRect
?GL_IMAGE_1D
?image1D
?GL_IMAGE_2D
?image2D
?GL_IMAGE_3D
?image3D
?GL_IMAGE_2D_RECT
?image2DRect
?GL_IMAGE_CUBE
?imageCube
?GL_IMAGE_BUFFER
?imageBuffer
?GL_IMAGE_1D_ARRAY
?image1DArray
?GL_IMAGE_2D_ARRAY
?image2DArray
?GL_IMAGE_2D_MULTISAMPLE
?image2DMS
?GL_IMAGE_2D_MULTISAMPLE_ARRAY
?image2DMSArray
?GL_INT_IMAGE_1D
?iimage1D
?GL_INT_IMAGE_2D
?iimage2D
?GL_INT_IMAGE_3D
?iimage3D
?GL_INT_IMAGE_2D_RECT
?iimage2DRect
?GL_INT_IMAGE_CUBE
?iimageCube
?GL_INT_IMAGE_BUFFER
?iimageBuffer
?GL_INT_IMAGE_1D_ARRAY
?iimage1DArray
?GL_INT_IMAGE_2D_ARRAY
?iimage2DArray
?GL_INT_IMAGE_2D_MULTISAMPLE
?iimage2DMS
?GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY
?iimage2DMSArray
?GL_UNSIGNED_INT_IMAGE_1D
?uimage1D
?GL_UNSIGNED_INT_IMAGE_2D
?uimage2D
?GL_UNSIGNED_INT_IMAGE_3D
?uimage3D
?GL_UNSIGNED_INT_IMAGE_2D_RECT
?uimage2DRect
?GL_UNSIGNED_INT_IMAGE_CUBE
?uimageCube
?GL_UNSIGNED_INT_IMAGE_BUFFER
?uimageBuffer
?GL_UNSIGNED_INT_IMAGE_1D_ARRAY
?uimage1DArray
?GL_UNSIGNED_INT_IMAGE_2D_ARRAY
?uimage2DArray
?GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE
?uimage2DMS
?GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY
?uimage2DMSArray
?GL_UNSIGNED_INT_ATOMIC_COUNTER
?atomic_uint
If one or more elements of an array are active, the name of the array is returned in Name
, the type is returned in Type
, and the Size
parameter returns the highest
array element index used, plus one, as determined by the compiler and/or linker. Only
one active uniform variable will be reported for a uniform array.
Uniform variables that are declared as structures or arrays of structures will not be returned directly by this function. Instead, each of these uniform variables will be reduced to its fundamental components containing the "." and "[]" operators such that each of the names is valid as an argument to gl:getUniformLocation/2 . Each of these reduced uniform variables is counted as one active uniform variable and is assigned an index. A valid name cannot be a structure, an array of structures, or a subcomponent of a vector or matrix.
The size of the uniform variable will be returned in Size
. Uniform variables other
than arrays will have a size of 1. Structures and arrays of structures will be reduced
as described earlier, such that each of the names returned will be a data type in the
earlier list. If this reduction results in an array, the size returned will be as described
for uniform arrays; otherwise, the size returned will be 1.
The list of active uniform variables may include both built-in uniform variables (which begin with the prefix "gl_") as well as user-defined uniform variable names.
This function will return as much information as it can about the specified active uniform
variable. If no information is available, Length
will be 0, and Name
will
be an empty string. This situation could occur if this function is called after a link
operation that failed. If an error occurs, the return values Length
, Size
, Type
, and Name
will be unmodified.
See
getAttachedShaders(Program, MaxCount) -> [integer()]
Program = integer()
MaxCount = integer()
Returns the handles of the shader objects attached to a program object
gl:getAttachedShaders
returns the names of the shader objects attached to Program
. The names of shader objects that are attached to Program
will be returned in Shaders.
The actual number of shader names written into Shaders
is returned in Count.
If no shader objects are attached to Program
, Count
is set to 0. The maximum
number of shader names that may be returned in Shaders
is specified by MaxCount
.
If the number of names actually returned is not required (for instance, if it has just
been obtained by calling gl:getProgramiv/2 ), a value of ?NULL
may be passed
for count. If no shader objects are attached to Program
, a value of 0 will be returned
in Count
. The actual number of attached shaders can be obtained by calling gl:getProgramiv/2
with the value ?GL_ATTACHED_SHADERS
.
See
getAttribLocation(Program, Name) -> integer()
Program = integer()
Name = string()
Returns the location of an attribute variable
gl:getAttribLocation
queries the previously linked program object specified by Program
for the attribute variable specified by Name
and returns the index of the generic
vertex attribute that is bound to that attribute variable. If Name
is a matrix
attribute variable, the index of the first column of the matrix is returned. If the named
attribute variable is not an active attribute in the specified program object or if Name
starts with the reserved prefix "gl_", a value of -1 is returned.
The association between an attribute variable name and a generic attribute index can be
specified at any time by calling gl:bindAttribLocation/3 . Attribute bindings do
not go into effect until gl:linkProgram/1 is called. After a program object has
been linked successfully, the index values for attribute variables remain fixed until
the next link command occurs. The attribute values can only be queried after a link if
the link was successful. gl:getAttribLocation
returns the binding that actually
went into effect the last time gl:linkProgram/1 was called for the specified program
object. Attribute bindings that have been specified since the last link operation are
not returned by gl:getAttribLocation
.
See
getProgramiv(Program, Pname) -> integer()
Program = integer()
Pname = enum()
Returns a parameter from a program object
gl:getProgram
returns in Params
the value of a parameter for a specific program
object. The following parameters are defined:
?GL_DELETE_STATUS
: Params
returns ?GL_TRUE
if Program
is currently
flagged for deletion, and ?GL_FALSE
otherwise.
?GL_LINK_STATUS
: Params
returns ?GL_TRUE
if the last link operation
on Program
was successful, and ?GL_FALSE
otherwise.
?GL_VALIDATE_STATUS
: Params
returns ?GL_TRUE
or if the last validation
operation on Program
was successful, and ?GL_FALSE
otherwise.
?GL_INFO_LOG_LENGTH
: Params
returns the number of characters in the information
log for Program
including the null termination character (i.e., the size of the
character buffer required to store the information log). If Program
has no information
log, a value of 0 is returned.
?GL_ATTACHED_SHADERS
: Params
returns the number of shader objects attached
to Program
.
?GL_ACTIVE_ATOMIC_COUNTER_BUFFERS
: Params
returns the number of active attribute
atomic counter buffers used by Program
.
?GL_ACTIVE_ATTRIBUTES
: Params
returns the number of active attribute variables
for Program
.
?GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
: Params
returns the length of the longest
active attribute name for Program
, including the null termination character (i.e.,
the size of the character buffer required to store the longest attribute name). If no
active attributes exist, 0 is returned.
?GL_ACTIVE_UNIFORMS
: Params
returns the number of active uniform variables
for Program
.
?GL_ACTIVE_UNIFORM_MAX_LENGTH
: Params
returns the length of the longest
active uniform variable name for Program
, including the null termination character
(i.e., the size of the character buffer required to store the longest uniform variable
name). If no active uniform variables exist, 0 is returned.
?GL_PROGRAM_BINARY_LENGTH
: Params
returns the length of the program binary,
in bytes that will be returned by a call to gl:getProgramBinary/2 . When a progam's
?GL_LINK_STATUS
is ?GL_FALSE
, its program binary length is zero.
?GL_TRANSFORM_FEEDBACK_BUFFER_MODE
: Params
returns a symbolic constant indicating
the buffer mode used when transform feedback is active. This may be ?GL_SEPARATE_ATTRIBS
or ?GL_INTERLEAVED_ATTRIBS
.
?GL_TRANSFORM_FEEDBACK_VARYINGS
: Params
returns the number of varying variables
to capture in transform feedback mode for the program.
?GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
: Params
returns the length of
the longest variable name to be used for transform feedback, including the null-terminator.
?GL_GEOMETRY_VERTICES_OUT
: Params
returns the maximum number of vertices
that the geometry shader in Program
will output.
?GL_GEOMETRY_INPUT_TYPE
: Params
returns a symbolic constant indicating the
primitive type accepted as input to the geometry shader contained in Program
.
?GL_GEOMETRY_OUTPUT_TYPE
: Params
returns a symbolic constant indicating
the primitive type that will be output by the geometry shader contained in Program
.
See
getProgramInfoLog(Program, BufSize) -> string()
Program = integer()
BufSize = integer()
Returns the information log for a program object
gl:getProgramInfoLog
returns the information log for the specified program object.
The information log for a program object is modified when the program object is linked
or validated. The string that is returned will be null terminated.
gl:getProgramInfoLog
returns in InfoLog
as much of the information log as
it can, up to a maximum of MaxLength
characters. The number of characters actually
returned, excluding the null termination character, is specified by Length
. If
the length of the returned string is not required, a value of ?NULL
can be passed
in the Length
argument. The size of the buffer required to store the returned
information log can be obtained by calling gl:getProgramiv/2 with the value ?GL_INFO_LOG_LENGTH
.
The information log for a program object is either an empty string, or a string containing information about the last link operation, or a string containing information about the last validation operation. It may contain diagnostic messages, warning messages, and other information. When a program object is created, its information log will be a string of length 0.
See
getShaderiv(Shader, Pname) -> integer()
Shader = integer()
Pname = enum()
Returns a parameter from a shader object
gl:getShader
returns in Params
the value of a parameter for a specific
shader object. The following parameters are defined:
?GL_SHADER_TYPE
: Params
returns ?GL_VERTEX_SHADER
if Shader
is a vertex shader object, ?GL_GEOMETRY_SHADER
if Shader
is a geometry
shader object, and ?GL_FRAGMENT_SHADER
if Shader
is a fragment shader
object.
?GL_DELETE_STATUS
: Params
returns ?GL_TRUE
if Shader
is
currently flagged for deletion, and ?GL_FALSE
otherwise.
?GL_COMPILE_STATUS
: Params
returns ?GL_TRUE
if the last compile
operation on Shader
was successful, and ?GL_FALSE
otherwise.
?GL_INFO_LOG_LENGTH
: Params
returns the number of characters in the information
log for Shader
including the null termination character (i.e., the size of
the character buffer required to store the information log). If Shader
has
no information log, a value of 0 is returned.
?GL_SHADER_SOURCE_LENGTH
: Params
returns the length of the concatenation
of the source strings that make up the shader source for the Shader
, including
the null termination character. (i.e., the size of the character buffer required to
store the shader source). If no source code exists, 0 is returned.
See
getShaderInfoLog(Shader, BufSize) -> string()
Shader = integer()
BufSize = integer()
Returns the information log for a shader object
gl:getShaderInfoLog
returns the information log for the specified shader object.
The information log for a shader object is modified when the shader is compiled. The
string that is returned will be null terminated.
gl:getShaderInfoLog
returns in InfoLog
as much of the information log as
it can, up to a maximum of MaxLength
characters. The number of characters actually
returned, excluding the null termination character, is specified by Length
. If
the length of the returned string is not required, a value of ?NULL
can be passed
in the Length
argument. The size of the buffer required to store the returned
information log can be obtained by calling gl:getShaderiv/2 with the value ?GL_INFO_LOG_LENGTH
.
The information log for a shader object is a string that may contain diagnostic messages, warning messages, and other information about the last compile operation. When a shader object is created, its information log will be a string of length 0.
See
getShaderSource(Shader, BufSize) -> string()
Shader = integer()
BufSize = integer()
Returns the source code string from a shader object
gl:getShaderSource
returns the concatenation of the source code strings from the
shader object specified by Shader
. The source code strings for a shader object
are the result of a previous call to gl:shaderSource/2 . The string returned by
the function will be null terminated.
gl:getShaderSource
returns in Source
as much of the source code string as
it can, up to a maximum of BufSize
characters. The number of characters actually
returned, excluding the null termination character, is specified by Length
. If
the length of the returned string is not required, a value of ?NULL
can be passed
in the Length
argument. The size of the buffer required to store the returned source
code string can be obtained by calling gl:getShaderiv/2 with the value ?GL_SHADER_SOURCE_LENGTH
.
See
getUniformLocation(Program, Name) -> integer()
Program = integer()
Name = string()
Returns the location of a uniform variable
gl:getUniformLocation
returns an integer that represents the location of a specific
uniform variable within a program object. Name
must be a null terminated string
that contains no white space. Name
must be an active uniform variable name in Program
that is not a structure, an array of structures, or a subcomponent of a vector or a matrix.
This function returns -1 if Name
does not correspond to an active uniform variable
in Program
, if Name
starts with the reserved prefix "gl_", or if Name
is associated with an atomic counter or a named uniform block.
Uniform variables that are structures or arrays of structures may be queried by calling gl:getUniformLocation
for each field within the structure. The array element operator "[]" and the structure
field operator "." may be used in Name
in order to select elements within an array
or fields within a structure. The result of using these operators is not allowed to be
another structure, an array of structures, or a subcomponent of a vector or a matrix.
Except if the last part of Name
indicates a uniform variable array, the location
of the first element of an array can be retrieved by using the name of the array, or by
using the name appended by "[0]".
The actual locations assigned to uniform variables are not known until the program object
is linked successfully. After linking has occurred, the command gl:getUniformLocation
can be used to obtain the location of a uniform variable. This location value can then
be passed to gl:uniform1f/2 to set the value of the uniform variable or to gl:getUniformfv/2
in order to query the current value of the uniform variable. After a program object has
been linked successfully, the index values for uniform variables remain fixed until the
next link command occurs. Uniform variable locations and values can only be queried after
a link if the link was successful.
See
getUniformfv(Program, Location) -> matrix()
Program = integer()
Location = integer()
Returns the value of a uniform variable
gl:getUniform
returns in Params
the value(s) of the specified uniform variable.
The type of the uniform variable specified by Location
determines the number of
values returned. If the uniform variable is defined in the shader as a boolean, int, or
float, a single value will be returned. If it is defined as a vec2, ivec2, or bvec2, two
values will be returned. If it is defined as a vec3, ivec3, or bvec3, three values will
be returned, and so on. To query values stored in uniform variables declared as arrays,
call gl:getUniform
for each element of the array. To query values stored in uniform
variables declared as structures, call gl:getUniform
for each field in the structure.
The values for uniform variables declared as a matrix will be returned in column major
order.
The locations assigned to uniform variables are not known until the program object is
linked. After linking has occurred, the command gl:getUniformLocation/2 can be
used to obtain the location of a uniform variable. This location value can then be passed
to gl:getUniform
in order to query the current value of the uniform variable. After
a program object has been linked successfully, the index values for uniform variables
remain fixed until the next link command occurs. The uniform variable values can only
be queried after a link if the link was successful.
See
getUniformiv(Program, Location) -> {integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer()}
Program = integer()
Location = integer()
See getUniformfv/2
getVertexAttribdv(Index, Pname) -> {float(), float(), float(), float()}
Index = integer()
Pname = enum()
Return a generic vertex attribute parameter
gl:getVertexAttrib
returns in Params
the value of a generic vertex attribute
parameter. The generic vertex attribute to be queried is specified by Index
, and
the parameter to be queried is specified by Pname
.
The accepted parameter names are as follows:
?GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
: Params
returns a single value, the
name of the buffer object currently bound to the binding point corresponding to generic
vertex attribute array Index
. If no buffer object is bound, 0 is returned. The
initial value is 0.
?GL_VERTEX_ATTRIB_ARRAY_ENABLED
: Params
returns a single value that is non-zero
(true) if the vertex attribute array for Index
is enabled and 0 (false) if it is
disabled. The initial value is ?GL_FALSE
.
?GL_VERTEX_ATTRIB_ARRAY_SIZE
: Params
returns a single value, the size of
the vertex attribute array for Index
. The size is the number of values for each
element of the vertex attribute array, and it will be 1, 2, 3, or 4. The initial value
is 4.
?GL_VERTEX_ATTRIB_ARRAY_STRIDE
: Params
returns a single value, the array
stride for (number of bytes between successive elements in) the vertex attribute array
for Index
. A value of 0 indicates that the array elements are stored sequentially
in memory. The initial value is 0.
?GL_VERTEX_ATTRIB_ARRAY_TYPE
: Params
returns a single value, a symbolic
constant indicating the array type for the vertex attribute array for Index
. Possible
values are ?GL_BYTE
, ?GL_UNSIGNED_BYTE
, ?GL_SHORT
, ?GL_UNSIGNED_SHORT
, ?GL_INT
, ?GL_UNSIGNED_INT
, ?GL_FLOAT
, and ?GL_DOUBLE
. The
initial value is ?GL_FLOAT
.
?GL_VERTEX_ATTRIB_ARRAY_NORMALIZED
: Params
returns a single value that is
non-zero (true) if fixed-point data types for the vertex attribute array indicated by Index
are normalized when they are converted to floating point, and 0 (false) otherwise. The
initial value is ?GL_FALSE
.
?GL_VERTEX_ATTRIB_ARRAY_INTEGER
: Params
returns a single value that is non-zero
(true) if fixed-point data types for the vertex attribute array indicated by Index
have integer data types, and 0 (false) otherwise. The initial value is 0 (?GL_FALSE
).
?GL_VERTEX_ATTRIB_ARRAY_DIVISOR
: Params
returns a single value that is the
frequency divisor used for instanced rendering. See gl:vertexAttribDivisor/2 . The
initial value is 0.
?GL_CURRENT_VERTEX_ATTRIB
: Params
returns four values that represent the
current value for the generic vertex attribute specified by index. Generic vertex attribute
0 is unique in that it has no current state, so an error will be generated if Index
is 0. The initial value for all other generic vertex attributes is (0,0,0,1).
gl:getVertexAttribdv
and gl:getVertexAttribfv
return the current attribute
values as four single-precision floating-point values; gl:getVertexAttribiv
reads
them as floating-point values and converts them to four integer values; gl:getVertexAttribIiv
and gl:getVertexAttribIuiv
read and return them as signed or unsigned integer values,
respectively; gl:getVertexAttribLdv
reads and returns them as four double-precision
floating-point values.
All of the parameters except ?GL_CURRENT_VERTEX_ATTRIB
represent state stored in
the currently bound vertex array object.
See
getVertexAttribfv(Index, Pname) -> {float(), float(), float(), float()}
Index = integer()
Pname = enum()
getVertexAttribiv(Index, Pname) -> {integer(), integer(), integer(), integer()}
Index = integer()
Pname = enum()
isProgram(Program) -> 0 | 1
Program = integer()
Determines if a name corresponds to a program object
gl:isProgram
returns ?GL_TRUE
if Program
is the name of a program
object previously created with gl:createProgram/0 and not yet deleted with gl:deleteProgram/1
. If Program
is zero or a non-zero value that is not the name of a program object,
or if an error occurs, gl:isProgram
returns ?GL_FALSE
.
See
isShader(Shader) -> 0 | 1
Shader = integer()
Determines if a name corresponds to a shader object
gl:isShader
returns ?GL_TRUE
if Shader
is the name of a shader object
previously created with gl:createShader/1 and not yet deleted with gl:deleteShader/1
. If Shader
is zero or a non-zero value that is not the name of a shader object,
or if an error occurs, gl:isShader
returns ?GL_FALSE
.
See
linkProgram(Program) -> ok
Program = integer()
Links a program object
gl:linkProgram
links the program object specified by Program
. If any shader
objects of type ?GL_VERTEX_SHADER
are attached to Program
, they will be
used to create an executable that will run on the programmable vertex processor. If any
shader objects of type ?GL_GEOMETRY_SHADER
are attached to Program
, they
will be used to create an executable that will run on the programmable geometry processor.
If any shader objects of type ?GL_FRAGMENT_SHADER
are attached to Program
,
they will be used to create an executable that will run on the programmable fragment processor.
The status of the link operation will be stored as part of the program object's state.
This value will be set to ?GL_TRUE
if the program object was linked without errors
and is ready for use, and ?GL_FALSE
otherwise. It can be queried by calling gl:getProgramiv/2
with arguments Program
and ?GL_LINK_STATUS
.
As a result of a successful link operation, all active user-defined uniform variables
belonging to Program
will be initialized to 0, and each of the program object's
active uniform variables will be assigned a location that can be queried by calling gl:getUniformLocation/2
. Also, any active user-defined attribute variables that have not been bound to a generic
vertex attribute index will be bound to one at this time.
Linking of a program object can fail for a number of reasons as specified in the OpenGL Shading Language Specification
. The following lists some of the conditions that will cause a link error.
The number of active attribute variables supported by the implementation has been exceeded.
The storage limit for uniform variables has been exceeded.
The number of active uniform variables supported by the implementation has been exceeded.
The main
function is missing for the vertex, geometry or fragment shader.
A varying variable actually used in the fragment shader is not declared in the same way (or is not declared at all) in the vertex shader, or geometry shader shader if present.
A reference to a function or variable name is unresolved.
A shared global is declared with two different types or two different initial values.
One or more of the attached shader objects has not been successfully compiled.
Binding a generic attribute matrix caused some rows of the matrix to fall outside the
allowed maximum of ?GL_MAX_VERTEX_ATTRIBS
.
Not enough contiguous vertex attribute slots could be found to bind attribute matrices.
The program object contains objects to form a fragment shader but does not contain objects to form a vertex shader.
The program object contains objects to form a geometry shader but does not contain objects to form a vertex shader.
The program object contains objects to form a geometry shader and the input primitive type, output primitive type, or maximum output vertex count is not specified in any compiled geometry shader object.
The program object contains objects to form a geometry shader and the input primitive type, output primitive type, or maximum output vertex count is specified differently in multiple geometry shader objects.
The number of active outputs in the fragment shader is greater than the value of ?GL_MAX_DRAW_BUFFERS
.
The program has an active output assigned to a location greater than or equal to the value
of ?GL_MAX_DUAL_SOURCE_DRAW_BUFFERS
and has an active output assigned an index
greater than or equal to one.
More than one varying out variable is bound to the same number and index.
The explicit binding assigments do not leave enough space for the linker to automatically assign a location for a varying out array, which requires multiple contiguous locations.
The Count
specified by gl:transformFeedbackVaryings/3 is non-zero, but the
program object has no vertex or geometry shader.
Any variable name specified to gl:transformFeedbackVaryings/3 in the Varyings
array is not declared as an output in the vertex shader (or the geometry shader, if active).
Any two entries in the Varyings
array given gl:transformFeedbackVaryings/3
specify the same varying variable.
The total number of components to capture in any transform feedback varying variable is
greater than the constant ?GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS
and the
buffer mode is ?SEPARATE_ATTRIBS
.
When a program object has been successfully linked, the program object can be made part of current state by calling gl:useProgram/1 . Whether or not the link operation was successful, the program object's information log will be overwritten. The information log can be retrieved by calling gl:getProgramInfoLog/2 .
gl:linkProgram
will also install the generated executables as part of the current
rendering state if the link operation was successful and the specified program object
is already currently in use as a result of a previous call to gl:useProgram/1 .
If the program object currently in use is relinked unsuccessfully, its link status will
be set to ?GL_FALSE
, but the executables and associated state will remain part
of the current state until a subsequent call to gl:useProgram
removes it from use.
After it is removed from use, it cannot be made part of current state until it has been
successfully relinked.
If Program
contains shader objects of type ?GL_VERTEX_SHADER
, and optionally
of type ?GL_GEOMETRY_SHADER
, but does not contain shader objects of type ?GL_FRAGMENT_SHADER
, the vertex shader executable will be installed on the programmable vertex processor,
the geometry shader executable, if present, will be installed on the programmable geometry
processor, but no executable will be installed on the fragment processor. The results
of rasterizing primitives with such a program will be undefined.
The program object's information log is updated and the program is generated at the time of the link operation. After the link operation, applications are free to modify attached shader objects, compile attached shader objects, detach shader objects, delete shader objects, and attach additional shader objects. None of these operations affects the information log or the program that is part of the program object.
See
shaderSource(Shader, String) -> ok
Shader = integer()
String = [string()]
Replaces the source code in a shader object
gl:shaderSource
sets the source code in Shader
to the source code in the
array of strings specified by String
. Any source code previously stored in the
shader object is completely replaced. The number of strings in the array is specified
by Count
. If Length
is ?NULL
, each string is assumed to be null
terminated. If Length
is a value other than ?NULL
, it points to an array
containing a string length for each of the corresponding elements of String
.
Each element in the Length
array may contain the length of the corresponding
string (the null character is not counted as part of the string length) or a value less
than 0 to indicate that the string is null terminated. The source code strings are not
scanned or parsed at this time; they are simply copied into the specified shader object.
See
useProgram(Program) -> ok
Program = integer()
Installs a program object as part of current rendering state
gl:useProgram
installs the program object specified by Program
as part of
current rendering state. One or more executables are created in a program object by
successfully attaching shader objects to it with gl:attachShader/2 , successfully
compiling the shader objects with gl:compileShader/1 , and successfully linking
the program object with gl:linkProgram/1 .
A program object will contain an executable that will run on the vertex processor if
it contains one or more shader objects of type ?GL_VERTEX_SHADER
that have been
successfully compiled and linked. A program object will contain an executable that will
run on the geometry processor if it contains one or more shader objects of type ?GL_GEOMETRY_SHADER
that have been successfully compiled and linked. Similarly, a program object will contain
an executable that will run on the fragment processor if it contains one or more shader
objects of type ?GL_FRAGMENT_SHADER
that have been successfully compiled and
linked.
While a program object is in use, applications are free to modify attached shader objects,
compile attached shader objects, attach additional shader objects, and detach or delete
shader objects. None of these operations will affect the executables that are part of
the current state. However, relinking the program object that is currently in use will
install the program object as part of the current rendering state if the link operation
was successful (see gl:linkProgram/1 ). If the program object currently in use
is relinked unsuccessfully, its link status will be set to ?GL_FALSE
, but the
executables and associated state will remain part of the current state until a subsequent
call to gl:useProgram
removes it from use. After it is removed from use, it cannot
be made part of current state until it has been successfully relinked.
If Program
is zero, then the current rendering state refers to an invalid
program object and the results of shader execution are undefined. However, this is not
an error.
If Program
does not contain shader objects of type ?GL_FRAGMENT_SHADER
,
an executable will be installed on the vertex, and possibly geometry processors, but
the results of fragment shader execution will be undefined.
See
uniform1f(Location, V0) -> ok
Location = integer()
V0 = float()
Specify the value of a uniform variable for the current program object
gl:uniform
modifies the value of a uniform variable or a uniform variable array.
The location of the uniform variable to be modified is specified by Location
, which
should be a value returned by gl:getUniformLocation/2 . gl:uniform
operates
on the program object that was made part of current state by calling gl:useProgram/1
.
The commands gl:uniform{1|2|3|4}{f|i|ui}
are used to change the value of the uniform
variable specified by Location
using the values passed as arguments. The number
specified in the command should match the number of components in the data type of the
specified uniform variable (e.g., 1
for float, int, unsigned int, bool; 2
for vec2, ivec2, uvec2, bvec2, etc.). The suffix f
indicates that floating-point
values are being passed; the suffix i
indicates that integer values are being passed;
the suffix ui
indicates that unsigned integer values are being passed, and this
type should also match the data type of the specified uniform variable. The i
variants
of this function should be used to provide values for uniform variables defined as int, ivec2
, ivec3, ivec4, or arrays of these. The ui
variants of this function should be
used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4,
or arrays of these. The f
variants should be used to provide values for uniform
variables of type float, vec2, vec3, vec4, or arrays of these. Either the i
, ui
or f
variants may be used to provide values for uniform variables of type bool, bvec2
, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input
value is 0 or 0.0f, and it will be set to true otherwise.
All active uniform variables defined in a program object are initialized to 0 when the
program object is linked successfully. They retain the values assigned to them by a call
to gl:uniform
until the next successful link operation occurs on the program object,
when they are once again initialized to 0.
The commands gl:uniform{1|2|3|4}{f|i|ui}v
can be used to modify a single uniform
variable or a uniform variable array. These commands pass a count and a pointer to the
values to be loaded into a uniform variable or a uniform variable array. A count of 1
should be used if modifying the value of a single uniform variable, and a count of 1 or
greater can be used to modify an entire array or part of an array. When loading n
elements starting at an arbitrary position m
in a uniform variable array, elements
m
+ n
- 1 in the array will be replaced with the new values. If M
+ N
- 1 is larger than the size of the uniform variable array, values for all array elements
beyond the end of the array will be ignored. The number specified in the name of the command
indicates the number of components for each element in Value
, and it should match
the number of components in the data type of the specified uniform variable (e.g., 1
for float, int, bool; 2
for vec2, ivec2, bvec2, etc.). The data type specified
in the name of the command must match the data type for the specified uniform variable
as described previously for gl:uniform{1|2|3|4}{f|i|ui}
.
For uniform variable arrays, each element of the array is considered to be of the type
indicated in the name of the command (e.g., gl:uniform3f
or gl:uniform3fv
can be used to load a uniform variable array of type vec3). The number of elements of
the uniform variable array to be modified is specified by Count
The commands gl:uniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv
are used to modify
a matrix or an array of matrices. The numbers in the command name are interpreted as the
dimensionality of the matrix. The number 2
indicates a 2 × 2 matrix (i.e., 4 values),
the number 3
indicates a 3 × 3 matrix (i.e., 9 values), and the number 4
indicates a 4 × 4 matrix (i.e., 16 values). Non-square matrix dimensionality is explicit,
with the first number representing the number of columns and the second number representing
the number of rows. For example, 2x4
indicates a 2 × 4 matrix with 2 columns and
4 rows (i.e., 8 values). If Transpose
is ?GL_FALSE
, each matrix is assumed
to be supplied in column major order. If Transpose
is ?GL_TRUE
, each matrix
is assumed to be supplied in row major order. The Count
argument indicates the
number of matrices to be passed. A count of 1 should be used if modifying the value of
a single matrix, and a count greater than 1 can be used to modify an array of matrices.
See
uniform3f(Location, V0, V1, V2) -> ok
Location = integer()
V0 = float()
V1 = float()
V2 = float()
See uniform1f/2
uniform4f(Location, V0, V1, V2, V3) -> ok
Location = integer()
V0 = float()
V1 = float()
V2 = float()
V3 = float()
See uniform1f/2
uniform3i(Location, V0, V1, V2) -> ok
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
See uniform1f/2
uniform4i(Location, V0, V1, V2, V3) -> ok
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
V3 = integer()
See uniform1f/2
uniform3fv(Location, Value) -> ok
Location = integer()
Value = [{float(), float(), float()}]
See uniform1f/2
uniform4fv(Location, Value) -> ok
Location = integer()
Value = [{float(), float(), float(), float()}]
See uniform1f/2
uniform2iv(Location, Value) -> ok
Location = integer()
Value = [{integer(), integer()}]
See uniform1f/2
uniform3iv(Location, Value) -> ok
Location = integer()
Value = [{integer(), integer(), integer()}]
See uniform1f/2
uniform4iv(Location, Value) -> ok
Location = integer()
Value = [{integer(), integer(), integer(), integer()}]
See uniform1f/2
uniformMatrix2fv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3fv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix4fv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
validateProgram(Program) -> ok
Program = integer()
Validates a program object
gl:validateProgram
checks to see whether the executables contained in Program
can execute given the current OpenGL state. The information generated by the validation
process will be stored in Program
's information log. The validation information
may consist of an empty string, or it may be a string containing information about how
the current program object interacts with the rest of current OpenGL state. This provides
a way for OpenGL implementers to convey more information about why the current program
is inefficient, suboptimal, failing to execute, and so on.
The status of the validation operation will be stored as part of the program object's
state. This value will be set to ?GL_TRUE
if the validation succeeded, and ?GL_FALSE
otherwise. It can be queried by calling gl:getProgramiv/2 with arguments Program
and ?GL_VALIDATE_STATUS
. If validation is successful, Program
is guaranteed
to execute given the current state. Otherwise, Program
is guaranteed to not execute.
This function is typically useful only during application development. The informational string stored in the information log is completely implementation dependent; therefore, an application should not expect different OpenGL implementations to produce identical information strings.
See
vertexAttrib1d(Index, X) -> ok
Index = integer()
X = float()
Specifies the value of a generic vertex attribute
The gl:vertexAttrib
family of entry points allows an application to pass generic
vertex attributes in numbered locations.
Generic attributes are defined as four-component values that are organized into an array.
The first entry of this array is numbered 0, and the size of the array is specified by
the implementation-dependent constant ?GL_MAX_VERTEX_ATTRIBS
. Individual elements
of this array can be modified with a gl:vertexAttrib
call that specifies the index
of the element to be modified and a value for that element.
These commands can be used to specify one, two, three, or all four components of the generic
vertex attribute specified by Index
. A 1
in the name of the command indicates
that only one value is passed, and it will be used to modify the first component of the
generic vertex attribute. The second and third components will be set to 0, and the fourth
component will be set to 1. Similarly, a 2
in the name of the command indicates
that values are provided for the first two components, the third component will be set
to 0, and the fourth component will be set to 1. A 3
in the name of the command
indicates that values are provided for the first three components and the fourth component
will be set to 1, whereas a 4
in the name indicates that values are provided for
all four components.
The letters s
, f
, i
, d
, ub
, us
, and ui
indicate whether the arguments are of type short, float, int, double, unsigned byte, unsigned
short, or unsigned int. When v
is appended to the name, the commands can take a
pointer to an array of such values.
Additional capitalized letters can indicate further alterations to the default behavior of the glVertexAttrib function:
The commands containing N
indicate that the arguments will be passed as fixed-point
values that are scaled to a normalized range according to the component conversion rules
defined by the OpenGL specification. Signed values are understood to represent fixed-point
values in the range [-1,1], and unsigned values are understood to represent fixed-point
values in the range [0,1].
The commands containing I
indicate that the arguments are extended to full signed
or unsigned integers.
The commands containing P
indicate that the arguments are stored as packed components
within a larger natural type.
The commands containing L
indicate that the arguments are full 64-bit quantities
and should be passed directly to shader inputs declared as 64-bit double precision types.
OpenGL Shading Language attribute variables are allowed to be of type mat2, mat3, or mat4.
Attributes of these types may be loaded using the gl:vertexAttrib
entry points.
Matrices must be loaded into successive generic attribute slots in column major order,
with one column of the matrix in each generic attribute slot.
A user-defined attribute variable declared in a vertex shader can be bound to a generic attribute index by calling gl:bindAttribLocation/3 . This allows an application to use more descriptive variable names in a vertex shader. A subsequent change to the specified generic vertex attribute will be immediately reflected as a change to the corresponding attribute variable in the vertex shader.
The binding between a generic vertex attribute index and a user-defined attribute variable in a vertex shader is part of the state of a program object, but the current value of the generic vertex attribute is not. The value of each generic vertex attribute is part of current state, just like standard vertex attributes, and it is maintained even if a different program object is used.
An application may freely modify generic vertex attributes that are not bound to a named vertex shader attribute variable. These values are simply maintained as part of current state and will not be accessed by the vertex shader. If a generic vertex attribute bound to an attribute variable in a vertex shader is not updated while the vertex shader is executing, the vertex shader will repeatedly use the current value for the generic vertex attribute.
See
vertexAttrib1sv(Index::integer(), V) -> ok
V = {X::integer()}
Equivalent to vertexAttrib1s(Index, X).
vertexAttrib2dv(Index::integer(), V) -> ok
V = {X::float(), Y::float()}
Equivalent to vertexAttrib2d(Index, X, Y).
vertexAttrib2fv(Index::integer(), V) -> ok
V = {X::float(), Y::float()}
Equivalent to vertexAttrib2f(Index, X, Y).
vertexAttrib2sv(Index::integer(), V) -> ok
V = {X::integer(), Y::integer()}
Equivalent to vertexAttrib2s(Index, X, Y).
vertexAttrib3d(Index, X, Y, Z) -> ok
Index = integer()
X = float()
Y = float()
Z = float()
See vertexAttrib1d/2
vertexAttrib3dv(Index::integer(), V) -> ok
V = {X::float(), Y::float(), Z::float()}
Equivalent to vertexAttrib3d(Index, X, Y, Z).
vertexAttrib3f(Index, X, Y, Z) -> ok
Index = integer()
X = float()
Y = float()
Z = float()
See vertexAttrib1d/2
vertexAttrib3fv(Index::integer(), V) -> ok
V = {X::float(), Y::float(), Z::float()}
Equivalent to vertexAttrib3f(Index, X, Y, Z).
vertexAttrib3s(Index, X, Y, Z) -> ok
Index = integer()
X = integer()
Y = integer()
Z = integer()
See vertexAttrib1d/2
vertexAttrib3sv(Index::integer(), V) -> ok
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to vertexAttrib3s(Index, X, Y, Z).
vertexAttrib4Nbv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4Niv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4Nsv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4Nub(Index, X, Y, Z, W) -> ok
Index = integer()
X = integer()
Y = integer()
Z = integer()
W = integer()
See vertexAttrib1d/2
vertexAttrib4Nubv(Index::integer(), V) -> ok
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertexAttrib4Nub(Index, X, Y, Z, W).
vertexAttrib4Nuiv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4Nusv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4bv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4d(Index, X, Y, Z, W) -> ok
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
See vertexAttrib1d/2
vertexAttrib4dv(Index::integer(), V) -> ok
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to vertexAttrib4d(Index, X, Y, Z, W).
vertexAttrib4f(Index, X, Y, Z, W) -> ok
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
See vertexAttrib1d/2
vertexAttrib4fv(Index::integer(), V) -> ok
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to vertexAttrib4f(Index, X, Y, Z, W).
vertexAttrib4iv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4s(Index, X, Y, Z, W) -> ok
Index = integer()
X = integer()
Y = integer()
Z = integer()
W = integer()
See vertexAttrib1d/2
vertexAttrib4sv(Index::integer(), V) -> ok
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertexAttrib4s(Index, X, Y, Z, W).
vertexAttrib4ubv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4uiv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4usv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttribPointer(Index, Size, Type, Normalized, Stride, Pointer) -> ok
Index = integer()
Size = integer()
Type = enum()
Normalized = 0 | 1
Stride = integer()
Pointer = offset() | mem()
Define an array of generic vertex attribute data
gl:vertexAttribPointer
, gl:vertexAttribIPointer
and gl:vertexAttribLPointer
specify the location and data format of the array of generic vertex attributes at index Index
to use when rendering. Size
specifies the number of components per attribute and
must be 1, 2, 3, 4, or ?GL_BGRA
. Type
specifies the data type of each component,
and Stride
specifies the byte stride from one attribute to the next, allowing vertices
and attributes to be packed into a single array or stored in separate arrays.
For gl:vertexAttribPointer
, if Normalized
is set to ?GL_TRUE
, it
indicates that values stored in an integer format are to be mapped to the range [-1,1]
(for signed values) or [0,1] (for unsigned values) when they are accessed and converted
to floating point. Otherwise, values will be converted to floats directly without normalization.
For gl:vertexAttribIPointer
, only the integer types ?GL_BYTE
, ?GL_UNSIGNED_BYTE
, ?GL_SHORT
, ?GL_UNSIGNED_SHORT
, ?GL_INT
, ?GL_UNSIGNED_INT
are accepted. Values are always left as integer values.
gl:vertexAttribLPointer
specifies state for a generic vertex attribute array associated
with a shader attribute variable declared with 64-bit double precision components. Type
must be ?GL_DOUBLE
. Index
, Size
, and Stride
behave as described
for gl:vertexAttribPointer
and gl:vertexAttribIPointer
.
If Pointer
is not NULL, a non-zero named buffer object must be bound to the ?GL_ARRAY_BUFFER
target (see gl:bindBuffer/2 ), otherwise an error is generated. Pointer
is treated as a byte offset into the buffer object's data store. The buffer object binding
(?GL_ARRAY_BUFFER_BINDING
) is saved as generic vertex attribute array state (?GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING
) for index Index
.
When a generic vertex attribute array is specified, Size
, Type
, Normalized
, Stride
, and Pointer
are saved as vertex array state, in addition to the
current vertex array buffer object binding.
To enable and disable a generic vertex attribute array, call gl:disableVertexAttribArray/1
and gl:disableVertexAttribArray/1 with Index
. If enabled, the generic vertex
attribute array is used when gl:drawArrays/3 , gl:multiDrawArrays/3 , gl:drawElements/4
, see glMultiDrawElements
, or gl:drawRangeElements/6 is called.
See
uniformMatrix2x3fv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3x2fv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix2x4fv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix4x2fv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3x4fv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix4x3fv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
colorMaski(Index, R, G, B, A) -> ok
Index = integer()
R = 0 | 1
G = 0 | 1
B = 0 | 1
A = 0 | 1
glColorMaski
See
disablei(Target, Index) -> ok
Target = enum()
Index = integer()
glEnablei
See
isEnabledi(Target, Index) -> 0 | 1
Target = enum()
Index = integer()
glIsEnabledi
See
beginTransformFeedback(PrimitiveMode) -> ok
PrimitiveMode = enum()
Start transform feedback operation
Transform feedback mode captures the values of varying variables written by the vertex
shader (or, if active, the geometry shader). Transform feedback is said to be active after
a call to gl:beginTransformFeedback
until a subsequent call to gl:beginTransformFeedback/1
. Transform feedback commands must be paired.
If no geometry shader is present, while transform feedback is active the Mode
parameter to gl:drawArrays/3 must match those specified in the following table:
Transform Feedback
PrimitiveMode
Allowed Render Primitive
Modes
?GL_POINTS
?GL_POINTS
?GL_LINES
?GL_LINES
, ?GL_LINE_LOOP
, ?GL_LINE_STRIP
, ?GL_LINES_ADJACENCY
, ?GL_LINE_STRIP_ADJACENCY
?GL_TRIANGLES
?GL_TRIANGLES
, ?GL_TRIANGLE_STRIP
, ?GL_TRIANGLE_FAN
, ?GL_TRIANGLES_ADJACENCY
, ?GL_TRIANGLE_STRIP_ADJACENCY
If a geometry shader is present, the output primitive type from the geometry shader must match those provided in the following table:
Transform Feedback
PrimitiveMode
Allowed Geometry Shader Output Primitive Type
?GL_POINTS
?points
?GL_LINES
?line_strip
?GL_TRIANGLES
?triangle_strip
See
endTransformFeedback() -> ok
bindBufferRange(Target, Index, Buffer, Offset, Size) -> ok
Target = enum()
Index = integer()
Buffer = integer()
Offset = integer()
Size = integer()
Bind a range within a buffer object to an indexed buffer target
gl:bindBufferRange
binds a range the buffer object Buffer
represented by Offset
and Size
to the binding point at index Index
of the array of targets specified
by Target
. Each Target
represents an indexed array of buffer binding points,
as well as a single general binding point that can be used by other buffer manipulation
functions such as gl:bindBuffer/2 or see glMapBuffer
. In addition to binding
a range of Buffer
to the indexed buffer binding target, gl:bindBufferBase
also binds the range to the generic buffer binding point specified by Target
.
Offset
specifies the offset in basic machine units into the buffer object Buffer
and Size
specifies the amount of data that can be read from the buffer object
while used as an indexed target.
See
bindBufferBase(Target, Index, Buffer) -> ok
Target = enum()
Index = integer()
Buffer = integer()
Bind a buffer object to an indexed buffer target
gl:bindBufferBase
binds the buffer object Buffer
to the binding point at
index Index
of the array of targets specified by Target
. Each Target
represents an indexed array of buffer binding points, as well as a single general binding
point that can be used by other buffer manipulation functions such as gl:bindBuffer/2
or see glMapBuffer
. In addition to binding Buffer
to the indexed buffer
binding target, gl:bindBufferBase
also binds Buffer
to the generic buffer
binding point specified by Target
.
See
transformFeedbackVaryings(Program, Varyings, BufferMode) -> ok
Program = integer()
Varyings = [string()]
BufferMode = enum()
Specify values to record in transform feedback buffers
The names of the vertex or geometry shader outputs to be recorded in transform feedback
mode are specified using gl:transformFeedbackVaryings
. When a geometry shader is
active, transform feedback records the values of selected geometry shader output variables
from the emitted vertices. Otherwise, the values of the selected vertex shader outputs
are recorded.
The state set by gl:tranformFeedbackVaryings
is stored and takes effect next time gl:linkProgram/1
is called on Program
. When gl:linkProgram/1 is called, Program
is
linked so that the values of the specified varying variables for the vertices of each
primitive generated by the GL are written to a single buffer object if BufferMode
is ?GL_INTERLEAVED_ATTRIBS
or multiple buffer objects if BufferMode
is ?GL_SEPARATE_ATTRIBS
.
In addition to the errors generated by gl:transformFeedbackVaryings
, the program Program
will fail to link if:
The count specified by gl:transformFeedbackVaryings
is non-zero, but the program
object has no vertex or geometry shader.
Any variable name specified in the Varyings
array is not declared as an output
in the vertex shader (or the geometry shader, if active).
Any two entries in the Varyings
array specify the same varying variable.
The total number of components to capture in any varying variable in Varyings
is greater than the constant ?GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS
and
the buffer mode is ?GL_SEPARATE_ATTRIBS
.
The total number of components to capture is greater than the constant ?GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS
and the buffer mode is ?GL_INTERLEAVED_ATTRIBS
.
See
getTransformFeedbackVarying(Program, Index, BufSize) -> {Size::integer(), Type::enum(), Name::string()}
Program = integer()
Index = integer()
BufSize = integer()
Retrieve information about varying variables selected for transform feedback
Information about the set of varying variables in a linked program that will be captured
during transform feedback may be retrieved by calling gl:getTransformFeedbackVarying
.
gl:getTransformFeedbackVarying
provides information about the varying variable selected
by Index
. An Index
of 0 selects the first varying variable specified in
the Varyings
array passed to gl:transformFeedbackVaryings/3 , and an Index
of ?GL_TRANSFORM_FEEDBACK_VARYINGS-1
selects the last such variable.
The name of the selected varying is returned as a null-terminated string in Name
.
The actual number of characters written into Name
, excluding the null terminator,
is returned in Length
. If Length
is NULL, no length is returned. The maximum
number of characters that may be written into Name
, including the null terminator,
is specified by BufSize
.
The length of the longest varying name in program is given by ?GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
, which can be queried with gl:getProgramiv/2 .
For the selected varying variable, its type is returned into Type
. The size of
the varying is returned into Size
. The value in Size
is in units of the
type returned in Type
. The type returned can be any of the scalar, vector, or matrix
attribute types returned by gl:getActiveAttrib/3 . If an error occurred, the return
parameters Length
, Size
, Type
and Name
will be unmodified.
This command will return as much information about the varying variables as possible.
If no information is available, Length
will be set to zero and Name
will
be an empty string. This situation could arise if gl:getTransformFeedbackVarying
is called after a failed link.
See
clampColor(Target, Clamp) -> ok
Target = enum()
Clamp = enum()
specify whether data read via
gl:readPixels/7 should be clamped
gl:clampColor
controls color clamping that is performed during gl:readPixels/7
. Target
must be ?GL_CLAMP_READ_COLOR
. If Clamp
is ?GL_TRUE
,
read color clamping is enabled; if Clamp
is ?GL_FALSE
, read color clamping
is disabled. If Clamp
is ?GL_FIXED_ONLY
, read color clamping is enabled
only if the selected read buffer has fixed point components and disabled otherwise.
See
beginConditionalRender(Id, Mode) -> ok
Id = integer()
Mode = enum()
Start conditional rendering
Conditional rendering is started using gl:beginConditionalRender
and ended using gl:endConditionalRender
. During conditional rendering, all vertex array commands, as well as gl:clear/1
and gl:clearBufferiv/3 have no effect if the (?GL_SAMPLES_PASSED
) result of
the query object Id
is zero, or if the (?GL_ANY_SAMPLES_PASSED
) result is ?GL_FALSE
. The results of commands setting the current vertex state, such as gl:vertexAttrib1d/2
are undefined. If the (?GL_SAMPLES_PASSED
) result is non-zero or if the (?GL_ANY_SAMPLES_PASSED
) result is ?GL_TRUE
, such commands are not discarded. The Id
parameter to gl:beginConditionalRender
must be the name of a query object previously returned from a call to gl:genQueries/1
. Mode
specifies how the results of the query object are to be interpreted. If Mode
is ?GL_QUERY_WAIT
, the GL waits for the results of the query to be available and
then uses the results to determine if subsequent rendering commands are discarded. If Mode
is ?GL_QUERY_NO_WAIT
, the GL may choose to unconditionally execute the subsequent
rendering commands without waiting for the query to complete.
If Mode
is ?GL_QUERY_BY_REGION_WAIT
, the GL will also wait for occlusion
query results and discard rendering commands if the result of the occlusion query is zero.
If the query result is non-zero, subsequent rendering commands are executed, but the GL
may discard the results of the commands for any region of the framebuffer that did not
contribute to the sample count in the specified occlusion query. Any such discarding is
done in an implementation-dependent manner, but the rendering command results may not
be discarded for any samples that contributed to the occlusion query sample count. If Mode
is ?GL_QUERY_BY_REGION_NO_WAIT
, the GL operates as in ?GL_QUERY_BY_REGION_WAIT
, but may choose to unconditionally execute the subsequent rendering commands without
waiting for the query to complete.
See
endConditionalRender() -> ok
vertexAttribIPointer(Index, Size, Type, Stride, Pointer) -> ok
Index = integer()
Size = integer()
Type = enum()
Stride = integer()
Pointer = offset() | mem()
glVertexAttribIPointer
See
getVertexAttribIiv(Index, Pname) -> {integer(), integer(), integer(), integer()}
Index = integer()
Pname = enum()
getVertexAttribIuiv(Index, Pname) -> {integer(), integer(), integer(), integer()}
Index = integer()
Pname = enum()
glGetVertexAttribI
See
vertexAttribI3i(Index, X, Y, Z) -> ok
Index = integer()
X = integer()
Y = integer()
Z = integer()
See vertexAttrib1d/2
vertexAttribI4i(Index, X, Y, Z, W) -> ok
Index = integer()
X = integer()
Y = integer()
Z = integer()
W = integer()
See vertexAttrib1d/2
vertexAttribI2ui(Index, X, Y) -> ok
Index = integer()
X = integer()
Y = integer()
See vertexAttrib1d/2
vertexAttribI3ui(Index, X, Y, Z) -> ok
Index = integer()
X = integer()
Y = integer()
Z = integer()
See vertexAttrib1d/2
vertexAttribI4ui(Index, X, Y, Z, W) -> ok
Index = integer()
X = integer()
Y = integer()
Z = integer()
W = integer()
See vertexAttrib1d/2
vertexAttribI1iv(Index::integer(), V) -> ok
V = {X::integer()}
Equivalent to vertexAttribI1i(Index, X).
vertexAttribI2iv(Index::integer(), V) -> ok
V = {X::integer(), Y::integer()}
Equivalent to vertexAttribI2i(Index, X, Y).
vertexAttribI3iv(Index::integer(), V) -> ok
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to vertexAttribI3i(Index, X, Y, Z).
vertexAttribI4iv(Index::integer(), V) -> ok
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertexAttribI4i(Index, X, Y, Z, W).
vertexAttribI1uiv(Index::integer(), V) -> ok
V = {X::integer()}
Equivalent to vertexAttribI1ui(Index, X).
vertexAttribI2uiv(Index::integer(), V) -> ok
V = {X::integer(), Y::integer()}
Equivalent to vertexAttribI2ui(Index, X, Y).
vertexAttribI3uiv(Index::integer(), V) -> ok
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to vertexAttribI3ui(Index, X, Y, Z).
vertexAttribI4uiv(Index::integer(), V) -> ok
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertexAttribI4ui(Index, X, Y, Z, W).
vertexAttribI4bv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttribI4sv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttribI4ubv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttribI4usv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
getUniformuiv(Program, Location) -> {integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer()}
Program = integer()
Location = integer()
See getUniformfv/2
bindFragDataLocation(Program, Color, Name) -> ok
Program = integer()
Color = integer()
Name = string()
Bind a user-defined varying out variable to a fragment shader color number
gl:bindFragDataLocation
explicitly specifies the binding of the user-defined varying
out variable Name
to fragment shader color number ColorNumber
for program Program
. If Name
was bound previously, its assigned binding is replaced with ColorNumber
. Name
must be a null-terminated string. ColorNumber
must be less than ?GL_MAX_DRAW_BUFFERS
.
The bindings specified by gl:bindFragDataLocation
have no effect until Program
is next linked. Bindings may be specified at any time after Program
has been created.
Specifically, they may be specified before shader objects are attached to the program.
Therefore, any name may be specified in Name
, including a name that is never used
as a varying out variable in any fragment shader object. Names beginning with ?gl_
are reserved by the GL.
In addition to the errors generated by gl:bindFragDataLocation
, the program Program
will fail to link if:
The number of active outputs is greater than the value ?GL_MAX_DRAW_BUFFERS
.
More than one varying out variable is bound to the same color number.
See
getFragDataLocation(Program, Name) -> integer()
Program = integer()
Name = string()
Query the bindings of color numbers to user-defined varying out variables
gl:getFragDataLocation
retrieves the assigned color number binding for the user-defined
varying out variable Name
for program Program
. Program
must have
previously been linked. Name
must be a null-terminated string. If Name
is
not the name of an active user-defined varying out fragment shader variable within Program
, -1 will be returned.
See
uniform3ui(Location, V0, V1, V2) -> ok
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
See uniform1f/2
uniform4ui(Location, V0, V1, V2, V3) -> ok
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
V3 = integer()
See uniform1f/2
uniform2uiv(Location, Value) -> ok
Location = integer()
Value = [{integer(), integer()}]
See uniform1f/2
uniform3uiv(Location, Value) -> ok
Location = integer()
Value = [{integer(), integer(), integer()}]
See uniform1f/2
uniform4uiv(Location, Value) -> ok
Location = integer()
Value = [{integer(), integer(), integer(), integer()}]
See uniform1f/2
texParameterIiv(Target, Pname, Params) -> ok
Target = enum()
Pname = enum()
Params = {integer()}
See texParameterf/3
texParameterIuiv(Target, Pname, Params) -> ok
Target = enum()
Pname = enum()
Params = {integer()}
glTexParameterI
See
getTexParameterIiv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Target = enum()
Pname = enum()
getTexParameterIuiv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Target = enum()
Pname = enum()
glGetTexParameterI
See
clearBufferiv(Buffer, Drawbuffer, Value) -> ok
Buffer = enum()
Drawbuffer = integer()
Value = {integer()}
Clear individual buffers of the currently bound draw framebuffer
gl:clearBuffer*
clears the specified buffer to the specified value(s). If Buffer
is ?GL_COLOR
, a particular draw buffer ?GL_DRAWBUFFER
I
is specified
by passing I
as DrawBuffer
. In this case, Value
points to a four-element
vector specifying the R, G, B and A color to clear that draw buffer to. If Buffer
is one of ?GL_FRONT
, ?GL_BACK
, ?GL_LEFT
, ?GL_RIGHT
, or ?GL_FRONT_AND_BACK
, identifying multiple buffers, each selected buffer is cleared to the same value. Clamping
and conversion for fixed-point color buffers are performed in the same fashion as gl:clearColor/4
.
If Buffer
is ?GL_DEPTH
, DrawBuffer
must be zero, and Value
points to a single value to clear the depth buffer to. Only gl:clearBufferfv
should
be used to clear depth buffers. Clamping and conversion for fixed-point depth buffers
are performed in the same fashion as gl:clearDepth/1 .
If Buffer
is ?GL_STENCIL
, DrawBuffer
must be zero, and Value
points to a single value to clear the stencil buffer to. Only gl:clearBufferiv
should
be used to clear stencil buffers. Masing and type conversion are performed in the same
fashion as gl:clearStencil/1 .
gl:clearBufferfi
may be used to clear the depth and stencil buffers. Buffer
must be ?GL_DEPTH_STENCIL
and DrawBuffer
must be zero. Depth
and Stencil
are the depth and stencil values, respectively.
The result of gl:clearBuffer
is undefined if no conversion between the type of Value
and the buffer being cleared is defined. However, this is not an error.
See
clearBufferuiv(Buffer, Drawbuffer, Value) -> ok
Buffer = enum()
Drawbuffer = integer()
Value = {integer()}
See clearBufferiv/3
clearBufferfv(Buffer, Drawbuffer, Value) -> ok
Buffer = enum()
Drawbuffer = integer()
Value = {float()}
See clearBufferiv/3
clearBufferfi(Buffer, Drawbuffer, Depth, Stencil) -> ok
Buffer = enum()
Drawbuffer = integer()
Depth = float()
Stencil = integer()
glClearBufferfi
See
drawArraysInstanced(Mode, First, Count, Primcount) -> ok
Mode = enum()
First = integer()
Count = integer()
Primcount = integer()
glDrawArraysInstance
See
drawElementsInstanced(Mode, Count, Type, Indices, Primcount) -> ok
Mode = enum()
Count = integer()
Type = enum()
Indices = offset() | mem()
Primcount = integer()
glDrawElementsInstance
See
texBuffer(Target, Internalformat, Buffer) -> ok
Target = enum()
Internalformat = enum()
Buffer = integer()
Attach the storage for a buffer object to the active buffer texture
gl:texBuffer
attaches the storage for the buffer object named Buffer
to the
active buffer texture, and specifies the internal format for the texel array found in
the attached buffer object. If Buffer
is zero, any buffer object attached to the
buffer texture is detached and no new buffer object is attached. If Buffer
is non-zero,
it must be the name of an existing buffer object. Target
must be ?GL_TEXTURE_BUFFER
. Internalformat
specifies the storage format, and must be one of the following
sized internal formats:
Component
Sized Internal Format
Base Type
Components
Norm
0123?GL_R8
ubyte1YESR00
1?GL_R16
ushort1YESR
001?GL_R16F
half1NO
R001?GL_R32F
float
1NOR001?GL_R8I
byte1NOR001?GL_R16I
short1NOR001?GL_R32I
int1NOR001
?GL_R8UI
ubyte1NOR0
01?GL_R16UI
ushort1NO
R001?GL_R32UI
uint1
NOR001?GL_RG8
ubyte
2YESRG01?GL_RG16
ushort2YESRG01?GL_RG16F
half2NORG0
1?GL_RG32F
float2NORG
01?GL_RG8I
byte2NO
RG01?GL_RG16I
short
2NORG01?GL_RG32I
int2NORG01?GL_RG8UI
ubyte2NORG01?GL_RG16UI
ushort2NORG0
1?GL_RG32UI
uint2NORG
01?GL_RGB32F
float3NO
RGB1?GL_RGB32I
int
3NORGB1?GL_RGB32UI
uint3NORGB1?GL_RGBA8
uint4YESRGB
A?GL_RGBA16
short4YESR
GBA?GL_RGBA16F
half4NO
RGBA?GL_RGBA32F
float
4NORGBA?GL_RGBA8I
byte4NORGBA?GL_RGBA16I
short4NORGB
A?GL_RGBA32I
int4NORG
BA?GL_RGBA8UI
ubyte4NO
RGBA?GL_RGBA16UI
ushort
4NORGBA?GL_RGBA32UI
uint4NORGBAWhen a buffer object is attached to a buffer texture, the buffer object's data store is taken as the texture's texel array. The number of texels in the buffer texture's texel array is given by buffer_size components×sizeof( base_type/)
where buffer_size
is the size of the buffer object, in basic machine units and
components and base type are the element count and base data type for elements, as specified
in the table above. The number of texels in the texel array is then clamped to the implementation-dependent
limit ?GL_MAX_TEXTURE_BUFFER_SIZE
. When a buffer texture is accessed in a shader,
the results of a texel fetch are undefined if the specified texel coordinate is negative,
or greater than or equal to the clamped number of texels in the texel array.
See
primitiveRestartIndex(Index) -> ok
Index = integer()
Specify the primitive restart index
gl:primitiveRestartIndex
specifies a vertex array element that is treated specially
when primitive restarting is enabled. This is known as the primitive restart index.
When one of the Draw*
commands transfers a set of generic attribute array elements
to the GL, if the index within the vertex arrays corresponding to that set is equal to
the primitive restart index, then the GL does not process those elements as a vertex.
Instead, it is as if the drawing command ended with the immediately preceding transfer,
and another drawing command is immediately started with the same parameters, but only
transferring the immediately following element through the end of the originally specified
elements.
When either gl:drawElementsBaseVertex/5 , gl:drawElementsInstancedBaseVertex/6
or see glMultiDrawElementsBaseVertex
is used, the primitive restart comparison
occurs before the basevertex offset is added to the array index.
See
getBufferParameteri64v(Target, Pname) -> [integer()]
Target = enum()
Pname = enum()
glGetBufferParameteri64v
See
framebufferTexture(Target, Attachment, Texture, Level) -> ok
Target = enum()
Attachment = enum()
Texture = integer()
Level = integer()
Attach a level of a texture object as a logical buffer to the currently bound framebuffer object
gl:framebufferTexture
, gl:framebufferTexture1D
, gl:framebufferTexture2D
,
and gl:framebufferTexture
attach a selected mipmap level or image of a texture object
as one of the logical buffers of the framebuffer object currently bound to Target
.
Target
must be ?GL_DRAW_FRAMEBUFFER
, ?GL_READ_FRAMEBUFFER
, or ?GL_FRAMEBUFFER
. ?GL_FRAMEBUFFER
is equivalent to ?GL_DRAW_FRAMEBUFFER
.
Attachment
specifies the logical attachment of the framebuffer and must be ?GL_COLOR_ATTACHMENT
i
, ?GL_DEPTH_ATTACHMENT
, ?GL_STENCIL_ATTACHMENT
or ?GL_DEPTH_STENCIL_ATTACHMMENT
. i
in ?GL_COLOR_ATTACHMENT
i
may range from zero to the value of ?GL_MAX_COLOR_ATTACHMENTS
- 1. Attaching a level of a texture to ?GL_DEPTH_STENCIL_ATTACHMENT
is equivalent
to attaching that level to both the ?GL_DEPTH_ATTACHMENT
and
the ?GL_STENCIL_ATTACHMENT
attachment points simultaneously.
Textarget
specifies what type of texture is named by Texture
, and for cube
map textures, specifies the face that is to be attached. If Texture
is not zero,
it must be the name of an existing texture with type Textarget
, unless it is a
cube map texture, in which case Textarget
must be ?GL_TEXTURE_CUBE_MAP_POSITIVE_X
?GL_TEXTURE_CUBE_MAP_NEGATIVE_X
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_Y
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_Z
, or ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
.
If Texture
is non-zero, the specified Level
of the texture object named Texture
is attached to the framebfufer attachment point named by Attachment
. For gl:framebufferTexture1D
, gl:framebufferTexture2D
, and gl:framebufferTexture3D
, Texture
must
be zero or the name of an existing texture with a target of Textarget
, or Texture
must be the name of an existing cube-map texture and Textarget
must be one of ?GL_TEXTURE_CUBE_MAP_POSITIVE_X
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_Y
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_Z
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_X
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
, or ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
.
If Textarget
is ?GL_TEXTURE_RECTANGLE
, ?GL_TEXTURE_2D_MULTISAMPLE
,
or ?GL_TEXTURE_2D_MULTISAMPLE_ARRAY
, then Level
must be zero. If Textarget
is ?GL_TEXTURE_3D
, then level must be greater than or equal to zero and less than
or equal to log2 of the value of ?GL_MAX_3D_TEXTURE_SIZE
. If Textarget
is
one of ?GL_TEXTURE_CUBE_MAP_POSITIVE_X
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_Y
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_Z
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_X
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
, or ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
, then Level
must be greater than or equal to zero and less than or equal to log2
of the value of ?GL_MAX_CUBE_MAP_TEXTURE_SIZE
. For all other values of Textarget
, Level
must be greater than or equal to zero and no larger than log2 of the value
of ?GL_MAX_TEXTURE_SIZE
.
Layer
specifies the layer of a 2-dimensional image within a 3-dimensional texture.
For gl:framebufferTexture1D
, if Texture
is not zero, then Textarget
must be ?GL_TEXTURE_1D
. For gl:framebufferTexture2D
, if Texture
is
not zero, Textarget
must be one of ?GL_TEXTURE_2D
, ?GL_TEXTURE_RECTANGLE
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_X
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_Y
, ?GL_TEXTURE_CUBE_MAP_POSITIVE_Z
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_X
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
, or ?GL_TEXTURE_2D_MULTISAMPLE
. For gl:framebufferTexture3D
, if Texture
is not zero, then Textarget
must be ?GL_TEXTURE_3D
.
See
vertexAttribDivisor(Index, Divisor) -> ok
Index = integer()
Divisor = integer()
Modify the rate at which generic vertex attributes advance during instanced rendering
gl:vertexAttribDivisor
modifies the rate at which generic vertex attributes advance
when rendering multiple instances of primitives in a single draw call. If Divisor
is zero, the attribute at slot Index
advances once per vertex. If Divisor
is non-zero, the attribute advances once per Divisor
instances of the set(s) of
vertices being rendered. An attribute is referred to as instanced if its ?GL_VERTEX_ATTRIB_ARRAY_DIVISOR
value is non-zero.
Index
must be less than the value of ?GL_MAX_VERTEX_ATTRIBUTES
.
See
minSampleShading(Value) -> ok
Value = clamp()
Specifies minimum rate at which sample shaing takes place
gl:minSampleShading
specifies the rate at which samples are shaded within a covered
pixel. Sample-rate shading is enabled by calling gl:enable/1 with the parameter ?GL_SAMPLE_SHADING
. If ?GL_MULTISAMPLE
or ?GL_SAMPLE_SHADING
is disabled, sample shading has
no effect. Otherwise, an implementation must provide at least as many unique color values
for each covered fragment as specified by Value
times Samples
where Samples
is the value of ?GL_SAMPLES
for the current framebuffer. At least 1 sample for
each covered fragment is generated.
A Value
of 1.0 indicates that each sample in the framebuffer should be indpendently
shaded. A Value
of 0.0 effectively allows the GL to ignore sample rate shading.
Any value between 0.0 and 1.0 allows the GL to shade only a subset of the total samples
within each covered fragment. Which samples are shaded and the algorithm used to select
that subset of the fragment's samples is implementation dependent.
See
blendEquationSeparatei(Buf, ModeRGB, ModeAlpha) -> ok
Buf = integer()
ModeRGB = enum()
ModeAlpha = enum()
blendFunci(Buf, Src, Dst) -> ok
Buf = integer()
Src = enum()
Dst = enum()
glBlendFunci
See
blendFuncSeparatei(Buf, SrcRGB, DstRGB, SrcAlpha, DstAlpha) -> ok
Buf = integer()
SrcRGB = enum()
DstRGB = enum()
SrcAlpha = enum()
DstAlpha = enum()
loadTransposeMatrixfARB(M) -> ok
M = matrix()
glLoadTransposeMatrixARB
See
loadTransposeMatrixdARB(M) -> ok
M = matrix()
glLoadTransposeMatrixARB
See
multTransposeMatrixfARB(M) -> ok
M = matrix()
glMultTransposeMatrixARB
See
multTransposeMatrixdARB(M) -> ok
M = matrix()
glMultTransposeMatrixARB
See
weightbvARB(Weights) -> ok
Weights = [integer()]
glWeightARB
See
weightsvARB(Weights) -> ok
Weights = [integer()]
glWeightARB
See
weightivARB(Weights) -> ok
Weights = [integer()]
glWeightARB
See
weightfvARB(Weights) -> ok
Weights = [float()]
glWeightARB
See
weightdvARB(Weights) -> ok
Weights = [float()]
glWeightARB
See
weightubvARB(Weights) -> ok
Weights = [integer()]
glWeightARB
See
weightusvARB(Weights) -> ok
Weights = [integer()]
glWeightARB
See
weightuivARB(Weights) -> ok
Weights = [integer()]
glWeightARB
See
vertexBlendARB(Count) -> ok
Count = integer()
glVertexBlenARB
See
currentPaletteMatrixARB(Index) -> ok
Index = integer()
glCurrentPaletteMatrixARB
See
matrixIndexubvARB(Indices) -> ok
Indices = [integer()]
glMatrixIndexARB
See
matrixIndexusvARB(Indices) -> ok
Indices = [integer()]
glMatrixIndexARB
See
matrixIndexuivARB(Indices) -> ok
Indices = [integer()]
glMatrixIndexARB
See
programStringARB(Target, Format, String) -> ok
Target = enum()
Format = enum()
String = string()
glProgramStringARB
See
bindProgramARB(Target, Program) -> ok
Target = enum()
Program = integer()
glBindProgramARB
See
deleteProgramsARB(Programs) -> ok
Programs = [integer()]
glDeleteProgramsARB
See
genProgramsARB(N) -> [integer()]
N = integer()
glGenProgramsARB
See
programEnvParameter4dARB(Target, Index, X, Y, Z, W) -> ok
Target = enum()
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
glProgramEnvParameterARB
See
programEnvParameter4dvARB(Target, Index, Params) -> ok
Target = enum()
Index = integer()
Params = {float(), float(), float(), float()}
glProgramEnvParameterARB
See
programEnvParameter4fARB(Target, Index, X, Y, Z, W) -> ok
Target = enum()
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
glProgramEnvParameterARB
See
programEnvParameter4fvARB(Target, Index, Params) -> ok
Target = enum()
Index = integer()
Params = {float(), float(), float(), float()}
glProgramEnvParameterARB
See
programLocalParameter4dARB(Target, Index, X, Y, Z, W) -> ok
Target = enum()
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
glProgramLocalParameterARB
See
programLocalParameter4dvARB(Target, Index, Params) -> ok
Target = enum()
Index = integer()
Params = {float(), float(), float(), float()}
glProgramLocalParameterARB
See
programLocalParameter4fARB(Target, Index, X, Y, Z, W) -> ok
Target = enum()
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
glProgramLocalParameterARB
See
programLocalParameter4fvARB(Target, Index, Params) -> ok
Target = enum()
Index = integer()
Params = {float(), float(), float(), float()}
glProgramLocalParameterARB
See
getProgramEnvParameterdvARB(Target, Index) -> {float(), float(), float(), float()}
Target = enum()
Index = integer()
glGetProgramEnvParameterARB
See
getProgramEnvParameterfvARB(Target, Index) -> {float(), float(), float(), float()}
Target = enum()
Index = integer()
glGetProgramEnvParameterARB
See
getProgramLocalParameterdvARB(Target, Index) -> {float(), float(), float(), float()}
Target = enum()
Index = integer()
glGetProgramLocalParameterARB
See
getProgramLocalParameterfvARB(Target, Index) -> {float(), float(), float(), float()}
Target = enum()
Index = integer()
glGetProgramLocalParameterARB
See
getProgramStringARB(Target, Pname, String) -> ok
Target = enum()
Pname = enum()
String = mem()
glGetProgramStringARB
See
getBufferParameterivARB(Target, Pname) -> [integer()]
Target = enum()
Pname = enum()
glGetBufferParameterARB
See
deleteObjectARB(Obj) -> ok
Obj = integer()
glDeleteObjectARB
See
getHandleARB(Pname) -> integer()
Pname = enum()
glGetHandleARB
See
detachObjectARB(ContainerObj, AttachedObj) -> ok
ContainerObj = integer()
AttachedObj = integer()
glDetachObjectARB
See
createShaderObjectARB(ShaderType) -> integer()
ShaderType = enum()
glCreateShaderObjectARB
See
shaderSourceARB(ShaderObj, String) -> ok
ShaderObj = integer()
String = [string()]
glShaderSourceARB
See
compileShaderARB(ShaderObj) -> ok
ShaderObj = integer()
glCompileShaderARB
See
createProgramObjectARB() -> integer()
glCreateProgramObjectARB
See
attachObjectARB(ContainerObj, Obj) -> ok
ContainerObj = integer()
Obj = integer()
glAttachObjectARB
See
linkProgramARB(ProgramObj) -> ok
ProgramObj = integer()
glLinkProgramARB
See
useProgramObjectARB(ProgramObj) -> ok
ProgramObj = integer()
glUseProgramObjectARB
See
validateProgramARB(ProgramObj) -> ok
ProgramObj = integer()
glValidateProgramARB
See
getObjectParameterfvARB(Obj, Pname) -> float()
Obj = integer()
Pname = enum()
glGetObjectParameterARB
See
getObjectParameterivARB(Obj, Pname) -> integer()
Obj = integer()
Pname = enum()
glGetObjectParameterARB
See
getInfoLogARB(Obj, MaxLength) -> string()
Obj = integer()
MaxLength = integer()
glGetInfoLogARB
See
getAttachedObjectsARB(ContainerObj, MaxCount) -> [integer()]
ContainerObj = integer()
MaxCount = integer()
glGetAttachedObjectsARB
See
getUniformLocationARB(ProgramObj, Name) -> integer()
ProgramObj = integer()
Name = string()
glGetUniformLocationARB
See
getActiveUniformARB(ProgramObj, Index, MaxLength) -> {Size::integer(), Type::enum(), Name::string()}
ProgramObj = integer()
Index = integer()
MaxLength = integer()
glGetActiveUniformARB
See
getUniformfvARB(ProgramObj, Location) -> matrix()
ProgramObj = integer()
Location = integer()
glGetUniformARB
See
getUniformivARB(ProgramObj, Location) -> {integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer()}
ProgramObj = integer()
Location = integer()
glGetUniformARB
See
getShaderSourceARB(Obj, MaxLength) -> string()
Obj = integer()
MaxLength = integer()
glGetShaderSourceARB
See
bindAttribLocationARB(ProgramObj, Index, Name) -> ok
ProgramObj = integer()
Index = integer()
Name = string()
glBindAttribLocationARB
See
getActiveAttribARB(ProgramObj, Index, MaxLength) -> {Size::integer(), Type::enum(), Name::string()}
ProgramObj = integer()
Index = integer()
MaxLength = integer()
glGetActiveAttribARB
See
getAttribLocationARB(ProgramObj, Name) -> integer()
ProgramObj = integer()
Name = string()
glGetAttribLocationARB
See
isRenderbuffer(Renderbuffer) -> 0 | 1
Renderbuffer = integer()
Determine if a name corresponds to a renderbuffer object
gl:isRenderbuffer
returns ?GL_TRUE
if Renderbuffer
is currently the
name of a renderbuffer object. If Renderbuffer
is zero, or if Renderbuffer
is not the name of a renderbuffer object, or if an error occurs, gl:isRenderbuffer
returns ?GL_FALSE
. If Renderbuffer
is a name returned by gl:genRenderbuffers/1
, by that has not yet been bound through a call to gl:bindRenderbuffer/2 or gl:framebufferRenderbuffer/4
, then the name is not a renderbuffer object and gl:isRenderbuffer
returns ?GL_FALSE
.
See
bindRenderbuffer(Target, Renderbuffer) -> ok
Target = enum()
Renderbuffer = integer()
Bind a renderbuffer to a renderbuffer target
gl:bindRenderbuffer
binds the renderbuffer object with name Renderbuffer
to the renderbuffer target specified by Target
. Target
must be ?GL_RENDERBUFFER
. Renderbuffer
is the name of a renderbuffer object previously returned from a
call to gl:genRenderbuffers/1 , or zero to break the existing binding of a renderbuffer
object to Target
.
See
deleteRenderbuffers(Renderbuffers) -> ok
Renderbuffers = [integer()]
Delete renderbuffer objects
gl:deleteRenderbuffers
deletes the N
renderbuffer objects whose names are
stored in the array addressed by Renderbuffers
. The name zero is reserved by the
GL and is silently ignored, should it occur in Renderbuffers
, as are other unused
names. Once a renderbuffer object is deleted, its name is again unused and it has no contents.
If a renderbuffer that is currently bound to the target ?GL_RENDERBUFFER
is deleted,
it is as though gl:bindRenderbuffer/2 had been executed with a Target
of ?GL_RENDERBUFFER
and a Name
of zero.
If a renderbuffer object is attached to one or more attachment points in the currently
bound framebuffer, then it as if gl:framebufferRenderbuffer/4 had been called,
with a Renderbuffer
of zero for each attachment point to which this image was attached
in the currently bound framebuffer. In other words, this renderbuffer object is first
detached from all attachment ponits in the currently bound framebuffer. Note that the
renderbuffer image is specifically not
detached from any non-bound framebuffers.
See
genRenderbuffers(N) -> [integer()]
N = integer()
Generate renderbuffer object names
gl:genRenderbuffers
returns N
renderbuffer object names in Renderbuffers
. 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 gl:genRenderbuffers
.
Renderbuffer object names returned by a call to gl:genRenderbuffers
are not returned
by subsequent calls, unless they are first deleted with gl:deleteRenderbuffers/1 .
The names returned in Renderbuffers
are marked as used, for the purposes of gl:genRenderbuffers
only, but they acquire state and type only when they are first bound.
See
renderbufferStorage(Target, Internalformat, Width, Height) -> ok
Target = enum()
Internalformat = enum()
Width = integer()
Height = integer()
Establish data storage, format and dimensions of a renderbuffer object's image
gl:renderbufferStorage
is equivalent to calling gl:renderbufferStorageMultisample/5
with the Samples
set to zero.
The target of the operation, specified by Target
must be ?GL_RENDERBUFFER
.
Internalformat
specifies the internal format to be used for the renderbuffer object's
storage and must be a color-renderable, depth-renderable, or stencil-renderable format. Width
and Height
are the dimensions, in pixels, of the renderbuffer. Both Width
and Height
must be less than or equal to the value of ?GL_MAX_RENDERBUFFER_SIZE
.
Upon success, gl:renderbufferStorage
deletes any existing data store for the renderbuffer
image and the contents of the data store after calling gl:renderbufferStorage
are
undefined.
See
getRenderbufferParameteriv(Target, Pname) -> integer()
Target = enum()
Pname = enum()
Retrieve information about a bound renderbuffer object
gl:getRenderbufferParameteriv
retrieves information about a bound renderbuffer object.
Target
specifies the target of the query operation and must be ?GL_RENDERBUFFER
. Pname
specifies the parameter whose value to query and must be one of ?GL_RENDERBUFFER_WIDTH
, ?GL_RENDERBUFFER_HEIGHT
, ?GL_RENDERBUFFER_INTERNAL_FORMAT
, ?GL_RENDERBUFFER_RED_SIZE
, ?GL_RENDERBUFFER_GREEN_SIZE
, ?GL_RENDERBUFFER_BLUE_SIZE
, ?GL_RENDERBUFFER_ALPHA_SIZE
, ?GL_RENDERBUFFER_DEPTH_SIZE
, ?GL_RENDERBUFFER_DEPTH_SIZE
, ?GL_RENDERBUFFER_STENCIL_SIZE
, or ?GL_RENDERBUFFER_SAMPLES
.
Upon a successful return from gl:getRenderbufferParameteriv
, if Pname
is ?GL_RENDERBUFFER_WIDTH
, ?GL_RENDERBUFFER_HEIGHT
, ?GL_RENDERBUFFER_INTERNAL_FORMAT
, or ?GL_RENDERBUFFER_SAMPLES
, then Params
will contain the width in pixels, the height in pixels, the internal
format, or the number of samples, respectively, of the image of the renderbuffer currently
bound to Target
.
If Pname
is ?GL_RENDERBUFFER_RED_SIZE
, ?GL_RENDERBUFFER_GREEN_SIZE
,
?GL_RENDERBUFFER_BLUE_SIZE
, ?GL_RENDERBUFFER_ALPHA_SIZE
, ?GL_RENDERBUFFER_DEPTH_SIZE
, or ?GL_RENDERBUFFER_STENCIL_SIZE
, then Params
will contain the actual
resolutions (not the resolutions specified when the image array was defined) for the red,
green, blue, alpha depth, or stencil components, respectively, of the image of the renderbuffer
currently bound to Target
.
See
isFramebuffer(Framebuffer) -> 0 | 1
Framebuffer = integer()
Determine if a name corresponds to a framebuffer object
gl:isFramebuffer
returns ?GL_TRUE
if Framebuffer
is currently the
name of a framebuffer object. If Framebuffer
is zero, or if ?framebuffer
is not the name of a framebuffer object, or if an error occurs, gl:isFramebuffer
returns ?GL_FALSE
. If Framebuffer
is a name returned by gl:genFramebuffers/1
, by that has not yet been bound through a call to gl:bindFramebuffer/2 , then the
name is not a framebuffer object and gl:isFramebuffer
returns ?GL_FALSE
.
See
bindFramebuffer(Target, Framebuffer) -> ok
Target = enum()
Framebuffer = integer()
Bind a framebuffer to a framebuffer target
gl:bindFramebuffer
binds the framebuffer object with name Framebuffer
to
the framebuffer target specified by Target
. Target
must be either ?GL_DRAW_FRAMEBUFFER
, ?GL_READ_FRAMEBUFFER
or ?GL_FRAMEBUFFER
. If a framebuffer object is bound
to ?GL_DRAW_FRAMEBUFFER
or ?GL_READ_FRAMEBUFFER
, it becomes the target for
rendering or readback operations, respectively, until it is deleted or another framebuffer
is bound to the corresponding bind point. Calling gl:bindFramebuffer
with Target
set to ?GL_FRAMEBUFFER
binds Framebuffer
to both the read and draw framebuffer
targets. Framebuffer
is the name of a framebuffer object previously returned from
a call to gl:genFramebuffers/1 , or zero to break the existing binding of a framebuffer
object to Target
.
See
deleteFramebuffers(Framebuffers) -> ok
Framebuffers = [integer()]
Delete framebuffer objects
gl:deleteFramebuffers
deletes the N
framebuffer objects whose names are stored
in the array addressed by Framebuffers
. The name zero is reserved by the GL and
is silently ignored, should it occur in Framebuffers
, as are other unused names.
Once a framebuffer object is deleted, its name is again unused and it has no attachments.
If a framebuffer that is currently bound to one or more of the targets ?GL_DRAW_FRAMEBUFFER
or ?GL_READ_FRAMEBUFFER
is deleted, it is as though gl:bindFramebuffer/2
had been executed with the corresponding Target
and Framebuffer
zero.
See
genFramebuffers(N) -> [integer()]
N = integer()
Generate framebuffer object names
gl:genFramebuffers
returns N
framebuffer object names in Ids
. 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 gl:genFramebuffers
.
Framebuffer object names returned by a call to gl:genFramebuffers
are not returned
by subsequent calls, unless they are first deleted with gl:deleteFramebuffers/1 .
The names returned in Ids
are marked as used, for the purposes of gl:genFramebuffers
only, but they acquire state and type only when they are first bound.
See
checkFramebufferStatus(Target) -> enum()
Target = enum()
Check the completeness status of a framebuffer
gl:checkFramebufferStatus
queries the completeness status of the framebuffer object
currently bound to Target
. Target
must be ?GL_DRAW_FRAMEBUFFER
, ?GL_READ_FRAMEBUFFER
or ?GL_FRAMEBUFFER
. ?GL_FRAMEBUFFER
is equivalent to ?GL_DRAW_FRAMEBUFFER
.
The return value is ?GL_FRAMEBUFFER_COMPLETE
if the framebuffer bound to Target
is complete. Otherwise, the return value is determined as follows:
?GL_FRAMEBUFFER_UNDEFINED
is returned if Target
is the default framebuffer,
but the default framebuffer does not exist.
?GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
is returned if any of the framebuffer attachment
points are framebuffer incomplete.
?GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
is returned if the framebuffer does
not have at least one image attached to it.
?GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
is returned if the value of ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
is ?GL_NONE
for any color attachment point(s) named by ?GL_DRAWBUFFERi
.
?GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
is returned if ?GL_READ_BUFFER
is
not ?GL_NONE
and the value of ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
is ?GL_NONE
for the color attachment point named by ?GL_READ_BUFFER
.
?GL_FRAMEBUFFER_UNSUPPORTED
is returned if the combination of internal formats
of the attached images violates an implementation-dependent set of restrictions.
?GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
is returned if the value of ?GL_RENDERBUFFER_SAMPLES
is not the same for all attached renderbuffers; if the value of ?GL_TEXTURE_SAMPLES
is the not same for all attached textures; or, if the attached images are a mix of renderbuffers
and textures, the value of ?GL_RENDERBUFFER_SAMPLES
does not match the value of ?GL_TEXTURE_SAMPLES
.
?GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
is also returned if the value of ?GL_TEXTURE_FIXED_SAMPLE_LOCATIONS
is not the same for all attached textures; or, if the attached images are a mix of renderbuffers
and textures, the value of ?GL_TEXTURE_FIXED_SAMPLE_LOCATIONS
is not ?GL_TRUE
for all attached textures.
?GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS
is returned if any framebuffer attachment
is layered, and any populated attachment is not layered, or if all populated color attachments
are not from textures of the same target.
Additionally, if an error occurs, zero is returned.
See
framebufferTexture1D(Target, Attachment, Textarget, Texture, Level) -> ok
Target = enum()
Attachment = enum()
Textarget = enum()
Texture = integer()
Level = integer()
framebufferTexture2D(Target, Attachment, Textarget, Texture, Level) -> ok
Target = enum()
Attachment = enum()
Textarget = enum()
Texture = integer()
Level = integer()
framebufferTexture3D(Target, Attachment, Textarget, Texture, Level, Zoffset) -> ok
Target = enum()
Attachment = enum()
Textarget = enum()
Texture = integer()
Level = integer()
Zoffset = integer()
framebufferRenderbuffer(Target, Attachment, Renderbuffertarget, Renderbuffer) -> ok
Target = enum()
Attachment = enum()
Renderbuffertarget = enum()
Renderbuffer = integer()
Attach a renderbuffer as a logical buffer to the currently bound framebuffer object
gl:framebufferRenderbuffer
attaches a renderbuffer as one of the logical buffers
of the currently bound framebuffer object. Renderbuffer
is the name of the renderbuffer
object to attach and must be either zero, or the name of an existing renderbuffer object
of type Renderbuffertarget
. If Renderbuffer
is not zero and if gl:framebufferRenderbuffer
is successful, then the renderbuffer name Renderbuffer
will be used as the logical
buffer identified by Attachment
of the framebuffer currently bound to Target
.
The value of ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
for the specified attachment
point is set to ?GL_RENDERBUFFER
and the value of ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
is set to Renderbuffer
. All other state values of the attachment point specified
by Attachment
are set to their default values. No change is made to the state of
the renderbuuffer object and any previous attachment to the Attachment
logical
buffer of the framebuffer Target
is broken.
Calling gl:framebufferRenderbuffer
with the renderbuffer name zero will detach
the image, if any, identified by Attachment
, in the framebuffer currently bound
to Target
. All state values of the attachment point specified by attachment in
the object bound to target are set to their default values.
Setting Attachment
to the value ?GL_DEPTH_STENCIL_ATTACHMENT
is a special
case causing both the depth and stencil attachments of the framebuffer object to be set
to Renderbuffer
, which should have the base internal format ?GL_DEPTH_STENCIL
.
See
getFramebufferAttachmentParameteriv(Target, Attachment, Pname) -> integer()
Target = enum()
Attachment = enum()
Pname = enum()
Retrieve information about attachments of a bound framebuffer object
gl:getFramebufferAttachmentParameter
returns information about attachments of a
bound framebuffer object. Target
specifies the framebuffer binding point and must
be ?GL_DRAW_FRAMEBUFFER
, ?GL_READ_FRAMEBUFFER
or ?GL_FRAMEBUFFER
. ?GL_FRAMEBUFFER
is equivalent to ?GL_DRAW_FRAMEBUFFER
.
If the default framebuffer is bound to Target
then Attachment
must be one
of ?GL_FRONT_LEFT
, ?GL_FRONT_RIGHT
, ?GL_BACK_LEFT
, or ?GL_BACK_RIGHT
, identifying a color buffer, ?GL_DEPTH
, identifying the depth buffer, or ?GL_STENCIL
, identifying the stencil buffer.
If a framebuffer object is bound, then Attachment
must be one of ?GL_COLOR_ATTACHMENT
i
, ?GL_DEPTH_ATTACHMENT
, ?GL_STENCIL_ATTACHMENT
, or ?GL_DEPTH_STENCIL_ATTACHMENT
. i
in ?GL_COLOR_ATTACHMENT
i
must be in the range zero to the value
of ?GL_MAX_COLOR_ATTACHMENTS
- 1.
If Attachment
is ?GL_DEPTH_STENCIL_ATTACHMENT
and different objects are
bound to the depth and stencil attachment points of Target
the query will fail.
If the same object is bound to both attachment points, information about that object will
be returned.
Upon successful return from gl:getFramebufferAttachmentParameteriv
, if Pname
is ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
, then Params
will contain one of ?GL_NONE
, ?GL_FRAMEBUFFER_DEFAULT
, ?GL_TEXTURE
, or ?GL_RENDERBUFFER
, identifying
the type of object which contains the attached image. Other values accepted for Pname
depend on the type of object, as described below.
If the value of ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
is ?GL_NONE
, no
framebuffer is bound to Target
. In this case querying Pname
?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
will return zero, and all other queries will generate an error.
If the value of ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
is not ?GL_NONE
,
these queries apply to all other framebuffer types:
If Pname
is ?GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE
, ?GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE
, ?GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE
, ?GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE
, ?GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE
, or ?GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE
, then Params
will contain the number of bits in the corresponding red, green,
blue, alpha, depth, or stencil component of the specified attachment. Zero is returned
if the requested component is not present in Attachment
.
If Pname
is ?GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE
, Params
will
contain the format of components of the specified attachment, one of ?GL_FLOAT
, GL_INT
, GL_UNSIGNED_INT
, GL_SIGNED_NORMALIZED
, or GL_UNSIGNED_NORMALIZED
for floating-point, signed integer, unsigned integer, signed normalized fixed-point, or
unsigned normalized fixed-point components respectively. Only color buffers may have integer
components.
If Pname
is ?GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING
, Param
will
contain the encoding of components of the specified attachment, one of ?GL_LINEAR
or ?GL_SRGB
for linear or sRGB-encoded components, respectively. Only color buffer
components may be sRGB-encoded; such components are treated as described in sections 4.1.7
and 4.1.8. For the default framebuffer, color encoding is determined by the implementation.
For framebuffer objects, components are sRGB-encoded if the internal format of a color
attachment is one of the color-renderable SRGB formats.
If the value of ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
is ?GL_RENDERBUFFER
,
then:
If Pname
is ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
, Params
will
contain the name of the renderbuffer object which contains the attached image.
If the value of ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
is ?GL_TEXTURE
,
then:
If Pname
is ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
, then Params
will contain the name of the texture object which contains the attached image.
If Pname
is ?GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL
, then Params
will contain the mipmap level of the texture object which contains the attached image.
If Pname
is ?GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE
and the texture
object named ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
is a cube map texture, then Params
will contain the cube map face of the cubemap texture object which contains the attached
image. Otherwise Params
will contain the value zero.
If Pname
is ?GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER
and the texture object
named ?GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME
is a layer of a three-dimensional
texture or a one-or two-dimensional array texture, then Params
will contain the
number of the texture layer which contains the attached image. Otherwise Params
will contain the value zero.
If Pname
is ?GL_FRAMEBUFFER_ATTACHMENT_LAYERED
, then Params
will
contain ?GL_TRUE
if an entire level of a three-dimesional texture, cube map texture,
or one-or two-dimensional array texture is attached. Otherwise, Params
will contain
?GL_FALSE
.
Any combinations of framebuffer type and Pname
not described above will generate
an error.
See
generateMipmap(Target) -> ok
Target = enum()
Generate mipmaps for a specified texture target
gl:generateMipmap
generates mipmaps for the texture attached to Target
of
the active texture unit. For cube map textures, a ?GL_INVALID_OPERATION
error is
generated if the texture attached to Target
is not cube complete.
Mipmap generation replaces texel array levels level base+1 through q with arrays derived from the level base array, regardless of their previous contents. All other mimap arrays, including the level base array, are left unchanged by this computation.
The internal formats of the derived mipmap arrays all match those of the level base array. The contents of the derived arrays are computed by repeated, filtered reduction of the level base array. For one- and two-dimensional texture arrays, each layer is filtered independently.
See
blitFramebuffer(SrcX0, SrcY0, SrcX1, SrcY1, DstX0, DstY0, DstX1, DstY1, Mask, Filter) -> ok
SrcX0 = integer()
SrcY0 = integer()
SrcX1 = integer()
SrcY1 = integer()
DstX0 = integer()
DstY0 = integer()
DstX1 = integer()
DstY1 = integer()
Mask = integer()
Filter = enum()
Copy a block of pixels from the read framebuffer to the draw framebuffer
gl:blitFramebuffer
transfers a rectangle of pixel values from one region of the
read framebuffer to another region in the draw framebuffer. Mask
is the bitwise
OR of a number of values indicating which buffers are to be copied. The values are ?GL_COLOR_BUFFER_BIT
, ?GL_DEPTH_BUFFER_BIT
, and ?GL_STENCIL_BUFFER_BIT
. The pixels corresponding
to these buffers are copied from the source rectangle bounded by the locations ( SrcX0
; SrcY0
) and ( SrcX1
; SrcY1
) to the destination rectangle bounded
by the locations ( DstX0
; DstY0
) and ( DstX1
; DstY1
). The lower
bounds of the rectangle are inclusive, while the upper bounds are exclusive.
The actual region taken from the read framebuffer is limited to the intersection of the source buffers being transferred, which may include the color buffer selected by the read buffer, the depth buffer, and/or the stencil buffer depending on mask. The actual region written to the draw framebuffer is limited to the intersection of the destination buffers being written, which may include multiple draw buffers, the depth buffer, and/or the stencil buffer depending on mask. Whether or not the source or destination regions are altered due to these limits, the scaling and offset applied to pixels being transferred is performed as though no such limits were present.
If the sizes of the source and destination rectangles are not equal, Filter
specifies
the interpolation method that will be applied to resize the source image , and must be ?GL_NEAREST
or ?GL_LINEAR
. ?GL_LINEAR
is only a valid interpolation method for the
color buffer. If Filter
is not ?GL_NEAREST
and Mask
includes ?GL_DEPTH_BUFFER_BIT
or ?GL_STENCIL_BUFFER_BIT
, no data is transferred and a ?GL_INVALID_OPERATION
error is generated.
If Filter
is ?GL_LINEAR
and the source rectangle would require sampling
outside the bounds of the source framebuffer, values are read as if the ?GL_CLAMP_TO_EDGE
texture wrapping mode were applied.
When the color buffer is transferred, values are taken from the read buffer of the read framebuffer and written to each of the draw buffers of the draw framebuffer.
If the source and destination rectangles overlap or are the same, and the read and draw buffers are the same, the result of the operation is undefined.
See
renderbufferStorageMultisample(Target, Samples, Internalformat, Width, Height) -> ok
Target = enum()
Samples = integer()
Internalformat = enum()
Width = integer()
Height = integer()
Establish data storage, format, dimensions and sample count of a renderbuffer object's image
gl:renderbufferStorageMultisample
establishes the data storage, format, dimensions
and number of samples of a renderbuffer object's image.
The target of the operation, specified by Target
must be ?GL_RENDERBUFFER
.
Internalformat
specifies the internal format to be used for the renderbuffer object's
storage and must be a color-renderable, depth-renderable, or stencil-renderable format. Width
and Height
are the dimensions, in pixels, of the renderbuffer. Both Width
and Height
must be less than or equal to the value of ?GL_MAX_RENDERBUFFER_SIZE
. Samples
specifies the number of samples to be used for the renderbuffer object's
image, and must be less than or equal to the value of ?GL_MAX_SAMPLES
. If Internalformat
is a signed or unsigned integer format then Samples
must be less than or equal
to the value of ?GL_MAX_INTEGER_SAMPLES
.
Upon success, gl:renderbufferStorageMultisample
deletes any existing data store
for the renderbuffer image and the contents of the data store after calling gl:renderbufferStorageMultisample
are undefined.
See
framebufferTextureLayer(Target, Attachment, Texture, Level, Layer) -> ok
Target = enum()
Attachment = enum()
Texture = integer()
Level = integer()
Layer = integer()
framebufferTextureFaceARB(Target, Attachment, Texture, Level, Face) -> ok
Target = enum()
Attachment = enum()
Texture = integer()
Level = integer()
Face = enum()
flushMappedBufferRange(Target, Offset, Length) -> ok
Target = enum()
Offset = integer()
Length = integer()
Indicate modifications to a range of a mapped buffer
gl:flushMappedBufferRange
indicates that modifications have been made to a range
of a mapped buffer. The buffer must previously have been mapped with the ?GL_MAP_FLUSH_EXPLICIT
flag. Offset
and Length
indicate the modified subrange of the mapping,
in basic units. The specified subrange to flush is relative to the start of the currently
mapped range of the buffer. gl:flushMappedBufferRange
may be called multiple times
to indicate distinct subranges of the mapping which require flushing.
See
bindVertexArray(Array) -> ok
Array = integer()
Bind a vertex array object
gl:bindVertexArray
binds the vertex array object with name Array
. Array
is the name of a vertex array object previously returned from a call to gl:genVertexArrays/1
, or zero to break the existing vertex array object binding.
If no vertex array object with name Array
exists, one is created when Array
is first bound. If the bind is successful no change is made to the state of the vertex
array object, and any previous vertex array object binding is broken.
See
deleteVertexArrays(Arrays) -> ok
Arrays = [integer()]
Delete vertex array objects
gl:deleteVertexArrays
deletes N
vertex array objects whose names are stored
in the array addressed by Arrays
. Once a vertex array object is deleted it has
no contents and its name is again unused. If a vertex array object that is currently bound
is deleted, the binding for that object reverts to zero and the default vertex array becomes
current. Unused names in Arrays
are silently ignored, as is the value zero.
See
genVertexArrays(N) -> [integer()]
N = integer()
Generate vertex array object names
gl:genVertexArrays
returns N
vertex array object names in Arrays
.
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 gl:genVertexArrays
.
Vertex array object names returned by a call to gl:genVertexArrays
are not returned
by subsequent calls, unless they are first deleted with gl:deleteVertexArrays/1 .
The names returned in Arrays
are marked as used, for the purposes of gl:genVertexArrays
only, but they acquire state and type only when they are first bound.
See
isVertexArray(Array) -> 0 | 1
Array = integer()
Determine if a name corresponds to a vertex array object
gl:isVertexArray
returns ?GL_TRUE
if Array
is currently the name of
a renderbuffer object. If Renderbuffer
is zero, or if Array
is not the name
of a renderbuffer object, or if an error occurs, gl:isVertexArray
returns ?GL_FALSE
. If Array
is a name returned by gl:genVertexArrays/1 , by that has not yet
been bound through a call to gl:bindVertexArray/1 , then the name is not a vertex
array object and gl:isVertexArray
returns ?GL_FALSE
.
See
getUniformIndices(Program, UniformNames) -> [integer()]
Program = integer()
UniformNames = [string()]
Retrieve the index of a named uniform block
gl:getUniformIndices
retrieves the indices of a number of uniforms within Program
.
Program
must be the name of a program object for which the command gl:linkProgram/1
must have been called in the past, although it is not required that gl:linkProgram/1
must have succeeded. The link could have failed because the number of active uniforms
exceeded the limit.
UniformCount
indicates both the number of elements in the array of names UniformNames
and the number of indices that may be written to UniformIndices
.
UniformNames
contains a list of UniformCount
name strings identifying the
uniform names to be queried for indices. For each name string in UniformNames
,
the index assigned to the active uniform of that name will be written to the corresponding
element of UniformIndices
. If a string in UniformNames
is not the name of
an active uniform, the special value ?GL_INVALID_INDEX
will be written to the corresponding
element of UniformIndices
.
If an error occurs, nothing is written to UniformIndices
.
See
getActiveUniformsiv(Program, UniformIndices, Pname) -> [integer()]
Program = integer()
UniformIndices = [integer()]
Pname = enum()
glGetActiveUniforms
See
getActiveUniformName(Program, UniformIndex, BufSize) -> string()
Program = integer()
UniformIndex = integer()
BufSize = integer()
Query the name of an active uniform
gl:getActiveUniformName
returns the name of the active uniform at UniformIndex
within Program
. If UniformName
is not NULL, up to BufSize
characters
(including a nul-terminator) will be written into the array whose address is specified
by UniformName
. If Length
is not NULL, the number of characters that were
(or would have been) written into UniformName
(not including the nul-terminator)
will be placed in the variable whose address is specified in Length
. If Length
is NULL, no length is returned. The length of the longest uniform name in Program
is given by the value of ?GL_ACTIVE_UNIFORM_MAX_LENGTH
, which can be queried with gl:getProgramiv/2
.
If gl:getActiveUniformName
is not successful, nothing is written to Length
or UniformName
.
Program
must be the name of a program for which the command gl:linkProgram/1
has been issued in the past. It is not necessary for Program
to have been linked
successfully. The link could have failed because the number of active uniforms exceeded
the limit.
UniformIndex
must be an active uniform index of the program Program
, in
the range zero to ?GL_ACTIVE_UNIFORMS
- 1. The value of ?GL_ACTIVE_UNIFORMS
can be queried with gl:getProgramiv/2 .
See
getUniformBlockIndex(Program, UniformBlockName) -> integer()
Program = integer()
UniformBlockName = string()
Retrieve the index of a named uniform block
gl:getUniformBlockIndex
retrieves the index of a uniform block within Program
.
Program
must be the name of a program object for which the command gl:linkProgram/1
must have been called in the past, although it is not required that gl:linkProgram/1
must have succeeded. The link could have failed because the number of active uniforms
exceeded the limit.
UniformBlockName
must contain a nul-terminated string specifying the name of the
uniform block.
gl:getUniformBlockIndex
returns the uniform block index for the uniform block named
UniformBlockName
of Program
. If UniformBlockName
does not identify
an active uniform block of Program
, gl:getUniformBlockIndex
returns the special
identifier, ?GL_INVALID_INDEX
. Indices of the active uniform blocks of a program
are assigned in consecutive order, beginning with zero.
See
getActiveUniformBlockiv(Program, UniformBlockIndex, Pname, Params) -> ok
Program = integer()
UniformBlockIndex = integer()
Pname = enum()
Params = mem()
Query information about an active uniform block
gl:getActiveUniformBlockiv
retrieves information about an active uniform block within
Program
.
Program
must be the name of a program object for which the command gl:linkProgram/1
must have been called in the past, although it is not required that gl:linkProgram/1
must have succeeded. The link could have failed because the number of active uniforms
exceeded the limit.
UniformBlockIndex
is an active uniform block index of Program
, and must
be less than the value of ?GL_ACTIVE_UNIFORM_BLOCKS
.
Upon success, the uniform block parameter(s) specified by Pname
are returned in Params
. If an error occurs, nothing will be written to Params
.
If Pname
is ?GL_UNIFORM_BLOCK_BINDING
, then the index of the uniform buffer
binding point last selected by the uniform block specified by UniformBlockIndex
for Program
is returned. If no uniform block has been previously specified, zero
is returned.
If Pname
is ?GL_UNIFORM_BLOCK_DATA_SIZE
, then the implementation-dependent
minimum total buffer object size, in basic machine units, required to hold all active
uniforms in the uniform block identified by UniformBlockIndex
is returned. It is
neither guaranteed nor expected that a given implementation will arrange uniform values
as tightly packed in a buffer object. The exception to this is the std140 uniform block layout
, which guarantees specific packing behavior and does not require the application to query
for offsets and strides. In this case the minimum size may still be queried, even though
it is determined in advance based only on the uniform block declaration.
If Pname
is ?GL_UNIFORM_BLOCK_NAME_LENGTH
, then the total length (including
the nul terminator) of the name of the uniform block identified by UniformBlockIndex
is returned.
If Pname
is ?GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS
, then the number of active
uniforms in the uniform block identified by UniformBlockIndex
is returned.
If Pname
is ?GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES
, then a list of the
active uniform indices for the uniform block identified by UniformBlockIndex
is
returned. The number of elements that will be written to Params
is the value of ?GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS
for UniformBlockIndex
.
If Pname
is ?GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER
, ?GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER
, or ?GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER
, then a boolean value indicating
whether the uniform block identified by UniformBlockIndex
is referenced by the
vertex, geometry, or fragment programming stages of program, respectively, is returned.
See
getActiveUniformBlockName(Program, UniformBlockIndex, BufSize) -> string()
Program = integer()
UniformBlockIndex = integer()
BufSize = integer()
Retrieve the name of an active uniform block
gl:getActiveUniformBlockName
retrieves the name of the active uniform block at UniformBlockIndex
within Program
.
Program
must be the name of a program object for which the command gl:linkProgram/1
must have been called in the past, although it is not required that gl:linkProgram/1
must have succeeded. The link could have failed because the number of active uniforms
exceeded the limit.
UniformBlockIndex
is an active uniform block index of Program
, and must
be less than the value of ?GL_ACTIVE_UNIFORM_BLOCKS
.
Upon success, the name of the uniform block identified by UnifomBlockIndex
is
returned into UniformBlockName
. The name is nul-terminated. The actual number of
characters written into UniformBlockName
, excluding the nul terminator, is returned
in Length
. If Length
is NULL, no length is returned.
BufSize
contains the maximum number of characters (including the nul terminator)
that will be written into UniformBlockName
.
If an error occurs, nothing will be written to UniformBlockName
or Length
.
See
uniformBlockBinding(Program, UniformBlockIndex, UniformBlockBinding) -> ok
Program = integer()
UniformBlockIndex = integer()
UniformBlockBinding = integer()
Assign a binding point to an active uniform block
Binding points for active uniform blocks are assigned using gl:uniformBlockBinding
.
Each of a program's active uniform blocks has a corresponding uniform buffer binding point.
Program
is the name of a program object for which the command gl:linkProgram/1
has been issued in the past.
If successful, gl:uniformBlockBinding
specifies that Program
will use the
data store of the buffer object bound to the binding point UniformBlockBinding
to extract the values of the uniforms in the uniform block identified by UniformBlockIndex
.
When a program object is linked or re-linked, the uniform buffer object binding point assigned to each of its active uniform blocks is reset to zero.
See
copyBufferSubData(ReadTarget, WriteTarget, ReadOffset, WriteOffset, Size) -> ok
ReadTarget = enum()
WriteTarget = enum()
ReadOffset = integer()
WriteOffset = integer()
Size = integer()
Copy part of the data store of a buffer object to the data store of another buffer object
gl:copyBufferSubData
copies part of the data store attached to Readtarget
to the data store attached to Writetarget
. The number of basic machine units indicated
by Size
is copied from the source, at offset Readoffset
to the destination
at Writeoffset
, also in basic machine units.
Readtarget
and Writetarget
must be ?GL_ARRAY_BUFFER
, ?GL_COPY_READ_BUFFER
, ?GL_COPY_WRITE_BUFFER
, ?GL_ELEMENT_ARRAY_BUFFER
, ?GL_PIXEL_PACK_BUFFER
, ?GL_PIXEL_UNPACK_BUFFER
, ?GL_TEXTURE_BUFFER
, ?GL_TRANSFORM_FEEDBACK_BUFFER
or ?GL_UNIFORM_BUFFER
. Any of these targets may be used, although the targets ?GL_COPY_READ_BUFFER
and ?GL_COPY_WRITE_BUFFER
are provided specifically to allow copies between buffers
without disturbing other GL state.
Readoffset
, Writeoffset
and Size
must all be greater than or equal
to zero. Furthermore, Readoffset
+ Size
must not exceeed the size of the
buffer object bound to Readtarget
, and Readoffset
+ Size
must not
exceeed the size of the buffer bound to Writetarget
. If the same buffer object
is bound to both Readtarget
and Writetarget
, then the ranges specified by Readoffset
, Writeoffset
and Size
must not overlap.
See
drawElementsBaseVertex(Mode, Count, Type, Indices, Basevertex) -> ok
Mode = enum()
Count = integer()
Type = enum()
Indices = offset() | mem()
Basevertex = integer()
Render primitives from array data with a per-element offset
gl:drawElementsBaseVertex
behaves identically to gl:drawElements/4 except
that the i
th element transferred by the corresponding draw call will be taken from
element Indices
[i] + Basevertex
of each enabled array. If the resulting
value is larger than the maximum value representable by Type
, it is as if the calculation
were upconverted to 32-bit unsigned integers (with wrapping on overflow conditions). The
operation is undefined if the sum would be negative.
See
drawRangeElementsBaseVertex(Mode, Start, End, Count, Type, Indices, Basevertex) -> ok
Mode = enum()
Start = integer()
End = integer()
Count = integer()
Type = enum()
Indices = offset() | mem()
Basevertex = integer()
Render primitives from array data with a per-element offset
gl:drawRangeElementsBaseVertex
is a restricted form of gl:drawElementsBaseVertex/5
. Mode
, Start
, End
, Count
and Basevertex
match the
corresponding arguments to gl:drawElementsBaseVertex/5 , with the additional constraint
that all values in the array Indices
must lie between Start
and End
,
inclusive, prior to adding Basevertex
. Index values lying outside the range [ Start
, End
] are treated in the same way as gl:drawElementsBaseVertex/5 . The i
th element transferred by the corresponding draw call will be taken from element Indices
[i] + Basevertex
of each enabled array. If the resulting value is larger than the
maximum value representable by Type
, it is as if the calculation were upconverted
to 32-bit unsigned integers (with wrapping on overflow conditions). The operation is undefined
if the sum would be negative.
See
drawElementsInstancedBaseVertex(Mode, Count, Type, Indices, Primcount, Basevertex) -> ok
Mode = enum()
Count = integer()
Type = enum()
Indices = offset() | mem()
Primcount = integer()
Basevertex = integer()
Render multiple instances of a set of primitives from array data with a per-element offset
gl:drawElementsInstancedBaseVertex
behaves identically to gl:drawElementsInstanced/5
except that the i
th element transferred by the corresponding draw call will be
taken from element Indices
[i] + Basevertex
of each enabled array. If the
resulting value is larger than the maximum value representable by Type
, it is as
if the calculation were upconverted to 32-bit unsigned integers (with wrapping on overflow
conditions). The operation is undefined if the sum would be negative.
See
provokingVertex(Mode) -> ok
Mode = enum()
Specifiy the vertex to be used as the source of data for flat shaded varyings
Flatshading
a vertex shader varying output means to assign all vetices of the primitive
the same value for that output. The vertex from which these values is derived is known
as the provoking vertex
and gl:provokingVertex
specifies which vertex is
to be used as the source of data for flat shaded varyings.
ProvokeMode
must be either ?GL_FIRST_VERTEX_CONVENTION
or ?GL_LAST_VERTEX_CONVENTION
, and controls the selection of the vertex whose values are assigned to flatshaded varying
outputs. The interpretation of these values for the supported primitive types is:
Primitive Type of Polygon
i
First Vertex Convention
Last Vertex Convention
point
i
i
independent line 2
i
- 1 2i
line loop
i
i
+ 1, if i
< n
i
= n
line strip
i
i
+ 1 independent triangle 3
i
- 2 3i
triangle strip
i
i
+ 2 triangle fan
i
+ 1 i
+ 2 line adjacency 4
i
- 2 4i
- 1 line strip adjacency
i
+ 1 i
+ 2 triangle adjacency 6
i
- 5 6i
- 1 triangle strip adjacency 2
i
- 1 2i
+ 3 If a vertex or geometry shader is active, user-defined varying outputs may be flatshaded by using the flat qualifier when declaring the output.
See
fenceSync(Condition, Flags) -> integer()
Condition = enum()
Flags = integer()
Create a new sync object and insert it into the GL command stream
gl:fenceSync
creates a new fence sync object, inserts a fence command into the GL
command stream and associates it with that sync object, and returns a non-zero name corresponding
to the sync object.
When the specified Condition
of the sync object is satisfied by the fence command,
the sync object is signaled by the GL, causing any gl:waitSync/3 , gl:clientWaitSync/3
commands blocking in Sync
to unblock
. No other state is affected by gl:fenceSync
or by the execution of the associated fence command.
Condition
must be ?GL_SYNC_GPU_COMMANDS_COMPLETE
. This condition is satisfied
by completion of the fence command corresponding to the sync object and all preceding
commands in the same command stream. The sync object will not be signaled until all effects
from these commands on GL client and server state and the framebuffer are fully realized.
Note that completion of the fence command occurs once the state of the corresponding sync
object has been changed, but commands waiting on that sync object may not be unblocked
until after the fence command completes.
See
isSync(Sync) -> 0 | 1
Sync = integer()
Determine if a name corresponds to a sync object
gl:isSync
returns ?GL_TRUE
if Sync
is currently the name of a sync
object. If Sync
is not the name of a sync object, or if an error occurs, gl:isSync
returns ?GL_FALSE
. Note that zero is not the name of a sync object.
See
deleteSync(Sync) -> ok
Sync = integer()
Delete a sync object
gl:deleteSync
deletes the sync object specified by Sync
. If the fence command
corresponding to the specified sync object has completed, or if no gl:waitSync/3
or gl:clientWaitSync/3 commands are blocking on Sync
, the object is deleted
immediately. Otherwise, Sync
is flagged for deletion and will be deleted when it
is no longer associated with any fence command and is no longer blocking any gl:waitSync/3
or gl:clientWaitSync/3 command. In either case, after gl:deleteSync
returns,
the name Sync
is invalid and can no longer be used to refer to the sync object.
gl:deleteSync
will silently ignore a Sync
value of zero.
See
clientWaitSync(Sync, Flags, Timeout) -> enum()
Sync = integer()
Flags = integer()
Timeout = integer()
Block and wait for a sync object to become signaled
gl:clientWaitSync
causes the client to block and wait for the sync object specified
by Sync
to become signaled. If Sync
is signaled when gl:clientWaitSync
is called, gl:clientWaitSync
returns immediately, otherwise it will block and wait
for up to Timeout
nanoseconds for Sync
to become signaled.
The return value is one of four status values:
?GL_ALREADY_SIGNALED
indicates that Sync
was signaled at the time that gl:clientWaitSync
was called.
?GL_TIMEOUT_EXPIRED
indicates that at least Timeout
nanoseconds passed and Sync
did not become signaled.
?GL_CONDITION_SATISFIED
indicates that Sync
was signaled before the timeout
expired.
?GL_WAIT_FAILED
indicates that an error occurred. Additionally, an OpenGL error
will be generated.
See
waitSync(Sync, Flags, Timeout) -> ok
Sync = integer()
Flags = integer()
Timeout = integer()
Instruct the GL server to block until the specified sync object becomes signaled
gl:waitSync
causes the GL server to block and wait until Sync
becomes signaled.
Sync
is the name of an existing sync object upon which to wait. Flags
and Timeout
are currently not used and must be set to zero and the special value ?GL_TIMEOUT_IGNORED
, respectively
Flags
and Timeout
are placeholders for anticipated future extensions of
sync object capabilities. They must have these reserved values in order that existing
code calling gl:waitSync
operate properly in the presence of such extensions.. gl:waitSync
will always wait no longer than an implementation-dependent timeout. The duration of
this timeout in nanoseconds may be queried by calling gl:getBooleanv/1 with the parameter ?GL_MAX_SERVER_WAIT_TIMEOUT
. There is currently no way to determine whether gl:waitSync
unblocked because the
timeout expired or because the sync object being waited on was signaled.
If an error occurs, gl:waitSync
does not cause the GL server to block.
See
getSynciv(Sync, Pname, BufSize) -> [integer()]
Sync = integer()
Pname = enum()
BufSize = integer()
Query the properties of a sync object
gl:getSynciv
retrieves properties of a sync object. Sync
specifies the name
of the sync object whose properties to retrieve.
On success, gl:getSynciv
replaces up to BufSize
integers in Values
with the corresponding property values of the object being queried. The actual number
of integers replaced is returned in the variable whose address is specified in Length
. If Length
is NULL, no length is returned.
If Pname
is ?GL_OBJECT_TYPE
, a single value representing the specific type
of the sync object is placed in Values
. The only type supported is ?GL_SYNC_FENCE
.
If Pname
is ?GL_SYNC_STATUS
, a single value representing the status of
the sync object (?GL_SIGNALED
or ?GL_UNSIGNALED
) is placed in Values
.
If Pname
is ?GL_SYNC_CONDITION
, a single value representing the condition
of the sync object is placed in Values
. The only condition supported is ?GL_SYNC_GPU_COMMANDS_COMPLETE
.
If Pname
is ?GL_SYNC_FLAGS
, a single value representing the flags with
which the sync object was created is placed in Values
. No flags are currently supported
Flags
is expected to be used in future extensions to the sync objects..
If an error occurs, nothing will be written to Values
or Length
.
See
texImage2DMultisample(Target, Samples, Internalformat, Width, Height, Fixedsamplelocations) -> ok
Target = enum()
Samples = integer()
Internalformat = integer()
Width = integer()
Height = integer()
Fixedsamplelocations = 0 | 1
Establish the data storage, format, dimensions, and number of samples of a multisample texture's image
gl:texImage2DMultisample
establishes the data storage, format, dimensions and number
of samples of a multisample texture's image.
Target
must be ?GL_TEXTURE_2D_MULTISAMPLE
or ?GL_PROXY_TEXTURE_2D_MULTISAMPLE
. Width
and Height
are the dimensions in texels of the texture, and must
be in the range zero to ?GL_MAX_TEXTURE_SIZE
- 1. Samples
specifies the
number of samples in the image and must be in the range zero to ?GL_MAX_SAMPLES
- 1.
Internalformat
must be a color-renderable, depth-renderable, or stencil-renderable
format.
If Fixedsamplelocations
is ?GL_TRUE
, the image will use identical sample
locations and the same number of samples for all texels in the image, and the sample locations
will not depend on the internal format or size of the image.
When a multisample texture is accessed in a shader, the access takes one vector of integers describing which texel to fetch and an integer corresponding to the sample numbers describing which sample within the texel to fetch. No standard sampling instructions are allowed on the multisample texture targets.
See
texImage3DMultisample(Target, Samples, Internalformat, Width, Height, Depth, Fixedsamplelocations) -> ok
Target = enum()
Samples = integer()
Internalformat = integer()
Width = integer()
Height = integer()
Depth = integer()
Fixedsamplelocations = 0 | 1
Establish the data storage, format, dimensions, and number of samples of a multisample texture's image
gl:texImage3DMultisample
establishes the data storage, format, dimensions and number
of samples of a multisample texture's image.
Target
must be ?GL_TEXTURE_2D_MULTISAMPLE_ARRAY
or ?GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY
. Width
and Height
are the dimensions in texels of the texture, and must
be in the range zero to ?GL_MAX_TEXTURE_SIZE
- 1. Depth
is the number of
array slices in the array texture's image. Samples
specifies the number of samples
in the image and must be in the range zero to ?GL_MAX_SAMPLES
- 1.
Internalformat
must be a color-renderable, depth-renderable, or stencil-renderable
format.
If Fixedsamplelocations
is ?GL_TRUE
, the image will use identical sample
locations and the same number of samples for all texels in the image, and the sample locations
will not depend on the internal format or size of the image.
When a multisample texture is accessed in a shader, the access takes one vector of integers describing which texel to fetch and an integer corresponding to the sample numbers describing which sample within the texel to fetch. No standard sampling instructions are allowed on the multisample texture targets.
See
getMultisamplefv(Pname, Index) -> {float(), float()}
Pname = enum()
Index = integer()
Retrieve the location of a sample
gl:getMultisamplefv
queries the location of a given sample. Pname
specifies
the sample parameter to retrieve and must be ?GL_SAMPLE_POSITION
. Index
corresponds to the sample for which the location should be returned. The sample location
is returned as two floating-point values in Val[0]
and Val[1]
, each between
0 and 1, corresponding to the X
and Y
locations respectively in the GL pixel
space of that sample. (0.5, 0.5) this corresponds to the pixel center. Index
must
be between zero and the value of ?GL_SAMPLES
- 1.
If the multisample mode does not have fixed sample locations, the returned values may only reflect the locations of samples within some pixels.
See
sampleMaski(Index, Mask) -> ok
Index = integer()
Mask = integer()
Set the value of a sub-word of the sample mask
gl:sampleMaski
sets one 32-bit sub-word of the multi-word sample mask, ?GL_SAMPLE_MASK_VALUE
.
MaskIndex
specifies which 32-bit sub-word of the sample mask to update, and Mask
specifies the new value to use for that sub-word. MaskIndex
must be less than
the value of ?GL_MAX_SAMPLE_MASK_WORDS
. Bit B
of mask word M
corresponds
to sample 32 x M
+ B
.
See
namedStringARB(Type, Name, String) -> ok
Type = enum()
Name = string()
String = string()
glNamedStringARB
See
deleteNamedStringARB(Name) -> ok
Name = string()
glDeleteNamedStringARB
See
compileShaderIncludeARB(Shader, Path) -> ok
Shader = integer()
Path = [string()]
glCompileShaderIncludeARB
See
isNamedStringARB(Name) -> 0 | 1
Name = string()
glIsNamedStringARB
See
getNamedStringARB(Name, BufSize) -> string()
Name = string()
BufSize = integer()
glGetNamedStringARB
See
getNamedStringivARB(Name, Pname) -> integer()
Name = string()
Pname = enum()
glGetNamedStringARB
See
bindFragDataLocationIndexed(Program, ColorNumber, Index, Name) -> ok
Program = integer()
ColorNumber = integer()
Index = integer()
Name = string()
glBindFragDataLocationIndexe
See
getFragDataIndex(Program, Name) -> integer()
Program = integer()
Name = string()
Query the bindings of color indices to user-defined varying out variables
gl:getFragDataIndex
returns the index of the fragment color to which the variable Name
was bound when the program object Program
was last linked. If Name
is not
a varying out variable of Program
, or if an error occurs, -1 will be returned.
See
genSamplers(Count) -> [integer()]
Count = integer()
Generate sampler object names
gl:genSamplers
returns N
sampler object names in Samplers
. 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 gl:genSamplers
.
Sampler object names returned by a call to gl:genSamplers
are not returned by subsequent
calls, unless they are first deleted with gl:deleteSamplers/1 .
The names returned in Samplers
are marked as used, for the purposes of gl:genSamplers
only, but they acquire state and type only when they are first bound.
See
deleteSamplers(Samplers) -> ok
Samplers = [integer()]
Delete named sampler objects
gl:deleteSamplers
deletes N
sampler objects named by the elements of the
array Ids
. After a sampler object is deleted, its name is again unused. If a sampler
object that is currently bound to a sampler unit is deleted, it is as though gl:bindSampler/2
is called with unit set to the unit the sampler is bound to and sampler zero. Unused
names in samplers are silently ignored, as is the reserved name zero.
See
isSampler(Sampler) -> 0 | 1
Sampler = integer()
Determine if a name corresponds to a sampler object
gl:isSampler
returns ?GL_TRUE
if Id
is currently the name of a sampler
object. If Id
is zero, or is a non-zero value that is not currently the name of
a sampler object, or if an error occurs, gl:isSampler
returns ?GL_FALSE
.
A name returned by gl:genSamplers/1 , is the name of a sampler object.
See
bindSampler(Unit, Sampler) -> ok
Unit = integer()
Sampler = integer()
Bind a named sampler to a texturing target
gl:bindSampler
binds Sampler
to the texture unit at index Unit
. Sampler
must be zero or the name of a sampler object previously returned from a call to gl:genSamplers/1
. Unit
must be less than the value of ?GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
.
When a sampler object is bound to a texture unit, its state supersedes that of the texture object bound to that texture unit. If the sampler name zero is bound to a texture unit, the currently bound texture's sampler state becomes active. A single sampler object may be bound to multiple texture units simultaneously.
See
samplerParameteri(Sampler, Pname, Param) -> ok
Sampler = integer()
Pname = enum()
Param = integer()
Set sampler parameters
gl:samplerParameter
assigns the value or values in Params
to the sampler
parameter specified as Pname
. Sampler
specifies the sampler object to be
modified, and must be the name of a sampler object previously returned from a call to gl:genSamplers/1
. 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 gl:texImage1D/8
, gl:texImage2D/9 , gl:texImage3D/10 , gl:copyTexImage1D/7 , or gl:copyTexImage2D/8
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.
Params
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_MIN_LOD
: Sets the minimum level-of-detail parameter. This floating-point
value limits the selection of highest resolution mipmap (lowest mipmap level). The initial
value is -1000.
?GL_TEXTURE_MAX_LOD
: Sets the maximum level-of-detail parameter. This floating-point
value limits the selection of the lowest resolution mipmap (highest mipmap level). The
initial value is 1000.
?GL_TEXTURE_WRAP_S
: Sets the wrap parameter for texture coordinate s to either ?GL_CLAMP_TO_EDGE
, ?GL_MIRRORED_REPEAT
, or ?GL_REPEAT
. ?GL_CLAMP_TO_BORDER
causes
the s coordinate to be clamped to the range [(-1 2/N) 1+(1 2/N)], where N is the size of the texture in
the direction of clamping.?GL_CLAMP_TO_EDGE
causes s coordinates to be clamped
to the range [(1 2/N) 1-(1 2/N)], 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. ?GL_MIRRORED_REPEAT
causes the s
coordinate to be set to the fractional part of the texture coordinate if the integer part
of s is even; if the integer part of s is odd, then the s texture coordinate is
set to 1-frac(s), where frac(s) represents the fractional part of s. 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_TO_EDGE
, ?GL_MIRRORED_REPEAT
, or ?GL_REPEAT
. See the discussion under ?GL_TEXTURE_WRAP_S
. Initially, ?GL_TEXTURE_WRAP_T
is set to ?GL_REPEAT
.
?GL_TEXTURE_WRAP_R
: Sets the wrap parameter for texture coordinate r to either ?GL_CLAMP_TO_EDGE
, ?GL_MIRRORED_REPEAT
, or ?GL_REPEAT
. See the discussion under ?GL_TEXTURE_WRAP_S
. Initially, ?GL_TEXTURE_WRAP_R
is set to ?GL_REPEAT
.
?GL_TEXTURE_BORDER_COLOR
: The data in Params
specifies four values that
define the border values that should be used for border texels. If a texel is sampled
from the border of the texture, the values of ?GL_TEXTURE_BORDER_COLOR
are interpreted
as an RGBA color to match the texture's internal format and substituted for the non-existent
texel data. If the texture contains depth components, the first component of ?GL_TEXTURE_BORDER_COLOR
is interpreted as a depth value. The initial value is (0.0, 0.0, 0.0, 0.0).
?GL_TEXTURE_COMPARE_MODE
: Specifies the texture comparison mode for currently
bound textures. That is, a texture whose internal format is ?GL_DEPTH_COMPONENT_*
;
see gl:texImage2D/9 ) Permissible values are:
?GL_COMPARE_REF_TO_TEXTURE
: Specifies that the interpolated and clamped r texture
coordinate should be compared to the value in the currently bound texture. See the discussion
of ?GL_TEXTURE_COMPARE_FUNC
for details of how the comparison is evaluated. The
result of the comparison is assigned to the red channel.
?GL_NONE
: Specifies that the red channel should be assigned the appropriate value
from the currently bound texture.
?GL_TEXTURE_COMPARE_FUNC
: Specifies the comparison operator used when ?GL_TEXTURE_COMPARE_MODE
is set to ?GL_COMPARE_REF_TO_TEXTURE
. Permissible values are:
Texture Comparison Function
Computed result
?GL_LEQUAL
result={1.0 0.0 r<=(D t) r>(D t))?GL_GEQUAL
result={1.0 0.0 r>=(D t) r<(D t))?GL_LESS
result={1.0 0.0 r<(D t) r>=(D t))?GL_GREATER
result={1.0 0.0 r>(D t) r<=(D t))?GL_EQUAL
result={1.0 0.0 r=(D t) r≠
(D t))?GL_NOTEQUAL
result={1.0 0.0 r≠(D t) r=(D t))?GL_ALWAYS
result=1.0?GL_NEVER
result=0.0where r is the current interpolated texture coordinate, and D t is the texture value sampled from the currently bound texture. result is assigned to R t.
See
samplerParameteriv(Sampler, Pname, Param) -> ok
Sampler = integer()
Pname = enum()
Param = [integer()]
samplerParameterf(Sampler, Pname, Param) -> ok
Sampler = integer()
Pname = enum()
Param = float()
samplerParameterfv(Sampler, Pname, Param) -> ok
Sampler = integer()
Pname = enum()
Param = [float()]
samplerParameterIiv(Sampler, Pname, Param) -> ok
Sampler = integer()
Pname = enum()
Param = [integer()]
samplerParameterIuiv(Sampler, Pname, Param) -> ok
Sampler = integer()
Pname = enum()
Param = [integer()]
glSamplerParameterI
See
getSamplerParameteriv(Sampler, Pname) -> [integer()]
Sampler = integer()
Pname = enum()
Return sampler parameter values
gl:getSamplerParameter
returns in Params
the value or values of the sampler
parameter specified as Pname
. Sampler
defines the target sampler, and must
be the name of an existing sampler object, returned from a previous call to gl:genSamplers/1
. Pname
accepts the same symbols as gl:samplerParameteri/3 , with the same
interpretations:
?GL_TEXTURE_MAG_FILTER
: Returns the single-valued texture magnification filter,
a symbolic constant. The initial value is ?GL_LINEAR
.
?GL_TEXTURE_MIN_FILTER
: Returns the single-valued texture minification filter,
a symbolic constant. The initial value is ?GL_NEAREST_MIPMAP_LINEAR
.
?GL_TEXTURE_MIN_LOD
: Returns the single-valued texture minimum level-of-detail
value. The initial value is -1000.
?GL_TEXTURE_MAX_LOD
: Returns the single-valued texture maximum level-of-detail
value. The initial value is 1000.
?GL_TEXTURE_WRAP_S
: Returns the single-valued wrapping function for texture coordinate
s, a symbolic constant. The initial value is ?GL_REPEAT
.
?GL_TEXTURE_WRAP_T
: Returns the single-valued wrapping function for texture coordinate
t, a symbolic constant. The initial value is ?GL_REPEAT
.
?GL_TEXTURE_WRAP_R
: Returns the single-valued wrapping function for texture coordinate
r, a symbolic constant. The initial value is ?GL_REPEAT
.
?GL_TEXTURE_BORDER_COLOR
: Returns four integer or floating-point numbers that
comprise the RGBA color of the texture border. Floating-point values are returned in the
range [0 1]. Integer values are returned as a linear mapping of the internal floating-point
representation such that 1.0 maps to the most positive representable integer and -1.0
maps to the most negative representable integer. The initial value is (0, 0, 0, 0).
?GL_TEXTURE_COMPARE_MODE
: Returns a single-valued texture comparison mode, a symbolic
constant. The initial value is ?GL_NONE
. See gl:samplerParameteri/3 .
?GL_TEXTURE_COMPARE_FUNC
: Returns a single-valued texture comparison function,
a symbolic constant. The initial value is ?GL_LEQUAL
. See gl:samplerParameteri/3
.
See
getSamplerParameterIiv(Sampler, Pname) -> [integer()]
Sampler = integer()
Pname = enum()
getSamplerParameterfv(Sampler, Pname) -> [float()]
Sampler = integer()
Pname = enum()
getSamplerParameterIuiv(Sampler, Pname) -> [integer()]
Sampler = integer()
Pname = enum()
glGetSamplerParameterI
See
queryCounter(Id, Target) -> ok
Id = integer()
Target = enum()
Record the GL time into a query object after all previous commands have reached the GL server but have not yet necessarily executed.
gl:queryCounter
causes the GL to record the current time into the query object named
Id
. Target
must be ?GL_TIMESTAMP
. The time is recorded after all
previous commands on the GL client and server state and the framebuffer have been fully
realized. When the time is recorded, the query result for that object is marked available.
gl:queryCounter
timer queries can be used within a gl:beginQuery/2 / gl:beginQuery/2
block where the target is ?GL_TIME_ELAPSED
and it does not affect the result of
that query object.
See
getQueryObjecti64v(Id, Pname) -> integer()
Id = integer()
Pname = enum()
glGetQueryObjecti64v
See
getQueryObjectui64v(Id, Pname) -> integer()
Id = integer()
Pname = enum()
glGetQueryObjectui64v
See
drawArraysIndirect(Mode, Indirect) -> ok
Mode = enum()
Indirect = offset() | mem()
Render primitives from array data, taking parameters from memory
gl:drawArraysIndirect
specifies multiple geometric primitives with very few subroutine
calls. gl:drawArraysIndirect
behaves similarly to gl:drawArraysInstancedBaseInstance/5
, execept that the parameters to gl:drawArraysInstancedBaseInstance/5 are stored
in memory at the address given by Indirect
.
The parameters addressed by Indirect
are packed into a structure that takes the
form (in C): typedef struct { uint count; uint primCount; uint first; uint baseInstance;
} DrawArraysIndirectCommand; const DrawArraysIndirectCommand *cmd = (const DrawArraysIndirectCommand
*)indirect; glDrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count, cmd->primCount,
cmd->baseInstance);
If a buffer is bound to the ?GL_DRAW_INDIRECT_BUFFER
binding at the time of a
call to gl:drawArraysIndirect
, Indirect
is interpreted as an offset, in basic
machine units, into that buffer and the parameter data is read from the buffer rather
than from client memory.
In contrast to gl:drawArraysInstancedBaseInstance/5 , the first member of the parameter structure is unsigned, and out-of-range indices do not generate an error.
Vertex attributes that are modified by gl:drawArraysIndirect
have an unspecified
value after gl:drawArraysIndirect
returns. Attributes that aren't modified remain
well defined.
See
drawElementsIndirect(Mode, Type, Indirect) -> ok
Mode = enum()
Type = enum()
Indirect = offset() | mem()
Render indexed primitives from array data, taking parameters from memory
gl:drawElementsIndirect
specifies multiple indexed geometric primitives with very
few subroutine calls. gl:drawElementsIndirect
behaves similarly to gl:drawElementsInstancedBaseVertexBaseInstance/7
, execpt that the parameters to gl:drawElementsInstancedBaseVertexBaseInstance/7
are stored in memory at the address given by Indirect
.
The parameters addressed by Indirect
are packed into a structure that takes the
form (in C): typedef struct { uint count; uint primCount; uint firstIndex; uint baseVertex;
uint baseInstance; } DrawElementsIndirectCommand;
gl:drawElementsIndirect
is equivalent to: void glDrawElementsIndirect(GLenum mode,
GLenum type, const void * indirect) { const DrawElementsIndirectCommand *cmd = (const
DrawElementsIndirectCommand *)indirect; glDrawElementsInstancedBaseVertexBaseInstance(mode,
cmd->count, type, cmd->firstIndex + size-of-type, cmd->primCount, cmd->baseVertex,
cmd->baseInstance); }
If a buffer is bound to the ?GL_DRAW_INDIRECT_BUFFER
binding at the time of a
call to gl:drawElementsIndirect
, Indirect
is interpreted as an offset, in
basic machine units, into that buffer and the parameter data is read from the buffer rather
than from client memory.
Note that indices stored in client memory are not supported. If no buffer is bound to
the ?GL_ELEMENT_ARRAY_BUFFER
binding, an error will be generated.
The results of the operation are undefined if the reservedMustBeZero member of the parameter structure is non-zero. However, no error is generated in this case.
Vertex attributes that are modified by gl:drawElementsIndirect
have an unspecified
value after gl:drawElementsIndirect
returns. Attributes that aren't modified remain
well defined.
See
uniform3d(Location, X, Y, Z) -> ok
Location = integer()
X = float()
Y = float()
Z = float()
See uniform1f/2
uniform4d(Location, X, Y, Z, W) -> ok
Location = integer()
X = float()
Y = float()
Z = float()
W = float()
See uniform1f/2
uniform3dv(Location, Value) -> ok
Location = integer()
Value = [{float(), float(), float()}]
See uniform1f/2
uniform4dv(Location, Value) -> ok
Location = integer()
Value = [{float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix2dv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3dv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix4dv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix2x3dv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix2x4dv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3x2dv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3x4dv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix4x2dv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix4x3dv(Location, Transpose, Value) -> ok
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
getUniformdv(Program, Location) -> matrix()
Program = integer()
Location = integer()
See getUniformfv/2
getSubroutineUniformLocation(Program, Shadertype, Name) -> integer()
Program = integer()
Shadertype = enum()
Name = string()
Retrieve the location of a subroutine uniform of a given shader stage within a program
gl:getSubroutineUniformLocation
returns the location of the subroutine uniform variable
Name
in the shader stage of type Shadertype
attached to Program
,
with behavior otherwise identical to gl:getUniformLocation/2 .
If Name
is not the name of a subroutine uniform in the shader stage, -1 is returned,
but no error is generated. If Name
is the name of a subroutine uniform in the shader
stage, a value between zero and the value of ?GL_ACTIVE_SUBROUTINE_LOCATIONS
minus
one will be returned. Subroutine locations are assigned using consecutive integers in
the range from zero to the value of ?GL_ACTIVE_SUBROUTINE_LOCATIONS
minus one for
the shader stage. For active subroutine uniforms declared as arrays, the declared array
elements are assigned consecutive locations.
See
getSubroutineIndex(Program, Shadertype, Name) -> integer()
Program = integer()
Shadertype = enum()
Name = string()
Retrieve the index of a subroutine uniform of a given shader stage within a program
gl:getSubroutineIndex
returns the index of a subroutine uniform within a shader
stage attached to a program object. Program
contains the name of the program to
which the shader is attached. Shadertype
specifies the stage from which to query
shader subroutine index. Name
contains the null-terminated name of the subroutine
uniform whose name to query.
If Name
is not the name of a subroutine uniform in the shader stage, ?GL_INVALID_INDEX
is returned, but no error is generated. If Name
is the name of a subroutine uniform
in the shader stage, a value between zero and the value of ?GL_ACTIVE_SUBROUTINES
minus one will be returned. Subroutine indices are assigned using consecutive integers
in the range from zero to the value of ?GL_ACTIVE_SUBROUTINES
minus one for the
shader stage.
See
getActiveSubroutineUniformName(Program, Shadertype, Index, Bufsize) -> string()
Program = integer()
Shadertype = enum()
Index = integer()
Bufsize = integer()
Query the name of an active shader subroutine uniform
gl:getActiveSubroutineUniformName
retrieves the name of an active shader subroutine
uniform. Program
contains the name of the program containing the uniform. Shadertype
specifies the stage for which which the uniform location, given by Index
, is valid.
Index
must be between zero and the value of ?GL_ACTIVE_SUBROUTINE_UNIFORMS
minus one for the shader stage.
The uniform name is returned as a null-terminated string in Name
. The actual number
of characters written into Name
, excluding the null terminator is returned in Length
. If Length
is ?NULL
, no length is returned. The maximum number of characters
that may be written into Name
, including the null terminator, is specified by Bufsize
. The length of the longest subroutine uniform name in Program
and Shadertype
is given by the value of ?GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
, which can be
queried with gl:getProgramStageiv/3 .
See
getActiveSubroutineName(Program, Shadertype, Index, Bufsize) -> string()
Program = integer()
Shadertype = enum()
Index = integer()
Bufsize = integer()
Query the name of an active shader subroutine
gl:getActiveSubroutineName
queries the name of an active shader subroutine uniform
from the program object given in Program
. Index
specifies the index of the
shader subroutine uniform within the shader stage given by Stage
, and must between
zero and the value of ?GL_ACTIVE_SUBROUTINES
minus one for the shader stage.
The name of the selected subroutine is returned as a null-terminated string in Name
. The actual number of characters written into Name
, not including the null-terminator,
is is returned in Length
. If Length
is ?NULL
, no length is returned.
The maximum number of characters that may be written into Name
, including the null-terminator,
is given in Bufsize
.
See
uniformSubroutinesuiv(Shadertype, Indices) -> ok
Shadertype = enum()
Indices = [integer()]
Load active subroutine uniforms
gl:uniformSubroutines
loads all active subroutine uniforms for shader stage Shadertype
of the current program with subroutine indices from Indices
, storing Indices[i]
into the uniform at location I
. Count
must be equal to the value of ?GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
for the program currently in use at shader stage Shadertype
. Furthermore, all
values in Indices
must be less than the value of ?GL_ACTIVE_SUBROUTINES
for the shader stage.
See
getUniformSubroutineuiv(Shadertype, Location) -> {integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer()}
Shadertype = enum()
Location = integer()
Retrieve the value of a subroutine uniform of a given shader stage of the current program
gl:getUniformSubroutine
retrieves the value of the subroutine uniform at location Location
for shader stage Shadertype
of the current program. Location
must be less
than the value of ?GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
for the shader currently
in use at shader stage Shadertype
. The value of the subroutine uniform is returned
in Values
.
See
getProgramStageiv(Program, Shadertype, Pname) -> integer()
Program = integer()
Shadertype = enum()
Pname = enum()
Retrieve properties of a program object corresponding to a specified shader stage
gl:getProgramStage
queries a parameter of a shader stage attached to a program object.
Program
contains the name of the program to which the shader is attached. Shadertype
specifies the stage from which to query the parameter. Pname
specifies which parameter
should be queried. The value or values of the parameter to be queried is returned in the
variable whose address is given in Values
.
If Pname
is ?GL_ACTIVE_SUBROUTINE_UNIFORMS
, the number of active subroutine
variables in the stage is returned in Values
.
If Pname
is ?GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
, the number of active
subroutine variable locations in the stage is returned in Values
.
If Pname
is ?GL_ACTIVE_SUBROUTINES
, the number of active subroutines in
the stage is returned in Values
.
If Pname
is ?GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
, the length of the
longest subroutine uniform for the stage is returned in Values
.
If Pname
is ?GL_ACTIVE_SUBROUTINE_MAX_LENGTH
, the length of the longest
subroutine name for the stage is returned in Values
. The returned name length includes
space for the null-terminator.
If there is no shader present of type Shadertype
, the returned value will be consistent
with a shader containing no subroutines or subroutine uniforms.
See
patchParameteri(Pname, Value) -> ok
Pname = enum()
Value = integer()
Specifies the parameters for patch primitives
gl:patchParameter
specifies the parameters that will be used for patch primitives. Pname
specifies the parameter to modify and must be either ?GL_PATCH_VERTICES
, ?GL_PATCH_DEFAULT_OUTER_LEVEL
or ?GL_PATCH_DEFAULT_INNER_LEVEL
. For gl:patchParameteri
, Value
specifies
the new value for the parameter specified by Pname
. For gl:patchParameterfv
,
Values
specifies the address of an array containing the new values for the parameter
specified by Pname
.
When Pname
is ?GL_PATCH_VERTICES
, Value
specifies the number of
vertices that will be used to make up a single patch primitive. Patch primitives are consumed
by the tessellation control shader (if present) and subsequently used for tessellation.
When primitives are specified using gl:drawArrays/3 or a similar function, each
patch will be made from Parameter
control points, each represented by a vertex
taken from the enabeld vertex arrays. Parameter
must be greater than zero, and
less than or equal to the value of ?GL_MAX_PATCH_VERTICES
.
When Pname
is ?GL_PATCH_DEFAULT_OUTER_LEVEL
or ?GL_PATCH_DEFAULT_INNER_LEVEL
, Values
contains the address of an array contiaining the default outer or inner
tessellation levels, respectively, to be used when no tessellation control shader is present.
See
bindTransformFeedback(Target, Id) -> ok
Target = enum()
Id = integer()
Bind a transform feedback object
gl:bindTransformFeedback
binds the transform feedback object with name Id
to the current GL state. Id
must be a name previously returned from a call to gl:genTransformFeedbacks/1
. If Id
has not previously been bound, a new transform feedback object with name Id
and initialized with with the default transform state vector is created.
In the initial state, a default transform feedback object is bound and treated as a transform feedback object with a name of zero. If the name zero is subsequently bound, the default transform feedback object is again bound to the GL state.
While a transform feedback buffer object is bound, GL operations on the target to which it is bound affect the bound transform feedback object, and queries of the target to which a transform feedback object is bound return state from the bound object. When buffer objects are bound for transform feedback, they are attached to the currently bound transform feedback object. Buffer objects are used for trans- form feedback only if they are attached to the currently bound transform feedback object.
See
deleteTransformFeedbacks(Ids) -> ok
Ids = [integer()]
Delete transform feedback objects
gl:deleteTransformFeedbacks
deletes the N
transform feedback objects whose
names are stored in the array Ids
. Unused names in Ids
are ignored, as is
the name zero. After a transform feedback object is deleted, its name is again unused
and it has no contents. If an active transform feedback object is deleted, its name immediately
becomes unused, but the underlying object is not deleted until it is no longer active.
See
genTransformFeedbacks(N) -> [integer()]
N = integer()
Reserve transform feedback object names
gl:genTransformFeedbacks
returns N
previously unused transform feedback object
names in Ids
. These names are marked as used, for the purposes of gl:genTransformFeedbacks
only, but they acquire transform feedback state only when they are first bound.
See
isTransformFeedback(Id) -> 0 | 1
Id = integer()
Determine if a name corresponds to a transform feedback object
gl:isTransformFeedback
returns ?GL_TRUE
if Id
is currently the name
of a transform feedback object. If Id
is zero, or if ?id
is not the name
of a transform feedback object, or if an error occurs, gl:isTransformFeedback
returns
?GL_FALSE
. If Id
is a name returned by gl:genTransformFeedbacks/1 ,
but that has not yet been bound through a call to gl:bindTransformFeedback/2 , then
the name is not a transform feedback object and gl:isTransformFeedback
returns ?GL_FALSE
.
See
pauseTransformFeedback() -> ok
Pause transform feedback operations
gl:pauseTransformFeedback
pauses transform feedback operations on the currently
active transform feedback object. When transform feedback operations are paused, transform
feedback is still considered active and changing most transform feedback state related
to the object results in an error. However, a new transform feedback object may be bound
while transform feedback is paused.
See
resumeTransformFeedback() -> ok
Resume transform feedback operations
gl:resumeTransformFeedback
resumes transform feedback operations on the currently
active transform feedback object. When transform feedback operations are paused, transform
feedback is still considered active and changing most transform feedback state related
to the object results in an error. However, a new transform feedback object may be bound
while transform feedback is paused.
See
drawTransformFeedback(Mode, Id) -> ok
Mode = enum()
Id = integer()
Render primitives using a count derived from a transform feedback object
gl:drawTransformFeedback
draws primitives of a type specified by Mode
using
a count retrieved from the transform feedback specified by Id
. Calling gl:drawTransformFeedback
is equivalent to calling gl:drawArrays/3 with Mode
as specified, First
set to zero, and Count
set to the number of vertices captured on vertex stream
zero the last time transform feedback was active on the transform feedback object named
by Id
.
See
drawTransformFeedbackStream(Mode, Id, Stream) -> ok
Mode = enum()
Id = integer()
Stream = integer()
Render primitives using a count derived from a specifed stream of a transform feedback object
gl:drawTransformFeedbackStream
draws primitives of a type specified by Mode
using a count retrieved from the transform feedback stream specified by Stream
of the transform feedback object specified by Id
. Calling gl:drawTransformFeedbackStream
is equivalent to calling gl:drawArrays/3 with Mode
as specified, First
set to zero, and Count
set to the number of vertices captured on vertex stream Stream
the last time transform feedback was active on the transform feedback object named by Id
.
Calling gl:drawTransformFeedback/2 is equivalent to calling gl:drawTransformFeedbackStream
with Stream
set to zero.
See
beginQueryIndexed(Target, Index, Id) -> ok
Target = enum()
Index = integer()
Id = integer()
glBeginQueryIndexe
See
endQueryIndexed(Target, Index) -> ok
Target = enum()
Index = integer()
Delimit the boundaries of a query object on an indexed target
gl:beginQueryIndexed
and gl:endQueryIndexed/2 delimit the boundaries of a
query object. Query
must be a name previously returned from a call to gl:genQueries/1
. If a query object with name Id
does not yet exist it is created with the type
determined by Target
. Target
must be one of ?GL_SAMPLES_PASSED
, ?GL_ANY_SAMPLES_PASSED
, ?GL_PRIMITIVES_GENERATED
, ?GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
, or ?GL_TIME_ELAPSED
. The behavior of the query object depends on its type and is as follows.
Index
specifies the index of the query target and must be between a Target
-specific
maximum.
If Target
is ?GL_SAMPLES_PASSED
, Id
must be an unused name, or the
name of an existing occlusion query object. When gl:beginQueryIndexed
is executed,
the query object's samples-passed counter is reset to 0. Subsequent rendering will increment
the counter for every sample that passes the depth test. If the value of ?GL_SAMPLE_BUFFERS
is 0, then the samples-passed count is incremented by 1 for each fragment. If the value
of ?GL_SAMPLE_BUFFERS
is 1, then the samples-passed count is incremented by the
number of samples whose coverage bit is set. However, implementations, at their discression
may instead increase the samples-passed count by the value of ?GL_SAMPLES
if any
sample in the fragment is covered. When gl:endQueryIndexed
is executed, the samples-passed
counter is assigned to the query object's result value. This value can be queried by calling
gl:getQueryObjectiv/2 with Pname
?GL_QUERY_RESULT
. When Target
is ?GL_SAMPLES_PASSED
, Index
must be zero.
If Target
is ?GL_ANY_SAMPLES_PASSED
, Id
must be an unused name,
or the name of an existing boolean occlusion query object. When gl:beginQueryIndexed
is executed, the query object's samples-passed flag is reset to ?GL_FALSE
. Subsequent
rendering causes the flag to be set to ?GL_TRUE
if any sample passes the depth
test. When gl:endQueryIndexed
is executed, the samples-passed flag is assigned to
the query object's result value. This value can be queried by calling gl:getQueryObjectiv/2
with Pname
?GL_QUERY_RESULT
. When Target
is ?GL_ANY_SAMPLES_PASSED
, Index
must be zero.
If Target
is ?GL_PRIMITIVES_GENERATED
, Id
must be an unused name,
or the name of an existing primitive query object previously bound to the ?GL_PRIMITIVES_GENERATED
query binding. When gl:beginQueryIndexed
is executed, the query object's primitives-generated
counter is reset to 0. Subsequent rendering will increment the counter once for every
vertex that is emitted from the geometry shader to the stream given by Index
, or
from the vertex shader if Index
is zero and no geometry shader is present. When gl:endQueryIndexed
is executed, the primitives-generated counter for stream Index
is assigned to
the query object's result value. This value can be queried by calling gl:getQueryObjectiv/2
with Pname
?GL_QUERY_RESULT
. When Target
is ?GL_PRIMITIVES_GENERATED
, Index
must be less than the value of ?GL_MAX_VERTEX_STREAMS
.
If Target
is ?GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
, Id
must
be an unused name, or the name of an existing primitive query object previously bound
to the ?GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
query binding. When gl:beginQueryIndexed
is executed, the query object's primitives-written counter for the stream specified by Index
is reset to 0. Subsequent rendering will increment the counter once for every vertex
that is written into the bound transform feedback buffer(s) for stream Index
. If
transform feedback mode is not activated between the call to gl:beginQueryIndexed
and gl:endQueryIndexed
, the counter will not be incremented. When gl:endQueryIndexed
is executed, the primitives-written counter for stream Index
is assigned to the
query object's result value. This value can be queried by calling gl:getQueryObjectiv/2
with Pname
?GL_QUERY_RESULT
. When Target
is ?GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
, Index
must be less than the value of ?GL_MAX_VERTEX_STREAMS
.
If Target
is ?GL_TIME_ELAPSED
, Id
must be an unused name, or the
name of an existing timer query object previously bound to the ?GL_TIME_ELAPSED
query binding. When gl:beginQueryIndexed
is executed, the query object's time counter
is reset to 0. When gl:endQueryIndexed
is executed, the elapsed server time that
has passed since the call to gl:beginQueryIndexed
is written into the query object's
time counter. This value can be queried by calling gl:getQueryObjectiv/2 with Pname
?GL_QUERY_RESULT
. When Target
is ?GL_TIME_ELAPSED
, Index
must
be zero.
Querying the ?GL_QUERY_RESULT
implicitly flushes the GL pipeline until the rendering
delimited by the query object has completed and the result is available. ?GL_QUERY_RESULT_AVAILABLE
can be queried to determine if the result is immediately available or if the rendering
is not yet complete.
See
getQueryIndexediv(Target, Index, Pname) -> integer()
Target = enum()
Index = integer()
Pname = enum()
Return parameters of an indexed query object target
gl:getQueryIndexediv
returns in Params
a selected parameter of the indexed
query object target specified by Target
and Index
. Index
specifies
the index of the query object target and must be between zero and a target-specific maxiumum.
Pname
names a specific query object target parameter. When Pname
is ?GL_CURRENT_QUERY
, the name of the currently active query for the specified Index
of Target
,
or zero if no query is active, will be placed in Params
. If Pname
is ?GL_QUERY_COUNTER_BITS
, the implementation-dependent number of bits used to hold the result of queries for Target
is returned in Params
.
See
releaseShaderCompiler() -> ok
Release resources consumed by the implementation's shader compiler
gl:releaseShaderCompiler
provides a hint to the implementation that it may free
internal resources associated with its shader compiler. gl:compileShader/1 may
subsequently be called and the implementation may at that time reallocate resources previously
freed by the call to gl:releaseShaderCompiler
.
See
shaderBinary(Shaders, Binaryformat, Binary) -> ok
Shaders = [integer()]
Binaryformat = enum()
Binary = binary()
Load pre-compiled shader binaries
gl:shaderBinary
loads pre-compiled shader binary code into the Count
shader
objects whose handles are given in Shaders
. Binary
points to Length
bytes of binary shader code stored in client memory. BinaryFormat
specifies the
format of the pre-compiled code.
The binary image contained in Binary
will be decoded according to the extension
specification defining the specified BinaryFormat
token. OpenGL does not define
any specific binary formats, but it does provide a mechanism to obtain token vaues for
such formats provided by such extensions.
Depending on the types of the shader objects in Shaders
, gl:shaderBinary
will individually load binary vertex or fragment shaders, or load an executable binary
that contains an optimized pair of vertex and fragment shaders stored in the same binary.
See
getShaderPrecisionFormat(Shadertype, Precisiontype) -> {Range::{integer(), integer()}, Precision::integer()}
Shadertype = enum()
Precisiontype = enum()
Retrieve the range and precision for numeric formats supported by the shader compiler
gl:getShaderPrecisionFormat
retrieves the numeric range and precision for the implementation's
representation of quantities in different numeric formats in specified shader type. ShaderType
specifies the type of shader for which the numeric precision and range is to be retrieved
and must be one of ?GL_VERTEX_SHADER
or ?GL_FRAGMENT_SHADER
. PrecisionType
specifies the numeric format to query and must be one of ?GL_LOW_FLOAT
, ?GL_MEDIUM_FLOAT
?GL_HIGH_FLOAT
, ?GL_LOW_INT
, ?GL_MEDIUM_INT
, or ?GL_HIGH_INT
.
Range
points to an array of two integers into which the format's numeric range
will be returned. If min and max are the smallest values representable in the format,
then the values returned are defined to be: Range
[0] = floor(log2(|min|)) and Range
[1] = floor(log2(|max|)).
Precision
specifies the address of an integer into which will be written the log2
value of the number of bits of precision of the format. If the smallest representable
value greater than 1 is 1 + eps
, then the integer addressed by Precision
will contain floor(-log2(eps)).
See
clearDepthf(D) -> ok
D = clamp()
glClearDepthf
See
getProgramBinary(Program, BufSize) -> {BinaryFormat::enum(), Binary::binary()}
Program = integer()
BufSize = integer()
Return a binary representation of a program object's compiled and linked executable source
gl:getProgramBinary
returns a binary representation of the compiled and linked executable
for Program
into the array of bytes whose address is specified in Binary
.
The maximum number of bytes that may be written into Binary
is specified by BufSize
. If the program binary is greater in size than BufSize
bytes, then an error is
generated, otherwise the actual number of bytes written into Binary
is returned
in the variable whose address is given by Length
. If Length
is ?NULL
,
then no length is returned.
The format of the program binary written into Binary
is returned in the variable
whose address is given by BinaryFormat
, and may be implementation dependent. The
binary produced by the GL may subsequently be returned to the GL by calling gl:programBinary/3
, with BinaryFormat
and Length
set to the values returned by gl:getProgramBinary
, and passing the returned binary data in the Binary
parameter.
See
programBinary(Program, BinaryFormat, Binary) -> ok
Program = integer()
BinaryFormat = enum()
Binary = binary()
Load a program object with a program binary
gl:programBinary
loads a program object with a program binary previously returned
from gl:getProgramBinary/2 . BinaryFormat
and Binary
must be those
returned by a previous call to gl:getProgramBinary/2 , and Length
must be
the length returned by gl:getProgramBinary/2 , or by gl:getProgramiv/2 when
called with Pname
set to ?GL_PROGRAM_BINARY_LENGTH
. If these conditions
are not met, loading the program binary will fail and Program
's ?GL_LINK_STATUS
will be set to ?GL_FALSE
.
A program object's program binary is replaced by calls to gl:linkProgram/1 or gl:programBinary
. When linking success or failure is concerned, gl:programBinary
can be considered
to perform an implicit linking operation. gl:linkProgram/1 and gl:programBinary
both set the program object's ?GL_LINK_STATUS
to ?GL_TRUE
or ?GL_FALSE
.
A successful call to gl:programBinary
will reset all uniform variables to their
initial values. The initial value is either the value of the variable's initializer as
specified in the original shader source, or zero if no initializer was present. Additionally,
all vertex shader input and fragment shader output assignments that were in effect when
the program was linked before saving are restored with gl:programBinary
is called.
See
programParameteri(Program, Pname, Value) -> ok
Program = integer()
Pname = enum()
Value = integer()
Specify a parameter for a program object
gl:programParameter
specifies a new value for the parameter nameed by Pname
for the program object Program
.
If Pname
is ?GL_PROGRAM_BINARY_RETRIEVABLE_HINT
, Value
should be ?GL_FALSE
or ?GL_TRUE
to indicate to the implementation the intention of the application
to retrieve the program's binary representation with gl:getProgramBinary/2 . The
implementation may use this information to store information that may be useful for a
future query of the program's binary. It is recommended to set ?GL_PROGRAM_BINARY_RETRIEVABLE_HINT
for the program to ?GL_TRUE
before calling gl:linkProgram/1 , and using
the program at run-time if the binary is to be retrieved later.
If Pname
is ?GL_PROGRAM_SEPARABLE
, Value
must be ?GL_TRUE
or ?GL_FALSE
and indicates whether Program
can be bound to individual pipeline
stages via gl:useProgramStages/3 . A program's ?GL_PROGRAM_SEPARABLE
parameter
must be set to ?GL_TRUE
before
gl:linkProgram/1 is called in order
for it to be usable with a program pipeline object. The initial state of ?GL_PROGRAM_SEPARABLE
is ?GL_FALSE
.
See
useProgramStages(Pipeline, Stages, Program) -> ok
Pipeline = integer()
Stages = integer()
Program = integer()
Bind stages of a program object to a program pipeline
gl:useProgramStages
binds executables from a program object associated with a specified
set of shader stages to the program pipeline object given by Pipeline
. Pipeline
specifies the program pipeline object to which to bind the executables. Stages
contains a logical combination of bits indicating the shader stages to use within Program
with the program pipeline object Pipeline
. Stages
must be a logical combination
of ?GL_VERTEX_SHADER_BIT
, ?GL_TESS_CONTROL_SHADER_BIT
, ?GL_TESS_EVALUATION_SHADER_BIT
, ?GL_GEOMETRY_SHADER_BIT
, and ?GL_FRAGMENT_SHADER_BIT
. Additionally, the
special value ?GL_ALL_SHADER_BITS
may be specified to indicate that all executables
contained in Program
should be installed in Pipeline
.
If Program
refers to a program object with a valid shader attached for an indicated
shader stage, gl:useProgramStages
installs the executable code for that stage in
the indicated program pipeline object Pipeline
. If Program
is zero, or refers
to a program object with no valid shader executable for a given stage, it is as if the
pipeline object has no programmable stage configured for the indicated shader stages. If Stages
contains bits other than those listed above, and is not equal to ?GL_ALL_SHADER_BITS
, an error is generated.
See
activeShaderProgram(Pipeline, Program) -> ok
Pipeline = integer()
Program = integer()
Set the active program object for a program pipeline object
gl:activeShaderProgram
sets the linked program named by Program
to be the
active program for the program pipeline object Pipeline
. The active program in
the active program pipeline object is the target of calls to gl:uniform1f/2 when
no program has been made current through a call to gl:useProgram/1 .
See
createShaderProgramv(Type, Strings) -> integer()
Type = enum()
Strings = [string()]
glCreateShaderProgramv
See
bindProgramPipeline(Pipeline) -> ok
Pipeline = integer()
Bind a program pipeline to the current context
gl:bindProgramPipeline
binds a program pipeline object to the current context. Pipeline
must be a name previously returned from a call to gl:genProgramPipelines/1 . If
no program pipeline exists with name Pipeline
then a new pipeline object is created
with that name and initialized to the default state vector.
When a program pipeline object is bound using gl:bindProgramPipeline
, any previous
binding is broken and is replaced with a binding to the specified pipeline object. If Pipeline
is zero, the previous binding is broken and is not replaced, leaving no pipeline object
bound. If no current program object has been established by gl:useProgram/1 , the
program objects used for each stage and for uniform updates are taken from the bound program
pipeline object, if any. If there is a current program object established by gl:useProgram/1
, the bound program pipeline object has no effect on rendering or uniform updates. When
a bound program pipeline object is used for rendering, individual shader executables are
taken from its program objects.
See
deleteProgramPipelines(Pipelines) -> ok
Pipelines = [integer()]
Delete program pipeline objects
gl:deleteProgramPipelines
deletes the N
program pipeline objects whose names
are stored in the array Pipelines
. Unused names in Pipelines
are ignored,
as is the name zero. After a program pipeline object is deleted, its name is again unused
and it has no contents. If program pipeline object that is currently bound is deleted,
the binding for that object reverts to zero and no program pipeline object becomes current.
See
genProgramPipelines(N) -> [integer()]
N = integer()
Reserve program pipeline object names
gl:genProgramPipelines
returns N
previously unused program pipeline object
names in Pipelines
. These names are marked as used, for the purposes of gl:genProgramPipelines
only, but they acquire program pipeline state only when they are first bound.
See
isProgramPipeline(Pipeline) -> 0 | 1
Pipeline = integer()
Determine if a name corresponds to a program pipeline object
gl:isProgramPipeline
returns ?GL_TRUE
if Pipeline
is currently the
name of a program pipeline object. If Pipeline
is zero, or if ?pipeline
is not the name of a program pipeline object, or if an error occurs, gl:isProgramPipeline
returns ?GL_FALSE
. If Pipeline
is a name returned by gl:genProgramPipelines/1
, but that has not yet been bound through a call to gl:bindProgramPipeline/1 , then
the name is not a program pipeline object and gl:isProgramPipeline
returns ?GL_FALSE
.
See
getProgramPipelineiv(Pipeline, Pname) -> integer()
Pipeline = integer()
Pname = enum()
Retrieve properties of a program pipeline object
gl:getProgramPipelineiv
retrieves the value of a property of the program pipeline
object Pipeline
. Pname
specifies the name of the parameter whose value to
retrieve. The value of the parameter is written to the variable whose address is given
by Params
.
If Pname
is ?GL_ACTIVE_PROGRAM
, the name of the active program object of
the program pipeline object is returned in Params
.
If Pname
is ?GL_VERTEX_SHADER
, the name of the current program object for
the vertex shader type of the program pipeline object is returned in Params
.
If Pname
is ?GL_TESS_CONTROL_SHADER
, the name of the current program object
for the tessellation control shader type of the program pipeline object is returned in Params
.
If Pname
is ?GL_TESS_EVALUATION_SHADER
, the name of the current program
object for the tessellation evaluation shader type of the program pipeline object is returned
in Params
.
If Pname
is ?GL_GEOMETRY_SHADER
, the name of the current program object
for the geometry shader type of the program pipeline object is returned in Params
.
If Pname
is ?GL_FRAGMENT_SHADER
, the name of the current program object
for the fragment shader type of the program pipeline object is returned in Params
.
If Pname
is ?GL_INFO_LOG_LENGTH
, the length of the info log, including
the null terminator, is returned in Params
. If there is no info log, zero is returned.
See
programUniform1i(Program, Location, V0) -> ok
Program = integer()
Location = integer()
V0 = integer()
Specify the value of a uniform variable for a specified program object
gl:programUniform
modifies the value of a uniform variable or a uniform variable
array. The location of the uniform variable to be modified is specified by Location
,
which should be a value returned by gl:getUniformLocation/2 . gl:programUniform
operates on the program object specified by Program
.
The commands gl:programUniform{1|2|3|4}{f|i|ui}
are used to change the value of
the uniform variable specified by Location
using the values passed as arguments.
The number specified in the command should match the number of components in the data
type of the specified uniform variable (e.g., 1
for float, int, unsigned int, bool;
2
for vec2, ivec2, uvec2, bvec2, etc.). The suffix f
indicates that floating-point
values are being passed; the suffix i
indicates that integer values are being passed;
the suffix ui
indicates that unsigned integer values are being passed, and this
type should also match the data type of the specified uniform variable. The i
variants
of this function should be used to provide values for uniform variables defined as int, ivec2
, ivec3, ivec4, or arrays of these. The ui
variants of this function should be
used to provide values for uniform variables defined as unsigned int, uvec2, uvec3, uvec4,
or arrays of these. The f
variants should be used to provide values for uniform
variables of type float, vec2, vec3, vec4, or arrays of these. Either the i
, ui
or f
variants may be used to provide values for uniform variables of type bool, bvec2
, bvec3, bvec4, or arrays of these. The uniform variable will be set to false if the input
value is 0 or 0.0f, and it will be set to true otherwise.
All active uniform variables defined in a program object are initialized to 0 when the
program object is linked successfully. They retain the values assigned to them by a call
to gl:programUniform
until the next successful link operation occurs on the program
object, when they are once again initialized to 0.
The commands gl:programUniform{1|2|3|4}{f|i|ui}v
can be used to modify a single
uniform variable or a uniform variable array. These commands pass a count and a pointer
to the values to be loaded into a uniform variable or a uniform variable array. A count
of 1 should be used if modifying the value of a single uniform variable, and a count of
1 or greater can be used to modify an entire array or part of an array. When loading n
elements starting at an arbitrary position m
in a uniform variable array, elements
m
+ n
- 1 in the array will be replaced with the new values. If M
+ N
- 1 is larger than the size of the uniform variable array, values for all array elements
beyond the end of the array will be ignored. The number specified in the name of the command
indicates the number of components for each element in Value
, and it should match
the number of components in the data type of the specified uniform variable (e.g., 1
for float, int, bool; 2
for vec2, ivec2, bvec2, etc.). The data type specified
in the name of the command must match the data type for the specified uniform variable
as described previously for gl:programUniform{1|2|3|4}{f|i|ui}
.
For uniform variable arrays, each element of the array is considered to be of the type
indicated in the name of the command (e.g., gl:programUniform3f
or gl:programUniform3fv
can be used to load a uniform variable array of type vec3). The number of elements of
the uniform variable array to be modified is specified by Count
The commands gl:programUniformMatrix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv
are used
to modify a matrix or an array of matrices. The numbers in the command name are interpreted
as the dimensionality of the matrix. The number 2
indicates a 2 × 2 matrix (i.e.,
4 values), the number 3
indicates a 3 × 3 matrix (i.e., 9 values), and the number 4
indicates a 4 × 4 matrix (i.e., 16 values). Non-square matrix dimensionality is explicit,
with the first number representing the number of columns and the second number representing
the number of rows. For example, 2x4
indicates a 2 × 4 matrix with 2 columns and
4 rows (i.e., 8 values). If Transpose
is ?GL_FALSE
, each matrix is assumed
to be supplied in column major order. If Transpose
is ?GL_TRUE
, each matrix
is assumed to be supplied in row major order. The Count
argument indicates the
number of matrices to be passed. A count of 1 should be used if modifying the value of
a single matrix, and a count greater than 1 can be used to modify an array of matrices.
See
programUniform1iv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [integer()]
programUniform1f(Program, Location, V0) -> ok
Program = integer()
Location = integer()
V0 = float()
programUniform1fv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [float()]
programUniform1d(Program, Location, V0) -> ok
Program = integer()
Location = integer()
V0 = float()
programUniform1dv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [float()]
programUniform1ui(Program, Location, V0) -> ok
Program = integer()
Location = integer()
V0 = integer()
programUniform1uiv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [integer()]
programUniform2i(Program, Location, V0, V1) -> ok
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
programUniform2iv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{integer(), integer()}]
programUniform2f(Program, Location, V0, V1) -> ok
Program = integer()
Location = integer()
V0 = float()
V1 = float()
programUniform2fv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{float(), float()}]
programUniform2d(Program, Location, V0, V1) -> ok
Program = integer()
Location = integer()
V0 = float()
V1 = float()
programUniform2dv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{float(), float()}]
programUniform2ui(Program, Location, V0, V1) -> ok
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
programUniform2uiv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{integer(), integer()}]
programUniform3i(Program, Location, V0, V1, V2) -> ok
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
programUniform3iv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{integer(), integer(), integer()}]
programUniform3f(Program, Location, V0, V1, V2) -> ok
Program = integer()
Location = integer()
V0 = float()
V1 = float()
V2 = float()
programUniform3fv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{float(), float(), float()}]
programUniform3d(Program, Location, V0, V1, V2) -> ok
Program = integer()
Location = integer()
V0 = float()
V1 = float()
V2 = float()
programUniform3dv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{float(), float(), float()}]
programUniform3ui(Program, Location, V0, V1, V2) -> ok
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
programUniform3uiv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{integer(), integer(), integer()}]
programUniform4i(Program, Location, V0, V1, V2, V3) -> ok
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
V3 = integer()
programUniform4iv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{integer(), integer(), integer(), integer()}]
programUniform4f(Program, Location, V0, V1, V2, V3) -> ok
Program = integer()
Location = integer()
V0 = float()
V1 = float()
V2 = float()
V3 = float()
programUniform4fv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{float(), float(), float(), float()}]
programUniform4d(Program, Location, V0, V1, V2, V3) -> ok
Program = integer()
Location = integer()
V0 = float()
V1 = float()
V2 = float()
V3 = float()
programUniform4dv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{float(), float(), float(), float()}]
programUniform4ui(Program, Location, V0, V1, V2, V3) -> ok
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
V3 = integer()
programUniform4uiv(Program, Location, Value) -> ok
Program = integer()
Location = integer()
Value = [{integer(), integer(), integer(), integer()}]
programUniformMatrix2fv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float()}]
programUniformMatrix3fv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix4fv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix2dv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float()}]
programUniformMatrix3dv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix4dv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix2x3fv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
programUniformMatrix3x2fv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
programUniformMatrix2x4fv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix4x2fv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix3x4fv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix4x3fv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix2x3dv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
programUniformMatrix3x2dv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
programUniformMatrix2x4dv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix4x2dv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix3x4dv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
programUniformMatrix4x3dv(Program, Location, Transpose, Value) -> ok
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float(), float()}]
validateProgramPipeline(Pipeline) -> ok
Pipeline = integer()
Validate a program pipeline object against current GL state
gl:validateProgramPipeline
instructs the implementation to validate the shader executables
contained in Pipeline
against the current GL state. The implementation may use
this as an opportunity to perform any internal shader modifications that may be required
to ensure correct operation of the installed shaders given the current GL state.
After a program pipeline has been validated, its validation status is set to ?GL_TRUE
. The validation status of a program pipeline object may be queried by calling gl:getProgramPipelineiv/2
with parameter ?GL_VALIDATE_STATUS
.
If Pipeline
is a name previously returned from a call to gl:genProgramPipelines/1
but that has not yet been bound by a call to gl:bindProgramPipeline/1 , a new program
pipeline object is created with name Pipeline
and the default state vector.
See
getProgramPipelineInfoLog(Pipeline, BufSize) -> string()
Pipeline = integer()
BufSize = integer()
Retrieve the info log string from a program pipeline object
gl:getProgramPipelineInfoLog
retrieves the info log for the program pipeline object
Pipeline
. The info log, including its null terminator, is written into the array
of characters whose address is given by InfoLog
. The maximum number of characters
that may be written into InfoLog
is given by BufSize
, and the actual number
of characters written into InfoLog
is returned in the integer whose address is
given by Length
. If Length
is ?NULL
, no length is returned.
The actual length of the info log for the program pipeline may be determined by calling gl:getProgramPipelineiv/2
with Pname
set to ?GL_INFO_LOG_LENGTH
.
See
vertexAttribL1d(Index, X) -> ok
Index = integer()
X = float()
glVertexAttribL
See
vertexAttribL2d(Index, X, Y) -> ok
Index = integer()
X = float()
Y = float()
glVertexAttribL
See
vertexAttribL3d(Index, X, Y, Z) -> ok
Index = integer()
X = float()
Y = float()
Z = float()
glVertexAttribL
See
vertexAttribL4d(Index, X, Y, Z, W) -> ok
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
glVertexAttribL
See
vertexAttribL1dv(Index::integer(), V) -> ok
V = {X::float()}
Equivalent to vertexAttribL1d(Index, X).
vertexAttribL2dv(Index::integer(), V) -> ok
V = {X::float(), Y::float()}
Equivalent to vertexAttribL2d(Index, X, Y).
vertexAttribL3dv(Index::integer(), V) -> ok
V = {X::float(), Y::float(), Z::float()}
Equivalent to vertexAttribL3d(Index, X, Y, Z).
vertexAttribL4dv(Index::integer(), V) -> ok
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to vertexAttribL4d(Index, X, Y, Z, W).
vertexAttribLPointer(Index, Size, Type, Stride, Pointer) -> ok
Index = integer()
Size = integer()
Type = enum()
Stride = integer()
Pointer = offset() | mem()
glVertexAttribLPointer
See
getVertexAttribLdv(Index, Pname) -> {float(), float(), float(), float()}
Index = integer()
Pname = enum()
glGetVertexAttribL
See
viewportArrayv(First, V) -> ok
First = integer()
V = [{float(), float(), float(), float()}]
glViewportArrayv
See
viewportIndexedf(Index, X, Y, W, H) -> ok
Index = integer()
X = float()
Y = float()
W = float()
H = float()
Set a specified viewport
gl:viewportIndexedf
and gl:viewportIndexedfv
specify the parameters for a
single viewport. Index
specifies the index of the viewport to modify. Index
must be less than the value of ?GL_MAX_VIEWPORTS
. For gl:viewportIndexedf
, X
, Y
, W
, and H
specify the left, bottom, width and height of the viewport
in pixels, respectively. For gl:viewportIndexedfv
, V
contains the address
of an array of floating point values specifying the left ( x), bottom ( y), width ( w),
and height ( h) of each viewport, in that order. x and y give the location of the viewport's
lower left corner, and w and h give the width and height of the viewport, respectively.
The viewport specifies the affine transformation of x and y from normalized device
coordinates to window coordinates. Let (x nd y nd) be normalized device coordinates. Then the window
coordinates (x w y w) are computed as follows:
x w=(x nd+1) (width/2)+x
y w=(y nd+1) (height/2)+y
The location of the viewport's bottom left corner, given by ( x, y) is clamped to be
within the implementaiton-dependent viewport bounds range. The viewport bounds range [
min, max] can be determined by calling gl:getBooleanv/1 with argument ?GL_VIEWPORT_BOUNDS_RANGE
. Viewport width and height are silently clamped to a range that depends on the implementation.
To query this range, call gl:getBooleanv/1 with argument ?GL_MAX_VIEWPORT_DIMS
.
The precision with which the GL interprets the floating point viewport bounds is implementation-dependent
and may be determined by querying the impementation-defined constant ?GL_VIEWPORT_SUBPIXEL_BITS
.
Calling gl:viewportIndexedfv
is equivalent to calling see glViewportArray
with First
set to Index
, Count
set to 1 and V
passsed directly.
gl:viewportIndexedf
is equivalent to: void glViewportIndexedf(GLuint index, GLfloat
x, GLfloat y, GLfloat w, GLfloat h) { const float v[4] = { x, y, w, h }; glViewportArrayv(index,
1, v); }
See
viewportIndexedfv(Index, V) -> ok
Index = integer()
V = {float(), float(), float(), float()}
scissorArrayv(First, V) -> ok
First = integer()
V = [{integer(), integer(), integer(), integer()}]
glScissorArrayv
See
scissorIndexed(Index, Left, Bottom, Width, Height) -> ok
Index = integer()
Left = integer()
Bottom = integer()
Width = integer()
Height = integer()
glScissorIndexe
See
scissorIndexedv(Index, V) -> ok
Index = integer()
V = {integer(), integer(), integer(), integer()}
glScissorIndexe
See
depthRangeArrayv(First, V) -> ok
First = integer()
V = [{clamp(), clamp()}]
glDepthRangeArrayv
See
depthRangeIndexed(Index, N, F) -> ok
Index = integer()
N = clamp()
F = clamp()
glDepthRangeIndexe
See
debugMessageControlARB(Source, Type, Severity, Ids, Enabled) -> ok
Source = enum()
Type = enum()
Severity = enum()
Ids = [integer()]
Enabled = 0 | 1
glDebugMessageControlARB
See
debugMessageInsertARB(Source, Type, Id, Severity, Buf) -> ok
Source = enum()
Type = enum()
Id = integer()
Severity = enum()
Buf = string()
glDebugMessageInsertARB
See
getDebugMessageLogARB(Count, Bufsize) -> {integer(), Sources::[enum()], Types::[enum()], Ids::[integer()], Severities::[enum()], MessageLog::[string()]}
Count = integer()
Bufsize = integer()
glGetDebugMessageLogARB
See
getGraphicsResetStatusARB() -> enum()
glGetGraphicsResetStatusARB
See
drawArraysInstancedBaseInstance(Mode, First, Count, Primcount, Baseinstance) -> ok
Mode = enum()
First = integer()
Count = integer()
Primcount = integer()
Baseinstance = integer()
Draw multiple instances of a range of elements with offset applied to instanced attributes
gl:drawArraysInstancedBaseInstance
behaves identically to gl:drawArrays/3
except that Primcount
instances of the range of elements are executed and the value
of the internal counter InstanceID
advances for each iteration. InstanceID
is an internal 32-bit integer counter that may be read by a vertex shader as ?gl_InstanceID
.
gl:drawArraysInstancedBaseInstance
has the same effect as: if ( mode or count is
invalid ) generate appropriate error else { for (int i = 0; i < primcount ; i++) {
instanceID = i; glDrawArrays(mode, first, count); } instanceID = 0; }
Specific vertex attributes may be classified as instanced
through the use of gl:vertexAttribDivisor/2
. Instanced vertex attributes supply per-instance vertex data to the vertex shader. The
index of the vertex fetched from the enabled instanced vertex attribute arrays is calculated
as: |gl_ InstanceID/divisor|+ baseInstance. Note that Baseinstance
does not affect the shader-visible
value of ?gl_InstanceID
.
See
drawElementsInstancedBaseInstance(Mode, Count, Type, Indices, Primcount, Baseinstance) -> ok
Mode = enum()
Count = integer()
Type = enum()
Indices = offset() | mem()
Primcount = integer()
Baseinstance = integer()
Draw multiple instances of a set of elements with offset applied to instanced attributes
gl:drawElementsInstancedBaseInstance
behaves identically to gl:drawElements/4
except that Primcount
instances of the set of elements are executed and the value
of the internal counter InstanceID
advances for each iteration. InstanceID
is an internal 32-bit integer counter that may be read by a vertex shader as ?gl_InstanceID
.
gl:drawElementsInstancedBaseInstance
has the same effect as: if (mode, count, or
type is invalid ) generate appropriate error else { for (int i = 0; i < primcount ;
i++) { instanceID = i; glDrawElements(mode, count, type, indices); } instanceID = 0; }
Specific vertex attributes may be classified as instanced
through the use of gl:vertexAttribDivisor/2
. Instanced vertex attributes supply per-instance vertex data to the vertex shader. The
index of the vertex fetched from the enabled instanced vertex attribute arrays is calculated
as |gl_ InstanceID/divisor|+ baseInstance. Note that Baseinstance
does not affect the shader-visible
value of ?gl_InstanceID
.
See
drawElementsInstancedBaseVertexBaseInstance(Mode, Count, Type, Indices, Primcount, Basevertex, Baseinstance) -> ok
Mode = enum()
Count = integer()
Type = enum()
Indices = offset() | mem()
Primcount = integer()
Basevertex = integer()
Baseinstance = integer()
Render multiple instances of a set of primitives from array data with a per-element offset
gl:drawElementsInstancedBaseVertexBaseInstance
behaves identically to gl:drawElementsInstanced/5
except that the i
th element transferred by the corresponding draw call will be
taken from element Indices
[i] + Basevertex
of each enabled array. If the
resulting value is larger than the maximum value representable by Type
, it is as
if the calculation were upconverted to 32-bit unsigned integers (with wrapping on overflow
conditions). The operation is undefined if the sum would be negative. The Basevertex
has no effect on the shader-visible value of ?gl_VertexID
.
Specific vertex attributes may be classified as instanced
through the use of gl:vertexAttribDivisor/2
. Instanced vertex attributes supply per-instance vertex data to the vertex shader. The
index of the vertex fetched from the enabled instanced vertex attribute arrays is calculated
as |gl_ InstanceID/divisor|+ baseInstance. Note that Baseinstance
does not affect the shader-visible
value of ?gl_InstanceID
.
See
drawTransformFeedbackInstanced(Mode, Id, Primcount) -> ok
Mode = enum()
Id = integer()
Primcount = integer()
glDrawTransformFeedbackInstance
See
drawTransformFeedbackStreamInstanced(Mode, Id, Stream, Primcount) -> ok
Mode = enum()
Id = integer()
Stream = integer()
Primcount = integer()
glDrawTransformFeedbackStreamInstance
See
getInternalformativ(Target, Internalformat, Pname, BufSize) -> [integer()]
Target = enum()
Internalformat = enum()
Pname = enum()
BufSize = integer()
glGetInternalformat
See
bindImageTexture(Unit, Texture, Level, Layered, Layer, Access, Format) -> ok
Unit = integer()
Texture = integer()
Level = integer()
Layered = 0 | 1
Layer = integer()
Access = enum()
Format = enum()
Bind a level of a texture to an image unit
gl:bindImageTexture
binds a single level of a texture to an image unit for the purpose
of reading and writing it from shaders. Unit
specifies the zero-based index of
the image unit to which to bind the texture level. Texture
specifies the name of
an existing texture object to bind to the image unit. If Texture
is zero, then
any existing binding to the image unit is broken. Level
specifies the level of
the texture to bind to the image unit.
If Texture
is the name of a one-, two-, or three-dimensional array texture, a
cube map or cube map array texture, or a two-dimensional multisample array texture, then
it is possible to bind either the entire array, or only a single layer of the array to
the image unit. In such cases, if Layered
is ?GL_TRUE
, the entire array
is attached to the image unit and Layer
is ignored. However, if Layered
is ?GL_FALSE
then Layer
specifies the layer of the array to attach to the image unit.
Access
specifies the access types to be performed by shaders and may be set to ?GL_READ_ONLY
, ?GL_WRITE_ONLY
, or ?GL_READ_WRITE
to indicate read-only, write-only or
read-write access, respectively. Violation of the access type specified in Access
(for example, if a shader writes to an image bound with Access
set to ?GL_READ_ONLY
) will lead to undefined results, possibly including program termination.
Format
specifies the format that is to be used when performing formatted stores
into the image from shaders. Format
must be compatible with the texture's internal
format and must be one of the formats listed in the following table.
Image Unit Format
Format Qualifier
?GL_RGBA32F
rgba32f?GL_RGBA16F
rgba16f?GL_RG32F
rg32f?GL_RG16F
rg16f?GL_R11F_G11F_B10F
r11f_g11f_b10f?GL_R32F
r32f?GL_R16F
r16f?GL_RGBA32UI
rgba32ui?GL_RGBA16UI
rgba16ui?GL_RGB10_A2UI
rgb10_a2ui?GL_RGBA8UI
rgba8ui?GL_RG32UI
rg32ui?GL_RG16UI
rg16ui?GL_RG8UI
rg8ui?GL_R32UI
r32ui?GL_R16UI
r16ui?GL_R8UI
r8ui?GL_RGBA32I
rgba32i?GL_RGBA16I
rgba16i?GL_RGBA8I
rgba8i?GL_RG32I
rg32i?GL_RG16I
rg16i?GL_RG8I
rg8i?GL_R32I
r32i?GL_R16I
r16i?GL_R8I
r8i?GL_RGBA16
rgba16?GL_RGB10_A2
rgb10_a2?GL_RGBA8
rgba8?GL_RG16
rg16?GL_RG8
rg8?GL_R16
r16?GL_R8
r8?GL_RGBA16_SNORM
rgba16_snorm?GL_RGBA8_SNORM
rgba8_snorm?GL_RG16_SNORM
rg16_snorm?GL_RG8_SNORM
rg8_snorm?GL_R16_SNORM
r16_snorm
?GL_R8_SNORM
r8_snormWhen a texture is bound to an image unit, the Format
parameter for the image unit
need not exactly match the texture internal format as long as the formats are considered
compatible as defined in the OpenGL Specification. The matching criterion used for a given
texture may be determined by calling gl:getTexParameterfv/2 with Value
set
to ?GL_IMAGE_FORMAT_COMPATIBILITY_TYPE
, with return values of ?GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE
and ?GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS
, specifying matches by size and class,
respectively.
See
memoryBarrier(Barriers) -> ok
Barriers = integer()
Defines a barrier ordering memory transactions
gl:memoryBarrier
defines a barrier ordering the memory transactions issued prior
to the command relative to those issued after the barrier. For the purposes of this ordering,
memory transactions performed by shaders are considered to be issued by the rendering
command that triggered the execution of the shader. Barriers
is a bitfield indicating
the set of operations that are synchronized with shader stores; the bits used in Barriers
are as follows:
?GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT
: If set, vertex data sourced from buffer objects
after the barrier will reflect data written by shaders prior to the barrier. The set of
buffer objects affected by this bit is derived from the buffer object bindings used for
generic vertex attributes derived from the ?GL_VERTEX_ATTRIB_ARRAY_BUFFER
bindings.
?GL_ELEMENT_ARRAY_BARRIER_BIT
: If set, vertex array indices sourced from buffer
objects after the barrier will reflect data written by shaders prior to the barrier. The
buffer objects affected by this bit are derived from the ?GL_ELEMENT_ARRAY_BUFFER
binding.
?GL_UNIFORM_BARRIER_BIT
: Shader uniforms sourced from buffer objects after the
barrier will reflect data written by shaders prior to the barrier.
?GL_TEXTURE_FETCH_BARRIER_BIT
: Texture fetches from shaders, including fetches
from buffer object memory via buffer textures, after the barrier will reflect data written
by shaders prior to the barrier.
?GL_SHADER_IMAGE_ACCESS_BARRIER_BIT
: Memory accesses using shader image load,
store, and atomic built-in functions issued after the barrier will reflect data written
by shaders prior to the barrier. Additionally, image stores and atomics issued after the
barrier will not execute until all memory accesses (e.g., loads, stores, texture fetches,
vertex fetches) initiated prior to the barrier complete.
?GL_COMMAND_BARRIER_BIT
: Command data sourced from buffer objects by Draw*Indirect
commands after the barrier will reflect data written by shaders prior to the barrier.
The buffer objects affected by this bit are derived from the ?GL_DRAW_INDIRECT_BUFFER
binding.
?GL_PIXEL_BUFFER_BARRIER_BIT
: Reads and writes of buffer objects via the ?GL_PIXEL_PACK_BUFFER
and ?GL_PIXEL_UNPACK_BUFFER
bindings (via gl:readPixels/7 , gl:texSubImage1D/7
, etc.) after the barrier will reflect data written by shaders prior to the barrier. Additionally,
buffer object writes issued after the barrier will wait on the completion of all shader
writes initiated prior to the barrier.
?GL_TEXTURE_UPDATE_BARRIER_BIT
: Writes to a texture via gl:tex(Sub)Image*
, gl:copyTex(Sub)Image*
, gl:compressedTex(Sub)Image*
, and reads via gl:getTexImage/5 after the barrier
will reflect data written by shaders prior to the barrier. Additionally, texture writes
from these commands issued after the barrier will not execute until all shader writes
initiated prior to the barrier complete.
?GL_BUFFER_UPDATE_BARRIER_BIT
: Reads or writes via gl:bufferSubData/4 , gl:copyBufferSubData/5
, or gl:getBufferSubData/4 , or to buffer object memory mapped by see glMapBuffer
or see glMapBufferRange
after the barrier will reflect data written by shaders
prior to the barrier. Additionally, writes via these commands issued after the barrier
will wait on the completion of any shader writes to the same memory initiated prior to
the barrier.
?GL_FRAMEBUFFER_BARRIER_BIT
: Reads and writes via framebuffer object attachments
after the barrier will reflect data written by shaders prior to the barrier. Additionally,
framebuffer writes issued after the barrier will wait on the completion of all shader
writes issued prior to the barrier.
?GL_TRANSFORM_FEEDBACK_BARRIER_BIT
: Writes via transform feedback bindings after
the barrier will reflect data written by shaders prior to the barrier. Additionally, transform
feedback writes issued after the barrier will wait on the completion of all shader writes
issued prior to the barrier.
?GL_ATOMIC_COUNTER_BARRIER_BIT
: Accesses to atomic counters after the barrier
will reflect writes prior to the barrier.
If Barriers
is ?GL_ALL_BARRIER_BITS
, shader memory accesses will be synchronized
relative to all the operations described above.
Implementations may cache buffer object and texture image memory that could be written
by shaders in multiple caches; for example, there may be separate caches for texture,
vertex fetching, and one or more caches for shader memory accesses. Implementations are
not required to keep these caches coherent with shader memory writes. Stores issued by
one invocation may not be immediately observable by other pipeline stages or other shader
invocations because the value stored may remain in a cache local to the processor executing
the store, or because data overwritten by the store is still in a cache elsewhere in the
system. When gl:memoryBarrier
is called, the GL flushes and/or invalidates any caches
relevant to the operations specified by the Barriers
parameter to ensure consistent
ordering of operations across the barrier.
To allow for independent shader invocations to communicate by reads and writes to a common
memory address, image variables in the OpenGL Shading Language may be declared as "coherent".
Buffer object or texture image memory accessed through such variables may be cached only
if caches are automatically updated due to stores issued by any other shader invocation.
If the same address is accessed using both coherent and non-coherent variables, the accesses
using variables declared as coherent will observe the results stored using coherent variables
in other invocations. Using variables declared as "coherent" guarantees only that the
results of stores will be immediately visible to shader invocations using similarly-declared
variables; calling gl:memoryBarrier
is required to ensure that the stores are visible
to other operations.
The following guidelines may be helpful in choosing when to use coherent memory accesses and when to use barriers.
Data that are read-only or constant may be accessed without using coherent variables or calling MemoryBarrier(). Updates to the read-only data via API calls such as BufferSubData will invalidate shader caches implicitly as required.
Data that are shared between shader invocations at a fine granularity (e.g., written by one invocation, consumed by another invocation) should use coherent variables to read and write the shared data.
Data written by one shader invocation and consumed by other shader invocations launched as a result of its execution ("dependent invocations") should use coherent variables in the producing shader invocation and call memoryBarrier() after the last write. The consuming shader invocation should also use coherent variables.
Data written to image variables in one rendering pass and read by the shader in a later
pass need not use coherent variables or memoryBarrier(). Calling MemoryBarrier() with
the SHADER_IMAGE_ACCESS_BARRIER_BIT set in Barriers
between passes is necessary.
Data written by the shader in one rendering pass and read by another mechanism (e.g.,
vertex or index buffer pulling) in a later pass need not use coherent variables or memoryBarrier().
Calling gl:memoryBarrier
with the appropriate bits set in Barriers
between
passes is necessary.
See
texStorage1D(Target, Levels, Internalformat, Width) -> ok
Target = enum()
Levels = integer()
Internalformat = enum()
Width = integer()
Simultaneously specify storage for all levels of a one-dimensional texture
gl:texStorage1D
specifies the storage requirements for all levels of a one-dimensional
texture simultaneously. Once a texture is specified with this command, the format and
dimensions of all levels become immutable unless it is a proxy texture. The contents of
the image may still be modified, however, its storage requirements may not change. Such
a texture is referred to as an immutable-format
texture.
Calling gl:texStorage1D
is equivalent, assuming no errors are generated, to executing
the following pseudo-code: for (i = 0; i < levels; i++) { glTexImage1D(target, i,
internalformat, width, 0, format, type, NULL); width = max(1, (width / 2)); }
Since no texture data is actually provided, the values used in the pseudo-code for Format
and Type
are irrelevant and may be considered to be any values that are legal
for the chosen Internalformat
enumerant. Internalformat
must be one of the
sized internal formats given in Table 1 below, one of the sized depth-component formats ?GL_DEPTH_COMPONENT32F
, ?GL_DEPTH_COMPONENT24
, or ?GL_DEPTH_COMPONENT16
, or one of the combined
depth-stencil formats, ?GL_DEPTH32F_STENCIL8
, or ?GL_DEPTH24_STENCIL8
. Upon
success, the value of ?GL_TEXTURE_IMMUTABLE_FORMAT
becomes ?GL_TRUE
. The
value of ?GL_TEXTURE_IMMUTABLE_FORMAT
may be discovered by calling gl:getTexParameterfv/2
with Pname
set to ?GL_TEXTURE_IMMUTABLE_FORMAT
. No further changes to the
dimensions or format of the texture object may be made. Using any command that might alter
the dimensions or format of the texture object (such as gl:texImage1D/8 or another
call to gl:texStorage1D
) will result in the generation of a ?GL_INVALID_OPERATION
error, even if it would not, in fact, alter the dimensions or format of the object.
See
texStorage2D(Target, Levels, Internalformat, Width, Height) -> ok
Target = enum()
Levels = integer()
Internalformat = enum()
Width = integer()
Height = integer()
Simultaneously specify storage for all levels of a two-dimensional or one-dimensional array texture
gl:texStorage2D
specifies the storage requirements for all levels of a two-dimensional
texture or one-dimensional texture array simultaneously. Once a texture is specified with
this command, the format and dimensions of all levels become immutable unless it is a
proxy texture. The contents of the image may still be modified, however, its storage requirements
may not change. Such a texture is referred to as an immutable-format
texture.
The behavior of gl:texStorage2D
depends on the Target
parameter. When Target
is ?GL_TEXTURE_2D
, ?GL_PROXY_TEXTURE_2D
, ?GL_TEXTURE_RECTANGLE
, ?GL_PROXY_TEXTURE_RECTANGLE
or ?GL_PROXY_TEXTURE_CUBE_MAP
, calling gl:texStorage2D
is equivalent, assuming
no errors are generated, to executing the following pseudo-code: for (i = 0; i < levels;
i++) { glTexImage2D(target, i, internalformat, width, height, 0, format, type, NULL);
width = max(1, (width / 2)); height = max(1, (height / 2)); }
When Target
is ?GL_TEXTURE_CUBE_MAP
, gl:texStorage2D
is equivalent
to: for (i = 0; i < levels; i++) { for (face in (+X, -X, +Y, -Y, +Z, -Z)) { glTexImage2D(face,
i, internalformat, width, height, 0, format, type, NULL); } width = max(1, (width / 2));
height = max(1, (height / 2)); }
When Target
is ?GL_TEXTURE_1D
or ?GL_TEXTURE_1D_ARRAY
, gl:texStorage2D
is equivalent to: for (i = 0; i < levels; i++) { glTexImage2D(target, i, internalformat,
width, height, 0, format, type, NULL); width = max(1, (width / 2)); }
Since no texture data is actually provided, the values used in the pseudo-code for Format
and Type
are irrelevant and may be considered to be any values that are legal
for the chosen Internalformat
enumerant. Internalformat
must be one of the
sized internal formats given in Table 1 below, one of the sized depth-component formats ?GL_DEPTH_COMPONENT32F
, ?GL_DEPTH_COMPONENT24
, or ?GL_DEPTH_COMPONENT16
, or one of the combined
depth-stencil formats, ?GL_DEPTH32F_STENCIL8
, or ?GL_DEPTH24_STENCIL8
. Upon
success, the value of ?GL_TEXTURE_IMMUTABLE_FORMAT
becomes ?GL_TRUE
. The
value of ?GL_TEXTURE_IMMUTABLE_FORMAT
may be discovered by calling gl:getTexParameterfv/2
with Pname
set to ?GL_TEXTURE_IMMUTABLE_FORMAT
. No further changes to the
dimensions or format of the texture object may be made. Using any command that might alter
the dimensions or format of the texture object (such as gl:texImage2D/9 or another
call to gl:texStorage2D
) will result in the generation of a ?GL_INVALID_OPERATION
error, even if it would not, in fact, alter the dimensions or format of the object.
See
texStorage3D(Target, Levels, Internalformat, Width, Height, Depth) -> ok
Target = enum()
Levels = integer()
Internalformat = enum()
Width = integer()
Height = integer()
Depth = integer()
Simultaneously specify storage for all levels of a three-dimensional, two-dimensional array or cube-map array texture
gl:texStorage3D
specifies the storage requirements for all levels of a three-dimensional,
two-dimensional array or cube-map array texture simultaneously. Once a texture is specified
with this command, the format and dimensions of all levels become immutable unless it
is a proxy texture. The contents of the image may still be modified, however, its storage
requirements may not change. Such a texture is referred to as an immutable-format
texture.
The behavior of gl:texStorage3D
depends on the Target
parameter. When Target
is ?GL_TEXTURE_3D
, or ?GL_PROXY_TEXTURE_3D
, calling gl:texStorage3D
is equivalent, assuming no errors are generated, to executing the following pseudo-code:
for (i = 0; i < levels; i++) { glTexImage3D(target, i, internalformat, width, height,
depth, 0, format, type, NULL); width = max(1, (width / 2)); height = max(1, (height /
2)); depth = max(1, (depth / 2)); }
When Target
is ?GL_TEXTURE_2D_ARRAY
, ?GL_PROXY_TEXTURE_2D_ARRAY
, ?GL_TEXTURE_CUBE_MAP_ARRAY
, or ?GL_PROXY_TEXTURE_CUBE_MAP_ARRAY
, gl:texStorage3D
is equivalent to:
for (i = 0; i < levels; i++) { glTexImage3D(target, i, internalformat, width, height,
depth, 0, format, type, NULL); width = max(1, (width / 2)); height = max(1, (height /
2)); }
Since no texture data is actually provided, the values used in the pseudo-code for Format
and Type
are irrelevant and may be considered to be any values that are legal
for the chosen Internalformat
enumerant. Internalformat
must be one of the
sized internal formats given in Table 1 below, one of the sized depth-component formats ?GL_DEPTH_COMPONENT32F
, ?GL_DEPTH_COMPONENT24
, or ?GL_DEPTH_COMPONENT16
, or one of the combined
depth-stencil formats, ?GL_DEPTH32F_STENCIL8
, or ?GL_DEPTH24_STENCIL8
. Upon
success, the value of ?GL_TEXTURE_IMMUTABLE_FORMAT
becomes ?GL_TRUE
. The
value of ?GL_TEXTURE_IMMUTABLE_FORMAT
may be discovered by calling gl:getTexParameterfv/2
with Pname
set to ?GL_TEXTURE_IMMUTABLE_FORMAT
. No further changes to the
dimensions or format of the texture object may be made. Using any command that might alter
the dimensions or format of the texture object (such as gl:texImage3D/10 or another
call to gl:texStorage3D
) will result in the generation of a ?GL_INVALID_OPERATION
error, even if it would not, in fact, alter the dimensions or format of the object.
See
depthBoundsEXT(Zmin, Zmax) -> ok
Zmin = clamp()
Zmax = clamp()
glDepthBoundsEXT
See
stencilClearTagEXT(StencilTagBits, StencilClearTag) -> ok
StencilTagBits = integer()
StencilClearTag = integer()
glStencilClearTagEXT
See