Provided by: erlang-manpages_18.3-dfsg-1ubuntu3.1_all 
NAME
gl - Standard OpenGL api.
DESCRIPTION
Standard OpenGL api. See www.opengl.org
Booleans are represented by integers 0 and 1.
DATA TYPES
clamp() = float():
0.0..1.0
enum() = non_neg_integer():
See wx/include/gl.hrl
matrix() = matrix12() | matrix16():
matrix12() = {float(), float(), float(), float(), float(), float(), float(), float(), float(), float(),
float(), float()}:
matrix16() = {float(), float(), float(), float(), float(), float(), float(), float(), float(), float(),
float(), float(), float(), float(), float(), float()}:
mem() = binary() | tuple():
Memory block
offset() = non_neg_integer():
Offset in memory block
EXPORTS
clearIndex(C) -> ok
Types:
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 external documentation.
clearColor(Red, Green, Blue, Alpha) -> ok
Types:
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 external documentation.
clear(Mask) -> ok
Types:
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 external documentation.
indexMask(Mask) -> ok
Types:
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 external documentation.
colorMask(Red, Green, Blue, Alpha) -> ok
Types:
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 external documentation.
alphaFunc(Func, Ref) -> ok
Types:
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 external documentation.
blendFunc(Sfactor, Dfactor) -> ok
Types:
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 external documentation.
logicOp(Opcode) -> ok
Types:
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.OpcodeResulting 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 external documentation.
cullFace(Mode) -> ok
Types:
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 external documentation.
frontFace(Mode) -> ok
Types:
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 external documentation.
pointSize(Size) -> ok
Types:
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 external documentation.
lineWidth(Width) -> ok
Types:
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 external documentation.
lineStipple(Factor, Pattern) -> ok
Types:
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 external documentation.
polygonMode(Face, Mode) -> ok
Types:
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 external documentation.
polygonOffset(Factor, Units) -> ok
Types:
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 external documentation.
polygonStipple(Mask) -> ok
Types:
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 external documentation.
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 external documentation.
edgeFlag(Flag) -> ok
Types:
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 external documentation.
edgeFlagv(Flag) -> ok
Types:
Flag = {Flag::0 | 1}
Equivalent to edgeFlag(Flag).
scissor(X, Y, Width, Height) -> ok
Types:
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 external documentation.
clipPlane(Plane, Equation) -> ok
Types:
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_PLANEi, where i is the plane number.
All clipping planes are initially defined as (0, 0, 0, 0) in eye coordinates and are disabled.
See external documentation.
getClipPlane(Plane) -> {float(), float(), float(), float()}
Types:
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 external documentation.
drawBuffer(Mode) -> ok
Types:
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 external documentation.
readBuffer(Mode) -> ok
Types:
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_ATTACHMENTi may be used to indicate the
ith 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 external documentation.
enable(Cap) -> ok
Types:
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_DISTANCEi: 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 external documentation.
disable(Cap) -> ok
Types:
Cap = enum()
See enable/1
isEnabled(Cap) -> 0 | 1
Types:
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 :ConstantSee
?GL_BLENDgl:blendFunc/2 , gl:logicOp/1
?GL_CLIP_DISTANCEigl:enable/1
?GL_COLOR_LOGIC_OPgl:logicOp/1
?GL_CULL_FACEgl:cullFace/1
?GL_DEPTH_CLAMPgl:enable/1
?GL_DEPTH_TESTgl:depthFunc/1 , gl:depthRange/2
?GL_DITHERgl:enable/1
?GL_FRAMEBUFFER_SRGBgl:enable/1
?GL_LINE_SMOOTHgl:lineWidth/1
?GL_MULTISAMPLEgl:sampleCoverage/2
?GL_POLYGON_SMOOTHgl:polygonMode/2
?GL_POLYGON_OFFSET_FILLgl:polygonOffset/2
?GL_POLYGON_OFFSET_LINEgl:polygonOffset/2
?GL_POLYGON_OFFSET_POINTgl:polygonOffset/2
?GL_PROGRAM_POINT_SIZEgl:enable/1
?GL_PRIMITIVE_RESTARTgl:enable/1 , gl:primitiveRestartIndex/1
?GL_SAMPLE_ALPHA_TO_COVERAGEgl:sampleCoverage/2
?GL_SAMPLE_ALPHA_TO_ONEgl:sampleCoverage/2
?GL_SAMPLE_COVERAGEgl:sampleCoverage/2
?GL_SAMPLE_MASKgl:enable/1
?GL_SCISSOR_TESTgl:scissor/4
?GL_STENCIL_TESTgl:stencilFunc/3 , gl:stencilOp/3
?GL_TEXTURE_CUBEMAP_SEAMLESSgl:enable/1
See external documentation.
enableClientState(Cap) -> ok
Types:
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 external documentation.
disableClientState(Cap) -> ok
Types:
Cap = enum()
See enableClientState/1
getBooleanv(Pname) -> [0 | 1]
Types:
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_BUFFERi: 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 external documentation.
getDoublev(Pname) -> [float()]
Types:
Pname = enum()
See getBooleanv/1
getFloatv(Pname) -> [float()]
Types:
Pname = enum()
See getBooleanv/1
getIntegerv(Pname) -> [integer()]
Types:
Pname = enum()
See getBooleanv/1
pushAttrib(Mask) -> ok
Types:
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_LIGHTi 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 external documentation.
popAttrib() -> ok
See pushAttrib/1
pushClientAttrib(Mask) -> ok
Types:
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 external documentation.
popClientAttrib() -> ok
See pushClientAttrib/1
renderMode(Mode) -> integer()
Types:
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 external documentation.
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 external documentation.
getString(Name) -> string()
Types:
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_numbermajor_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 external documentation.
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 external documentation.
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 external documentation.
hint(Target, Mode) -> ok
Types:
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 external documentation.
clearDepth(Depth) -> ok
Types:
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 external documentation.
depthFunc(Func) -> ok
Types:
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 external documentation.
depthMask(Flag) -> ok
Types:
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 external documentation.
depthRange(Near_val, Far_val) -> ok
Types:
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 external documentation.
clearAccum(Red, Green, Blue, Alpha) -> ok
Types:
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 external documentation.
accum(Op, Value) -> ok
Types:
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 external documentation.
matrixMode(Mode) -> ok
Types:
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 external documentation.
ortho(Left, Right, Bottom, Top, Near_val, Far_val) -> ok
Types:
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 external documentation.
frustum(Left, Right, Bottom, Top, Near_val, Far_val) -> ok
Types:
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 external documentation.
viewport(X, Y, Width, Height) -> ok
Types:
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 external documentation.
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 external documentation.
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 external documentation.
loadMatrixd(M) -> ok
Types:
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 external documentation.
loadMatrixf(M) -> ok
Types:
M = matrix()
See loadMatrixd/1
multMatrixd(M) -> ok
Types:
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 external documentation.
multMatrixf(M) -> ok
Types:
M = matrix()
See multMatrixd/1
rotated(Angle, X, Y, Z) -> ok
Types:
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 external documentation.
rotatef(Angle, X, Y, Z) -> ok
Types:
Angle = float()
X = float()
Y = float()
Z = float()
See rotated/4
scaled(X, Y, Z) -> ok
Types:
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 external documentation.
scalef(X, Y, Z) -> ok
Types:
X = float()
Y = float()
Z = float()
See scaled/3
translated(X, Y, Z) -> ok
Types:
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 external documentation.
translatef(X, Y, Z) -> ok
Types:
X = float()
Y = float()
Z = float()
See translated/3
isList(List) -> 0 | 1
Types:
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 external documentation.
deleteLists(List, Range) -> ok
Types:
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 external documentation.
genLists(Range) -> integer()
Types:
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 external documentation.
newList(List, Mode) -> ok
Types:
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 external documentation.
endList() -> ok
glBeginList
See external documentation.
callList(List) -> ok
Types:
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 external documentation.
callLists(Lists) -> ok
Types:
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 external documentation.
listBase(Base) -> ok
Types:
Base = integer()
set the display-list base for
gl:callLists/1
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 external documentation.
begin(Mode) -> ok
Types:
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 external documentation.
end() -> ok
See 'begin'/1
vertex2d(X, Y) -> ok
Types:
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 external documentation.
vertex2f(X, Y) -> ok
Types:
X = float()
Y = float()
See vertex2d/2
vertex2i(X, Y) -> ok
Types:
X = integer()
Y = integer()
See vertex2d/2
vertex2s(X, Y) -> ok
Types:
X = integer()
Y = integer()
See vertex2d/2
vertex3d(X, Y, Z) -> ok
Types:
X = float()
Y = float()
Z = float()
See vertex2d/2
vertex3f(X, Y, Z) -> ok
Types:
X = float()
Y = float()
Z = float()
See vertex2d/2
vertex3i(X, Y, Z) -> ok
Types:
X = integer()
Y = integer()
Z = integer()
See vertex2d/2
vertex3s(X, Y, Z) -> ok
Types:
X = integer()
Y = integer()
Z = integer()
See vertex2d/2
vertex4d(X, Y, Z, W) -> ok
Types:
X = float()
Y = float()
Z = float()
W = float()
See vertex2d/2
vertex4f(X, Y, Z, W) -> ok
Types:
X = float()
Y = float()
Z = float()
W = float()
See vertex2d/2
vertex4i(X, Y, Z, W) -> ok
Types:
X = integer()
Y = integer()
Z = integer()
W = integer()
See vertex2d/2
vertex4s(X, Y, Z, W) -> ok
Types:
X = integer()
Y = integer()
Z = integer()
W = integer()
See vertex2d/2
vertex2dv(V) -> ok
Types:
V = {X::float(), Y::float()}
Equivalent to vertex2d(X, Y).
vertex2fv(V) -> ok
Types:
V = {X::float(), Y::float()}
Equivalent to vertex2f(X, Y).
vertex2iv(V) -> ok
Types:
V = {X::integer(), Y::integer()}
Equivalent to vertex2i(X, Y).
vertex2sv(V) -> ok
Types:
V = {X::integer(), Y::integer()}
Equivalent to vertex2s(X, Y).
vertex3dv(V) -> ok
Types:
V = {X::float(), Y::float(), Z::float()}
Equivalent to vertex3d(X, Y, Z).
vertex3fv(V) -> ok
Types:
V = {X::float(), Y::float(), Z::float()}
Equivalent to vertex3f(X, Y, Z).
vertex3iv(V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to vertex3i(X, Y, Z).
vertex3sv(V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to vertex3s(X, Y, Z).
vertex4dv(V) -> ok
Types:
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to vertex4d(X, Y, Z, W).
vertex4fv(V) -> ok
Types:
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to vertex4f(X, Y, Z, W).
vertex4iv(V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertex4i(X, Y, Z, W).
vertex4sv(V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertex4s(X, Y, Z, W).
normal3b(Nx, Ny, Nz) -> ok
Types:
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 external documentation.
normal3d(Nx, Ny, Nz) -> ok
Types:
Nx = float()
Ny = float()
Nz = float()
See normal3b/3
normal3f(Nx, Ny, Nz) -> ok
Types:
Nx = float()
Ny = float()
Nz = float()
See normal3b/3
normal3i(Nx, Ny, Nz) -> ok
Types:
Nx = integer()
Ny = integer()
Nz = integer()
See normal3b/3
normal3s(Nx, Ny, Nz) -> ok
Types:
Nx = integer()
Ny = integer()
Nz = integer()
See normal3b/3
normal3bv(V) -> ok
Types:
V = {Nx::integer(), Ny::integer(), Nz::integer()}
Equivalent to normal3b(Nx, Ny, Nz).
normal3dv(V) -> ok
Types:
V = {Nx::float(), Ny::float(), Nz::float()}
Equivalent to normal3d(Nx, Ny, Nz).
normal3fv(V) -> ok
Types:
V = {Nx::float(), Ny::float(), Nz::float()}
Equivalent to normal3f(Nx, Ny, Nz).
normal3iv(V) -> ok
Types:
V = {Nx::integer(), Ny::integer(), Nz::integer()}
Equivalent to normal3i(Nx, Ny, Nz).
normal3sv(V) -> ok
Types:
V = {Nx::integer(), Ny::integer(), Nz::integer()}
Equivalent to normal3s(Nx, Ny, Nz).
indexd(C) -> ok
Types:
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 external documentation.
indexf(C) -> ok
Types:
C = float()
See indexd/1
indexi(C) -> ok
Types:
C = integer()
See indexd/1
indexs(C) -> ok
Types:
C = integer()
See indexd/1
indexub(C) -> ok
Types:
C = integer()
See indexd/1
indexdv(C) -> ok
Types:
C = {C::float()}
Equivalent to indexd(C).
indexfv(C) -> ok
Types:
C = {C::float()}
Equivalent to indexf(C).
indexiv(C) -> ok
Types:
C = {C::integer()}
Equivalent to indexi(C).
indexsv(C) -> ok
Types:
C = {C::integer()}
Equivalent to indexs(C).
indexubv(C) -> ok
Types:
C = {C::integer()}
Equivalent to indexub(C).
color3b(Red, Green, Blue) -> ok
Types:
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 external documentation.
color3d(Red, Green, Blue) -> ok
Types:
Red = float()
Green = float()
Blue = float()
See color3b/3
color3f(Red, Green, Blue) -> ok
Types:
Red = float()
Green = float()
Blue = float()
See color3b/3
color3i(Red, Green, Blue) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
See color3b/3
color3s(Red, Green, Blue) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
See color3b/3
color3ub(Red, Green, Blue) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
See color3b/3
color3ui(Red, Green, Blue) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
See color3b/3
color3us(Red, Green, Blue) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
See color3b/3
color4b(Red, Green, Blue, Alpha) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color4d(Red, Green, Blue, Alpha) -> ok
Types:
Red = float()
Green = float()
Blue = float()
Alpha = float()
See color3b/3
color4f(Red, Green, Blue, Alpha) -> ok
Types:
Red = float()
Green = float()
Blue = float()
Alpha = float()
See color3b/3
color4i(Red, Green, Blue, Alpha) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color4s(Red, Green, Blue, Alpha) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color4ub(Red, Green, Blue, Alpha) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color4ui(Red, Green, Blue, Alpha) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color4us(Red, Green, Blue, Alpha) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
Alpha = integer()
See color3b/3
color3bv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3b(Red, Green, Blue).
color3dv(V) -> ok
Types:
V = {Red::float(), Green::float(), Blue::float()}
Equivalent to color3d(Red, Green, Blue).
color3fv(V) -> ok
Types:
V = {Red::float(), Green::float(), Blue::float()}
Equivalent to color3f(Red, Green, Blue).
color3iv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3i(Red, Green, Blue).
color3sv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3s(Red, Green, Blue).
color3ubv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3ub(Red, Green, Blue).
color3uiv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3ui(Red, Green, Blue).
color3usv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to color3us(Red, Green, Blue).
color4bv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4b(Red, Green, Blue, Alpha).
color4dv(V) -> ok
Types:
V = {Red::float(), Green::float(), Blue::float(), Alpha::float()}
Equivalent to color4d(Red, Green, Blue, Alpha).
color4fv(V) -> ok
Types:
V = {Red::float(), Green::float(), Blue::float(), Alpha::float()}
Equivalent to color4f(Red, Green, Blue, Alpha).
color4iv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4i(Red, Green, Blue, Alpha).
color4sv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4s(Red, Green, Blue, Alpha).
color4ubv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4ub(Red, Green, Blue, Alpha).
color4uiv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4ui(Red, Green, Blue, Alpha).
color4usv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer(), Alpha::integer()}
Equivalent to color4us(Red, Green, Blue, Alpha).
texCoord1d(S) -> ok
Types:
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 external documentation.
texCoord1f(S) -> ok
Types:
S = float()
See texCoord1d/1
texCoord1i(S) -> ok
Types:
S = integer()
See texCoord1d/1
texCoord1s(S) -> ok
Types:
S = integer()
See texCoord1d/1
texCoord2d(S, T) -> ok
Types:
S = float()
T = float()
See texCoord1d/1
texCoord2f(S, T) -> ok
Types:
S = float()
T = float()
See texCoord1d/1
texCoord2i(S, T) -> ok
Types:
S = integer()
T = integer()
See texCoord1d/1
texCoord2s(S, T) -> ok
Types:
S = integer()
T = integer()
See texCoord1d/1
texCoord3d(S, T, R) -> ok
Types:
S = float()
T = float()
R = float()
See texCoord1d/1
texCoord3f(S, T, R) -> ok
Types:
S = float()
T = float()
R = float()
See texCoord1d/1
texCoord3i(S, T, R) -> ok
Types:
S = integer()
T = integer()
R = integer()
See texCoord1d/1
texCoord3s(S, T, R) -> ok
Types:
S = integer()
T = integer()
R = integer()
See texCoord1d/1
texCoord4d(S, T, R, Q) -> ok
Types:
S = float()
T = float()
R = float()
Q = float()
See texCoord1d/1
texCoord4f(S, T, R, Q) -> ok
Types:
S = float()
T = float()
R = float()
Q = float()
See texCoord1d/1
texCoord4i(S, T, R, Q) -> ok
Types:
S = integer()
T = integer()
R = integer()
Q = integer()
See texCoord1d/1
texCoord4s(S, T, R, Q) -> ok
Types:
S = integer()
T = integer()
R = integer()
Q = integer()
See texCoord1d/1
texCoord1dv(V) -> ok
Types:
V = {S::float()}
Equivalent to texCoord1d(S).
texCoord1fv(V) -> ok
Types:
V = {S::float()}
Equivalent to texCoord1f(S).
texCoord1iv(V) -> ok
Types:
V = {S::integer()}
Equivalent to texCoord1i(S).
texCoord1sv(V) -> ok
Types:
V = {S::integer()}
Equivalent to texCoord1s(S).
texCoord2dv(V) -> ok
Types:
V = {S::float(), T::float()}
Equivalent to texCoord2d(S, T).
texCoord2fv(V) -> ok
Types:
V = {S::float(), T::float()}
Equivalent to texCoord2f(S, T).
texCoord2iv(V) -> ok
Types:
V = {S::integer(), T::integer()}
Equivalent to texCoord2i(S, T).
texCoord2sv(V) -> ok
Types:
V = {S::integer(), T::integer()}
Equivalent to texCoord2s(S, T).
texCoord3dv(V) -> ok
Types:
V = {S::float(), T::float(), R::float()}
Equivalent to texCoord3d(S, T, R).
texCoord3fv(V) -> ok
Types:
V = {S::float(), T::float(), R::float()}
Equivalent to texCoord3f(S, T, R).
texCoord3iv(V) -> ok
Types:
V = {S::integer(), T::integer(), R::integer()}
Equivalent to texCoord3i(S, T, R).
texCoord3sv(V) -> ok
Types:
V = {S::integer(), T::integer(), R::integer()}
Equivalent to texCoord3s(S, T, R).
texCoord4dv(V) -> ok
Types:
V = {S::float(), T::float(), R::float(), Q::float()}
Equivalent to texCoord4d(S, T, R, Q).
texCoord4fv(V) -> ok
Types:
V = {S::float(), T::float(), R::float(), Q::float()}
Equivalent to texCoord4f(S, T, R, Q).
texCoord4iv(V) -> ok
Types:
V = {S::integer(), T::integer(), R::integer(), Q::integer()}
Equivalent to texCoord4i(S, T, R, Q).
texCoord4sv(V) -> ok
Types:
V = {S::integer(), T::integer(), R::integer(), Q::integer()}
Equivalent to texCoord4s(S, T, R, Q).
rasterPos2d(X, Y) -> ok
Types:
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 external documentation.
rasterPos2f(X, Y) -> ok
Types:
X = float()
Y = float()
See rasterPos2d/2
rasterPos2i(X, Y) -> ok
Types:
X = integer()
Y = integer()
See rasterPos2d/2
rasterPos2s(X, Y) -> ok
Types:
X = integer()
Y = integer()
See rasterPos2d/2
rasterPos3d(X, Y, Z) -> ok
Types:
X = float()
Y = float()
Z = float()
See rasterPos2d/2
rasterPos3f(X, Y, Z) -> ok
Types:
X = float()
Y = float()
Z = float()
See rasterPos2d/2
rasterPos3i(X, Y, Z) -> ok
Types:
X = integer()
Y = integer()
Z = integer()
See rasterPos2d/2
rasterPos3s(X, Y, Z) -> ok
Types:
X = integer()
Y = integer()
Z = integer()
See rasterPos2d/2
rasterPos4d(X, Y, Z, W) -> ok
Types:
X = float()
Y = float()
Z = float()
W = float()
See rasterPos2d/2
rasterPos4f(X, Y, Z, W) -> ok
Types:
X = float()
Y = float()
Z = float()
W = float()
See rasterPos2d/2
rasterPos4i(X, Y, Z, W) -> ok
Types:
X = integer()
Y = integer()
Z = integer()
W = integer()
See rasterPos2d/2
rasterPos4s(X, Y, Z, W) -> ok
Types:
X = integer()
Y = integer()
Z = integer()
W = integer()
See rasterPos2d/2
rasterPos2dv(V) -> ok
Types:
V = {X::float(), Y::float()}
Equivalent to rasterPos2d(X, Y).
rasterPos2fv(V) -> ok
Types:
V = {X::float(), Y::float()}
Equivalent to rasterPos2f(X, Y).
rasterPos2iv(V) -> ok
Types:
V = {X::integer(), Y::integer()}
Equivalent to rasterPos2i(X, Y).
rasterPos2sv(V) -> ok
Types:
V = {X::integer(), Y::integer()}
Equivalent to rasterPos2s(X, Y).
rasterPos3dv(V) -> ok
Types:
V = {X::float(), Y::float(), Z::float()}
Equivalent to rasterPos3d(X, Y, Z).
rasterPos3fv(V) -> ok
Types:
V = {X::float(), Y::float(), Z::float()}
Equivalent to rasterPos3f(X, Y, Z).
rasterPos3iv(V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to rasterPos3i(X, Y, Z).
rasterPos3sv(V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to rasterPos3s(X, Y, Z).
rasterPos4dv(V) -> ok
Types:
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to rasterPos4d(X, Y, Z, W).
rasterPos4fv(V) -> ok
Types:
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to rasterPos4f(X, Y, Z, W).
rasterPos4iv(V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to rasterPos4i(X, Y, Z, W).
rasterPos4sv(V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to rasterPos4s(X, Y, Z, W).
rectd(X1, Y1, X2, Y2) -> ok
Types:
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 external documentation.
rectf(X1, Y1, X2, Y2) -> ok
Types:
X1 = float()
Y1 = float()
X2 = float()
Y2 = float()
See rectd/4
recti(X1, Y1, X2, Y2) -> ok
Types:
X1 = integer()
Y1 = integer()
X2 = integer()
Y2 = integer()
See rectd/4
rects(X1, Y1, X2, Y2) -> ok
Types:
X1 = integer()
Y1 = integer()
X2 = integer()
Y2 = integer()
See rectd/4
rectdv(V1, V2) -> ok
Types:
V1 = {float(), float()}
V2 = {float(), float()}
See rectd/4
rectfv(V1, V2) -> ok
Types:
V1 = {float(), float()}
V2 = {float(), float()}
See rectd/4
rectiv(V1, V2) -> ok
Types:
V1 = {integer(), integer()}
V2 = {integer(), integer()}
See rectd/4
rectsv(V1, V2) -> ok
Types:
V1 = {integer(), integer()}
V2 = {integer(), integer()}
See rectd/4
vertexPointer(Size, Type, Stride, Ptr) -> ok
Types:
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 external documentation.
normalPointer(Type, Stride, Ptr) -> ok
Types:
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 external documentation.
colorPointer(Size, Type, Stride, Ptr) -> ok
Types:
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 external documentation.
indexPointer(Type, Stride, Ptr) -> ok
Types:
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 external documentation.
texCoordPointer(Size, Type, Stride, Ptr) -> ok
Types:
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 external documentation.
edgeFlagPointer(Stride, Ptr) -> ok
Types:
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 external documentation.
arrayElement(I) -> ok
Types:
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 external documentation.
drawArrays(Mode, First, Count) -> ok
Types:
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 external documentation.
drawElements(Mode, Count, Type, Indices) -> ok
Types:
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 external documentation.
interleavedArrays(Format, Stride, Pointer) -> ok
Types:
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 external documentation.
shadeModel(Mode) -> ok
Types:
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 external documentation.
lightf(Light, Pname, Param) -> ok
Types:
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 external documentation.
lighti(Light, Pname, Param) -> ok
Types:
Light = enum()
Pname = enum()
Param = integer()
See lightf/3
lightfv(Light, Pname, Params) -> ok
Types:
Light = enum()
Pname = enum()
Params = tuple()
See lightf/3
lightiv(Light, Pname, Params) -> ok
Types:
Light = enum()
Pname = enum()
Params = tuple()
See lightf/3
getLightfv(Light, Pname) -> {float(), float(), float(), float()}
Types:
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 external documentation.
getLightiv(Light, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Light = enum()
Pname = enum()
See getLightfv/2
lightModelf(Pname, Param) -> ok
Types:
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 external documentation.
lightModeli(Pname, Param) -> ok
Types:
Pname = enum()
Param = integer()
See lightModelf/2
lightModelfv(Pname, Params) -> ok
Types:
Pname = enum()
Params = tuple()
See lightModelf/2
lightModeliv(Pname, Params) -> ok
Types:
Pname = enum()
Params = tuple()
See lightModelf/2
materialf(Face, Pname, Param) -> ok
Types:
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 external documentation.
materiali(Face, Pname, Param) -> ok
Types:
Face = enum()
Pname = enum()
Param = integer()
See materialf/3
materialfv(Face, Pname, Params) -> ok
Types:
Face = enum()
Pname = enum()
Params = tuple()
See materialf/3
materialiv(Face, Pname, Params) -> ok
Types:
Face = enum()
Pname = enum()
Params = tuple()
See materialf/3
getMaterialfv(Face, Pname) -> {float(), float(), float(), float()}
Types:
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 external documentation.
getMaterialiv(Face, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Face = enum()
Pname = enum()
See getMaterialfv/2
colorMaterial(Face, Mode) -> ok
Types:
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 external documentation.
pixelZoom(Xfactor, Yfactor) -> ok
Types:
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 external documentation.
pixelStoref(Pname, Param) -> ok
Types:
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.PnameTypeInitial ValueValid 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 external documentation.
pixelStorei(Pname, Param) -> ok
Types:
Pname = enum()
Param = integer()
See pixelStoref/2
pixelTransferf(Pname, Param) -> ok
Types:
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.PnameTypeInitial ValueValid 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 external documentation.
pixelTransferi(Pname, Param) -> ok
Types:
Pname = enum()
Param = integer()
See pixelTransferf/2
pixelMapfv(Map, Mapsize, Values) -> ok
Types:
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.MapLookup IndexLookup ValueInitial SizeInitial 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 external documentation.
pixelMapuiv(Map, Mapsize, Values) -> ok
Types:
Map = enum()
Mapsize = integer()
Values = binary()
See pixelMapfv/3
pixelMapusv(Map, Mapsize, Values) -> ok
Types:
Map = enum()
Mapsize = integer()
Values = binary()
See pixelMapfv/3
getPixelMapfv(Map, Values) -> ok
Types:
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 external documentation.
getPixelMapuiv(Map, Values) -> ok
Types:
Map = enum()
Values = mem()
See getPixelMapfv/2
getPixelMapusv(Map, Values) -> ok
Types:
Map = enum()
Values = mem()
See getPixelMapfv/2
bitmap(Width, Height, Xorig, Yorig, Xmove, Ymove, Bitmap) -> ok
Types:
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 external documentation.
readPixels(X, Y, Width, Height, Format, Type, Pixels) -> ok
Types:
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).TypeIndex
MaskComponent 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 external documentation.
drawPixels(Width, Height, Format, Type, Pixels) -> ok
Types:
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:TypeCorresponding 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 external documentation.
copyPixels(X, Y, Width, Height, Type) -> ok
Types:
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 external documentation.
stencilFunc(Func, Ref, Mask) -> ok
Types:
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 external documentation.
stencilMask(Mask) -> ok
Types:
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 external documentation.
stencilOp(Fail, Zfail, Zpass) -> ok
Types:
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 external documentation.
clearStencil(S) -> ok
Types:
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 external documentation.
texGend(Coord, Pname, Param) -> ok
Types:
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 external documentation.
texGenf(Coord, Pname, Param) -> ok
Types:
Coord = enum()
Pname = enum()
Param = float()
See texGend/3
texGeni(Coord, Pname, Param) -> ok
Types:
Coord = enum()
Pname = enum()
Param = integer()
See texGend/3
texGendv(Coord, Pname, Params) -> ok
Types:
Coord = enum()
Pname = enum()
Params = tuple()
See texGend/3
texGenfv(Coord, Pname, Params) -> ok
Types:
Coord = enum()
Pname = enum()
Params = tuple()
See texGend/3
texGeniv(Coord, Pname, Params) -> ok
Types:
Coord = enum()
Pname = enum()
Params = tuple()
See texGend/3
getTexGendv(Coord, Pname) -> {float(), float(), float(), float()}
Types:
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 external documentation.
getTexGenfv(Coord, Pname) -> {float(), float(), float(), float()}
Types:
Coord = enum()
Pname = enum()
See getTexGendv/2
getTexGeniv(Coord, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Coord = enum()
Pname = enum()
See getTexGendv/2
texEnvf(Target, Pname, Param) -> ok
Types:
Target = enum()
Pname = enum()
Param = float()
glTexEnvf
See external documentation.
texEnvi(Target, Pname, Param) -> ok
Types:
Target = enum()
Pname = enum()
Param = integer()
glTexEnvi
See external documentation.
texEnvfv(Target, Pname, Params) -> ok
Types:
Target = enum()
Pname = enum()
Params = tuple()
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 t
A 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 p
A 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 s
A 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_RGBTexture 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_ALPHATexture 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
In 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_RGBArgument 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_ALPHAArgument 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 external documentation.
texEnviv(Target, Pname, Params) -> ok
Types:
Target = enum()
Pname = enum()
Params = tuple()
See texEnvfv/3
getTexEnvfv(Target, Pname) -> {float(), float(), float(), float()}
Types:
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 external documentation.
getTexEnviv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Target = enum()
Pname = enum()
See getTexEnvfv/2
texParameterf(Target, Pname, Param) -> ok
Types:
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 FunctionComputed
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.0
where 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 external documentation.
texParameteri(Target, Pname, Param) -> ok
Types:
Target = enum()
Pname = enum()
Param = integer()
See texParameterf/3
texParameterfv(Target, Pname, Params) -> ok
Types:
Target = enum()
Pname = enum()
Params = tuple()
See texParameterf/3
texParameteriv(Target, Pname, Params) -> ok
Types:
Target = enum()
Pname = enum()
Params = tuple()
See texParameterf/3
getTexParameterfv(Target, Pname) -> {float(), float(), float(), float()}
Types:
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 external documentation.
getTexParameteriv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Target = enum()
Pname = enum()
See getTexParameterfv/2
getTexLevelParameterfv(Target, Level, Pname) -> {float()}
Types:
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 external documentation.
getTexLevelParameteriv(Target, Level, Pname) -> {integer()}
Types:
Target = enum()
Level = integer()
Pname = enum()
See getTexLevelParameterfv/3
texImage1D(Target, Level, InternalFormat, Width, Border, Format, Type, Pixels) -> ok
Types:
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 external documentation.
texImage2D(Target, Level, InternalFormat, Width, Height, Border, Format, Type, Pixels) -> ok
Types:
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 external documentation.
getTexImage(Target, Level, Format, Type, Pixels) -> ok
Types:
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 external documentation.
genTextures(N) -> [integer()]
Types:
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 external documentation.
deleteTextures(Textures) -> ok
Types:
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 external documentation.
bindTexture(Target, Texture) -> ok
Types:
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 external documentation.
prioritizeTextures(Textures, Priorities) -> ok
Types:
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 external documentation.
areTexturesResident(Textures) -> {0 | 1, Residences::[0 | 1]}
Types:
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 external documentation.
isTexture(Texture) -> 0 | 1
Types:
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 external documentation.
texSubImage1D(Target, Level, Xoffset, Width, Format, Type, Pixels) -> ok
Types:
Target = enum()
Level = integer()
Xoffset = integer()
Width = integer()
Format = enum()
Type = enum()
Pixels = offset() | mem()
glTexSubImage
See external documentation.
texSubImage2D(Target, Level, Xoffset, Yoffset, Width, Height, Format, Type, Pixels) -> ok
Types:
Target = enum()
Level = integer()
Xoffset = integer()
Yoffset = integer()
Width = integer()
Height = integer()
Format = enum()
Type = enum()
Pixels = offset() | mem()
glTexSubImage
See external documentation.
copyTexImage1D(Target, Level, Internalformat, X, Y, Width, Border) -> ok
Types:
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 external documentation.
copyTexImage2D(Target, Level, Internalformat, X, Y, Width, Height, Border) -> ok
Types:
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 external documentation.
copyTexSubImage1D(Target, Level, Xoffset, X, Y, Width) -> ok
Types:
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 external documentation.
copyTexSubImage2D(Target, Level, Xoffset, Yoffset, X, Y, Width, Height) -> ok
Types:
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 external documentation.
map1d(Target, U1, U2, Stride, Order, Points) -> ok
Types:
Target = enum()
U1 = float()
U2 = float()
Stride = integer()
Order = integer()
Points = binary()
glMap
See external documentation.
map1f(Target, U1, U2, Stride, Order, Points) -> ok
Types:
Target = enum()
U1 = float()
U2 = float()
Stride = integer()
Order = integer()
Points = binary()
glMap
See external documentation.
map2d(Target, U1, U2, Ustride, Uorder, V1, V2, Vstride, Vorder, Points) -> ok
Types:
Target = enum()
U1 = float()
U2 = float()
Ustride = integer()
Uorder = integer()
V1 = float()
V2 = float()
Vstride = integer()
Vorder = integer()
Points = binary()
glMap
See external documentation.
map2f(Target, U1, U2, Ustride, Uorder, V1, V2, Vstride, Vorder, Points) -> ok
Types:
Target = enum()
U1 = float()
U2 = float()
Ustride = integer()
Uorder = integer()
V1 = float()
V2 = float()
Vstride = integer()
Vorder = integer()
Points = binary()
glMap
See external documentation.
getMapdv(Target, Query, V) -> ok
Types:
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 external documentation.
getMapfv(Target, Query, V) -> ok
Types:
Target = enum()
Query = enum()
V = mem()
See getMapdv/3
getMapiv(Target, Query, V) -> ok
Types:
Target = enum()
Query = enum()
V = mem()
See getMapdv/3
evalCoord1d(U) -> ok
Types:
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 external documentation.
evalCoord1f(U) -> ok
Types:
U = float()
See evalCoord1d/1
evalCoord1dv(U) -> ok
Types:
U = {U::float()}
Equivalent to evalCoord1d(U).
evalCoord1fv(U) -> ok
Types:
U = {U::float()}
Equivalent to evalCoord1f(U).
evalCoord2d(U, V) -> ok
Types:
U = float()
V = float()
See evalCoord1d/1
evalCoord2f(U, V) -> ok
Types:
U = float()
V = float()
See evalCoord1d/1
evalCoord2dv(U) -> ok
Types:
U = {U::float(), V::float()}
Equivalent to evalCoord2d(U, V).
evalCoord2fv(U) -> ok
Types:
U = {U::float(), V::float()}
Equivalent to evalCoord2f(U, V).
mapGrid1d(Un, U1, U2) -> ok
Types:
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 external documentation.
mapGrid1f(Un, U1, U2) -> ok
Types:
Un = integer()
U1 = float()
U2 = float()
See mapGrid1d/3
mapGrid2d(Un, U1, U2, Vn, V1, V2) -> ok
Types:
Un = integer()
U1 = float()
U2 = float()
Vn = integer()
V1 = float()
V2 = float()
See mapGrid1d/3
mapGrid2f(Un, U1, U2, Vn, V1, V2) -> ok
Types:
Un = integer()
U1 = float()
U2 = float()
Vn = integer()
V1 = float()
V2 = float()
See mapGrid1d/3
evalPoint1(I) -> ok
Types:
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 external documentation.
evalPoint2(I, J) -> ok
Types:
I = integer()
J = integer()
See evalPoint1/1
evalMesh1(Mode, I1, I2) -> ok
Types:
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 external documentation.
evalMesh2(Mode, I1, I2, J1, J2) -> ok
Types:
Mode = enum()
I1 = integer()
I2 = integer()
J1 = integer()
J2 = integer()
See evalMesh1/3
fogf(Pname, Param) -> ok
Types:
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 external documentation.
fogi(Pname, Param) -> ok
Types:
Pname = enum()
Param = integer()
See fogf/2
fogfv(Pname, Params) -> ok
Types:
Pname = enum()
Params = tuple()
See fogf/2
fogiv(Pname, Params) -> ok
Types:
Pname = enum()
Params = tuple()
See fogf/2
feedbackBuffer(Size, Type, Buffer) -> ok
Types:
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.TypeCoordinatesColorTextureTotal Number of Values
?GL_2Dx, y 2
?GL_3Dx, y, z 3
?GL_3D_COLORx, y, z k 3+k
?GL_3D_COLOR_TEXTUREx, y, z k 4 7+k
?GL_4D_COLOR_TEXTUREx, y, z, w k 4 8+k
Feedback 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 external documentation.
passThrough(Token) -> ok
Types:
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 external documentation.
selectBuffer(Size, Buffer) -> ok
Types:
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 external documentation.
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 external documentation.
loadName(Name) -> ok
Types:
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 external documentation.
pushName(Name) -> ok
Types:
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 external documentation.
popName() -> ok
See pushName/1
blendColor(Red, Green, Blue, Alpha) -> ok
Types:
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 external documentation.
blendEquation(Mode) -> ok
Types:
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].ModeRGB ComponentsAlpha 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 external documentation.
drawRangeElements(Mode, Start, End, Count, Type, Indices) -> ok
Types:
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 external documentation.
texImage3D(Target, Level, InternalFormat, Width, Height, Depth, Border, Format, Type, Pixels) -> ok
Types:
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 external documentation.
texSubImage3D(Target, Level, Xoffset, Yoffset, Zoffset, Width, Height, Depth, Format, Type, Pixels) -> ok
Types:
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 external documentation.
copyTexSubImage3D(Target, Level, Xoffset, Yoffset, Zoffset, X, Y, Width, Height) -> ok
Types:
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 external documentation.
colorTable(Target, Internalformat, Width, Format, Type, Table) -> ok
Types:
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
FormatRedGreenBlueAlphaLuminanceIntensity
?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:RepresentationMeaning
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 FormatRGBA
?GL_ALPHARGBA[a]
?GL_LUMINANCEL[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_RGBR[r] G[g]B[b]A
?GL_RGBAR[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 external documentation.
colorTableParameterfv(Target, Pname, Params) -> ok
Types:
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 external documentation.
colorTableParameteriv(Target, Pname, Params) -> ok
Types:
Target = enum()
Pname = enum()
Params = {integer(), integer(), integer(), integer()}
See colorTableParameterfv/3
copyColorTable(Target, Internalformat, X, Y, Width) -> ok
Types:
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
FormatRedGreenBlueAlphaLuminanceIntensity
?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 external documentation.
getColorTable(Target, Format, Type, Table) -> ok
Types:
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 areInternal ComponentResulting Component
Red Red
Green Green
Blue Blue
Alpha Alpha
Luminance Red
Intensity Red
See external documentation.
getColorTableParameterfv(Target, Pname) -> {float(), float(), float(), float()}
Types:
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.ParameterNMeaning
?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 external documentation.
getColorTableParameteriv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Target = enum()
Pname = enum()
See getColorTableParameterfv/2
colorSubTable(Target, Start, Count, Format, Type, Data) -> ok
Types:
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 external documentation.
copyColorSubTable(Target, Start, X, Y, Width) -> ok
Types:
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 external documentation.
convolutionFilter1D(Target, Internalformat, Width, Format, Type, Image) -> ok
Types:
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 FormatRedGreenBlueAlphaLuminanceIntensity
?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 ith 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 external documentation.
convolutionFilter2D(Target, Internalformat, Width, Height, Format, Type, Image) -> ok
Types:
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 FormatRedGreenBlueAlphaLuminanceIntensity
?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 Nth 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 external documentation.
convolutionParameterf(Target, Pname, Params) -> ok
Types:
Target = enum()
Pname = enum()
Params = tuple()
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 external documentation.
convolutionParameterfv(Target::enum(), Pname::enum(), Params) -> ok
Types:
Params = {Params::tuple()}
Equivalent to convolutionParameterf(Target, Pname, Params).
convolutionParameteri(Target, Pname, Params) -> ok
Types:
Target = enum()
Pname = enum()
Params = tuple()
See convolutionParameterf/3
convolutionParameteriv(Target::enum(), Pname::enum(), Params) -> ok
Types:
Params = {Params::tuple()}
Equivalent to convolutionParameteri(Target, Pname, Params).
copyConvolutionFilter1D(Target, Internalformat, X, Y, Width) -> ok
Types:
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 FormatRedGreenBlueAlphaLuminanceIntensity
?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 external documentation.
copyConvolutionFilter2D(Target, Internalformat, X, Y, Width, Height) -> ok
Types:
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 FormatRedGreenBlueAlphaLuminanceIntensity
?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 external documentation.
getConvolutionFilter(Target, Format, Type, Image) -> ok
Types:
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 ComponentResulting Component
Red Red
Green Green
Blue Blue
Alpha Alpha
Luminance Red
Intensity Red
See external documentation.
getConvolutionParameterfv(Target, Pname) -> {float(), float(), float(), float()}
Types:
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 external documentation.
getConvolutionParameteriv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Target = enum()
Pname = enum()
See getConvolutionParameterfv/2
separableFilter2D(Target, Internalformat, Width, Height, Format, Type, Row, Column) -> ok
Types:
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 FormatRedGreenBlueAlphaLuminanceIntensity
?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 external documentation.
getHistogram(Target, Reset, Format, Type, Values) -> ok
Types:
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 ComponentResulting Component
Red Red
Green Green
Blue Blue
Alpha Alpha
Luminance Red
See external documentation.
getHistogramParameterfv(Target, Pname) -> {float()}
Types:
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:ParameterDescription
?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 external documentation.
getHistogramParameteriv(Target, Pname) -> {integer()}
Types:
Target = enum()
Pname = enum()
See getHistogramParameterfv/2
getMinmax(Target, Reset, Format, Types, Values) -> ok
Types:
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 ComponentResulting 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 external documentation.
getMinmaxParameterfv(Target, Pname) -> {float()}
Types:
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:ParameterDescription
?GL_MINMAX_FORMAT Internal format of minmax table
?GL_MINMAX_SINK Value of the sink parameter
See external documentation.
getMinmaxParameteriv(Target, Pname) -> {integer()}
Types:
Target = enum()
Pname = enum()
See getMinmaxParameterfv/2
histogram(Target, Width, Internalformat, Sink) -> ok
Types:
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 external documentation.
minmax(Target, Internalformat, Sink) -> ok
Types:
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 external documentation.
resetHistogram(Target) -> ok
Types:
Target = enum()
Reset histogram table entries to zero
gl:resetHistogram resets all the elements of the current histogram table to zero.
See external documentation.
resetMinmax(Target) -> ok
Types:
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 external documentation.
activeTexture(Texture) -> ok
Types:
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 external documentation.
sampleCoverage(Value, Invert) -> ok
Types:
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 external documentation.
compressedTexImage3D(Target, Level, Internalformat, Width, Height, Depth, Border, ImageSize, Data) -> ok
Types:
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 external documentation.
compressedTexImage2D(Target, Level, Internalformat, Width, Height, Border, ImageSize, Data) -> ok
Types:
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 external documentation.
compressedTexImage1D(Target, Level, Internalformat, Width, Border, ImageSize, Data) -> ok
Types:
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 external documentation.
compressedTexSubImage3D(Target, Level, Xoffset, Yoffset, Zoffset, Width, Height, Depth, Format,
ImageSize, Data) -> ok
Types:
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 external documentation.
compressedTexSubImage2D(Target, Level, Xoffset, Yoffset, Width, Height, Format, ImageSize, Data) -> ok
Types:
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 external documentation.
compressedTexSubImage1D(Target, Level, Xoffset, Width, Format, ImageSize, Data) -> ok
Types:
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 external documentation.
getCompressedTexImage(Target, Lod, Img) -> ok
Types:
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 external documentation.
clientActiveTexture(Texture) -> ok
Types:
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 external documentation.
multiTexCoord1d(Target, S) -> ok
Types:
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 external documentation.
multiTexCoord1dv(Target::enum(), V) -> ok
Types:
V = {S::float()}
Equivalent to multiTexCoord1d(Target, S).
multiTexCoord1f(Target, S) -> ok
Types:
Target = enum()
S = float()
See multiTexCoord1d/2
multiTexCoord1fv(Target::enum(), V) -> ok
Types:
V = {S::float()}
Equivalent to multiTexCoord1f(Target, S).
multiTexCoord1i(Target, S) -> ok
Types:
Target = enum()
S = integer()
See multiTexCoord1d/2
multiTexCoord1iv(Target::enum(), V) -> ok
Types:
V = {S::integer()}
Equivalent to multiTexCoord1i(Target, S).
multiTexCoord1s(Target, S) -> ok
Types:
Target = enum()
S = integer()
See multiTexCoord1d/2
multiTexCoord1sv(Target::enum(), V) -> ok
Types:
V = {S::integer()}
Equivalent to multiTexCoord1s(Target, S).
multiTexCoord2d(Target, S, T) -> ok
Types:
Target = enum()
S = float()
T = float()
See multiTexCoord1d/2
multiTexCoord2dv(Target::enum(), V) -> ok
Types:
V = {S::float(), T::float()}
Equivalent to multiTexCoord2d(Target, S, T).
multiTexCoord2f(Target, S, T) -> ok
Types:
Target = enum()
S = float()
T = float()
See multiTexCoord1d/2
multiTexCoord2fv(Target::enum(), V) -> ok
Types:
V = {S::float(), T::float()}
Equivalent to multiTexCoord2f(Target, S, T).
multiTexCoord2i(Target, S, T) -> ok
Types:
Target = enum()
S = integer()
T = integer()
See multiTexCoord1d/2
multiTexCoord2iv(Target::enum(), V) -> ok
Types:
V = {S::integer(), T::integer()}
Equivalent to multiTexCoord2i(Target, S, T).
multiTexCoord2s(Target, S, T) -> ok
Types:
Target = enum()
S = integer()
T = integer()
See multiTexCoord1d/2
multiTexCoord2sv(Target::enum(), V) -> ok
Types:
V = {S::integer(), T::integer()}
Equivalent to multiTexCoord2s(Target, S, T).
multiTexCoord3d(Target, S, T, R) -> ok
Types:
Target = enum()
S = float()
T = float()
R = float()
See multiTexCoord1d/2
multiTexCoord3dv(Target::enum(), V) -> ok
Types:
V = {S::float(), T::float(), R::float()}
Equivalent to multiTexCoord3d(Target, S, T, R).
multiTexCoord3f(Target, S, T, R) -> ok
Types:
Target = enum()
S = float()
T = float()
R = float()
See multiTexCoord1d/2
multiTexCoord3fv(Target::enum(), V) -> ok
Types:
V = {S::float(), T::float(), R::float()}
Equivalent to multiTexCoord3f(Target, S, T, R).
multiTexCoord3i(Target, S, T, R) -> ok
Types:
Target = enum()
S = integer()
T = integer()
R = integer()
See multiTexCoord1d/2
multiTexCoord3iv(Target::enum(), V) -> ok
Types:
V = {S::integer(), T::integer(), R::integer()}
Equivalent to multiTexCoord3i(Target, S, T, R).
multiTexCoord3s(Target, S, T, R) -> ok
Types:
Target = enum()
S = integer()
T = integer()
R = integer()
See multiTexCoord1d/2
multiTexCoord3sv(Target::enum(), V) -> ok
Types:
V = {S::integer(), T::integer(), R::integer()}
Equivalent to multiTexCoord3s(Target, S, T, R).
multiTexCoord4d(Target, S, T, R, Q) -> ok
Types:
Target = enum()
S = float()
T = float()
R = float()
Q = float()
See multiTexCoord1d/2
multiTexCoord4dv(Target::enum(), V) -> ok
Types:
V = {S::float(), T::float(), R::float(), Q::float()}
Equivalent to multiTexCoord4d(Target, S, T, R, Q).
multiTexCoord4f(Target, S, T, R, Q) -> ok
Types:
Target = enum()
S = float()
T = float()
R = float()
Q = float()
See multiTexCoord1d/2
multiTexCoord4fv(Target::enum(), V) -> ok
Types:
V = {S::float(), T::float(), R::float(), Q::float()}
Equivalent to multiTexCoord4f(Target, S, T, R, Q).
multiTexCoord4i(Target, S, T, R, Q) -> ok
Types:
Target = enum()
S = integer()
T = integer()
R = integer()
Q = integer()
See multiTexCoord1d/2
multiTexCoord4iv(Target::enum(), V) -> ok
Types:
V = {S::integer(), T::integer(), R::integer(), Q::integer()}
Equivalent to multiTexCoord4i(Target, S, T, R, Q).
multiTexCoord4s(Target, S, T, R, Q) -> ok
Types:
Target = enum()
S = integer()
T = integer()
R = integer()
Q = integer()
See multiTexCoord1d/2
multiTexCoord4sv(Target::enum(), V) -> ok
Types:
V = {S::integer(), T::integer(), R::integer(), Q::integer()}
Equivalent to multiTexCoord4s(Target, S, T, R, Q).
loadTransposeMatrixf(M) -> ok
Types:
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 external documentation.
loadTransposeMatrixd(M) -> ok
Types:
M = matrix()
See loadTransposeMatrixf/1
multTransposeMatrixf(M) -> ok
Types:
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 external documentation.
multTransposeMatrixd(M) -> ok
Types:
M = matrix()
See multTransposeMatrixf/1
blendFuncSeparate(SfactorRGB, DfactorRGB, SfactorAlpha, DfactorAlpha) -> ok
Types:
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].ParameterRGB FactorAlpha 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/A
In 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 external documentation.
multiDrawArrays(Mode, First, Count) -> ok
Types:
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 external documentation.
pointParameterf(Pname, Param) -> ok
Types:
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 external documentation.
pointParameterfv(Pname, Params) -> ok
Types:
Pname = enum()
Params = tuple()
See pointParameterf/2
pointParameteri(Pname, Param) -> ok
Types:
Pname = enum()
Param = integer()
See pointParameterf/2
pointParameteriv(Pname, Params) -> ok
Types:
Pname = enum()
Params = tuple()
See pointParameterf/2
fogCoordf(Coord) -> ok
Types:
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 external documentation.
fogCoordfv(Coord) -> ok
Types:
Coord = {Coord::float()}
Equivalent to fogCoordf(Coord).
fogCoordd(Coord) -> ok
Types:
Coord = float()
See fogCoordf/1
fogCoorddv(Coord) -> ok
Types:
Coord = {Coord::float()}
Equivalent to fogCoordd(Coord).
fogCoordPointer(Type, Stride, Pointer) -> ok
Types:
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 external documentation.
secondaryColor3b(Red, Green, Blue) -> ok
Types:
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 external documentation.
secondaryColor3bv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3b(Red, Green, Blue).
secondaryColor3d(Red, Green, Blue) -> ok
Types:
Red = float()
Green = float()
Blue = float()
See secondaryColor3b/3
secondaryColor3dv(V) -> ok
Types:
V = {Red::float(), Green::float(), Blue::float()}
Equivalent to secondaryColor3d(Red, Green, Blue).
secondaryColor3f(Red, Green, Blue) -> ok
Types:
Red = float()
Green = float()
Blue = float()
See secondaryColor3b/3
secondaryColor3fv(V) -> ok
Types:
V = {Red::float(), Green::float(), Blue::float()}
Equivalent to secondaryColor3f(Red, Green, Blue).
secondaryColor3i(Red, Green, Blue) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
See secondaryColor3b/3
secondaryColor3iv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3i(Red, Green, Blue).
secondaryColor3s(Red, Green, Blue) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
See secondaryColor3b/3
secondaryColor3sv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3s(Red, Green, Blue).
secondaryColor3ub(Red, Green, Blue) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
See secondaryColor3b/3
secondaryColor3ubv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3ub(Red, Green, Blue).
secondaryColor3ui(Red, Green, Blue) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
See secondaryColor3b/3
secondaryColor3uiv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3ui(Red, Green, Blue).
secondaryColor3us(Red, Green, Blue) -> ok
Types:
Red = integer()
Green = integer()
Blue = integer()
See secondaryColor3b/3
secondaryColor3usv(V) -> ok
Types:
V = {Red::integer(), Green::integer(), Blue::integer()}
Equivalent to secondaryColor3us(Red, Green, Blue).
secondaryColorPointer(Size, Type, Stride, Pointer) -> ok
Types:
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 external documentation.
windowPos2d(X, Y) -> ok
Types:
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 external documentation.
windowPos2dv(V) -> ok
Types:
V = {X::float(), Y::float()}
Equivalent to windowPos2d(X, Y).
windowPos2f(X, Y) -> ok
Types:
X = float()
Y = float()
See windowPos2d/2
windowPos2fv(V) -> ok
Types:
V = {X::float(), Y::float()}
Equivalent to windowPos2f(X, Y).
windowPos2i(X, Y) -> ok
Types:
X = integer()
Y = integer()
See windowPos2d/2
windowPos2iv(V) -> ok
Types:
V = {X::integer(), Y::integer()}
Equivalent to windowPos2i(X, Y).
windowPos2s(X, Y) -> ok
Types:
X = integer()
Y = integer()
See windowPos2d/2
windowPos2sv(V) -> ok
Types:
V = {X::integer(), Y::integer()}
Equivalent to windowPos2s(X, Y).
windowPos3d(X, Y, Z) -> ok
Types:
X = float()
Y = float()
Z = float()
See windowPos2d/2
windowPos3dv(V) -> ok
Types:
V = {X::float(), Y::float(), Z::float()}
Equivalent to windowPos3d(X, Y, Z).
windowPos3f(X, Y, Z) -> ok
Types:
X = float()
Y = float()
Z = float()
See windowPos2d/2
windowPos3fv(V) -> ok
Types:
V = {X::float(), Y::float(), Z::float()}
Equivalent to windowPos3f(X, Y, Z).
windowPos3i(X, Y, Z) -> ok
Types:
X = integer()
Y = integer()
Z = integer()
See windowPos2d/2
windowPos3iv(V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to windowPos3i(X, Y, Z).
windowPos3s(X, Y, Z) -> ok
Types:
X = integer()
Y = integer()
Z = integer()
See windowPos2d/2
windowPos3sv(V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to windowPos3s(X, Y, Z).
genQueries(N) -> [integer()]
Types:
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 external documentation.
deleteQueries(Ids) -> ok
Types:
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 external documentation.
isQuery(Id) -> 0 | 1
Types:
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 external documentation.
beginQuery(Target, Id) -> ok
Types:
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 external documentation.
endQuery(Target) -> ok
Types:
Target = enum()
See beginQuery/2
getQueryiv(Target, Pname) -> integer()
Types:
Target = enum()
Pname = enum()
glGetQuery
See external documentation.
getQueryObjectiv(Id, Pname) -> integer()
Types:
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 external documentation.
getQueryObjectuiv(Id, Pname) -> integer()
Types:
Id = integer()
Pname = enum()
See getQueryObjectiv/2
bindBuffer(Target, Buffer) -> ok
Types:
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 external documentation.
deleteBuffers(Buffers) -> ok
Types:
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 external documentation.
genBuffers(N) -> [integer()]
Types:
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 external documentation.
isBuffer(Buffer) -> 0 | 1
Types:
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 external documentation.
bufferData(Target, Size, Data, Usage) -> ok
Types:
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 external documentation.
bufferSubData(Target, Offset, Size, Data) -> ok
Types:
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 external documentation.
getBufferSubData(Target, Offset, Size, Data) -> ok
Types:
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 external documentation.
getBufferParameteriv(Target, Pname) -> integer()
Types:
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 external documentation.
blendEquationSeparate(ModeRGB, ModeAlpha) -> ok
Types:
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].ModeRGB ComponentsAlpha 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 external documentation.
drawBuffers(Bufs) -> ok
Types:
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_ATTACHMENTn: The fragment shader output value is written into the nth 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 external documentation.
stencilOpSeparate(Face, Sfail, Dpfail, Dppass) -> ok
Types:
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 external documentation.
stencilFuncSeparate(Face, Func, Ref, Mask) -> ok
Types:
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 external documentation.
stencilMaskSeparate(Face, Mask) -> ok
Types:
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 external documentation.
attachShader(Program, Shader) -> ok
Types:
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 external documentation.
bindAttribLocation(Program, Index, Name) -> ok
Types:
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 external documentation.
compileShader(Shader) -> ok
Types:
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 external documentation.
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 external documentation.
createShader(Type) -> integer()
Types:
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 external documentation.
deleteProgram(Program) -> ok
Types:
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 external documentation.
deleteShader(Shader) -> ok
Types:
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 external documentation.
detachShader(Program, Shader) -> ok
Types:
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 external documentation.
disableVertexAttribArray(Index) -> ok
Types:
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 external documentation.
enableVertexAttribArray(Index) -> ok
Types:
Index = integer()
See disableVertexAttribArray/1
getActiveAttrib(Program, Index, BufSize) -> {Size::integer(), Type::enum(), Name::string()}
Types:
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 external documentation.
getActiveUniform(Program, Index, BufSize) -> {Size::integer(), Type::enum(), Name::string()}
Types:
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 ContantShader
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 external documentation.
getAttachedShaders(Program, MaxCount) -> [integer()]
Types:
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 external documentation.
getAttribLocation(Program, Name) -> integer()
Types:
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 external documentation.
getProgramiv(Program, Pname) -> integer()
Types:
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 external documentation.
getProgramInfoLog(Program, BufSize) -> string()
Types:
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 external documentation.
getShaderiv(Shader, Pname) -> integer()
Types:
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 external documentation.
getShaderInfoLog(Shader, BufSize) -> string()
Types:
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 external documentation.
getShaderSource(Shader, BufSize) -> string()
Types:
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 external documentation.
getUniformLocation(Program, Name) -> integer()
Types:
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 external documentation.
getUniformfv(Program, Location) -> matrix()
Types:
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 external documentation.
getUniformiv(Program, Location) -> {integer(), integer(), integer(), integer(), integer(), integer(),
integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(),
integer()}
Types:
Program = integer()
Location = integer()
See getUniformfv/2
getVertexAttribdv(Index, Pname) -> {float(), float(), float(), float()}
Types:
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 external documentation.
getVertexAttribfv(Index, Pname) -> {float(), float(), float(), float()}
Types:
Index = integer()
Pname = enum()
See getVertexAttribdv/2
getVertexAttribiv(Index, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Index = integer()
Pname = enum()
See getVertexAttribdv/2
isProgram(Program) -> 0 | 1
Types:
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 external documentation.
isShader(Shader) -> 0 | 1
Types:
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 external documentation.
linkProgram(Program) -> ok
Types:
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 external documentation.
shaderSource(Shader, String) -> ok
Types:
Shader = integer()
String = iolist()
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 external documentation.
useProgram(Program) -> ok
Types:
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 external documentation.
uniform1f(Location, V0) -> ok
Types:
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 external documentation.
uniform2f(Location, V0, V1) -> ok
Types:
Location = integer()
V0 = float()
V1 = float()
See uniform1f/2
uniform3f(Location, V0, V1, V2) -> ok
Types:
Location = integer()
V0 = float()
V1 = float()
V2 = float()
See uniform1f/2
uniform4f(Location, V0, V1, V2, V3) -> ok
Types:
Location = integer()
V0 = float()
V1 = float()
V2 = float()
V3 = float()
See uniform1f/2
uniform1i(Location, V0) -> ok
Types:
Location = integer()
V0 = integer()
See uniform1f/2
uniform2i(Location, V0, V1) -> ok
Types:
Location = integer()
V0 = integer()
V1 = integer()
See uniform1f/2
uniform3i(Location, V0, V1, V2) -> ok
Types:
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
See uniform1f/2
uniform4i(Location, V0, V1, V2, V3) -> ok
Types:
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
V3 = integer()
See uniform1f/2
uniform1fv(Location, Value) -> ok
Types:
Location = integer()
Value = [float()]
See uniform1f/2
uniform2fv(Location, Value) -> ok
Types:
Location = integer()
Value = [{float(), float()}]
See uniform1f/2
uniform3fv(Location, Value) -> ok
Types:
Location = integer()
Value = [{float(), float(), float()}]
See uniform1f/2
uniform4fv(Location, Value) -> ok
Types:
Location = integer()
Value = [{float(), float(), float(), float()}]
See uniform1f/2
uniform1iv(Location, Value) -> ok
Types:
Location = integer()
Value = [integer()]
See uniform1f/2
uniform2iv(Location, Value) -> ok
Types:
Location = integer()
Value = [{integer(), integer()}]
See uniform1f/2
uniform3iv(Location, Value) -> ok
Types:
Location = integer()
Value = [{integer(), integer(), integer()}]
See uniform1f/2
uniform4iv(Location, Value) -> ok
Types:
Location = integer()
Value = [{integer(), integer(), integer(), integer()}]
See uniform1f/2
uniformMatrix2fv(Location, Transpose, Value) -> ok
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3fv(Location, Transpose, Value) -> ok
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix4fv(Location, Transpose, Value) -> ok
Types:
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
Types:
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 external documentation.
vertexAttrib1d(Index, X) -> ok
Types:
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 external documentation.
vertexAttrib1dv(Index::integer(), V) -> ok
Types:
V = {X::float()}
Equivalent to vertexAttrib1d(Index, X).
vertexAttrib1f(Index, X) -> ok
Types:
Index = integer()
X = float()
See vertexAttrib1d/2
vertexAttrib1fv(Index::integer(), V) -> ok
Types:
V = {X::float()}
Equivalent to vertexAttrib1f(Index, X).
vertexAttrib1s(Index, X) -> ok
Types:
Index = integer()
X = integer()
See vertexAttrib1d/2
vertexAttrib1sv(Index::integer(), V) -> ok
Types:
V = {X::integer()}
Equivalent to vertexAttrib1s(Index, X).
vertexAttrib2d(Index, X, Y) -> ok
Types:
Index = integer()
X = float()
Y = float()
See vertexAttrib1d/2
vertexAttrib2dv(Index::integer(), V) -> ok
Types:
V = {X::float(), Y::float()}
Equivalent to vertexAttrib2d(Index, X, Y).
vertexAttrib2f(Index, X, Y) -> ok
Types:
Index = integer()
X = float()
Y = float()
See vertexAttrib1d/2
vertexAttrib2fv(Index::integer(), V) -> ok
Types:
V = {X::float(), Y::float()}
Equivalent to vertexAttrib2f(Index, X, Y).
vertexAttrib2s(Index, X, Y) -> ok
Types:
Index = integer()
X = integer()
Y = integer()
See vertexAttrib1d/2
vertexAttrib2sv(Index::integer(), V) -> ok
Types:
V = {X::integer(), Y::integer()}
Equivalent to vertexAttrib2s(Index, X, Y).
vertexAttrib3d(Index, X, Y, Z) -> ok
Types:
Index = integer()
X = float()
Y = float()
Z = float()
See vertexAttrib1d/2
vertexAttrib3dv(Index::integer(), V) -> ok
Types:
V = {X::float(), Y::float(), Z::float()}
Equivalent to vertexAttrib3d(Index, X, Y, Z).
vertexAttrib3f(Index, X, Y, Z) -> ok
Types:
Index = integer()
X = float()
Y = float()
Z = float()
See vertexAttrib1d/2
vertexAttrib3fv(Index::integer(), V) -> ok
Types:
V = {X::float(), Y::float(), Z::float()}
Equivalent to vertexAttrib3f(Index, X, Y, Z).
vertexAttrib3s(Index, X, Y, Z) -> ok
Types:
Index = integer()
X = integer()
Y = integer()
Z = integer()
See vertexAttrib1d/2
vertexAttrib3sv(Index::integer(), V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to vertexAttrib3s(Index, X, Y, Z).
vertexAttrib4Nbv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4Niv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4Nsv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4Nub(Index, X, Y, Z, W) -> ok
Types:
Index = integer()
X = integer()
Y = integer()
Z = integer()
W = integer()
See vertexAttrib1d/2
vertexAttrib4Nubv(Index::integer(), V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertexAttrib4Nub(Index, X, Y, Z, W).
vertexAttrib4Nuiv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4Nusv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4bv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4d(Index, X, Y, Z, W) -> ok
Types:
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
See vertexAttrib1d/2
vertexAttrib4dv(Index::integer(), V) -> ok
Types:
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to vertexAttrib4d(Index, X, Y, Z, W).
vertexAttrib4f(Index, X, Y, Z, W) -> ok
Types:
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
See vertexAttrib1d/2
vertexAttrib4fv(Index::integer(), V) -> ok
Types:
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to vertexAttrib4f(Index, X, Y, Z, W).
vertexAttrib4iv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4s(Index, X, Y, Z, W) -> ok
Types:
Index = integer()
X = integer()
Y = integer()
Z = integer()
W = integer()
See vertexAttrib1d/2
vertexAttrib4sv(Index::integer(), V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertexAttrib4s(Index, X, Y, Z, W).
vertexAttrib4ubv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4uiv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttrib4usv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttribPointer(Index, Size, Type, Normalized, Stride, Pointer) -> ok
Types:
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 external documentation.
uniformMatrix2x3fv(Location, Transpose, Value) -> ok
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3x2fv(Location, Transpose, Value) -> ok
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix2x4fv(Location, Transpose, Value) -> ok
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix4x2fv(Location, Transpose, Value) -> ok
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3x4fv(Location, Transpose, Value) -> ok
Types:
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
Types:
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
Types:
Index = integer()
R = 0 | 1
G = 0 | 1
B = 0 | 1
A = 0 | 1
glColorMaski
See external documentation.
getBooleani_v(Target, Index) -> [0 | 1]
Types:
Target = enum()
Index = integer()
See getBooleanv/1
getIntegeri_v(Target, Index) -> [integer()]
Types:
Target = enum()
Index = integer()
See getBooleanv/1
enablei(Target, Index) -> ok
Types:
Target = enum()
Index = integer()
See enable/1
disablei(Target, Index) -> ok
Types:
Target = enum()
Index = integer()
glEnablei
See external documentation.
isEnabledi(Target, Index) -> 0 | 1
Types:
Target = enum()
Index = integer()
glIsEnabledi
See external documentation.
beginTransformFeedback(PrimitiveMode) -> ok
Types:
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
FeedbackPrimitiveModeAllowed Render PrimitiveModes
?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 FeedbackPrimitiveModeAllowed Geometry Shader
Output Primitive Type
?GL_POINTS?points
?GL_LINES?line_strip
?GL_TRIANGLES?triangle_strip
See external documentation.
endTransformFeedback() -> ok
See beginTransformFeedback/1
bindBufferRange(Target, Index, Buffer, Offset, Size) -> ok
Types:
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 external documentation.
bindBufferBase(Target, Index, Buffer) -> ok
Types:
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 external documentation.
transformFeedbackVaryings(Program, Varyings, BufferMode) -> ok
Types:
Program = integer()
Varyings = iolist()
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 external documentation.
getTransformFeedbackVarying(Program, Index, BufSize) -> {Size::integer(), Type::enum(), Name::string()}
Types:
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 external documentation.
clampColor(Target, Clamp) -> ok
Types:
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 external documentation.
beginConditionalRender(Id, Mode) -> ok
Types:
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 external documentation.
endConditionalRender() -> ok
See beginConditionalRender/2
vertexAttribIPointer(Index, Size, Type, Stride, Pointer) -> ok
Types:
Index = integer()
Size = integer()
Type = enum()
Stride = integer()
Pointer = offset() | mem()
glVertexAttribIPointer
See external documentation.
getVertexAttribIiv(Index, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Index = integer()
Pname = enum()
See getVertexAttribdv/2
getVertexAttribIuiv(Index, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Index = integer()
Pname = enum()
glGetVertexAttribI
See external documentation.
vertexAttribI1i(Index, X) -> ok
Types:
Index = integer()
X = integer()
See vertexAttrib1d/2
vertexAttribI2i(Index, X, Y) -> ok
Types:
Index = integer()
X = integer()
Y = integer()
See vertexAttrib1d/2
vertexAttribI3i(Index, X, Y, Z) -> ok
Types:
Index = integer()
X = integer()
Y = integer()
Z = integer()
See vertexAttrib1d/2
vertexAttribI4i(Index, X, Y, Z, W) -> ok
Types:
Index = integer()
X = integer()
Y = integer()
Z = integer()
W = integer()
See vertexAttrib1d/2
vertexAttribI1ui(Index, X) -> ok
Types:
Index = integer()
X = integer()
See vertexAttrib1d/2
vertexAttribI2ui(Index, X, Y) -> ok
Types:
Index = integer()
X = integer()
Y = integer()
See vertexAttrib1d/2
vertexAttribI3ui(Index, X, Y, Z) -> ok
Types:
Index = integer()
X = integer()
Y = integer()
Z = integer()
See vertexAttrib1d/2
vertexAttribI4ui(Index, X, Y, Z, W) -> ok
Types:
Index = integer()
X = integer()
Y = integer()
Z = integer()
W = integer()
See vertexAttrib1d/2
vertexAttribI1iv(Index::integer(), V) -> ok
Types:
V = {X::integer()}
Equivalent to vertexAttribI1i(Index, X).
vertexAttribI2iv(Index::integer(), V) -> ok
Types:
V = {X::integer(), Y::integer()}
Equivalent to vertexAttribI2i(Index, X, Y).
vertexAttribI3iv(Index::integer(), V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to vertexAttribI3i(Index, X, Y, Z).
vertexAttribI4iv(Index::integer(), V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertexAttribI4i(Index, X, Y, Z, W).
vertexAttribI1uiv(Index::integer(), V) -> ok
Types:
V = {X::integer()}
Equivalent to vertexAttribI1ui(Index, X).
vertexAttribI2uiv(Index::integer(), V) -> ok
Types:
V = {X::integer(), Y::integer()}
Equivalent to vertexAttribI2ui(Index, X, Y).
vertexAttribI3uiv(Index::integer(), V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer()}
Equivalent to vertexAttribI3ui(Index, X, Y, Z).
vertexAttribI4uiv(Index::integer(), V) -> ok
Types:
V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
Equivalent to vertexAttribI4ui(Index, X, Y, Z, W).
vertexAttribI4bv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttribI4sv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttribI4ubv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
See vertexAttrib1d/2
vertexAttribI4usv(Index, V) -> ok
Types:
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()}
Types:
Program = integer()
Location = integer()
See getUniformfv/2
bindFragDataLocation(Program, Color, Name) -> ok
Types:
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 external documentation.
getFragDataLocation(Program, Name) -> integer()
Types:
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 external documentation.
uniform1ui(Location, V0) -> ok
Types:
Location = integer()
V0 = integer()
See uniform1f/2
uniform2ui(Location, V0, V1) -> ok
Types:
Location = integer()
V0 = integer()
V1 = integer()
See uniform1f/2
uniform3ui(Location, V0, V1, V2) -> ok
Types:
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
See uniform1f/2
uniform4ui(Location, V0, V1, V2, V3) -> ok
Types:
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
V3 = integer()
See uniform1f/2
uniform1uiv(Location, Value) -> ok
Types:
Location = integer()
Value = [integer()]
See uniform1f/2
uniform2uiv(Location, Value) -> ok
Types:
Location = integer()
Value = [{integer(), integer()}]
See uniform1f/2
uniform3uiv(Location, Value) -> ok
Types:
Location = integer()
Value = [{integer(), integer(), integer()}]
See uniform1f/2
uniform4uiv(Location, Value) -> ok
Types:
Location = integer()
Value = [{integer(), integer(), integer(), integer()}]
See uniform1f/2
texParameterIiv(Target, Pname, Params) -> ok
Types:
Target = enum()
Pname = enum()
Params = tuple()
See texParameterf/3
texParameterIuiv(Target, Pname, Params) -> ok
Types:
Target = enum()
Pname = enum()
Params = tuple()
glTexParameterI
See external documentation.
getTexParameterIiv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Target = enum()
Pname = enum()
See getTexParameterfv/2
getTexParameterIuiv(Target, Pname) -> {integer(), integer(), integer(), integer()}
Types:
Target = enum()
Pname = enum()
glGetTexParameterI
See external documentation.
clearBufferiv(Buffer, Drawbuffer, Value) -> ok
Types:
Buffer = enum()
Drawbuffer = integer()
Value = tuple()
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 external documentation.
clearBufferuiv(Buffer, Drawbuffer, Value) -> ok
Types:
Buffer = enum()
Drawbuffer = integer()
Value = tuple()
See clearBufferiv/3
clearBufferfv(Buffer, Drawbuffer, Value) -> ok
Types:
Buffer = enum()
Drawbuffer = integer()
Value = tuple()
See clearBufferiv/3
clearBufferfi(Buffer, Drawbuffer, Depth, Stencil) -> ok
Types:
Buffer = enum()
Drawbuffer = integer()
Depth = float()
Stencil = integer()
glClearBufferfi
See external documentation.
getStringi(Name, Index) -> string()
Types:
Name = enum()
Index = integer()
See getString/1
drawArraysInstanced(Mode, First, Count, Primcount) -> ok
Types:
Mode = enum()
First = integer()
Count = integer()
Primcount = integer()
glDrawArraysInstance
See external documentation.
drawElementsInstanced(Mode, Count, Type, Indices, Primcount) -> ok
Types:
Mode = enum()
Count = integer()
Type = enum()
Indices = offset() | mem()
Primcount = integer()
glDrawElementsInstance
See external documentation.
texBuffer(Target, Internalformat, Buffer) -> ok
Types:
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 FormatBase TypeComponentsNorm0123
?GL_R8ubyte1YESR00 1
?GL_R16ushort1YESR 001
?GL_R16Fhalf1NO R001
?GL_R32Ffloat 1NOR001
?GL_R8I byte1NOR001
?GL_R16I short1NOR001
?GL_R32Iint1NOR001
?GL_R8UIubyte1NOR0 01
?GL_R16UIushort1NO R001
?GL_R32UIuint1 NOR001
?GL_RG8ubyte 2YESRG01
?GL_RG16 ushort2YESRG01
?GL_RG16Fhalf2NORG0 1
?GL_RG32Ffloat2NORG 01
?GL_RG8Ibyte2NO RG01
?GL_RG16Ishort 2NORG01
?GL_RG32I int2NORG01
?GL_RG8UI ubyte2NORG01
?GL_RG16UIushort2NORG0 1
?GL_RG32UIuint2NORG 01
?GL_RGB32Ffloat3NO RGB1
?GL_RGB32Iint 3NORGB1
?GL_RGB32UI uint3NORGB1
?GL_RGBA8uint4YESRGB A
?GL_RGBA16short4YESR GBA
?GL_RGBA16Fhalf4NO RGBA
?GL_RGBA32Ffloat 4NORGBA
?GL_RGBA8I byte4NORGBA
?GL_RGBA16Ishort4NORGB A
?GL_RGBA32Iint4NORG BA
?GL_RGBA8UIubyte4NO RGBA
?GL_RGBA16UIushort 4NORGBA
?GL_RGBA32UI uint4NORGBA
When 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 external documentation.
primitiveRestartIndex(Index) -> ok
Types:
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 external documentation.
getInteger64i_v(Target, Index) -> [integer()]
Types:
Target = enum()
Index = integer()
See getBooleanv/1
getBufferParameteri64v(Target, Pname) -> [integer()]
Types:
Target = enum()
Pname = enum()
glGetBufferParameteri64v
See external documentation.
framebufferTexture(Target, Attachment, Texture, Level) -> ok
Types:
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_ATTACHMENTi 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_ATTACHMENTand 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 external documentation.
vertexAttribDivisor(Index, Divisor) -> ok
Types:
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 external documentation.
minSampleShading(Value) -> ok
Types:
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 external documentation.
blendEquationi(Buf, Mode) -> ok
Types:
Buf = integer()
Mode = enum()
See blendEquation/1
blendEquationSeparatei(Buf, ModeRGB, ModeAlpha) -> ok
Types:
Buf = integer()
ModeRGB = enum()
ModeAlpha = enum()
See blendEquationSeparate/2
blendFunci(Buf, Src, Dst) -> ok
Types:
Buf = integer()
Src = enum()
Dst = enum()
glBlendFunci
See external documentation.
blendFuncSeparatei(Buf, SrcRGB, DstRGB, SrcAlpha, DstAlpha) -> ok
Types:
Buf = integer()
SrcRGB = enum()
DstRGB = enum()
SrcAlpha = enum()
DstAlpha = enum()
See blendFuncSeparate/4
loadTransposeMatrixfARB(M) -> ok
Types:
M = matrix()
glLoadTransposeMatrixARB
See external documentation.
loadTransposeMatrixdARB(M) -> ok
Types:
M = matrix()
glLoadTransposeMatrixARB
See external documentation.
multTransposeMatrixfARB(M) -> ok
Types:
M = matrix()
glMultTransposeMatrixARB
See external documentation.
multTransposeMatrixdARB(M) -> ok
Types:
M = matrix()
glMultTransposeMatrixARB
See external documentation.
weightbvARB(Weights) -> ok
Types:
Weights = [integer()]
glWeightARB
See external documentation.
weightsvARB(Weights) -> ok
Types:
Weights = [integer()]
glWeightARB
See external documentation.
weightivARB(Weights) -> ok
Types:
Weights = [integer()]
glWeightARB
See external documentation.
weightfvARB(Weights) -> ok
Types:
Weights = [float()]
glWeightARB
See external documentation.
weightdvARB(Weights) -> ok
Types:
Weights = [float()]
glWeightARB
See external documentation.
weightubvARB(Weights) -> ok
Types:
Weights = [integer()]
glWeightARB
See external documentation.
weightusvARB(Weights) -> ok
Types:
Weights = [integer()]
glWeightARB
See external documentation.
weightuivARB(Weights) -> ok
Types:
Weights = [integer()]
glWeightARB
See external documentation.
vertexBlendARB(Count) -> ok
Types:
Count = integer()
glVertexBlenARB
See external documentation.
currentPaletteMatrixARB(Index) -> ok
Types:
Index = integer()
glCurrentPaletteMatrixARB
See external documentation.
matrixIndexubvARB(Indices) -> ok
Types:
Indices = [integer()]
glMatrixIndexARB
See external documentation.
matrixIndexusvARB(Indices) -> ok
Types:
Indices = [integer()]
glMatrixIndexARB
See external documentation.
matrixIndexuivARB(Indices) -> ok
Types:
Indices = [integer()]
glMatrixIndexARB
See external documentation.
programStringARB(Target, Format, String) -> ok
Types:
Target = enum()
Format = enum()
String = string()
glProgramStringARB
See external documentation.
bindProgramARB(Target, Program) -> ok
Types:
Target = enum()
Program = integer()
glBindProgramARB
See external documentation.
deleteProgramsARB(Programs) -> ok
Types:
Programs = [integer()]
glDeleteProgramsARB
See external documentation.
genProgramsARB(N) -> [integer()]
Types:
N = integer()
glGenProgramsARB
See external documentation.
programEnvParameter4dARB(Target, Index, X, Y, Z, W) -> ok
Types:
Target = enum()
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
glProgramEnvParameterARB
See external documentation.
programEnvParameter4dvARB(Target, Index, Params) -> ok
Types:
Target = enum()
Index = integer()
Params = {float(), float(), float(), float()}
glProgramEnvParameterARB
See external documentation.
programEnvParameter4fARB(Target, Index, X, Y, Z, W) -> ok
Types:
Target = enum()
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
glProgramEnvParameterARB
See external documentation.
programEnvParameter4fvARB(Target, Index, Params) -> ok
Types:
Target = enum()
Index = integer()
Params = {float(), float(), float(), float()}
glProgramEnvParameterARB
See external documentation.
programLocalParameter4dARB(Target, Index, X, Y, Z, W) -> ok
Types:
Target = enum()
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
glProgramLocalParameterARB
See external documentation.
programLocalParameter4dvARB(Target, Index, Params) -> ok
Types:
Target = enum()
Index = integer()
Params = {float(), float(), float(), float()}
glProgramLocalParameterARB
See external documentation.
programLocalParameter4fARB(Target, Index, X, Y, Z, W) -> ok
Types:
Target = enum()
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
glProgramLocalParameterARB
See external documentation.
programLocalParameter4fvARB(Target, Index, Params) -> ok
Types:
Target = enum()
Index = integer()
Params = {float(), float(), float(), float()}
glProgramLocalParameterARB
See external documentation.
getProgramEnvParameterdvARB(Target, Index) -> {float(), float(), float(), float()}
Types:
Target = enum()
Index = integer()
glGetProgramEnvParameterARB
See external documentation.
getProgramEnvParameterfvARB(Target, Index) -> {float(), float(), float(), float()}
Types:
Target = enum()
Index = integer()
glGetProgramEnvParameterARB
See external documentation.
getProgramLocalParameterdvARB(Target, Index) -> {float(), float(), float(), float()}
Types:
Target = enum()
Index = integer()
glGetProgramLocalParameterARB
See external documentation.
getProgramLocalParameterfvARB(Target, Index) -> {float(), float(), float(), float()}
Types:
Target = enum()
Index = integer()
glGetProgramLocalParameterARB
See external documentation.
getProgramStringARB(Target, Pname, String) -> ok
Types:
Target = enum()
Pname = enum()
String = mem()
glGetProgramStringARB
See external documentation.
getBufferParameterivARB(Target, Pname) -> [integer()]
Types:
Target = enum()
Pname = enum()
glGetBufferParameterARB
See external documentation.
deleteObjectARB(Obj) -> ok
Types:
Obj = integer()
glDeleteObjectARB
See external documentation.
getHandleARB(Pname) -> integer()
Types:
Pname = enum()
glGetHandleARB
See external documentation.
detachObjectARB(ContainerObj, AttachedObj) -> ok
Types:
ContainerObj = integer()
AttachedObj = integer()
glDetachObjectARB
See external documentation.
createShaderObjectARB(ShaderType) -> integer()
Types:
ShaderType = enum()
glCreateShaderObjectARB
See external documentation.
shaderSourceARB(ShaderObj, String) -> ok
Types:
ShaderObj = integer()
String = iolist()
glShaderSourceARB
See external documentation.
compileShaderARB(ShaderObj) -> ok
Types:
ShaderObj = integer()
glCompileShaderARB
See external documentation.
createProgramObjectARB() -> integer()
glCreateProgramObjectARB
See external documentation.
attachObjectARB(ContainerObj, Obj) -> ok
Types:
ContainerObj = integer()
Obj = integer()
glAttachObjectARB
See external documentation.
linkProgramARB(ProgramObj) -> ok
Types:
ProgramObj = integer()
glLinkProgramARB
See external documentation.
useProgramObjectARB(ProgramObj) -> ok
Types:
ProgramObj = integer()
glUseProgramObjectARB
See external documentation.
validateProgramARB(ProgramObj) -> ok
Types:
ProgramObj = integer()
glValidateProgramARB
See external documentation.
getObjectParameterfvARB(Obj, Pname) -> float()
Types:
Obj = integer()
Pname = enum()
glGetObjectParameterARB
See external documentation.
getObjectParameterivARB(Obj, Pname) -> integer()
Types:
Obj = integer()
Pname = enum()
glGetObjectParameterARB
See external documentation.
getInfoLogARB(Obj, MaxLength) -> string()
Types:
Obj = integer()
MaxLength = integer()
glGetInfoLogARB
See external documentation.
getAttachedObjectsARB(ContainerObj, MaxCount) -> [integer()]
Types:
ContainerObj = integer()
MaxCount = integer()
glGetAttachedObjectsARB
See external documentation.
getUniformLocationARB(ProgramObj, Name) -> integer()
Types:
ProgramObj = integer()
Name = string()
glGetUniformLocationARB
See external documentation.
getActiveUniformARB(ProgramObj, Index, MaxLength) -> {Size::integer(), Type::enum(), Name::string()}
Types:
ProgramObj = integer()
Index = integer()
MaxLength = integer()
glGetActiveUniformARB
See external documentation.
getUniformfvARB(ProgramObj, Location) -> matrix()
Types:
ProgramObj = integer()
Location = integer()
glGetUniformARB
See external documentation.
getUniformivARB(ProgramObj, Location) -> {integer(), integer(), integer(), integer(), integer(),
integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(),
integer(), integer()}
Types:
ProgramObj = integer()
Location = integer()
glGetUniformARB
See external documentation.
getShaderSourceARB(Obj, MaxLength) -> string()
Types:
Obj = integer()
MaxLength = integer()
glGetShaderSourceARB
See external documentation.
bindAttribLocationARB(ProgramObj, Index, Name) -> ok
Types:
ProgramObj = integer()
Index = integer()
Name = string()
glBindAttribLocationARB
See external documentation.
getActiveAttribARB(ProgramObj, Index, MaxLength) -> {Size::integer(), Type::enum(), Name::string()}
Types:
ProgramObj = integer()
Index = integer()
MaxLength = integer()
glGetActiveAttribARB
See external documentation.
getAttribLocationARB(ProgramObj, Name) -> integer()
Types:
ProgramObj = integer()
Name = string()
glGetAttribLocationARB
See external documentation.
isRenderbuffer(Renderbuffer) -> 0 | 1
Types:
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 external documentation.
bindRenderbuffer(Target, Renderbuffer) -> ok
Types:
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 external documentation.
deleteRenderbuffers(Renderbuffers) -> ok
Types:
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 external documentation.
genRenderbuffers(N) -> [integer()]
Types:
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 external documentation.
renderbufferStorage(Target, Internalformat, Width, Height) -> ok
Types:
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 external documentation.
getRenderbufferParameteriv(Target, Pname) -> integer()
Types:
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 external documentation.
isFramebuffer(Framebuffer) -> 0 | 1
Types:
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 external documentation.
bindFramebuffer(Target, Framebuffer) -> ok
Types:
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 external documentation.
deleteFramebuffers(Framebuffers) -> ok
Types:
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 external documentation.
genFramebuffers(N) -> [integer()]
Types:
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 external documentation.
checkFramebufferStatus(Target) -> enum()
Types:
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 external documentation.
framebufferTexture1D(Target, Attachment, Textarget, Texture, Level) -> ok
Types:
Target = enum()
Attachment = enum()
Textarget = enum()
Texture = integer()
Level = integer()
See framebufferTexture/4
framebufferTexture2D(Target, Attachment, Textarget, Texture, Level) -> ok
Types:
Target = enum()
Attachment = enum()
Textarget = enum()
Texture = integer()
Level = integer()
See framebufferTexture/4
framebufferTexture3D(Target, Attachment, Textarget, Texture, Level, Zoffset) -> ok
Types:
Target = enum()
Attachment = enum()
Textarget = enum()
Texture = integer()
Level = integer()
Zoffset = integer()
See framebufferTexture/4
framebufferRenderbuffer(Target, Attachment, Renderbuffertarget, Renderbuffer) -> ok
Types:
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 external documentation.
getFramebufferAttachmentParameteriv(Target, Attachment, Pname) -> integer()
Types:
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_ATTACHMENTi 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 external documentation.
generateMipmap(Target) -> ok
Types:
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 external documentation.
blitFramebuffer(SrcX0, SrcY0, SrcX1, SrcY1, DstX0, DstY0, DstX1, DstY1, Mask, Filter) -> ok
Types:
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 external documentation.
renderbufferStorageMultisample(Target, Samples, Internalformat, Width, Height) -> ok
Types:
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 external documentation.
framebufferTextureLayer(Target, Attachment, Texture, Level, Layer) -> ok
Types:
Target = enum()
Attachment = enum()
Texture = integer()
Level = integer()
Layer = integer()
See framebufferTexture/4
framebufferTextureFaceARB(Target, Attachment, Texture, Level, Face) -> ok
Types:
Target = enum()
Attachment = enum()
Texture = integer()
Level = integer()
Face = enum()
See framebufferTexture/4
flushMappedBufferRange(Target, Offset, Length) -> ok
Types:
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 external documentation.
bindVertexArray(Array) -> ok
Types:
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 external documentation.
deleteVertexArrays(Arrays) -> ok
Types:
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 external documentation.
genVertexArrays(N) -> [integer()]
Types:
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 external documentation.
isVertexArray(Array) -> 0 | 1
Types:
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 external documentation.
getUniformIndices(Program, UniformNames) -> [integer()]
Types:
Program = integer()
UniformNames = iolist()
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 external documentation.
getActiveUniformsiv(Program, UniformIndices, Pname) -> [integer()]
Types:
Program = integer()
UniformIndices = [integer()]
Pname = enum()
glGetActiveUniforms
See external documentation.
getActiveUniformName(Program, UniformIndex, BufSize) -> string()
Types:
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 external documentation.
getUniformBlockIndex(Program, UniformBlockName) -> integer()
Types:
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 external documentation.
getActiveUniformBlockiv(Program, UniformBlockIndex, Pname, Params) -> ok
Types:
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 external documentation.
getActiveUniformBlockName(Program, UniformBlockIndex, BufSize) -> string()
Types:
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 external documentation.
uniformBlockBinding(Program, UniformBlockIndex, UniformBlockBinding) -> ok
Types:
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 external documentation.
copyBufferSubData(ReadTarget, WriteTarget, ReadOffset, WriteOffset, Size) -> ok
Types:
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 external documentation.
drawElementsBaseVertex(Mode, Count, Type, Indices, Basevertex) -> ok
Types:
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 ith 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 external documentation.
drawRangeElementsBaseVertex(Mode, Start, End, Count, Type, Indices, Basevertex) -> ok
Types:
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 external documentation.
drawElementsInstancedBaseVertex(Mode, Count, Type, Indices, Primcount, Basevertex) -> ok
Types:
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 ith 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 external documentation.
provokingVertex(Mode) -> ok
Types:
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
PolygoniFirst Vertex ConventionLast Vertex Convention
point ii
independent line 2i - 1 2i
line loop i
i + 1, if i < n 1, if i = n
line strip ii + 1
independent triangle 3i - 2 3i
triangle strip ii + 2
triangle fan i + 1 i + 2
line adjacency 4i - 2 4i - 1
line strip adjacency i + 1 i + 2
triangle adjacency 6i - 5 6i - 1
triangle strip adjacency 2i - 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 external documentation.
fenceSync(Condition, Flags) -> integer()
Types:
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 external documentation.
isSync(Sync) -> 0 | 1
Types:
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 external documentation.
deleteSync(Sync) -> ok
Types:
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 external documentation.
clientWaitSync(Sync, Flags, Timeout) -> enum()
Types:
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 external documentation.
waitSync(Sync, Flags, Timeout) -> ok
Types:
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 external documentation.
getInteger64v(Pname) -> [integer()]
Types:
Pname = enum()
See getBooleanv/1
getSynciv(Sync, Pname, BufSize) -> [integer()]
Types:
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 external documentation.
texImage2DMultisample(Target, Samples, Internalformat, Width, Height, Fixedsamplelocations) -> ok
Types:
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 external documentation.
texImage3DMultisample(Target, Samples, Internalformat, Width, Height, Depth, Fixedsamplelocations) -> ok
Types:
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 external documentation.
getMultisamplefv(Pname, Index) -> {float(), float()}
Types:
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 external documentation.
sampleMaski(Index, Mask) -> ok
Types:
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 external documentation.
namedStringARB(Type, Name, String) -> ok
Types:
Type = enum()
Name = string()
String = string()
glNamedStringARB
See external documentation.
deleteNamedStringARB(Name) -> ok
Types:
Name = string()
glDeleteNamedStringARB
See external documentation.
compileShaderIncludeARB(Shader, Path) -> ok
Types:
Shader = integer()
Path = iolist()
glCompileShaderIncludeARB
See external documentation.
isNamedStringARB(Name) -> 0 | 1
Types:
Name = string()
glIsNamedStringARB
See external documentation.
getNamedStringARB(Name, BufSize) -> string()
Types:
Name = string()
BufSize = integer()
glGetNamedStringARB
See external documentation.
getNamedStringivARB(Name, Pname) -> integer()
Types:
Name = string()
Pname = enum()
glGetNamedStringARB
See external documentation.
bindFragDataLocationIndexed(Program, ColorNumber, Index, Name) -> ok
Types:
Program = integer()
ColorNumber = integer()
Index = integer()
Name = string()
glBindFragDataLocationIndexe
See external documentation.
getFragDataIndex(Program, Name) -> integer()
Types:
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 external documentation.
genSamplers(Count) -> [integer()]
Types:
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 external documentation.
deleteSamplers(Samplers) -> ok
Types:
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 external documentation.
isSampler(Sampler) -> 0 | 1
Types:
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 external documentation.
bindSampler(Unit, Sampler) -> ok
Types:
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 external documentation.
samplerParameteri(Sampler, Pname, Param) -> ok
Types:
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 FunctionComputed
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.0
where 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 external documentation.
samplerParameteriv(Sampler, Pname, Param) -> ok
Types:
Sampler = integer()
Pname = enum()
Param = [integer()]
See samplerParameteri/3
samplerParameterf(Sampler, Pname, Param) -> ok
Types:
Sampler = integer()
Pname = enum()
Param = float()
See samplerParameteri/3
samplerParameterfv(Sampler, Pname, Param) -> ok
Types:
Sampler = integer()
Pname = enum()
Param = [float()]
See samplerParameteri/3
samplerParameterIiv(Sampler, Pname, Param) -> ok
Types:
Sampler = integer()
Pname = enum()
Param = [integer()]
See samplerParameteri/3
samplerParameterIuiv(Sampler, Pname, Param) -> ok
Types:
Sampler = integer()
Pname = enum()
Param = [integer()]
glSamplerParameterI
See external documentation.
getSamplerParameteriv(Sampler, Pname) -> [integer()]
Types:
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 external documentation.
getSamplerParameterIiv(Sampler, Pname) -> [integer()]
Types:
Sampler = integer()
Pname = enum()
See getSamplerParameteriv/2
getSamplerParameterfv(Sampler, Pname) -> [float()]
Types:
Sampler = integer()
Pname = enum()
See getSamplerParameteriv/2
getSamplerParameterIuiv(Sampler, Pname) -> [integer()]
Types:
Sampler = integer()
Pname = enum()
glGetSamplerParameterI
See external documentation.
queryCounter(Id, Target) -> ok
Types:
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 external documentation.
getQueryObjecti64v(Id, Pname) -> integer()
Types:
Id = integer()
Pname = enum()
glGetQueryObjecti64v
See external documentation.
getQueryObjectui64v(Id, Pname) -> integer()
Types:
Id = integer()
Pname = enum()
glGetQueryObjectui64v
See external documentation.
drawArraysIndirect(Mode, Indirect) -> ok
Types:
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 external documentation.
drawElementsIndirect(Mode, Type, Indirect) -> ok
Types:
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 external documentation.
uniform1d(Location, X) -> ok
Types:
Location = integer()
X = float()
See uniform1f/2
uniform2d(Location, X, Y) -> ok
Types:
Location = integer()
X = float()
Y = float()
See uniform1f/2
uniform3d(Location, X, Y, Z) -> ok
Types:
Location = integer()
X = float()
Y = float()
Z = float()
See uniform1f/2
uniform4d(Location, X, Y, Z, W) -> ok
Types:
Location = integer()
X = float()
Y = float()
Z = float()
W = float()
See uniform1f/2
uniform1dv(Location, Value) -> ok
Types:
Location = integer()
Value = [float()]
See uniform1f/2
uniform2dv(Location, Value) -> ok
Types:
Location = integer()
Value = [{float(), float()}]
See uniform1f/2
uniform3dv(Location, Value) -> ok
Types:
Location = integer()
Value = [{float(), float(), float()}]
See uniform1f/2
uniform4dv(Location, Value) -> ok
Types:
Location = integer()
Value = [{float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix2dv(Location, Transpose, Value) -> ok
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3dv(Location, Transpose, Value) -> ok
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix4dv(Location, Transpose, Value) -> ok
Types:
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
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix2x4dv(Location, Transpose, Value) -> ok
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3x2dv(Location, Transpose, Value) -> ok
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix3x4dv(Location, Transpose, Value) -> ok
Types:
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
Types:
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See uniform1f/2
uniformMatrix4x3dv(Location, Transpose, Value) -> ok
Types:
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()
Types:
Program = integer()
Location = integer()
See getUniformfv/2
getSubroutineUniformLocation(Program, Shadertype, Name) -> integer()
Types:
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 external documentation.
getSubroutineIndex(Program, Shadertype, Name) -> integer()
Types:
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 external documentation.
getActiveSubroutineUniformName(Program, Shadertype, Index, Bufsize) -> string()
Types:
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 external documentation.
getActiveSubroutineName(Program, Shadertype, Index, Bufsize) -> string()
Types:
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 external documentation.
uniformSubroutinesuiv(Shadertype, Indices) -> ok
Types:
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 external documentation.
getUniformSubroutineuiv(Shadertype, Location) -> {integer(), integer(), integer(), integer(), integer(),
integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(), integer(),
integer(), integer()}
Types:
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 external documentation.
getProgramStageiv(Program, Shadertype, Pname) -> integer()
Types:
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 external documentation.
patchParameteri(Pname, Value) -> ok
Types:
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 external documentation.
patchParameterfv(Pname, Values) -> ok
Types:
Pname = enum()
Values = [float()]
See patchParameteri/2
bindTransformFeedback(Target, Id) -> ok
Types:
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 external documentation.
deleteTransformFeedbacks(Ids) -> ok
Types:
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 external documentation.
genTransformFeedbacks(N) -> [integer()]
Types:
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 external documentation.
isTransformFeedback(Id) -> 0 | 1
Types:
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 external documentation.
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 external documentation.
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 external documentation.
drawTransformFeedback(Mode, Id) -> ok
Types:
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 external documentation.
drawTransformFeedbackStream(Mode, Id, Stream) -> ok
Types:
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 external documentation.
beginQueryIndexed(Target, Index, Id) -> ok
Types:
Target = enum()
Index = integer()
Id = integer()
glBeginQueryIndexe
See external documentation.
endQueryIndexed(Target, Index) -> ok
Types:
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 external documentation.
getQueryIndexediv(Target, Index, Pname) -> integer()
Types:
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 external documentation.
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 external documentation.
shaderBinary(Shaders, Binaryformat, Binary) -> ok
Types:
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 external documentation.
getShaderPrecisionFormat(Shadertype, Precisiontype) -> {Range::{integer(), integer()},
Precision::integer()}
Types:
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 external documentation.
depthRangef(N, F) -> ok
Types:
N = clamp()
F = clamp()
See depthRange/2
clearDepthf(D) -> ok
Types:
D = clamp()
glClearDepthf
See external documentation.
getProgramBinary(Program, BufSize) -> {BinaryFormat::enum(), Binary::binary()}
Types:
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 external documentation.
programBinary(Program, BinaryFormat, Binary) -> ok
Types:
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 external documentation.
programParameteri(Program, Pname, Value) -> ok
Types:
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_TRUEbefore 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 external documentation.
useProgramStages(Pipeline, Stages, Program) -> ok
Types:
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 external documentation.
activeShaderProgram(Pipeline, Program) -> ok
Types:
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 external documentation.
createShaderProgramv(Type, Strings) -> integer()
Types:
Type = enum()
Strings = iolist()
glCreateShaderProgramv
See external documentation.
bindProgramPipeline(Pipeline) -> ok
Types:
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 external documentation.
deleteProgramPipelines(Pipelines) -> ok
Types:
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 external documentation.
genProgramPipelines(N) -> [integer()]
Types:
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 external documentation.
isProgramPipeline(Pipeline) -> 0 | 1
Types:
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 external documentation.
getProgramPipelineiv(Pipeline, Pname) -> integer()
Types:
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 external documentation.
programUniform1i(Program, Location, V0) -> ok
Types:
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 external documentation.
programUniform1iv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [integer()]
See programUniform1i/3
programUniform1f(Program, Location, V0) -> ok
Types:
Program = integer()
Location = integer()
V0 = float()
See programUniform1i/3
programUniform1fv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [float()]
See programUniform1i/3
programUniform1d(Program, Location, V0) -> ok
Types:
Program = integer()
Location = integer()
V0 = float()
See programUniform1i/3
programUniform1dv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [float()]
See programUniform1i/3
programUniform1ui(Program, Location, V0) -> ok
Types:
Program = integer()
Location = integer()
V0 = integer()
See programUniform1i/3
programUniform1uiv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [integer()]
See programUniform1i/3
programUniform2i(Program, Location, V0, V1) -> ok
Types:
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
See programUniform1i/3
programUniform2iv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{integer(), integer()}]
See programUniform1i/3
programUniform2f(Program, Location, V0, V1) -> ok
Types:
Program = integer()
Location = integer()
V0 = float()
V1 = float()
See programUniform1i/3
programUniform2fv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{float(), float()}]
See programUniform1i/3
programUniform2d(Program, Location, V0, V1) -> ok
Types:
Program = integer()
Location = integer()
V0 = float()
V1 = float()
See programUniform1i/3
programUniform2dv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{float(), float()}]
See programUniform1i/3
programUniform2ui(Program, Location, V0, V1) -> ok
Types:
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
See programUniform1i/3
programUniform2uiv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{integer(), integer()}]
See programUniform1i/3
programUniform3i(Program, Location, V0, V1, V2) -> ok
Types:
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
See programUniform1i/3
programUniform3iv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{integer(), integer(), integer()}]
See programUniform1i/3
programUniform3f(Program, Location, V0, V1, V2) -> ok
Types:
Program = integer()
Location = integer()
V0 = float()
V1 = float()
V2 = float()
See programUniform1i/3
programUniform3fv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{float(), float(), float()}]
See programUniform1i/3
programUniform3d(Program, Location, V0, V1, V2) -> ok
Types:
Program = integer()
Location = integer()
V0 = float()
V1 = float()
V2 = float()
See programUniform1i/3
programUniform3dv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{float(), float(), float()}]
See programUniform1i/3
programUniform3ui(Program, Location, V0, V1, V2) -> ok
Types:
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
See programUniform1i/3
programUniform3uiv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{integer(), integer(), integer()}]
See programUniform1i/3
programUniform4i(Program, Location, V0, V1, V2, V3) -> ok
Types:
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
V3 = integer()
See programUniform1i/3
programUniform4iv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{integer(), integer(), integer(), integer()}]
See programUniform1i/3
programUniform4f(Program, Location, V0, V1, V2, V3) -> ok
Types:
Program = integer()
Location = integer()
V0 = float()
V1 = float()
V2 = float()
V3 = float()
See programUniform1i/3
programUniform4fv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{float(), float(), float(), float()}]
See programUniform1i/3
programUniform4d(Program, Location, V0, V1, V2, V3) -> ok
Types:
Program = integer()
Location = integer()
V0 = float()
V1 = float()
V2 = float()
V3 = float()
See programUniform1i/3
programUniform4dv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{float(), float(), float(), float()}]
See programUniform1i/3
programUniform4ui(Program, Location, V0, V1, V2, V3) -> ok
Types:
Program = integer()
Location = integer()
V0 = integer()
V1 = integer()
V2 = integer()
V3 = integer()
See programUniform1i/3
programUniform4uiv(Program, Location, Value) -> ok
Types:
Program = integer()
Location = integer()
Value = [{integer(), integer(), integer(), integer()}]
See programUniform1i/3
programUniformMatrix2fv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix3fv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix4fv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(),
float(), float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix2dv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix3dv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix4dv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(),
float(), float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix2x3fv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix3x2fv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix2x4fv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix4x2fv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix3x4fv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(),
float(), float(), float()}]
See programUniform1i/3
programUniformMatrix4x3fv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(),
float(), float(), float()}]
See programUniform1i/3
programUniformMatrix2x3dv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix3x2dv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix2x4dv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix4x2dv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float()}]
See programUniform1i/3
programUniformMatrix3x4dv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(),
float(), float(), float()}]
See programUniform1i/3
programUniformMatrix4x3dv(Program, Location, Transpose, Value) -> ok
Types:
Program = integer()
Location = integer()
Transpose = 0 | 1
Value = [{float(), float(), float(), float(), float(), float(), float(), float(), float(),
float(), float(), float()}]
See programUniform1i/3
validateProgramPipeline(Pipeline) -> ok
Types:
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 external documentation.
getProgramPipelineInfoLog(Pipeline, BufSize) -> string()
Types:
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 external documentation.
vertexAttribL1d(Index, X) -> ok
Types:
Index = integer()
X = float()
glVertexAttribL
See external documentation.
vertexAttribL2d(Index, X, Y) -> ok
Types:
Index = integer()
X = float()
Y = float()
glVertexAttribL
See external documentation.
vertexAttribL3d(Index, X, Y, Z) -> ok
Types:
Index = integer()
X = float()
Y = float()
Z = float()
glVertexAttribL
See external documentation.
vertexAttribL4d(Index, X, Y, Z, W) -> ok
Types:
Index = integer()
X = float()
Y = float()
Z = float()
W = float()
glVertexAttribL
See external documentation.
vertexAttribL1dv(Index::integer(), V) -> ok
Types:
V = {X::float()}
Equivalent to vertexAttribL1d(Index, X).
vertexAttribL2dv(Index::integer(), V) -> ok
Types:
V = {X::float(), Y::float()}
Equivalent to vertexAttribL2d(Index, X, Y).
vertexAttribL3dv(Index::integer(), V) -> ok
Types:
V = {X::float(), Y::float(), Z::float()}
Equivalent to vertexAttribL3d(Index, X, Y, Z).
vertexAttribL4dv(Index::integer(), V) -> ok
Types:
V = {X::float(), Y::float(), Z::float(), W::float()}
Equivalent to vertexAttribL4d(Index, X, Y, Z, W).
vertexAttribLPointer(Index, Size, Type, Stride, Pointer) -> ok
Types:
Index = integer()
Size = integer()
Type = enum()
Stride = integer()
Pointer = offset() | mem()
glVertexAttribLPointer
See external documentation.
getVertexAttribLdv(Index, Pname) -> {float(), float(), float(), float()}
Types:
Index = integer()
Pname = enum()
glGetVertexAttribL
See external documentation.
viewportArrayv(First, V) -> ok
Types:
First = integer()
V = [{float(), float(), float(), float()}]
glViewportArrayv
See external documentation.
viewportIndexedf(Index, X, Y, W, H) -> ok
Types:
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 external documentation.
viewportIndexedfv(Index, V) -> ok
Types:
Index = integer()
V = {float(), float(), float(), float()}
See viewportIndexedf/5
scissorArrayv(First, V) -> ok
Types:
First = integer()
V = [{integer(), integer(), integer(), integer()}]
glScissorArrayv
See external documentation.
scissorIndexed(Index, Left, Bottom, Width, Height) -> ok
Types:
Index = integer()
Left = integer()
Bottom = integer()
Width = integer()
Height = integer()
glScissorIndexe
See external documentation.
scissorIndexedv(Index, V) -> ok
Types:
Index = integer()
V = {integer(), integer(), integer(), integer()}
glScissorIndexe
See external documentation.
depthRangeArrayv(First, V) -> ok
Types:
First = integer()
V = [{clamp(), clamp()}]
glDepthRangeArrayv
See external documentation.
depthRangeIndexed(Index, N, F) -> ok
Types:
Index = integer()
N = clamp()
F = clamp()
glDepthRangeIndexe
See external documentation.
getFloati_v(Target, Index) -> [float()]
Types:
Target = enum()
Index = integer()
See getBooleanv/1
getDoublei_v(Target, Index) -> [float()]
Types:
Target = enum()
Index = integer()
See getBooleanv/1
debugMessageControlARB(Source, Type, Severity, Ids, Enabled) -> ok
Types:
Source = enum()
Type = enum()
Severity = enum()
Ids = [integer()]
Enabled = 0 | 1
glDebugMessageControlARB
See external documentation.
debugMessageInsertARB(Source, Type, Id, Severity, Buf) -> ok
Types:
Source = enum()
Type = enum()
Id = integer()
Severity = enum()
Buf = string()
glDebugMessageInsertARB
See external documentation.
getDebugMessageLogARB(Count, Bufsize) -> {integer(), Sources::[enum()], Types::[enum()],
Ids::[integer()], Severities::[enum()], MessageLog::[string()]}
Types:
Count = integer()
Bufsize = integer()
glGetDebugMessageLogARB
See external documentation.
getGraphicsResetStatusARB() -> enum()
glGetGraphicsResetStatusARB
See external documentation.
drawArraysInstancedBaseInstance(Mode, First, Count, Primcount, Baseinstance) -> ok
Types:
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 external documentation.
drawElementsInstancedBaseInstance(Mode, Count, Type, Indices, Primcount, Baseinstance) -> ok
Types:
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 external documentation.
drawElementsInstancedBaseVertexBaseInstance(Mode, Count, Type, Indices, Primcount, Basevertex,
Baseinstance) -> ok
Types:
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 ith 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 external documentation.
drawTransformFeedbackInstanced(Mode, Id, Primcount) -> ok
Types:
Mode = enum()
Id = integer()
Primcount = integer()
glDrawTransformFeedbackInstance
See external documentation.
drawTransformFeedbackStreamInstanced(Mode, Id, Stream, Primcount) -> ok
Types:
Mode = enum()
Id = integer()
Stream = integer()
Primcount = integer()
glDrawTransformFeedbackStreamInstance
See external documentation.
getInternalformativ(Target, Internalformat, Pname, BufSize) -> [integer()]
Types:
Target = enum()
Internalformat = enum()
Pname = enum()
BufSize = integer()
glGetInternalformat
See external documentation.
bindImageTexture(Unit, Texture, Level, Layered, Layer, Access, Format) -> ok
Types:
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 FormatFormat Qualifier
?GL_RGBA32Frgba32f
?GL_RGBA16F rgba16f
?GL_RG32Frg32f
?GL_RG16F rg16f
?GL_R11F_G11F_B10Fr11f_g11f_b10f
?GL_R32Fr32f
?GL_R16Fr16f
?GL_RGBA32UIrgba32ui
?GL_RGBA16UI rgba16ui
?GL_RGB10_A2UIrgb10_a2ui
?GL_RGBA8UI rgba8ui
?GL_RG32UIrg32ui
?GL_RG16UI rg16ui
?GL_RG8UIrg8ui
?GL_R32UI r32ui
?GL_R16UIr16ui
?GL_R8UI r8ui
?GL_RGBA32Irgba32i
?GL_RGBA16I rgba16i
?GL_RGBA8Irgba8i
?GL_RG32I rg32i
?GL_RG16Irg16i
?GL_RG8I rg8i
?GL_R32Ir32i
?GL_R16I r16i
?GL_R8Ir8i
?GL_RGBA16 rgba16
?GL_RGB10_A2rgb10_a2
?GL_RGBA8 rgba8
?GL_RG16rg16
?GL_RG8 rg8
?GL_R16r16
?GL_R8 r8
?GL_RGBA16_SNORMrgba16_snorm
?GL_RGBA8_SNORM rgba8_snorm
?GL_RG16_SNORMrg16_snorm
?GL_RG8_SNORMrg8_snorm
?GL_R16_SNORMr16_snorm
?GL_R8_SNORMr8_snorm
When 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 external documentation.
memoryBarrier(Barriers) -> ok
Types:
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 external documentation.
texStorage1D(Target, Levels, Internalformat, Width) -> ok
Types:
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 external documentation.
texStorage2D(Target, Levels, Internalformat, Width, Height) -> ok
Types:
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 external documentation.
texStorage3D(Target, Levels, Internalformat, Width, Height, Depth) -> ok
Types:
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 external documentation.
depthBoundsEXT(Zmin, Zmax) -> ok
Types:
Zmin = clamp()
Zmax = clamp()
glDepthBoundsEXT
See external documentation.
stencilClearTagEXT(StencilTagBits, StencilClearTag) -> ok
Types:
StencilTagBits = integer()
StencilClearTag = integer()
glStencilClearTagEXT
See external documentation.
AUTHORS
<>
wx 1.6.1 gl(3erl)