Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
gl(3)			   Erlang Module Definition			 gl(3)

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()  =  {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  con-
	      verted  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	previ-
	      ously  selected by gl:clearColor , gl:clearDepth,	and gl:clearS-
	      tencil. 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 sev-
	      eral 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  buf-
	      fers

	      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 con-
	      stant  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  compari-
	      son,  no	change is made to the frame buffer at that pixel loca-
	      tion. 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, poly-
	      gons, 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 buf-
	      fers 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_AL-
	      PHA, ?GL_CONSTANT_COLOR, ?GL_ONE_MINUS_CONSTANT_COLOR , ?GL_CON-
	      STANT_ALPHA,  ?GL_ONE_MINUS_CONSTANT_ALPHA,  ?GL_SRC_ALPHA_SATU-
	      RATE , ?GL_SRC1_COLOR, ?GL_ONE_MINUS_SRC1_COLOR, ?GL_SRC1_ALPHA,
	      and ?GL_ONE_MINUS_SRC1_ALPHA .  The  possible  methods  are  de-
	      scribed  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), respec-
	      tively. 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 al-
	      pha 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].Parame-
	      ter(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	multi-
	      plicand,	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  sug-
	      gest, 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,  quadrilater-
	      als, polygons, and rectangles.

	      gl:frontFace/1  specifies	 which	of  the	clockwise and counter-
	      clockwise	facets are front-facing	and back-facing. See gl:front-
	      Face/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	clock-
	      wise 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	 counterclock-
	      wise 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 frag-
	      ment 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  cen-
	      tered  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  en-
	      abled.  If  an  unsupported width	is requested, the nearest sup-
	      ported width is used. Only width 1  is  guaranteed  to  be  sup-
	      ported;  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  rasteri-
	      zation;  those  fragments	 will  not  be	drawn.	The masking is
	      achieved by using	three parameters: the 16-bit line stipple pat-
	      tern  Pattern , the repeat count Factor ,	and an integer stipple
	      counter s.

	      Counter s	is reset to 0 whenever gl:'begin'/1 is called and  be-
	      fore  each  line	segment	of a gl:'begin'/1 (?GL_LINES)/ gl:'be-
	      gin'/1 sequence is generated. It is incremented after each frag-
	      ment  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  1Awidth  rectan-
	      gles  for	 purposes of stippling.	Whether	rectangle s is raster-
	      ized 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 dis-
	      abled, 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 ras-
	      terization. Face describes which polygons	Mode applies to:  both
	      front  and back-facing polygons (?GL_FRONT_AND_BACK ). The poly-
	      gon 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  seg-
	      ments.	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 ef-
	      fect.

	      ?GL_FILL:	The interior of	the polygon  is	 filled.  Polygon  at-
	      tributes 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 fac-
	      torADZ+rAunits, where DZ is a measurement	of the change in depth
	      relative	to the screen area of the polygon, and r is the	small-
	      est 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 high-
	      lighted 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 32A32	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 32A32 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_UN-
	      PACK_BUFFER  target  (see	gl:bindBuffer/2	) while	a stipple pat-
	      tern 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	32A32 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 32A32 color	index buffer. Unlike  gl:read-
	      Pixels/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 quadri-
	      lateral 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  win-
	      dow  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  ini-
	      tially disabled. While the test is enabled, only pixels that lie
	      within the scissor box can be modified by	drawing	commands. Win-
	      dow  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:get-
	      Booleanv/1 with argument	?GL_MAX_CLIP_PLANES.  All  implementa-
	      tions support at least six such clipping planes. Because the re-
	      sulting 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 result-
	      ing 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 specifi-
	      cations 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 indepen-
	      dently 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  con-
	      text 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	subse-
	      quent  gl:readPixels/7  ,	 gl:copyTexImage1D/7  ,	 gl:copyTexIm-
	      age2D/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 indi-
	      cate 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  nonexis-
	      tent 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  capabili-
	      ties.  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_MULTISAM-
	      PLE 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-de-
	      fined half space i.

	      ?GL_COLOR_LOGIC_OP:  If  enabled,	 apply	the currently selected
	      logical operation	to the computed	fragment color and color  buf-
	      fer 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 be-
	      fore they	are written to the color buffer.

	      ?GL_FRAMEBUFFER_SRGB: If enabled and  the	 value	of  ?GL_FRAME-
	      BUFFER_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  ren-
	      dered  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 ren-
	      dered 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 compari-
	      son is performed,	if the polygon is rendered in ?GL_POINT	 mode.
	      See gl:polygonOffset/2 .

	      ?GL_POLYGON_SMOOTH:  If  enabled,	draw polygons with proper fil-
	      tering.  Otherwise,  draw	 aliased  polygons.  For  correct  an-
	      tialiased	 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_COVER-
	      AGE_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:sample-
	      Maski/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 be-
	      tween zero and the count of indexed capabilities for Cap .  Ini-
	      tially   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  dis-
	      able   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 en-
	      abled  for  writing  and used during rendering when gl:arrayEle-
	      ment/1 , gl:drawArrays/3 , gl:drawElements/4 ,  gl:drawRangeEle-
	      ments/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:ar-
	      rayElement/1   ,	 gl:drawArrays/3   ,	gl:drawElements/4    ,
	      gl:drawRangeElements/6  gl:multiDrawArrays/3  ,  or  see	glMul-
	      tiDrawElements is	called.	See gl:colorPointer/4 .

	      ?GL_TEXTURE_COORD_ARRAY: If enabled, the texture coordinate  ar-
	      ray is enabled for writing and used during rendering when	gl:ar-
	      rayElement/1   ,	 gl:drawArrays/3   ,	gl:drawElements/4    ,
	      gl:drawRangeElements/6  gl:multiDrawArrays/3  ,  or  see	glMul-
	      tiDrawElements 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 indi-
	      cated 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 con-
	      verted  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 re-
	      turned as	?GL_TRUE or ?GL_FALSE, and  integer  values  are  con-
	      verted 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_AR-
	      RAY_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 con-
	      stant identifying	the alpha destination blend function. The ini-
	      tial value is ?GL_ZERO. See gl:blendFunc/2 and gl:blendFuncSepa-
	      rate/4 .

	      ?GL_BLEND_DST_RGB:  Params  returns one value, the symbolic con-
	      stant identifying	the RGB	destination blend function.  The  ini-
	      tial value is ?GL_ZERO. See gl:blendFunc/2 and gl:blendFuncSepa-
	      rate/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 con-
	      stant  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 con-
	      stant 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  in-
	      ternal  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	 indi-
	      cating  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  sym-
	      bolic constants of length	?GL_NUM_COMPRESSED_TEXTURE_FORMATS in-
	      dicating 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 ob-
	      ject 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 representa-
	      tion such	that 1.0 returns the most positive representable inte-
	      ger value, and -1.0 returns the most negative representable  in-
	      teger 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  re-
	      quested,	are  linearly  mapped from the internal	floating-point
	      representation such that 1.0 returns the	most  positive	repre-
	      sentable	integer	value, and -1.0	returns	the most negative rep-
	      resentable 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 indi-
	      cating 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 indicat-
	      ing 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,  oth-
	      erwise 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,	other-
	      wise 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_FRAME-
	      BUFFER target. If	the default framebuffer	is bound,  this	 value
	      will  be	zero.  The  initial  value  is zero. See gl:bindFrame-
	      buffer/2 .

	      ?GL_READ_FRAMEBUFFER_BINDING: Params returns one value, the name
	      of the framebuffer object	currently bound	to the ?GL_READ_FRAME-
	      BUFFER target. If	the default framebuffer	is bound,  this	 value
	      will  be	zero.  The  initial  value  is zero. See gl:bindFrame-
	      buffer/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:bind-
	      Buffer/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 indicat-
	      ing 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 con-
	      stant 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	imple-
	      mentation	 dependent  specifc vertex of a	primitive that is used
	      to select	the rendering layer. If	the value returned is  equiva-
	      lent  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	primi-
	      tive.  If	 the  value  returned  is  equivalent to ?GL_LAST_VER-
	      TEX_CONVENTION , then the	selection is  always  taken  from  the
	      last  vertex  in the primitive. If the value returned is equiva-
	      lent to ?GL_UNDEFINED_VERTEX, then the selection is not  guaran-
	      teed 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 esti-
	      mate 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 pro-
	      cessor combined. If both the vertex shader and the fragment pro-
	      cessing 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-sten-
	      cil texture.

	      ?GL_MAX_DRAW_BUFFERS: Params returns one value, the maximum num-
	      ber 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	recom-
	      mended   maximum	 number	  of   vertex	array	indices.   See
	      gl:drawRangeElements/6 .

	      ?GL_MAX_ELEMENTS_VERTICES: Params	returns	one value, the	recom-
	      mended   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:uni-
	      form1f/2 .

	      ?GL_MAX_FRAGMENT_UNIFORM_VECTORS:	Params returns one value,  the
	      maximum  number of individual 4-vectors of floating-point, inte-
	      ger, 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	geome-
	      try 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:uni-
	      form1f/2 .

	      ?GL_MAX_INTEGER_SAMPLES: Params returns one value,  the  maximum
	      number  of  samples supported in integer format multisample buf-
	      fers.

	      ?GL_MIN_MAP_BUFFER_ALIGNMENT: Params returns one value, the min-
	      imum alignment in	basic machine units of pointers	returned from-
	      see 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 max-
	      imum texel offset	allowed	in a texture lookup, which must	be  at
	      least 7.

	      ?GL_MIN_PROGRAM_TEXEL_OFFSET: Params returns one value, the min-
	      imum 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 maxi-
	      mum gl:waitSync/3	timeout	interval.

	      ?GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS:  Params  returns  a	single
	      value, the maximum number	of atomic counters available  to  tes-
	      sellation	control	shaders.

	      ?GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS: Params returns a	single
	      value, the maximum number	of atomic counters available  to  tes-
	      sellation	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 maxi-
	      mum 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 maxi-
	      mum 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 vari-
	      ables used by vertex and fragment	shaders. This value represents
	      the  number  of individual floating-point	values that can	be in-
	      terpolated; 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:vertexAt-
	      trib1d/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_UNI-
	      FORM_VECTORS  is	equal  to  the	value  of  ?GL_MAX_VERTEX_UNI-
	      FORM_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 in-
	      teger value indicating the number	of available  compressed  tex-
	      ture  formats.  The  minimum value is 4. See gl:compressedTexIm-
	      age2D/8 .

	      ?GL_NUM_EXTENSIONS: Params returns one value, the	number of  ex-
	      tensions supported by the	GL implementation for the current con-
	      text. See	gl:getString/1 .

	      ?GL_NUM_PROGRAM_BINARY_FORMATS: Params returns  one  value,  the
	      number  of  program  binary formats supported by the implementa-
	      tion.

	      ?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 sup-
	      ports 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	 indi-
	      cating  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 mem-
	      ory. 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 indi-
	      cating 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 tar-
	      get,  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:bind-
	      Buffer/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  cur-
	      rent  primitive  restart	index.	The  initial  value  is	0. See
	      gl:primitiveRestartIndex/1 .

	      ?GL_PROGRAM_BINARY_FORMATS:  Params  an  array  of  ?GL_NUM_PRO-
	      GRAM_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 pro-
	      gram 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:polygonOff-
	      set/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:polygonOff-
	      set/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:polygonOff-
	      set/2 .

	      ?GL_POLYGON_SMOOTH:  Params returns a single boolean value indi-
	      cating 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  ini-
	      tial  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:bindRen-
	      derbuffer/2 .

	      ?GL_SAMPLE_BUFFERS: Params returns a single integer value	 indi-
	      cating  the  number of sample buffers associated with the	frame-
	      buffer. 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 in-
	      verted. 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 indicat-
	      ing  whether  scissoring	is  enabled.  The  initial  value   is
	      ?GL_FALSE. See gl:scissor/4 .

	      ?GL_SHADER_COMPILER: Params returns a single boolean value indi-
	      cating whether an	online shader compiler is present in  the  im-
	      plementation.  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 in-
	      dicating 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 con-
	      stant 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 con-
	      stant  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:stencilFuncSepa-
	      rate/4 .

	      ?GL_STENCIL_BACK_PASS_DEPTH_FAIL:	Params returns	one  value,  a
	      symbolic	constant indicating what action	is taken for back-fac-
	      ing 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-fac-
	      ing polygons when	the stencil test passes	 and  the  depth  test
	      passes.  The  initial  value  is ?GL_KEEP. See gl:stencilOpSepa-
	      rate/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:sten-
	      cilFuncSeparate/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:stencilFuncSepa-
	      rate/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:stencilMaskSepa-
	      rate/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:stencilOpSep-
	      arate/4 .

	      ?GL_STENCIL_FUNC:	 Params	returns	one value, a symbolic constant
	      indicating what function is used to compare the  stencil	refer-
	      ence  value  with	the stencil buffer value. The initial value is
	      ?GL_ALWAYS. See gl:stencilFunc/3 . This stencil state  only  af-
	      fects  non-polygons and front-facing polygons. Back-facing poly-
	      gons use separate	stencil	state. See gl:stencilFuncSeparate/4 .

	      ?GL_STENCIL_PASS_DEPTH_FAIL: Params returns one  value,  a  sym-
	      bolic  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 sym-
	      bolic 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:stencilFuncSepa-
	      rate/4 .

	      ?GL_STENCIL_TEST:	Params returns a single	boolean	value indicat-
	      ing 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_TEX-
	      TURE_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_TEX-
	      TURE_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:bind-
	      Texture/2	.

	      ?GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:	 Params	returns	a sin-
	      gle 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_TEX-
	      TURE_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_TEX-
	      TURE_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_TEX-
	      TURE_RECTANGLE. The initial value	is 0. See gl:bindTexture/2 .

	      ?GL_TEXTURE_COMPRESSION_HINT: Params returns a single value  in-
	      dicating	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-in-
	      dexed variants of	gl:get (such as	 gl:getIntegerv),  Params  re-
	      turns  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:bindBuffer-
	      Base/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 vari-
	      ants  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 tar-
	      get  ?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	align-
	      ment  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  in-
	      dicating	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 mem-
	      ory. 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 in-
	      dicating whether the bytes of two-byte and four-byte  pixel  in-
	      dices  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 en-
	      abled. If	enabled, and a vertex shader is	active,	then the point
	      size  is	taken  from  the shader	built-in gl_PointSize. If dis-
	      abled, 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:view-
	      port/4 . When used with indexed  variants	 of  gl:get  (such  as
	      gl:getIntegeri_v),  Params returns four values: the x and	y win-
	      dow 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	 mini-
	      mum  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_VER-
	      TEX_CONVENTION , then the	selection is  always  taken  from  the
	      last  vertex  in the primitive. If the value returned is equiva-
	      lent to ?GL_UNDEFINED_VERTEX, then the selection is not  guaran-
	      teed 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  in-
	      terpret 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.  Sym-
	      bolic  constants are used	to set bits in the mask. Mask is typi-
	      cally 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 mate-
	      rial
	       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 at-
	      tribute 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_VER-
	      TEX_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 argu-
	      ment, 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 buf-
	      fer, which must be created (see gl:selectBuffer/2	)  before  se-
	      lection 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	opera-
	      tion.

	      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 er-
	      ror 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_ER-
	      ROR.  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 arbi-
	      trary 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 sym-
	      bolic constant is	guaranteed to be 0.

	      ?GL_INVALID_ENUM:	An unacceptable	value is specified for an enu-
	      merated 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 of-
	      fending 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 unde-
	      fined 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 generat-
	      ing 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	imple-
	      mentation. 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 num-
	      ber 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_num-
	      ber

	      Vendor-specific  information  may	follow the version number. Its
	      format depends on	the implementation, but	a space	 always	 sepa-
	      rates 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  differ-
	      ent locations, including network buffers and the graphics	accel-
	      erator itself. gl:flush empties all of  these  buffers,  causing
	      all  issued  commands  to	be executed as quickly as they are ac-
	      cepted 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 interpre-
	      tation,  can  be controlled with hints. A	hint is	specified with
	      two arguments. Target is a symbolic constant indicating the  be-
	      havior  to  be controlled, and Mode is another symbolic constant
	      indicating the desired behavior. The initial value for each Tar-
	      get 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	imple-
	      mentation. 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 an-
	      tialiased	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  an-
	      tialiased	 polygons. Hinting ?GL_NICEST can result in more pixel
	      fragments	being generated	during rasterization, if a larger fil-
	      ter function is applied.

	      ?GL_TEXTURE_COMPRESSION_HINT:  Indicates the quality and perfor-
	      mance of the compressing texture images. Hinting ?GL_FASTEST in-
	      dicates  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	incom-
	      ing pixel	depth value with the depth value present in the	 depth
	      buffer. The comparison is	performed only if depth	testing	is en-
	      abled. (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 en-
	      abled.

	      See external documentation.

       depthRange(Near_val, Far_val) ->	ok

	      Types:

		 Near_val = clamp()
		 Far_val = clamp()

	      Specify mapping of depth values from normalized  device  coordi-
	      nates 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.  Regard-
	      less  of	the actual depth buffer	implementation,	window coordi-
	      nate 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 ac-
	      cepted.

	      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  uti-
	      lized.

	      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. Im-
	      ages are not rendered into it. Rather, images rendered into  one
	      of  the color buffers are	added to the contents of the accumula-
	      tion 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 exam-
	      ine this number by calling gl:getBooleanv/1 four times, with ar-
	      guments	 ?GL_ACCUM_RED_BITS,   ?GL_ACCUM_GREEN_BITS,   ?GL_AC-
	      CUM_BLUE_BITS, and ?GL_ACCUM_ALPHA_BITS .	Regardless of the num-
	      ber  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 argu-
	      ment, 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_RE-
	      TURN.

	      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 con-
	      tents 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  cur-
	      rently  selected for reading (see	gl:readBuffer/1	). Each	compo-
	      nent value is divided by 2 n-1, where n is the  number  of  bits
	      allocated	to each	color component	in the currently selected buf-
	      fer. 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, over-
	      writing 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	corre-
	      sponding 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	corre-
	      sponding	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  mod-
	      elview matrix stack.

	      ?GL_PROJECTION: Applies subsequent matrix	operations to the pro-
	      jection matrix stack.

	      ?GL_TEXTURE: Applies subsequent matrix operations	to the texture
	      matrix stack.

	      ?GL_COLOR: Applies subsequent matrix operations to the color ma-
	      trix stack.

	      To find out which	matrix stack is	currently the  target  of  all
	      matrix  operations,  call	gl:getBooleanv/1 with argument ?GL_MA-
	      TRIX_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	multi-
	      plied 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/(far-
	      Val-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 per-
	      spective 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  coordi-
	      nates (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:get-
	      Booleanv/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, du-
	      plicating	the current matrix. That  is,  after  a	 gl:pushMatrix
	      call, the	matrix on top of the stack is identical	to the one be-
	      low 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:loadMa-
	      trixd/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 el-
	      ements 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-preci-
	      sion  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])A(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	speci-
	      fied 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  ma-
	      trix,  as	if gl:multMatrixd/1 were called	with the following ma-
	      trix 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  un-
	      rotated 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  ma-
	      trix  (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 dis-
	      play 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 dis-
	      play 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	gener-
	      ated, 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  com-
	      piled 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:feedback-
	      Buffer/3 , gl:finish/0 , gl:flush/0 , gl:genLists/1 , gl:genTex-
	      tures/1  , gl:indexPointer/3 , gl:interleavedArrays/3 , gl:isEn-
	      abled/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:texIm-
	      age3D/10 are executed immediately	and not	compiled into the dis-
	      play 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 exe-
	      cutes immediately	when its argument is ?GL_PROXY_HISTOGRAM. Sim-
	      ilarly,  gl:colorTable/6 executes	immediately when its first ar-
	      gument   is    ?GL_PROXY_COLOR_TABLE,    ?GL_PROXY_POST_CONVOLU-
	      TION_COLOR_TABLE , or ?GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE.

	      For  OpenGL  versions 1.3	and greater, or	when the ARB_multitex-
	      ture 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  pos-
	      sibility	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 inte-
	      gers, 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	 inte-
	      gers.

	      ?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 pos-
	      sibility 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:call-
	      Lists. 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	refer-
	      ence 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	primi-
	      tives

	      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 interpreta-
	      tions are	as follows:

	      ?GL_POINTS:  Treats  each	vertex as a single point. Vertex n de-
	      fines 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  ver-
	      tices 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	trian-
	      gle 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 tri-
	      angle is defined for each	vertex presented after the  first  two
	      vertices.	Vertices 1, n+1, and n+2 define	triangle n. N-2	trian-
	      gles 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 af-
	      ter 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:fogCo-
	      ordf/1 , gl:texCoord1d/1 , gl:multiTexCoord1d/2  ,  gl:vertexAt-
	      trib1d/2	,  gl:evalCoord1d/1  ,	gl:evalPoint1/1	, gl:arrayEle-
	      ment/1 , gl:materialf/3 ,	and gl:edgeFlag/1 . Also,  it  is  ac-
	      ceptable	to use gl:callList/1 or	gl:callLists/1 to execute dis-
	      play 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	 poly-
	      gons  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 asso-
	      ciated 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  con-
	      verted  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 re-
	      quires 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  re-
	      sulting  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 inte-
	      gers 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 pre-
	      cisely 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  in-
	      terpolated 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(), Al-
		 pha::integer()}

	      Equivalent to color4b(Red, Green,	Blue, Alpha).

       color4dv(V) -> ok

	      Types:

		 V  =  {Red::float(),	Green::float(),	  Blue::float(),   Al-
		 pha::float()}

	      Equivalent to color4d(Red, Green,	Blue, Alpha).

       color4fv(V) -> ok

	      Types:

		 V   =	 {Red::float(),	  Green::float(),  Blue::float(),  Al-
		 pha::float()}

	      Equivalent to color4f(Red, Green,	Blue, Alpha).

       color4iv(V) -> ok

	      Types:

		 V = {Red::integer(), Green::integer(),	 Blue::integer(),  Al-
		 pha::integer()}

	      Equivalent to color4i(Red, Green,	Blue, Alpha).

       color4sv(V) -> ok

	      Types:

		 V  =  {Red::integer(),	Green::integer(), Blue::integer(), Al-
		 pha::integer()}

	      Equivalent to color4s(Red, Green,	Blue, Alpha).

       color4ubv(V) -> ok

	      Types:

		 V = {Red::integer(), Green::integer(),	 Blue::integer(),  Al-
		 pha::integer()}

	      Equivalent to color4ub(Red, Green, Blue, Alpha).

       color4uiv(V) -> ok

	      Types:

		 V  =  {Red::integer(),	Green::integer(), Blue::integer(), Al-
		 pha::integer()}

	      Equivalent to color4ui(Red, Green, Blue, Alpha).

       color4usv(V) -> ok

	      Types:

		 V = {Red::integer(), Green::integer(),	 Blue::integer(),  Al-
		 pha::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  coordi-
	      nates  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 explic-
	      itly as (s t r q).

	      The current texture coordinates are part of the data that	is as-
	      sociated	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 posi-
	      tion,  called the	raster position, is used to position pixel and
	      bitmap write operations. It is maintained	 with  subpixel	 accu-
	      racy. 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 dis-
	      tance,  a	valid bit, and associated color	data and texture coor-
	      dinates. 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 pro-
	      jected  and  scaled  to window coordinates, which	become the new
	      current  raster  position,  and	the   ?GL_CURRENT_RASTER_POSI-
	      TION_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_CUR-
	      RENT_RASTER_INDEX	(in color index	mode) is set to	the color pro-
	      duced  by	 the lighting calculation (see gl:lightf/3 , gl:light-
	      Modelf/2 , and gl:shadeModel/1 ).	If lighting is disabled,  cur-
	      rent  color  (in RGBA mode, state	variable ?GL_CURRENT_COLOR) or
	      color index (in color index mode,	state variable ?GL_CURRENT_IN-
	      DEX)  is	used  to  update  the  current	raster color. ?GL_CUR-
	      RENT_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 sys-
	      tem 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 cur-
	      rent 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,  or-
	      ganized  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 fol-
	      lowing 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	speci-
	      fies 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 ef-
	      ficient on some implementations; see gl:interleavedArrays/3 .)

	      If a non-zero named buffer object	is bound to the	?GL_ARRAY_BUF-
	      FER target (see gl:bindBuffer/2 )	while a	vertex array is	speci-
	      fied,  Pointer  is  treated as a byte offset into	the buffer ob-
	      ject's data store. Also,	the  buffer  object  binding  (?GL_AR-
	      RAY_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 cur-
	      rent vertex array	buffer object binding.

	      To  enable  and  disable	the  vertex  array,  call   gl:enable-
	      ClientState/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  at-
	      tributes	to be packed into a single array or stored in separate
	      arrays. (Single-array storage may	be more	efficient on some  im-
	      plementations; see gl:interleavedArrays/3	.)

	      If a non-zero named buffer object	is bound to the	?GL_ARRAY_BUF-
	      FER target (see gl:bindBuffer/2 )	while a	normal array is	speci-
	      fied,  Pointer  is  treated as a byte offset into	the buffer ob-
	      ject's data store. Also,	the  buffer  object  binding  (?GL_AR-
	      RAY_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 ver-
	      tex array	buffer object binding.

	      To  enable  and  disable	the  normal  array,  call   gl:enable-
	      ClientState/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:arrayEle-
	      ment/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 ar-
	      ray 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 ef-
	      ficient on some implementations; see gl:interleavedArrays/3 .)

	      If a non-zero named buffer object	is bound to the	?GL_ARRAY_BUF-
	      FER  target (see gl:bindBuffer/2 ) while a color array is	speci-
	      fied, Pointer is treated as a byte offset	into  the  buffer  ob-
	      ject's  data  store.  Also,  the	buffer object binding (?GL_AR-
	      RAY_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  cur-
	      rent vertex array	buffer object binding.

	      To   enable   and	 disable  the  color  array,  call  gl:enable-
	      ClientState/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:arrayEle-
	      ment/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 ar-
	      ray  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	 sepa-
	      rate arrays.

	      If a non-zero named buffer object	is bound to the	?GL_ARRAY_BUF-
	      FER 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_AR-
	      RAY_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 cur-
	      rent vertex array	buffer object binding.

	      To enable	and disable the	color  index  array,  call  gl:enable-
	      ClientState/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:arrayEle-
	      ment/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	speci-
	      fies  the	 number	of coordinates per texture coordinate set, and
	      must be 1, 2, 3, or 4. Type specifies the	data type of each tex-
	      ture  coordinate,	 and Stride specifies the byte stride from one
	      texture coordinate set to	the next, allowing  vertices  and  at-
	      tributes	to be packed into a single array or stored in separate
	      arrays. (Single-array storage may	be more	efficient on some  im-
	      plementations; see gl:interleavedArrays/3	.)

	      If a non-zero named buffer object	is bound to the	?GL_ARRAY_BUF-
	      FER target (see gl:bindBuffer/2 )	while a	texture	coordinate ar-
	      ray  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 ver-
	      tex  array   client-side	 state	 (?GL_TEXTURE_COORD_ARRAY_BUF-
	      FER_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:en-
	      ableClientState/1	and gl:enableClientState/1 with	 the  argument
	      ?GL_TEXTURE_COORD_ARRAY.	If enabled, the	texture	coordinate ar-
	      ray is used when gl:arrayElement/1 , gl:drawArrays/3  ,  gl:mul-
	      tiDrawArrays/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	speci-
	      fies 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_BUF-
	      FER  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_AR-
	      RAY_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:enable-
	      ClientState/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:ar-
	      rayElement/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:'be-
	      gin'/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 modi-
	      fied.

	      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,  nor-
	      mals,  and colors	and use	them to	construct a sequence of	primi-
	      tives 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 un-
	      specified	 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 ele-
	      ments 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  ag-
	      gregate  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, nor-
	      mal coordinates are extracted. Vertex coordinates	are always ex-
	      tracted.

	      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  as-
	      signing  different colors	to each	resulting pixel	fragment. Flat
	      shading selects the computed color of just one  vertex  and  as-
	      signs  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.	Start-
	      ing when gl:'begin'/1 is issued and counting vertices and	primi-
	      tives  from  1, the GL gives each	flat-shaded line segment i the
	      computed color of	vertex i+1, its	second vertex. Counting	 simi-
	      larly 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 pa-
	      rameters,	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  en-
	      abled  and disabled using	gl:enable/1 and	gl:enable/1 with argu-
	      ment ?GL_LIGHT i.

	      The ten light parameters are as follows:

	      ?GL_AMBIENT: Params contains four	integer	or floating-point val-
	      ues  that	specify	the ambient RGBA intensity of the light. Inte-
	      ger values are mapped linearly such that the most	positive  rep-
	      resentable  value	 maps  to  1.0,	 and  the most negative	repre-
	      sentable 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 val-
	      ues  that	specify	the diffuse RGBA intensity of the light. Inte-
	      ger values are mapped linearly such that the most	positive  rep-
	      resentable  value	 maps  to  1.0,	 and  the most negative	repre-
	      sentable 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	repre-
	      sentable	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 ob-
	      ject 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 dis-
	      abled. 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 homoge-
	      neous 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  mod-
	      elview  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 val-
	      ues in the range [0 128] are accepted.

	      Effective	light intensity	is attenuated by the cosine of the an-
	      gle  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 val-
	      ues  in the range	[0 90] and the special value 180 are accepted.
	      If the angle between the direction of the	light and  the	direc-
	      tion  from the light to the vertex being lighted is greater than
	      the spot cutoff angle, the light is  completely  masked.	Other-
	      wise,  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	float-
	      ing-point	value that specifies one of the	three  light  attenua-
	      tion  factors.  Integer and floating-point values	are mapped di-
	      rectly. 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), result-
	      ing 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	= {float()}

	      See lightf/3

       lightiv(Light, Pname, Params) ->	ok

	      Types:

		 Light = enum()
		 Pname = enum()
		 Params	= {integer()}

	      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	depen-
	      dent 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  val-
	      ues  representing	the ambient intensity of the light source. In-
	      teger values, when requested, are	linearly mapped	from  the  in-
	      ternal  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 val-
	      ues representing the diffuse intensity of	the light source.  In-
	      teger  values,  when requested, are linearly mapped from the in-
	      ternal 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 val-
	      ues representing the specular intensity of the light source. In-
	      teger  values,  when requested, are linearly mapped from the in-
	      ternal 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 val-
	      ues representing the position of the light source. Integer  val-
	      ues,  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. In-
	      teger values, when requested, are	computed by rounding  the  in-
	      ternal  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 normaliza-
	      tion. 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 in-
	      teger value, when	requested, is computed by rounding the	inter-
	      nal  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  in-
	      ternal 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-re-
	      lated) attenuation of the	light.	An  integer  value,  when  re-
	      quested,	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 inte-
	      ger. 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 near-
	      est integer. The initial value is	0.

	      See external documentation.

       getLightiv(Light, Pname)	->  {integer(),	 integer(),  integer(),	 inte-
       ger()}

	      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	light-
	      ing model	parameters:

	      ?GL_LIGHT_MODEL_AMBIENT:	Params contains	four integer or	float-
	      ing-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 neg-
	      ative  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_SEPA-
	      RATE_SPECULAR_COLOR or ?GL_SINGLE_COLOR. ?GL_SINGLE_COLOR	speci-
	      fies that	a single color is generated from the lighting computa-
	      tion  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 an-
	      gles are computed. If Params is 0	(or 0.0), specular  reflection
	      angles  take the view direction to be parallel to	and in the di-
	      rection 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	float-
	      ing-point	value that specifies whether one- or two-sided	light-
	      ing  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, ver-
	      tices of back-facing polygons are	lighted	using the  back	 mate-
	      rial  parameters	and  have  their  normals  reversed before the
	      lighting equation	is evaluated. Vertices of  front-facing	 poly-
	      gons  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  in-
	      tensity. 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 re-
	      flectance, 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:ma-
	      terialf/3	using ?GL_COLOR_INDEXES. Diffuse and specular  coeffi-
	      cients, 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	= {float()}

	      See lightModelf/2

       lightModeliv(Pname, Params) -> ok

	      Types:

		 Pname = enum()
		 Params	= {integer()}

	      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-fac-
	      ing,  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 calcula-
	      tions.

	      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 val-
	      ues 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	repre-
	      sentable	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 val-
	      ues  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	repre-
	      sentable 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	 mate-
	      rial. Integer values are mapped linearly such that the most pos-
	      itive 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 ma-
	      terial. 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 val-
	      ues in the range [0 128] are accepted. The initial specular  ex-
	      ponent 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	light-
	      ing 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	= {float()}

	      See materialf/3

       materialiv(Face,	Pname, Params) -> ok

	      Types:

		 Face =	enum()
		 Pname = enum()
		 Params	= {integer()}

	      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  parame-
	      ter Pname	of material Face . Six parameters are defined:

	      ?GL_AMBIENT:  Params returns four	integer	or floating-point val-
	      ues representing the ambient reflectance of the material.	 Inte-
	      ger  values, when	requested, are linearly	mapped from the	inter-
	      nal 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  val-
	      ues  representing	the diffuse reflectance	of the material. Inte-
	      ger values, when requested, are linearly mapped from the	inter-
	      nal 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 val-
	      ues representing the specular reflectance	of the material. Inte-
	      ger  values, when	requested, are linearly	mapped from the	inter-
	      nal 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 val-
	      ues  representing	 the  emitted light intensity of the material.
	      Integer values, when requested, are linearly mapped from the in-
	      ternal  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.	 Inte-
	      ger  values, when	requested, are computed	by rounding the	inter-
	      nal floating-point value to the nearest integer value. The  ini-
	      tial value is 0.

	      ?GL_COLOR_INDEXES:  Params  returns  three  integer or floating-
	      point values representing	the ambient, diffuse, and specular in-
	      dices of the material. These indices are used only for color in-
	      dex 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 inte-
	      ger values.

	      See external documentation.

       getMaterialiv(Face,  Pname)  -> {integer(), integer(), integer(), inte-
       ger()}

	      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. Dur-
	      ing  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 pix-
	      els 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 modi-
	      fied.

	      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 tex-
	      ture patterns (see gl:texImage1D/8 , gl:texImage2D/9 , gl:texIm-
	      age3D/10	,  gl:texSubImage1D/7  ,  gl:texSubImage1D/7 , gl:tex-
	      SubImage1D/7 ), gl:compressedTexImage1D/7	,  gl:compressedTexIm-
	      age2D/8  ,  gl:compressedTexImage3D/9  ,	gl:compressedTexSubIm-
	      age1D/7 ,	gl:compressedTexSubImage2D/9 or	gl:compressedTexSubIm-
	      age1D/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 de-
	      fines 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  tex-
	      ture  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_IM-
	      AGES

	      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. Set-
	      ting ?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 re-
	      versed. 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  ef-
	      fect  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_UN-
	      PACK_ROW_LENGTH if it is greater than 0, the width  argument  to
	      the  pixel  routine  otherwise),	a  is  the  value  of  ?GL_UN-
	      PACK_ALIGNMENT , and s is	the size, in bytes, of a single	compo-
	      nent (if a< s, then it is	as if a= s). In	the case of 1-bit val-
	      ues, 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_IM-
	      AGE_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_UN-
	      PACK_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 ar-
	      gument to	gl:texImage3D/10 otherwise), a is the value of ?GL_UN-
	      PACK_ALIGNMENT, and s is the size, in bytes, of a	single	compo-
	      nent (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 in-
	      crementing the pointer passed  to	 gl:texImage1D/8  ,  gl:texIm-
	      age2D/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_UN-
	      PACK_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_UN-
	      PACK_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 oper-
	      ation  of	 subsequent  gl:copyPixels/5  ,	 gl:copyTexImage1D/7 ,
	      gl:copyTexImage2D/8 , gl:copyTexSubImage1D/6 ,  gl:copyTexSubIm-
	      age2D/8 ,	gl:copyTexSubImage3D/9 , gl:drawPixels/5 , gl:readPix-
	      els/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:convolu-
	      tionFilter1D/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:copyPix-
	      els/5 gl:copyTexImage1D/7	,  gl:copyTexImage2D/8	,  gl:copyTex-
	      SubImage1D/6 , gl:copyTexSubImage2D/8 , gl:copyTexSubImage3D/9 ,
	      and gl:readPixels/7 ), or	unpacked from client memory ( gl:draw-
	      Pixels/5	, gl:texImage1D/8 , gl:texImage2D/9 , gl:texImage3D/10
	      ,	gl:texSubImage1D/7 ,  gl:texSubImage1D/7  ,  and  gl:texSubIm-
	      age1D/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:pixel-
	      Storef/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	 expo-
	      nent  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 rep-
	      resents  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 com-
	      ponent  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	compo-
	      nent   is	  multiplied   by   ?GL_BLUE_SCALE  ,  then  added  to
	      ?GL_BLUE_BIAS; and the alpha component is	multiplied by  ?GL_AL-
	      PHA_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  con-
	      tents  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 con-
	      tents 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	multi-
	      plied   by   ?GL_POST_COLOR_MATRIX_GREEN_SCALE,  then  added  to
	      ?GL_POST_COLOR_MATRIX_GREEN_BIAS;	the blue component  is	multi-
	      plied   by  ?GL_POST_COLOR_MATRIX_BLUE_SCALE  ,  then  added  to
	      ?GL_POST_COLOR_MATRIX_BLUE_BIAS; and the alpha component is mul-
	      tiplied  by  ?GL_POST_COLOR_MATRIX_ALPHA_SCALE,  then  added  to
	      ?GL_POST_COLOR_MATRIX_ALPHA_BIAS . After all four	 color	compo-
	      nents 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  pro-
	      cessing by the enabled convolution filter. That is, the red com-
	      ponent 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	multi-
	      plied  by	 ?GL_POST_CONVOLUTION_BLUE_SCALE  ,  then   added   to
	      ?GL_POST_CONVOLUTION_BLUE_BIAS;  and the alpha component is mul-
	      tiplied  by  ?GL_POST_CONVOLUTION_ALPHA_SCALE,  then  added   to
	      ?GL_POST_CONVOLUTION_ALPHA_BIAS  .  After	 all four color	compo-
	      nents 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 con-
	      tinue  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:pixelTrans-
	      fer  .  The  contents of the index map is	specified with gl:pix-
	      elMapfv/3	.

	      If the resulting pixels are to be	written	to an RGBA color  buf-
	      fer, 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_STEN-
	      CIL 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  parame-
	      ter.  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:copyTex-
	      SubImage3D/9  ,  gl:drawPixels/5	,  gl:readPixels/7 , gl:texIm-
	      age1D/8 ,	 gl:texImage2D/9  ,  gl:texImage3D/10  ,  gl:texSubIm-
	      age1D/7  ,  gl:texSubImage1D/7  ,	and gl:texSubImage1D/7 . Addi-
	      tionally,	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 com-
	      pletely 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	refer-
	      ence 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_UN-
	      PACK_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	float-
	      ing-point	 numbers, unsigned short integers, or unsigned int in-
	      tegers.  Maps  that  store  color	 component  values  (all   but
	      ?GL_PIXEL_MAP_I_TO_I and ?GL_PIXEL_MAP_S_TO_S) retain their val-
	      ues in floating-point format, with unspecified mantissa and  ex-
	      ponent  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  con-
	      verted 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 con-
	      verted 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:get-
	      Booleanv/1 with argument ?GL_MAX_PIXEL_MAP_TABLE	.  The	single
	      maximum  applies	to  all	 maps; it is at	least 32.MapLookup In-
	      dexLookup	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:draw-
	      Pixels/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:copy-
	      TexSubImage3D/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	speci-
	      fies  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_UN-
	      PACK_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:draw-
	      Pixels/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	 posi-
	      tioned 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 bit-
	      map origin. Fragments are	then generated for each	 pixel	corre-
	      sponding	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-frag-
	      ment 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	 posi-
	      tion,  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  parame-
	      ters  control  the  processing  of  the  pixel data before it is
	      placed into client memory. These parameters are set with gl:pix-
	      elStoref/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 re-
	      turned 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; ac-
	      cepted values are:

	      ?GL_STENCIL_INDEX: Stencil values	are read from the stencil buf-
	      fer.  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, in-
	      dices  are   replaced   by   their   mappings   in   the	 table
	      ?GL_PIXEL_MAP_S_TO_S.

	      ?GL_DEPTH_COMPONENT:  Depth  values are read from	the depth buf-
	      fer. 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_UN-
	      SIGNED_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_STEN-
	      CIL_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-preci-
	      sion 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 con-
	      verted to	the client's single-precision floating-point format if
	      it  is different from the	one used by the	GL).TypeIndex MaskCom-
	      ponent 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	param-
	      eters  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,  pro-
	      vided that the raster position is	valid. Use gl:rasterPos2d/2 or
	      gl:windowPos2d/2 to set the current raster position; use gl:get-
	      Booleanv/1  with	argument  ?GL_CURRENT_RASTER_POSITION_VALID to
	      determine	if the specified raster	position is valid, and gl:get-
	      Booleanv/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  com-
	      mands:  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	speci-
	      fied 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_UN-
	      SIGNED_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_UN-
	      SIGNED_BYTE_3_3_2	   ,	 ?GL_UNSIGNED_SHORT_5_6_5,     ?GL_UN-
	      SIGNED_SHORT_4_4_4_4,   ?GL_UNSIGNED_SHORT_5_5_5_1   ,   ?GL_UN-
	      SIGNED_INT_8_8_8_8,  or  ?GL_UNSIGNED_INT_10_10_10_2,  each  un-
	      signed 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  in-
	      terpreted	 as containing all color components, specified by For-
	      mat , 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:pixel-
	      Storef/2 ).

	      widthAheight 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	 argu-
	      ment ?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_UN-
	      PACK_BUFFER target (see gl:bindBuffer/2 )	while a	block of  pix-
	      els is specified,	Data is	treated	as a byte offset into the buf-
	      fer object's data	store.

	      The widthAheight pixels that are read from memory	are each oper-
	      ated  on in the same way,	based on the values of several parame-
	      ters 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 mem-
	      ory 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 nega-
	      tive,  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  in-
	      dex.  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  con-
	      verted  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 nega-
	      tive, 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 num-
	      ber 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 af-
	      fect these write operations.

	      ?GL_DEPTH_COMPONENT: Each	pixel  is  a  single-depth  component.
	      Floating-point  data is converted	directly to an internal	float-
	      ing-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	float-
	      ing-point	format such that the most positive representable inte-
	      ger value	maps to	1.0, and the most negative representable value
	      maps to -1.0. (Note that this mapping does not  convert  0  pre-
	      cisely  to  0.0.)	Unsigned integer data is mapped	similarly: The
	      largest integer value maps to 1.0, and 0 maps to	0.0.  The  re-
	      sulting  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  re-
	      spectively.

	      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 coordi-
	      nates 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	compo-
	      nent 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	compo-
	      nent 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,  fol-
	      lowed  by	green, followed	by blue; for ?GL_BGR, the first	compo-
	      nent 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 con-
	      version, the pixel is treated as if it had been read as an  RGBA
	      pixel.

	      ?GL_LUMINANCE_ALPHA:  Each pixel is a two-component group: lumi-
	      nance 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 lumi-
	      nance 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  con-
	      stants 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  re-
	      versed 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 re-
	      versed 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  re-
	      versed 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 re-
	      versed 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 re-
	      versed 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	depen-
	      dent 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:pixel-
	      Zoom/2 . This reference page describes the effects on  gl:copyP-
	      ixels 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  cur-
	      rently  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  replace-
	      ment  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 com-
	      ponents 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  com-
	      ponent 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 co-
	      ordinates	(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	gener-
	      ated 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 con-
	      verted directly to an internal floating-point  format  with  un-
	      specified	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 co-
	      ordinates	(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	gener-
	      ated 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 unspeci-
	      fied  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	other-
	      wise 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 re-
	      placement	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 writ-
	      ten  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  af-
	      fect 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 rectan-
	      gle, 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 us-
	      ing the stencil planes to	mask out portions of the screen. Sten-
	      ciling  is  typically  used in multipass rendering algorithms to
	      achieve special effects, such as	decals,	 outlining,  and  con-
	      structive	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  parame-
	      ters;  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 compari-
	      son function. It accepts one of eight values, shown in the  fol-
	      lowing  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 com-
	      parison.

	      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  buf-
	      fer.

	      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-fac-
	      ing  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 spe-
	      cial 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  af-
	      fects  front-facing polygons as well as other non-polygon	primi-
	      tives. 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 in-
	      cremented	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 buf-
	      fer, 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 num-
	      ber 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_OB-
	      JECT_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_REFLEC-
	      TION_MAP.	If Pname is either ?GL_OBJECT_PLANE or	?GL_EYE_PLANE,
	      Params  contains coefficients for	the corresponding texture gen-
	      eration function.

	      If the texture generation	 function  is  ?GL_OBJECT_LINEAR,  the
	      function

	      g=p 1Ax o+p 2Ay o+p 3Az o+p 4Aw 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 coordi-
	      nates of the vertex. This	function can be	used, for example,  to
	      texture-map  terrain  using  sea level as	a reference plane (de-
	      fined by p 1, p 2, p 3, and p 4).	The altitude of	a terrain ver-
	      tex  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	 func-
	      tion

	      g=(p 1)"Ax e+(p 2)"Ay e+(p 3)"Az e+(p 4)"Aw 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 ver-
	      tex, 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	 coor-
	      dinates  that  can  produce  dynamic contour lines on moving ob-
	      jects.

	      If the texture generation	function is ?GL_SPHERE_MAP  and	 Coord
	      is either	?GL_S or ?GL_T,	s and t	texture	coordinates are	gener-
	      ated as follows. Let u be	the unit vector	pointing from the ori-
	      gin  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 tex-
	      ture-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 coordi-
	      nate 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  tex-
	      ture 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	= {float()}

	      See texGend/3

       texGenfv(Coord, Pname, Params) -> ok

	      Types:

		 Coord = enum()
		 Pname = enum()
		 Params	= {float()}

	      See texGend/3

       texGeniv(Coord, Pname, Params) -> ok

	      Types:

		 Coord = enum()
		 Pname = enum()
		 Params	= {integer()}

	      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:tex-
	      Gend/3  .	 Coord	names  one of the (s, t, r, q) texture coordi-
	      nates, 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 coeffi-
	      cients 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  coeffi-
	      cients  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(),	 inte-
       ger()}

	      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	= {float()}

	      Set texture environment parameters

	      A	 texture  environment  specifies how texture values are	inter-
	      preted when a fragment is	 textured.  When  Target  is  ?GL_TEX-
	      TURE_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_AL-
	      PHA.

	      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	compo-
	      nents.  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:texPa-
	      rameterf/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 process-
	      ing  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_MOD-
	      ULATE  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_COM-
	      BINE_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 rep-
	      resented	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 Arg0AArg1
	      ?GL_ADD Arg0+Arg1
	      ?GL_ADD_SIGNED Arg0+Arg1-0.5
	      ?GL_INTERPOLATE Arg0AArg2+Arg1A(1- Arg2)
	      ?GL_SUBTRACT Arg0-Arg1
	      ?GL_DOT3_RGB    or   ?GL_DOT3_RGBA   4A((((Arg0	r)-0.5)A((Arg1
	      r)-0.5))+(((Arg0 g)-0.5)A((Arg1 g)-0.5))+(((Arg0	b)-0.5)A((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_MOD-
	      ULATE,  ?GL_ADD,	?GL_ADD_SIGNED,	 ?GL_INTERPOLATE,  or ?GL_SUB-
	      TRACT. The following table describes how alpha values  are  com-
	      bined:?GL_COMBINE_ALPHATexture Function
	      ?GL_REPLACE Arg0
	      ?GL_MODULATE Arg0AArg1
	      ?GL_ADD Arg0+Arg1
	      ?GL_ADD_SIGNED Arg0+Arg1-0.5
	      ?GL_INTERPOLATE Arg0AArg2+Arg1A(1- Arg2)
	      ?GL_SUBTRACT Arg0-Arg1

	      In the following tables, the value C s represents	the color sam-
	      pled from	the currently bound texture, C c represents  the  con-
	      stant  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	 oper-
	      ands:?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_AL-
	      PHA?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, respec-
	      tively, and clamped to the range [0 1].

	      If Pname is ?GL_TEXTURE_ENV_COLOR, Params	is a pointer to	an ar-
	      ray  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_TEX-
	      TURE_MIN_FILTER, will be sampled.

	      ?GL_TEXTURE_ENV_MODE  defaults  to  ?GL_MODULATE	and   ?GL_TEX-
	      TURE_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	= {integer()}

	      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  en-
	      vironment	 that was specified with gl:texEnvfv/3 . Target	speci-
	      fies 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_AL-
	      PHA_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  fol-
	      lows:

	      ?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 nega-
	      tive 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 ini-
	      tial value is ?GL_TEXTURE.

	      ?GL_SRC1_ALPHA: Params returns a single symbolic constant	 value
	      representing  the	 texture combiner one's	alpha source. The ini-
	      tial value is ?GL_PREVIOUS.

	      ?GL_SRC2_ALPHA: Params returns a single symbolic constant	 value
	      representing  the	 texture combiner two's	alpha source. The ini-
	      tial 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 rep-
	      resenting	 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	repre-
	      senting  the current point sprite	texture	coordinate replacement
	      enable state. The	initial	value is ?GL_FALSE .

	      See external documentation.

       getTexEnviv(Target, Pname) -> {integer(), integer(),  integer(),	 inte-
       ger()}

	      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_TEX-
	      TURE_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 de-
	      fined mipmap level. This is an integer value. The	initial	 value
	      is 0.

	      ?GL_TEXTURE_BORDER_COLOR:	The data in Params specifies four val-
	      ues 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 substi-
	      tuted for	the non-existent texel data. If	the  texture  contains
	      depth   components,  the	first  component  of  ?GL_TEXTURE_BOR-
	      DER_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_TEX-
	      TURE. 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&ne; (D t))
	      ?GL_NOTEQUAL result={1.0 0.0 r&ne;(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 in-
	      ternal 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  con-
	      stant ?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  ei-
	      ther  the	nearest	texture	elements or a weighted average of mul-
	      tiple 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	dimen-
	      sions 2 nA2 m, there are max(n m)+1 mipmaps. The first mipmap is
	      the original texture, with dimensions 2 nA2 m.  Each  subsequent
	      mipmap  has  dimensions 2(k-1)A2(l-1), where 2 kA2 l are the di-
	      mensions of the previous mipmap, until either  k=0  or  l=0.  At
	      that  point,  subsequent	mipmaps	 have  dimension  1A2(l-1)  or
	      2(k-1)A1 until the final mipmap, which has dimension 1A1.	To de-
	      fine  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 1A1
	      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 coordi-
	      nates.

	      ?GL_LINEAR: Returns the weighted average of the four texture el-
	      ements  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	speci-
	      fied 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 el-
	      ements 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	speci-
	      fied 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 pro-
	      duce 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 ren-
	      dered and	can produce moire patterns or ragged transitions.  The
	      initial	 value	  of   ?GL_TEXTURE_MIN_FILTER	is   ?GL_NEAR-
	      EST_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_LIN-
	      EAR .

	      ?GL_NEAREST: Returns the value of	the texture  element  that  is
	      nearest (in Manhattan distance) to the specified texture coordi-
	      nates.

	      ?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_TEX-
	      TURE_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 reso-
	      lution 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_TEX-
	      TURE_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  re-
	      turned  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_TEX-
	      TURE_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 coordi-
	      nate  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_BOR-
	      DER_COLOR. ?GL_REPEAT causes the integer part of the  s  coordi-
	      nate  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 coordi-
	      nate  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 coordi-
	      nate  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	= {float()}

	      See texParameterf/3

       texParameteriv(Target, Pname, Params) ->	ok

	      Types:

		 Target	= enum()
		 Pname = enum()
		 Params	= {integer()}

	      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_RECTAN-
	      GLE,  ?GL_TEXTURE_CUBE_MAP,  ?GL_TEXTURE_CUBE_MAP_ARRAY  specify
	      one-, two-, or three-dimensional,	one-dimensional	array, two-di-
	      mensional	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	magni-
	      fication	filter,	 a  symbolic  constant.	 The  initial value is
	      ?GL_LINEAR.

	      ?GL_TEXTURE_MIN_FILTER: Returns the single-valued	texture	 mini-
	      fication	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	float-
	      ing-point	representation such that 1.0 maps to the most positive
	      representable integer and	-1.0 maps to the most negative	repre-
	      sentable integer.	The initial value is (0, 0, 0, 0).

	      ?GL_TEXTURE_COMPARE_MODE:	 Returns  a single-valued texture com-
	      parison  mode,  a	 symbolic  constant.  The  initial  value   is
	      ?GL_NONE.	See gl:texParameterf/3 .

	      ?GL_TEXTURE_COMPARE_FUNC:	 Returns  a single-valued texture com-
	      parison 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:texParame-
	      terf/3 , gl:getTexParameter accepts the following	read-only  pa-
	      rameters:

	      ?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 val-
	      ues 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_TEX-
	      TURE_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_NEGA-
	      TIVE_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 ac-
	      commodated, 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	compo-
	      nent.  The  types	 ?GL_NONE  ,  ?GL_SIGNED_NORMALIZED,   ?GL_UN-
	      SIGNED_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	inter-
	      nal format. The initiali value is	?GL_FALSE .

	      ?GL_TEXTURE_COMPRESSED_IMAGE_SIZE: Params	returns	a single inte-
	      ger value, the number of unsigned	bytes of the  compressed  tex-
	      ture  image  that	 would be returned from	gl:getCompressedTexIm-
	      age/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 de-
	      scribe 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 capabili-
	      ties. If the implementation cannot handle	a texture of  the  re-
	      quested  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  se-
	      quence of	signed or unsigned bytes, shorts, or longs, or single-
	      precision	floating-point values, depending on Type . These  val-
	      ues  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_UN-
	      PACK_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 ar-
	      ray. Subsequent elements progress	left-to-right through the  re-
	      maining  texels  in  the texture array. The final	element	corre-
	      sponds 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 con-
	      verts 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  attach-
	      ing 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	compo-
	      nent 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	 reso-
	      lution or	in a certain format, it	can request the	resolution and
	      format with InternalFormat . The GL will choose an internal rep-
	      resentation  that	 closely approximates that requested by	Inter-
	      nalFormat	, 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  com-
	      pressed 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_COM-
	      PRESSED_RGB, or ?GL_COMPRESSED_RGBA, the GL will replace the in-
	      ternal format with the symbolic constant for a specific internal
	      format  and  compress  the  texture before storage. If no	corre-
	      sponding internal	format is available, or	the GL	can  not  com-
	      press  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&le; 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 tex-
	      ture 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 co-
	      ordinates	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, For-
       mat, 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 de-
	      scribe the parameters of the  texture  image,  such  as  height,
	      width,  width of the border, level-of-detail number (see gl:tex-
	      Parameterf/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 han-
	      dle  a texture of	the requested texture size, it sets all	of the
	      image state to 0,	but does not generate an error (see  gl:getEr-
	      ror/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 se-
	      quence of	signed or unsigned bytes, shorts, or longs, or single-
	      precision	 floating-point	values,	depending on Type . These val-
	      ues 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 ar-
	      ray of one-dimensional images.

	      If a non-zero named buffer object	is bound to the	 ?GL_PIXEL_UN-
	      PACK_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  im-
	      age.  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  at-
	      taching 0	for blue, and 1	for alpha. Each	component is then mul-
	      tiplied 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  attach-
	      ing 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	compo-
	      nent 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 reso-
	      lution or	in a certain format, it	can request the	resolution and
	      format with InternalFormat . The GL will choose an internal rep-
	      resentation that closely approximates that requested  by	Inter-
	      nalFormat	 ,  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 com-
	      pressed 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_COM-
	      PRESSED_RGB, or ?GL_COMPRESSED_RGBA, the GL will replace the in-
	      ternal format with the symbolic constant for a specific internal
	      format and compress the texture before  storage.	If  no	corre-
	      sponding	internal  format  is available,	or the GL can not com-
	      press 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  conver-
	      sion from	the sRGB encoded component c s to a linear component c
	      l	is:

	      c	l={ c s/12.92if	c s&le;	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 tar-
	      get  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:get-
	      TexLevelParameterfv/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  co-
	      ordinates	 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	speci-
	      fies  whether  the  desired  texture  image  is one specified by
	      gl:texImage1D/8  (?GL_TEXTURE_1D	),  gl:texImage2D/9  (?GL_TEX-
	      TURE_1D_ARRAY,  ?GL_TEXTURE_RECTANGLE,  ?GL_TEXTURE_2D or	any of
	      ?GL_TEXTURE_CUBE_MAP_*), or gl:texImage3D/10 (?GL_TEXTURE_2D_AR-
	      RAY  , ?GL_TEXTURE_3D). Level specifies the level-of-detail num-
	      ber 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 tex-
	      ture  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  se-
	      lected 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	excep-
	      tion 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 im-
	      ages.

	      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  tex-
	      tures  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:getTexLevelParam-
	      eterfv/3 to determine the	dimensions of the internal texture im-
	      age, then	scale the required number of pixels by the storage re-
	      quired 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; how-
	      ever, 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 re-
	      turned 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  con-
	      tents or dimensionality, and its name is free for	reuse (for ex-
	      ample by gl:genTextures/1	). If  a  texture  that	 is  currently
	      bound  is	 deleted,  the	binding	reverts	to 0 (the default tex-
	      ture).

	      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_TEX-
	      TURE_2D,	?GL_TEXTURE_3D	,  or  ?GL_TEXTURE_1D_ARRAY,  ?GL_TEX-
	      TURE_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. Tex-
	      ture 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 win-
	      dows 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-di-
	      mensional	texture, a texture first bound to  ?GL_TEXTURE_3D  be-
	      comes  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-dimen-
	      sional arary texture, a texture first bound to  ?GL_TEXTURE_REC-
	      TANGLE  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-dimen-
	      sional multisampled  texture,  and  a  texture  first  bound  to
	      ?GL_TEXTURE_2D_MULTISAMPLE_ARRAY	becomes	a two-dimensional mul-
	      tisampled	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	 simi-
	      larly 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 ef-
	      fect, the	texture	targets	become aliases for the	textures  cur-
	      rently  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 un-
	      til  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	origi-
	      nal  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 tar-
	      get 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  determin-
	      ing 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 in-
	      dicates 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 ex-
	      isting texture.

	      gl:prioritizeTextures does not require that any of the  textures
	      named  by	 Textures  be bound to a texture target. gl:texParame-
	      terf/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  re-
	      turns  ?GL_FALSE,	 and detailed status is	returned in the	N ele-
	      ments 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 argu-
	      ment 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:readPix-
	      els/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	corre-
	      spond 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  cur-
	      rent  rendering context, then the	values obtained	for those pix-
	      els 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, Bor-
       der) -> 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  for-
	      mat of the texture array.

	      The pixels in the	rectangle are processed	exactly	as if gl:read-
	      Pixels/7 had been	called,	but the	process	stops just before  fi-
	      nal  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  cur-
	      rent  ?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:texSubIm-
	      age1D/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 des-
	      tination 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:readPix-
	      els/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	param-
	      eters 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-di-
	      mensional	 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 xoff-
	      set+width-1, inclusive, and  y  indices  Yoffset	through	 yoff-
	      set+height -1, inclusive,	at the mipmap level specified by Level
	      .

	      The pixels in the	rectangle are processed	exactly	as if gl:read-
	      Pixels/7	had been called, but the process stops just before fi-
	      nal 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	speci-
	      fied. 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 cur-
	      rent ?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  bor-
	      der 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 spe-
	      cific 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	 func-
	      tion.  One-dimensional  evaluators  return order control points,
	      and  two-dimensional  evaluators	return	uorderAvorder  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  or-
	      der,  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 inte-
	      ger 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 .	 Inte-
	      ger  values, when	requested, are computed	by rounding the	inter-
	      nal 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	 simu-
	      lated.  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  en-
	      abled, 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	evalu-
	      ations 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  com-
	      mands,  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 re-
	      cent gl:color3b/3	, gl:indexd/1 ,	gl:normal3b/3 ,	and  gl:texCo-
	      ord1d/1 commands.

	      No  commands  are	 issued	for maps that are not enabled. If more
	      than one texture evaluation is enabled for a  particular	dimen-
	      sion  (for  example,  ?GL_MAP2_TEXTURE_COORD_1 and ?GL_MAP2_TEX-
	      TURE_COORD_2 ), then only	the evaluation of the  map  that  pro-
	      duces   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	dimen-
	      sion, 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	gener-
	      ates surface normals analytically, regardless of the contents or
	      enabling of the ?GL_MAP2_NORMAL map. Let

	      m=((&PartialD;  p)/(&PartialD;  u))A((&PartialD;	p)/(&PartialD;
	      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  val-
	      ues.  gl:evalMesh1/3  steps through the integer domain of	a one-
	      or two-dimensional grid, whose range is the domain of the	evalu-
	      ation maps specified by gl:map1d/6 and gl:map1d/6	.

	      gl:mapGrid1 and gl:mapGrid2 specify the linear grid mappings be-
	      tween 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  coordi-
	      nate  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 effi-
	      ciently generate and evaluate a series of	evenly spaced map  do-
	      main  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.&Delta;	u+u 1 ); where &Delta; u=(u 2-u	1)/n

	      and n, u 1, and u	2 are the arguments to the most	recent gl:map-
	      Grid1d/3	command.  The one absolute numeric requirement is that
	      if i=n, then the value computed from i.&Delta; u+u 1 is  exactly
	      u	2.

	      In the two-dimensional case, gl:evalPoint2, let

	      &Delta; u=(u 2-u 1)/n

	      &Delta; 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. &Delta; u+u 1, j.&Delta;
	      v+v 1 ); The only	absolute numeric requirements are that if i=n,
	      then the value computed from i.&Delta; u+u 1 is exactly u	2, and
	      if j=m, then the value computed from j.&Delta; 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  val-
	      ues.  gl:evalMesh	 steps through the integer domain of a one- or
	      two-dimensional grid, whose range	is the domain of  the  evalua-
	      tion  maps  specified by gl:map1d/6 and gl:map1d/6 . Mode	deter-
	      mines 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.&Delta;	u+u 1 ); glEnd(); where

	      &Delta; u=(u 2-u 1)/n

	      and n, u 1, and u	2 are the arguments to the most	recent gl:map-
	      Grid1d/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.&Delta; u+u	1 is exactly u 2.

	      In the two-dimensional case, gl:evalMesh2, let .cp &Delta;  u=(u
	      2-u 1)/n

	      &Delta; 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.&Delta;  u+u  1,
	      j.&Delta;	 v+v  1	); glEvalCoord2( i.&Delta; u+u 1,(j+1).&Delta;
	      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.&Delta;	u+u 1,
	      j.&Delta;	 v+v 1 ); glEnd(); } for ( i = I1 ; i <= I2 ; i	+= 1 )
	      {	glBegin( GL_LINE_STRIP ); for (	j = J1 ; j <= J1 ; j  +=  1  )
	      glEvalCoord2( i.&Delta; u+u 1, j.	&Delta;	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.&Delta;	u+u 1,
	      j.&Delta;	v+v 1 ); glEnd();

	      In all three cases, the only absolute numeric  requirements  are
	      that if i=n, then	the value computed from	i.&Delta; u+u 1	is ex-
	      actly u 2, and if	j=m, then the value  computed  from  j.&Delta;
	      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	opera-
	      tions.  To  enable  and disable fog, call	gl:enable/1 and	gl:en-
	      able/1 with argument ?GL_FOG.

	      gl:fog assigns the value or values in Params to the fog  parame-
	      ter  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 sym-
	      bolic 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 expo-
	      nential  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  conver-
	      sion,  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  sym-
	      bolic    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 com-
	      puted  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]  af-
	      ter  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)"=fAC r+(1-f)AC 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)Ai f

	      See external documentation.

       fogi(Pname, Param) -> ok

	      Types:

		 Pname = enum()
		 Param = integer()

	      See fogf/2

       fogfv(Pname, Params) -> ok

	      Types:

		 Pname = enum()
		 Params	= {float()}

	      See fogf/2

       fogiv(Pname, Params) -> ok

	      Types:

		 Pname = enum()
		 Params	= {integer()}

	      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:ren-
	      derMode/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 sym-
	      bolic 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 re-
	      turns the	number of entries placed in the	feedback array and re-
	      sets the feedback	array pointer to the base of the feedback buf-
	      fer. The returned	value never exceeds Size  .  If	 the  feedback
	      data  required  more room	than was available in Buffer , gl:ren-
	      derMode/1	returns	a negative value. To take the GL out of	 feed-
	      back  mode,  call	 gl:renderMode/1  with a parameter value other
	      than ?GL_FEEDBACK.

	      While in feedback	mode, each primitive, bitmap, or pixel rectan-
	      gle  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	imple-
	      mentation	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 val-
	      ues in RGBA mode and one value in	color index mode.

	      feedbackList a feedbackItem feedbackList | feedbackItem

	      feedbackItem a point | lineSegment | polygon | bitmap  |	pixel-
	      Rectangle	| passThru

	      point a?GL_POINT_TOKEN vertex

	      lineSegment a?GL_LINE_TOKEN vertex vertex	| ?GL_LINE_RESET_TOKEN
	      vertex vertex

	      polygon a?GL_POLYGON_TOKEN n polySpec

	      polySpec a polySpec vertex | vertex vertex vertex

	      bitmap a?GL_BITMAP_TOKEN vertex

	      pixelRectangle a?GL_DRAW_PIXEL_TOKEN vertex | ?GL_COPY_PIXEL_TO-
	      KEN vertex

	      passThru a?GL_PASS_THROUGH_TOKEN value

	      vertex a 2d | 3d | 3dColor | 3dColorTexture | 4dColorTexture

	      2d a value value

	      3d a value value value

	      3dColor a	value value value color

	      3dColorTexture a value value value color tex

	      4dColorTexture a value value value value color tex

	      color a rgba | index

	      rgba a value value value value

	      index a value

	      tex a value value	value value

	      value  is	a floating-point number, and n is a floating-point in-
	      teger  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 when-
	      ever  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, informa-
	      tion  about  primitives  that  would have	been rasterized	is fed
	      back to the application  using  the  GL.	See  the  gl:feedback-
	      Buffer/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 ar-
	      ray of unsigned integers,	and Size indicates the size of the ar-
	      ray.  Buffer  returns  values  from the name stack (see gl:init-
	      Names/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 rasteri-
	      zation. 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 oc-
	      curred since the last such event (name stack change  or  gl:ren-
	      derMode/1	 call).	The hit	record consists	of the number of names
	      in the name stack	at the time of the event, followed by the min-
	      imum 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 se-
	      lection 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  ma-
	      nipulate	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 ren-
	      der 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 des-
	      tination	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  com-
	      ponents  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 an-
	      tialiasing and transparency, among other things.

	      Initially, both the RGB blend equation and the alpha blend equa-
	      tion 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	,  in-
	      clusive.

	      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_IN-
	      DICES . If end-start+1 is	greater	than the value of ?GL_MAX_ELE-
	      MENTS_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.  At-
	      tributes 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 de-
	      scribe 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  capabili-
	      ties.  If	 the implementation cannot handle a texture of the re-
	      quested 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 se-
	      quence of	signed or unsigned bytes, shorts, or longs, or single-
	      precision	 floating-point	values,	depending on Type . These val-
	      ues 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_UN-
	      PACK_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 im-
	      age. 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 attach-
	      ing 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	compo-
	      nent 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	 reso-
	      lution or	in a certain format, it	can request the	resolution and
	      format with InternalFormat . The GL will choose an internal rep-
	      resentation  that	 closely approximates that requested by	Inter-
	      nalFormat	, 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  com-
	      pressed 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_COM-
	      PRESSED_RGB, or ?GL_COMPRESSED_RGBA, the GL will replace the in-
	      ternal format with the symbolic constant for a specific internal
	      format  and  compress  the  texture before storage. If no	corre-
	      sponding internal	format is available, or	the GL	can  not  com-
	      press  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  com-
	      ponent c l is:

	      c	 l={  c	s/12.92if c s&le; 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 tex-
	      ture 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 por-
	      tion of the texture array	with x indices Xoffset	through	 xoff-
	      set+width-1,  inclusive,	and  y	indices	 Yoffset through yoff-
	      set+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:read-
	      Pixels/7 had been	called,	but the	process	stops just before  fi-
	      nal  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	speci-
	      fied. 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  cur-
	      rent ?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_UN-
	      PACK_BUFFER target (see gl:bindBuffer/2 )	while a	color table is
	      specified,  Data is treated as a byte offset into	the buffer ob-
	      ject'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  val-
	      ues  of the pixel	(R, G, B, and A) to the	values included	in the
	      internal format (red, green, blue, alpha,	luminance, and	inten-
	      sity).  The mapping is as	follows:Internal FormatRedGreenBlueAl-
	      phaLuminanceIntensity
	      ?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	inten-
	      sity  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_TA-
	      BLE_RED_SIZE,	?GL_COLOR_TABLE_GREEN_SIZE,	 ?GL_COLOR_TA-
	      BLE_BLUE_SIZE  , ?GL_COLOR_TABLE_ALPHA_SIZE, ?GL_COLOR_TABLE_LU-
	      MINANCE_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:getCol-
	      orTableParameterfv/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 fol-
	      lows: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_CONVO-
	      LUTION_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 result-
	      ing from the color matrix	operation are mapped by	the post color
	      matrix color lookup table	before being used by the histogram op-
	      eration.

	      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_MA-
	      TRIX_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  or-
	      der.

	      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:col-
	      orTable/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  cur-
	      rent  ?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:readPix-
	      els/7 were called, with Internalformat set to RGBA, but process-
	      ing 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 val-
	      ues of the pixel (R, G, B, and A)	to the values included in  the
	      internal	format (red, green, blue, alpha, luminance, and	inten-
	      sity). The mapping is as follows:Internal	 FormatRedGreenBlueAl-
	      phaLuminanceIntensity
	      ?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	inten-
	      sity 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  ta-
	      ble  specified by	Target . No pixel transfer operations are per-
	      formed, but pixel	storage	modes that are applicable to  gl:read-
	      Pixels/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 his-
	      togram  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 areInter-
	      nal 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_TA-
	      BLE_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_MA-
	      TRIX_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  for-
	      mat  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:col-
	      orTable/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(), inte-
       ger(), 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 pix-
	      els 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  ef-
	      fect.

	      If  a non-zero named buffer object is bound to the ?GL_PIXEL_UN-
	      PACK_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 fil-
	      ter 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_UN-
	      PACK_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_CONVOLU-
	      TION_FILTER_SCALE	and ?GL_CONVOLUTION_FILTER_BIAS	. The  parame-
	      ters  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  val-
	      ues  of the pixel	(R, G, B, and A) to the	values included	in the
	      internal format (red, green, blue, alpha,	luminance, and	inten-
	      sity).  The mapping is as	follows:Internal FormatRedGreenBlueAl-
	      phaLuminanceIntensity
	      ?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	compo-
	      nents  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_CON-
	      VOLUTION_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 fil-
	      ter 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  fi-
	      nal expansion to RGBA is completed.

	      If  a non-zero named buffer object is bound to the ?GL_PIXEL_UN-
	      PACK_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_CONVOLU-
	      TION_FILTER_SCALE	 and ?GL_CONVOLUTION_FILTER_BIAS . The parame-
	      ters 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 val-
	      ues of the pixel (R, G, B, and A)	to the values included in  the
	      internal	format (red, green, blue, alpha, luminance, and	inten-
	      sity). The mapping is as follows:Internal	 FormatRedGreenBlueAl-
	      phaLuminanceIntensity
	      ?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	compo-
	      nents 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_CON-
	      VOLUTION_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	= {float()}

	      Set convolution parameters

	      gl:convolutionParameter sets the value of	a convolution  parame-
	      ter.

	      Target selects the convolution filter to be affected: ?GL_CONVO-
	      LUTION_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_FIL-
	      TER_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  de-
	      tails. 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	convo-
	      lution 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 con-
	      volved  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 convolu-
	      tion  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  out-
	      ermost pixel on the border of the	source image were replicated.

	      See external documentation.

       convolutionParameterfv(Target::enum(), Pname::enum(), Params) ->	ok

	      Types:

		 Params	= {Params::{float()}}

	      Equivalent to convolutionParameterf(Target, Pname, Params).

       convolutionParameteri(Target, Pname, Params) -> ok

	      Types:

		 Target	= enum()
		 Pname = enum()
		 Params	= {integer()}

	      See convolutionParameterf/3

       convolutionParameteriv(Target::enum(), Pname::enum(), Params) ->	ok

	      Types:

		 Params	= {Params::{integer()}}

	      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:convolu-
	      tionFilter1D/6 ).

	      The screen-aligned pixel rectangle with lower-left corner	at ( X
	      ,	 Y  ), width Width and height 1	is used	to define the convolu-
	      tion filter. If any pixels within	this region  are  outside  the
	      window  that  is	associated with	the GL context,	the values ob-
	      tained for those pixels are undefined.

	      The pixels in the	rectangle are processed	exactly	as if gl:read-
	      Pixels/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_CON-
	      VOLUTION_FILTER_SCALE parameters	and  biased  by	 the  four  1D
	      ?GL_CONVOLUTION_FILTER_BIAS  parameters. (The scale and bias pa-
	      rameters	are  set  by  gl:convolutionParameterf/3   using   the
	      ?GL_CONVOLUTION_1D  target  and  the  names ?GL_CONVOLUTION_FIL-
	      TER_SCALE	and ?GL_CONVOLUTION_FILTER_BIAS	. The parameters them-
	      selves  are  vectors  of	four  values  that are applied to red,
	      green, blue, and alpha, in that order.) The R, G,	B, and A  val-
	      ues 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  val-
	      ues  of the pixel	(R, G, B, and A) to the	values included	in the
	      internal format (red, green, blue, alpha,	luminance, and	inten-
	      sity).  The mapping is as	follows:Internal FormatRedGreenBlueAl-
	      phaLuminanceIntensity
	      ?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	compo-
	      nents  of	 the  resulting	 pixels	 are  stored in	floating-point
	      rather than integer format.

	      Pixel ordering is	such that lower	x  screen  coordinates	corre-
	      spond 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_CON-
	      VOLUTION_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:convolu-
	      tionFilter2D/7 ).

	      The screen-aligned pixel rectangle with lower-left corner	at ( X
	      ,	 Y ), width Width and height Height is used to define the con-
	      volution 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:read-
	      Pixels/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_CON-
	      VOLUTION_FILTER_SCALE parameters	and  biased  by	 the  four  2D
	      ?GL_CONVOLUTION_FILTER_BIAS  parameters. (The scale and bias pa-
	      rameters	are  set  by  gl:convolutionParameterf/3   using   the
	      ?GL_CONVOLUTION_2D  target  and  the  names ?GL_CONVOLUTION_FIL-
	      TER_SCALE	and ?GL_CONVOLUTION_FILTER_BIAS	. The parameters them-
	      selves  are  vectors  of	four  values  that are applied to red,
	      green, blue, and alpha, in that order.) The R, G,	B, and A  val-
	      ues 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  val-
	      ues  of the pixel	(R, G, B, and A) to the	values included	in the
	      internal format (red, green, blue, alpha,	luminance, and	inten-
	      sity).  The mapping is as	follows:Internal FormatRedGreenBlueAl-
	      phaLuminanceIntensity
	      ?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	compo-
	      nents  of	 the  resulting	 pixels	 are  stored in	floating-point
	      rather than integer format.

	      Pixel ordering is	such that lower	x  screen  coordinates	corre-
	      spond  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_CON-
	      VOLUTION_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 con-
	      volution	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 as-
	      signments	of internal color components to	the components of For-
	      mat 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 de-
	      termines 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 col-
	      ors.

	      ?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  fac-
	      tors 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:con-
	      volutionFilter1D/6  ,  gl:convolutionFilter2D/7 ,	and gl:separa-
	      bleFilter2D/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(),  in-
       teger(),	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 convolu-
	      tion 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_UN-
	      PACK_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_CONVOLU-
	      TION_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_CONVO-
	      LUTION_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 val-
	      ues of the pixel (R, G, B, and A)	to the values included in  the
	      internal	format (red, green, blue, alpha, luminance, and	inten-
	      sity). The mapping is as follows:Internal	 FormatRedGreenBlueAl-
	      phaLuminanceIntensity
	      ?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	compo-
	      nents 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_CON-
	      VOLUTION_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-di-
	      mensional	 image	with the same width as the histogram. No pixel
	      transfer operations are performed	on this	image, but pixel stor-
	      age 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 his-
	      togram  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 his-
	      togram, 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	infor-
	      mation 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 mini-
	      mum 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 For-
	      mat 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  min-
	      max table	by setting Pname to one	of the following values:Param-
	      eterDescription
	      ?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  con-
	      verted  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 de-
	      rived from the R color component determines the luminance	 table
	      entry  to	 be incremented.) If a histogram table entry is	incre-
	      mented beyond its	maximum	value, then its	 value	becomes	 unde-
	      fined. (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	 rede-
	      fined,  but  does	 not actually define the new table. If the re-
	      quested 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 pix-
	      els are compared to the minimum and maximum values for each com-
	      ponent,  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	corre-
	      sponding component in the	maximum	element, then the maximum ele-
	      ment  is updated with the	pixel component	value. If a pixel com-
	      ponent is	less than the corresponding component in  the  minimum
	      element, then the	minimum	element	is updated with	the pixel com-
	      ponent value. (In	both cases, if the internal format of the min-
	      max  table includes luminance, then the R	color component	of in-
	      coming pixels is used for	comparison.) The contents of the  min-
	      max table	may be retrieved at a later time by calling gl:getMin-
	      max/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	compo-
	      nent 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 his-
	      togram 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 mini-
	      mum 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	imple-
	      mentation	 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	imple-
	      mentation-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 determin-
	      ing which	samples	will be	used in	resolving the  final  fragment
	      color.  This mask	is bitwise-anded with the coverage mask	gener-
	      ated 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	gener-
	      ated by combining	several	samples	per pixel.  Each  sample  con-
	      tains  color, depth, and stencil information, allowing those op-
	      erations 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  re-
	      trieved, 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 im-
	      age 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 se-
	      lects from one of	its extensions supporting compressed textures.
	      In  order	 to  load  the	compressed texture image using gl:com-
	      pressedTexImage3D, 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_UN-
	      PACK_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-rec-
	      tangle 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_COM-
	      PRESSED_BLOCK_SIZE,  ?GL_UNPACK_COMPRESSED_BLOCK_WIDTH,  ?GL_UN-
	      PACK_COMPRESSED_BLOCK_HEIGHT	,      and     ?GL_UNPACK_COM-
	      PRESSED_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_IM-
	      AGE_HEIGHT and ?GL_UNPACK_SKIP_IMAGES are	ignored	for compressed
	      images.	 To    enable	?GL_UNPACK_SKIP_PIXELS	 and   ?GL_UN-
	      PACK_ROW_LENGTH ,	b s and	b w must both be non-zero. To also en-
	      able ?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	sA|width b/w|A|height b/h|A|depth b/d|

	      See external documentation.

       compressedTexImage2D(Target, Level, Internalformat, Width, Height, Bor-
       der, 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 re-
	      trieved, compressed two-dimensional texture image	if  Target  is
	      ?GL_TEXTURE_2D,  or  one	of the cube map	faces such as ?GL_TEX-
	      TURE_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 ar-
	      ray, 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 se-
	      lects from one of	its extensions supporting compressed textures.
	      In  order	 to  load  the	compressed texture image using gl:com-
	      pressedTexImage2D, 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_UN-
	      PACK_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-rec-
	      tangle 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_COM-
	      PRESSED_BLOCK_SIZE,  ?GL_UNPACK_COMPRESSED_BLOCK_WIDTH,  ?GL_UN-
	      PACK_COMPRESSED_BLOCK_HEIGHT	,      and     ?GL_UNPACK_COM-
	      PRESSED_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_IM-
	      AGE_HEIGHT and ?GL_UNPACK_SKIP_IMAGES are	ignored	for compressed
	      images.	 To    enable	?GL_UNPACK_SKIP_PIXELS	 and   ?GL_UN-
	      PACK_ROW_LENGTH ,	b s and	b w must both be non-zero. To also en-
	      able ?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	sA|width b/w|A|height b/h|

	      See external documentation.

       compressedTexImage1D(Target, Level, Internalformat, Width, Border, Ima-
       geSize, 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  re-
	      trieved,	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  capabili-
	      ties.  If	 the implementation cannot handle a texture of the re-
	      quested 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 tex-
	      tures.  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_UN-
	      PACK_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-rec-
	      tangle 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_COM-
	      PRESSED_BLOCK_SIZE,  ?GL_UNPACK_COMPRESSED_BLOCK_WIDTH,  ?GL_UN-
	      PACK_COMPRESSED_BLOCK_HEIGHT	,      and     ?GL_UNPACK_COM-
	      PRESSED_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_IM-
	      AGE_HEIGHT and ?GL_UNPACK_SKIP_IMAGES are	ignored	for compressed
	      images.	 To    enable	?GL_UNPACK_SKIP_PIXELS	 and   ?GL_UN-
	      PACK_ROW_LENGTH ,	b s and	b w must both be non-zero. To also en-
	      able ?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	sA|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	refer-
	      enced 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 tex-
	      els 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_UN-
	      PACK_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 for-
	      mat

	      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	origi-
	      nally 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_UN-
	      PACK_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,	Image-
       Size, 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 for-
	      mat

	      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 ef-
	      fect.

	      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_UN-
	      PACK_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:texIm-
	      age1D/8 (?GL_TEXTURE_1D),	gl:texImage2D/9	(?GL_TEXTURE_2D	or any
	      of   ?GL_TEXTURE_CUBE_MAP_*  ),  or  gl:texImage3D/10  (?GL_TEX-
	      TURE_3D).	Lod specifies the level-of-detail number  of  the  de-
	      sired image.

	      If   a   non-zero	  named	  buffer   object   is	bound  to  the
	      ?GL_PIXEL_PACK_BUFFER target (see	gl:bindBuffer/2	) while	a tex-
	      ture  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_TEX-
	      TURE_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_TEX-
	      TURE_COMPRESSED_IMAGE_SIZE.  Finally, retrieve the internal for-
	      mat 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  re-
	      trieved  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 pa-
	      rameters 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_CO-
	      ORD_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 de-
	      fines all	four components	explicitly as (s t r q).

	      The current texture coordinates are part of the data that	is as-
	      sociated	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, depend-
	      ing 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-preci-
	      sion 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])A(v[0] v[1]	v[2] v[3])

	      Projection and texture transformations are similarly defined.

	      Calling gl:loadTransposeMatrix with matrix M is identical	in op-
	      eration  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 al-
	      pha 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	multi-
	      plicand,	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	primi-
	      tives  with  very	 few subroutine	calls. Instead of calling a GL
	      procedure	to pass	each individual	vertex,	normal,	texture	 coor-
	      dinate,  edge flag, or color, you	can prespecify separate	arrays
	      of vertices, normals, and	colors and use them to construct a se-
	      quence 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  in-
	      stead.

	      When gl:multiDrawArrays is called, it uses Count sequential ele-
	      ments from each enabled array to construct a sequence of geomet-
	      ric  primitives,	beginning  with	element	First .	Mode specifies
	      what kind	of primitives are constructed, and how the array  ele-
	      ments construct those primitives.

	      Vertex  attributes  that are modified by gl:multiDrawArrays have
	      an  unspecified  value  after  gl:multiDrawArrays	 returns.  At-
	      tributes 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  specify-
	      ing   the	  point	  sprite  texture  coordinate  origin,	either
	      ?GL_LOWER_LEFT or	?GL_UPPER_LEFT.	The default value  is  ?GL_UP-
	      PER_LEFT.

	      See external documentation.

       pointParameterfv(Pname, Params) -> ok

	      Types:

		 Pname = enum()
		 Params	= {float()}

	      See pointParameterf/2

       pointParameteri(Pname, Param) ->	ok

	      Types:

		 Pname = enum()
		 Param = integer()

	      See pointParameterf/2

       pointParameteriv(Pname, Params) -> ok

	      Types:

		 Pname = enum()
		 Params	= {integer()}

	      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 ver-
	      tices 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_BUF-
	      FER target (see gl:bindBuffer/2 )	while a	fog  coordinate	 array
	      is  specified, Pointer is	treated	as a byte offset into the buf-
	      fer  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 cur-
	      rent vertex array	buffer object binding.

	      To enable	and disable the	fog coordinate array, call  gl:enable-
	      ClientState/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:drawEle-
	      ments/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 sec-
	      ondary 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	light-
	      ing  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	 frag-
	      ment,  regardless	of the state of	?GL_COLOR_SUM, under such con-
	      ditions.	When  ?GL_SEPARATE_SPECULAR_COLOR  is  specified,  the
	      value  returned from querying the	current	secondary color	is un-
	      defined.

	      gl:secondaryColor3b,  gl:secondaryColor3s,   and	 gl:secondary-
	      Color3i take three signed	byte, short, or	long integers as argu-
	      ments. 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 unspeci-
	      fied mantissa and	exponent sizes.	Unsigned integer color	compo-
	      nents,  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 in-
	      teger 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 pre-
	      cisely 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  in-
	      terpolated 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_BUF-
	      FER target (see gl:bindBuffer/2 )	while a	secondary color	 array
	      is  specified, Pointer is	treated	as a byte offset into the buf-
	      fer  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_BIND-
	      ING ).

	      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:enable-
	      ClientState/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:mul-
	      tiDrawArrays/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  op-
	      erations

	      The GL maintains a 3D position in	window coordinates. This posi-
	      tion, called the raster position,	is used	to position pixel  and
	      bitmap  write  operations.  It is	maintained with	subpixel accu-
	      racy. See	gl:bitmap/7 , gl:drawPixels/5 ,	and gl:copyPixels/5 .

	      gl:windowPos2 specifies the x and	y coordinates, while z is  im-
	      plicitly	set  to	 0.  gl:windowPos3 specifies all three coordi-
	      nates. 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 pro-
	      jection matrices,	nor by the viewport-to-window transform. The z
	      coordinate of the	current	raster position	is updated in the fol-
	      lowing manner:

	      z={n f(n+zA(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_CUR-
	      RENT_RASTER_INDEX	(in color index	mode) is set to	the color pro-
	      duced by the lighting calculation	(see gl:lightf/3  ,  gl:light-
	      Modelf/2	, and gl:shadeModel/1 ). If lighting is	disabled, cur-
	      rent color (in RGBA mode,	state variable	?GL_CURRENT_COLOR)  or
	      color index (in color index mode,	state variable ?GL_CURRENT_IN-
	      DEX) is used  to	update	the  current  raster  color.  ?GL_CUR-
	      RENT_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_CUR-
	      RENT_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; how-
	      ever,  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:gen-
	      Queries/1	).

	      gl:deleteQueries silently	ignores	0's and	names that do not cor-
	      respond 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_SAM-
	      PLES_PASSED,   ?GL_PRIMITIVES_GENERATED	,  ?GL_TRANSFORM_FEED-
	      BACK_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:begin-
	      Query  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	incre-
	      mented  by  1 for	each fragment. If the value of ?GL_SAMPLE_BUF-
	      FERS is 1, then the samples-passed count is incremented  by  the
	      number  of samples whose coverage	bit is set. However, implemen-
	      tations, 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	previ-
	      ously bound to the ?GL_PRIMITIVES_GENERATED query	binding.  When
	      gl:beginQuery  is	executed, the query object's primitives-gener-
	      ated counter is reset to 0. Subsequent rendering will  increment
	      the counter once for every vertex	that is	emitted	from the geom-
	      etry 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_PRIMI-
	      TIVES_WRITTEN query binding. When	gl:beginQuery is executed, the
	      query object's primitives-written	counter	is reset to 0.	Subse-
	      quent 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	incre-
	      mented.  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:getQueryObjec-
	      tiv/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 re-
	      served,  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  tar-
	      get).  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 ac-
	      cess 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_OPERA-
	      TION 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_INDI-
	      RECT_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_AR-
	      RAY_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  af-
	      fected:  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_UN-
	      PACK_BUFFER target, the following	commands are affected: gl:com-
	      pressedTexImage1D/7 , gl:compressedTexImage2D/8 ,	gl:compressed-
	      TexImage3D/9 , gl:compressedTexSubImage1D/7 ,  gl:compressedTex-
	      SubImage2D/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	param-
	      eter is interpreted as an	offset within the buffer  object  mea-
	      sured in basic machine units.

	      The  buffer targets ?GL_COPY_READ_BUFFER and ?GL_COPY_WRITE_BUF-
	      FER 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 bind-
	      ing 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_BUF-
	      FER 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 ac-
	      tive 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  tar-
	      get  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 ob-
	      ject).

	      gl:deleteBuffers silently	ignores	0's and	names that do not cor-
	      respond 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	 inte-
	      gers;  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 oc-
	      curs, 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  ob-
	      ject's  data  store will be accessed. This enables the GL	imple-
	      mentation	to make	more intelligent decisions that	 may  signifi-
	      cantly  impact  buffer object performance. It does not, however,
	      constrain	the actual usage of the	data store. Usage can be  bro-
	      ken down into two	parts: first, the frequency of access (modifi-
	      cation 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	appli-
	      cation.

	      COPY: The	data store contents are	modified by reading data  from
	      the GL, and used as the source for GL drawing and	image specifi-
	      cation 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  pat-
	      tern. 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 sepa-
	      rately

	      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 equa-
	      tion 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:blendEquationSepa-
	      rate 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 com-
	      ponents 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 an-
	      tialiasing and transparency, among other things.

	      Initially, both the RGB blend equation and the alpha blend equa-
	      tion 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	 vari-
	      ables,  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  fol-
	      lowing:

	      ?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 writ-
	      ten  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 buf-
	      fers 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 spe-
	      cial  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 af-
	      fects front-facing polygons as well as other non-polygon	primi-
	      tives.  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	possi-
	      ble.

	      ?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 in-
	      cremented	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  con-
	      stants  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 spe-
	      cial 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  parame-
	      ters;  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 compari-
	      son function. It accepts one of eight values, shown in the  fol-
	      lowing  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 com-
	      parison.

	      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  buf-
	      fer.

	      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-fac-
	      ing  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 permis-
	      sible 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	attri-
	      bute variable

	      gl:bindAttribLocation is used to associate a user-defined	attri-
	      bute  variable in	the program object specified by	Program	with a
	      generic vertex attribute index. The name of the user-defined at-
	      tribute 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  de-
	      scriptive	 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 cur-
	      rent 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 In-
	      dex .

	      Attribute	variable name-to-generic attribute index bindings  for
	      a	program	object can be explicitly assigned at any time by call-
	      ing gl:bindAttribLocation. Attribute bindings do not go into ef-
	      fect  until  gl:linkProgram/1  is	called.	After a	program	object
	      has been linked successfully, the	index values for  generic  at-
	      tributes	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 ob-
	      ject'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 pro-
	      vides a mechanism	to specify the shader  objects	that  will  be
	      linked  to create	a program. It also provides a means for	check-
	      ing 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 suc-
	      cessfully	attaching shader objects to it with  gl:attachShader/2
	      ,	 successfully  compiling  the  shader objects with gl:compile-
	      Shader/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_VER-
	      TEX_SHADER is a shader that is intended to run on	 the  program-
	      mable vertex processor. A	shader of type ?GL_TESS_CONTROL_SHADER
	      is a shader that is intended to run on the programmable  tessel-
	      lation  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_FRAG-
	      MENT_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 asso-
	      ciated  with  the	program	object specified by Program. This com-
	      mand effectively undoes the effects of a call  to	 gl:createPro-
	      gram/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 ren-
	      dering context. If a program object to be	deleted	has shader ob-
	      jects 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 dele-
	      tion,   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	 asso-
	      ciated 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  ob-
	      ject,  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 wher-
	      ever 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_STA-
	      TUS.

	      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  de-
	      fault,  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:getPro-
	      gramiv/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  at-
	      tribute 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	speci-
	      fied  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_UN-
	      SIGNED_INT_VEC4,	 ?DOUBLE,  ?DOUBLE_VEC2,  ?DOUBLE_VEC3,	 ?DOU-
	      BLE_VEC4,	 ?DOUBLE_MAT2  ,  ?DOUBLE_MAT3,	 ?DOUBLE_MAT4,	 ?DOU-
	      BLE_MAT2x3,   ?DOUBLE_MAT2x4,   ?DOUBLE_MAT3x2,  ?DOUBLE_MAT3x4,
	      ?DOUBLE_MAT4x2, or ?DOUBLE_MAT4x3	may be returned. The Size  ar-
	      gument  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  val-
	      ues 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:get-
	      Programiv/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:uni-
	      form1f/2 . A uniform variable (either built-in or	 user-defined)
	      is  considered active if it is determined	during the link	opera-
	      tion that	it may be accessed during  program  execution.	There-
	      fore,  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 in-
	      dicated by Index , storing it in the character buffer  specified
	      by  Name	. The string returned will be null terminated. The ac-
	      tual 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 vari-
	      able's data type.	The symbolic constants	returned  for  uniform
	      types  are  shown	 in  the  table	 below.Returned	 Symbolic Con-
	      tantShader 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. In-
	      stead, 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:getU-
	      niformLocation/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	. Uni-
	      form  variables  other than arrays will have a size of 1.	Struc-
	      tures and	arrays of structures will be reduced as	described ear-
	      lier,  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;	other-
	      wise, 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  val-
	      ues 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 at-
	      tached 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:getPro-
	      gramiv/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_AT-
	      TACHED_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  ob-
	      ject  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 ef-
	      fect 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 re-
	      turned 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 cur-
	      rently flagged for deletion, and ?GL_FALSE otherwise.

	      ?GL_LINK_STATUS: Params returns ?GL_TRUE if the last link	opera-
	      tion on Program was successful, and ?GL_FALSE otherwise.

	      ?GL_VALIDATE_STATUS: Params returns ?GL_TRUE or if the last val-
	      idation operation	on Program was successful, and ?GL_FALSE  oth-
	      erwise.

	      ?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 ob-
	      jects 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 at-
	      tribute 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 buf-
	      fer  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 buf-
	      fer 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 pro-
	      gram binary, in bytes that will be returned by a call to gl:get-
	      ProgramBinary/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_INTER-
	      LEAVED_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  in-
	      dicating	the  primitive	type accepted as input to the geometry
	      shader contained in Program .

	      ?GL_GEOMETRY_OUTPUT_TYPE:	Params returns a symbolic constant in-
	      dicating	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	speci-
	      fied 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 informa-
	      tion log as it can, up to	a maximum of MaxLength characters. The
	      number  of characters actually returned, excluding the null ter-
	      mination 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, warn-
	      ing 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	geome-
	      try shader object, and ?GL_FRAGMENT_SHADER if Shader is a	 frag-
	      ment shader object.

	      ?GL_DELETE_STATUS:  Params  returns  ?GL_TRUE  if	Shader is cur-
	      rently 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 con-
	      catenation 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	speci-
	      fied shader object. The information log for a shader  object  is
	      modified	when  the  shader  is compiled.	The string that	is re-
	      turned will be null terminated.

	      gl:getShaderInfoLog returns in InfoLog as	much of	 the  informa-
	      tion log as it can, up to	a maximum of MaxLength characters. The
	      number of	characters actually returned, excluding	the null  ter-
	      mination	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	infor-
	      mation 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  ter-
	      mination	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 lo-
	      cation  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  subcompo-
	      nent  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 as-
	      sociated 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 se-
	      lect 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 vari-
	      ables 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  uni-
	      form  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 de-
	      fined 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	 loca-
	      tion  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 success-
	      ful.

	      See external documentation.

       getUniformiv(Program,  Location)	 ->  {integer(), integer(), integer(),
       integer(), integer(), integer(),	integer(), integer(), integer(), inte-
       ger(),  integer(),  integer(),  integer(),  integer(), integer(), inte-
       ger()}

	      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 ver-
	      tex  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  ele-
	      ments  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  at-
	      tribute  array for Index . Possible values are ?GL_BYTE, ?GL_UN-
	      SIGNED_BYTE, ?GL_SHORT, ?GL_UNSIGNED_SHORT  ,  ?GL_INT,  ?GL_UN-
	      SIGNED_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 rep-
	      resent the current value for the generic vertex attribute	speci-
	      fied  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  un-
	      signed 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  pro-
	      gram  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 program-
	      mable  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	 frag-
	      ment 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-de-
	      fined 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	attri-
	      bute variables that have not been	bound to a generic vertex  at-
	      tribute 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	imple-
	      mentation	has been exceeded.

	      The storage limit	for uniform variables has been exceeded.

	      The  number  of active uniform variables supported by the	imple-
	      mentation	has been exceeded.

	      The main function	is missing for the vertex, geometry  or	 frag-
	      ment 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 ver-
	      tex 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 dif-
	      ferent initial values.

	      One or more of the attached shader objects has not been success-
	      fully compiled.

	      Binding  a  generic attribute matrix caused some rows of the ma-
	      trix to fall outside the allowed maximum	of  ?GL_MAX_VERTEX_AT-
	      TRIBS.

	      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	geome-
	      try 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:transformFeed-
	      backVaryings/3 specify the same varying variable.

	      The total	number of components to	capture	in any transform feed-
	      back   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:usePro-
	      gram/1 . Whether or not the link operation was  successful,  the
	      program object's information log will be overwritten. The	infor-
	      mation 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 un-
	      til 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  proces-
	      sor,  the	 geometry  shader  executable, if present, will	be in-
	      stalled on the programmable  geometry  processor,	 but  no  exe-
	      cutable 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  ob-
	      jects,  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 pro-
	      gram that	is part	of the program object.

	      See external documentation.

       shaderSource(Shader, String) -> ok

	      Types:

		 Shader	= integer()
		 String	= [string()]

	      Replaces the source code in a shader object

	      gl:shaderSource sets the source code in  Shader  to  the	source
	      code  in	the  array of strings specified	by String . Any	source
	      code previously stored in	the shader object  is  completely  re-
	      placed. The number of strings in the array is specified by Count
	      .	If Length is ?NULL, each string	is assumed to be  null	termi-
	      nated.  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 con-
	      tain 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 ob-
	      jects  to	it with	gl:attachShader/2 , successfully compiling the
	      shader objects with gl:compileShader/1 , and successfully	 link-
	      ing 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  con-
	      tains  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  mod-
	      ify  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  pro-
	      gram  object  that  is currently in use will install the program
	      object as	part of	the current rendering state if the link	opera-
	      tion  was	successful (see	gl:linkProgram/1 ). If the program ob-
	      ject currently in	use is relinked	unsuccessfully,	its link  sta-
	      tus 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_FRAG-
	      MENT_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 modi-
	      fied 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:usePro-
	      gram/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  suf-
	      fix 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 uni-
	      form 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	 func-
	      tion  should be used to provide values for uniform variables de-
	      fined 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	start-
	      ing at an	arbitrary position m in	a uniform variable array, ele-
	      ments m +	n - 1 in the array will	be replaced with the new  val-
	      ues.  If	M + N -	1 is larger than the size of the uniform vari-
	      able 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:uni-
	      form{1|2|3|4}{f|i|ui}.

	      For uniform variable arrays, each	element	of the array  is  con-
	      sidered  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  uni-
	      form 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 A 2 matrix (i.e., 4 values),
	      the number 3 indicates a 3 A 3 matrix (i.e., 9 values), and  the
	      number  4	indicates a 4 A	4 matrix (i.e.,	16 values). Non-square
	      matrix dimensionality is explicit, with the first	number	repre-
	      senting the number of columns and	the second number representing
	      the number of rows. For example, 2x4 indicates a 2  A  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  con-
	      tained  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,  Pro-
	      gram is guaranteed to not	execute.

	      This function is typically useful	only during application	devel-
	      opment. The informational	string stored in the  information  log
	      is  completely  implementation dependent;	therefore, an applica-
	      tion should not expect different OpenGL implementations to  pro-
	      duce 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 num-
	      bered 0, and the size of the array is specified by the implemen-
	      tation-dependent constant	?GL_MAX_VERTEX_ATTRIBS.	Individual el-
	      ements 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 In-
	      dex . A 1	in the name of the command  indicates  that  only  one
	      value  is	passed,	and it will be used to modify the first	compo-
	      nent of the generic vertex attribute. The	second and third  com-
	      ponents  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 com-
	      ponent 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 pro-
	      vided 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  ar-
	      guments  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 ex-
	      tended 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:bindAt-
	      tribLocation/3 . This allows an application to use more descrip-
	      tive  variable  names in a vertex	shader.	A subsequent change to
	      the specified generic vertex attribute will be  immediately  re-
	      flected  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	attri-
	      bute is part of current state, just  like	 standard  vertex  at-
	      tributes,	 and  it is maintained even if a different program ob-
	      ject 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	attri-
	      bute 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 at-
	      tribute.

	      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:vertexAt-
	      tribLPointer  specify  the location and data format of the array
	      of generic vertex	attributes at index Index to use when  render-
	      ing.  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 un-
	      signed 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 at-
	      tribute array associated with a shader  attribute	 variable  de-
	      clared  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:drawEle-
	      ments/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:begin-
	      TransformFeedback/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 FeedbackPrimitiveMod-
	      eAllowed 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_TRIAN-
	      GLE_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	repre-
	      sented by	Offset and Size	to the binding point at	index Index of
	      the array	of targets specified by	Target .  Each	Target	repre-
	      sents  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	glMap-
	      Buffer. 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 buf-
	      fer 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:bind-
	      Buffer/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 = [string()]
		 BufferMode = enum()

	      Specify values to	record in transform feedback buffers

	      The  names  of  the  vertex  or  geometry	 shader	 outputs to be
	      recorded	in  transform  feedback	 mode  are   specified	 using
	      gl:transformFeedbackVaryings.  When a geometry shader is active,
	      transform	feedback  records  the	values	of  selected  geometry
	      shader  output  variables	 from the emitted vertices. Otherwise,
	      the values of the	selected vertex	shader outputs are recorded.

	      The state	set by gl:tranformFeedbackVaryings is stored and takes
	      effect  next  time  gl:linkProgram/1 is called on	Program	. When
	      gl:linkProgram/1 is called, Program is linked so that the	values
	      of  the  specified  varying  variables  for the vertices of each
	      primitive	generated by the GL are	written	to a single buffer ob-
	      ject if BufferMode is ?GL_INTERLEAVED_ATTRIBS or multiple	buffer
	      objects if BufferMode is ?GL_SEPARATE_ATTRIBS .

	      In addition to the errors	generated by gl:transformFeedbackVary-
	      ings, 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  de-
	      clared  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 vari-
	      able in Varyings is greater  than	 the  constant	?GL_MAX_TRANS-
	      FORM_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::inte-
       ger(), Type::enum(), Name::string()}

	      Types:

		 Program = integer()
		 Index = integer()
		 BufSize = integer()

	      Retrieve information about varying variables selected for	trans-
	      form feedback

	      Information about	the set	of varying variables in	a linked  pro-
	      gram  that will be captured during transform feedback may	be re-
	      trieved by calling gl:getTransformFeedbackVarying.  gl:getTrans-
	      formFeedbackVarying provides information about the varying vari-
	      able selected by Index . An Index	of 0 selects the first varying
	      variable specified in the	Varyings array passed to gl:transform-
	      FeedbackVaryings/3  ,  and  an  Index   of   ?GL_TRANSFORM_FEED-
	      BACK_VARYINGS-1 selects the last such variable.

	      The  name	 of  the selected varying is returned as a null-termi-
	      nated 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  re-
	      turned  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 un-
	      modified.	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  se-
	      lected  read buffer has fixed point components and disabled oth-
	      erwise.

	      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_SAM-
	      PLES_PASSED)  result is ?GL_FALSE	. The results of commands set-
	      ting 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  com-
	      mands  are  discarded.  If Mode is ?GL_QUERY_NO_WAIT, the	GL may
	      choose to	unconditionally	execute	the subsequent rendering  com-
	      mands 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 im-
	      plementation-dependent manner, but the rendering command results
	      may not be discarded for any samples that	contributed to the oc-
	      clusion  query  sample  count.  If  Mode	 is   ?GL_QUERY_BY_RE-
	      GION_NO_WAIT,  the  GL operates as in ?GL_QUERY_BY_REGION_WAIT ,
	      but may choose to	unconditionally	execute	the subsequent render-
	      ing 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(), inte-
       ger(),  integer(),  integer(),  integer(),  integer(), integer(), inte-
       ger()}

	      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 pre-
	      viously, 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 bind-
	      ing  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	= {integer()}

	      See texParameterf/3

       texParameterIuiv(Target,	Pname, Params) -> ok

	      Types:

		 Target	= enum()
		 Pname = enum()
		 Params	= {integer()}

	      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 = {integer()}

	      Clear individual buffers of the currently	bound draw framebuffer

	      gl:clearBuffer*  clears  the  specified  buffer to the specified
	      value(s).	If Buffer  is  ?GL_COLOR,  a  particular  draw	buffer
	      ?GL_DRAWBUFFER  I	 is  specified by passing I as DrawBuffer . In
	      this case, Value points to a four-element	vector specifying  the
	      R,  G,  B	and A color to clear that draw buffer to. If Buffer is
	      one   of	 ?GL_FRONT,   ?GL_BACK,	  ?GL_LEFT,   ?GL_RIGHT,    or
	      ?GL_FRONT_AND_BACK , identifying multiple	buffers, each selected
	      buffer is	cleared	to the same value. Clamping and	conversion for
	      fixed-point  color  buffers are performed	in the same fashion as
	      gl:clearColor/4 .

	      If Buffer	is ?GL_DEPTH,  DrawBuffer  must	 be  zero,  and	 Value
	      points  to  a  single  value  to clear the depth buffer to. Only
	      gl:clearBufferfv should be used to clear depth buffers. Clamping
	      and  conversion  for  fixed-point	depth buffers are performed in
	      the same fashion as gl:clearDepth/1 .

	      If Buffer	is ?GL_STENCIL,	DrawBuffer must	 be  zero,  and	 Value
	      points  to  a  single value to clear the stencil buffer to. Only
	      gl:clearBufferiv should be used to clear stencil buffers.	Masing
	      and  type	 conversion  are  performed  in	 the  same  fashion as
	      gl:clearStencil/1	.

	      gl:clearBufferfi may be used to clear the	depth and stencil buf-
	      fers.  Buffer  must  be ?GL_DEPTH_STENCIL	and DrawBuffer must be
	      zero. Depth and Stencil are the depth and	 stencil  values,  re-
	      spectively.

	      The  result  of gl:clearBuffer is	undefined if no	conversion be-
	      tween 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 = {integer()}

	      See clearBufferiv/3

       clearBufferfv(Buffer, Drawbuffer, Value)	-> ok

	      Types:

		 Buffer	= enum()
		 Drawbuffer = integer()
		 Value = {float()}

	      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 tex-
	      ture

	      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 tex-
	      ture 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 componentsAsizeof( base_type/)

	      where buffer_size	is the size of the buffer object, in basic ma-
	      chine 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_BUF-
	      FER_SIZE.	When a buffer texture is accessed in a shader, the re-
	      sults  of	a texel	fetch are undefined if the specified texel co-
	      ordinate 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	attri-
	      bute 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 transfer-
	      ring the immediately following element through the  end  of  the
	      originally specified elements.

	      When  either  gl:drawElementsBaseVertex/5	 ,  gl:drawElementsIn-
	      stancedBaseVertex/6  or  see  glMultiDrawElementsBaseVertex   is
	      used,  the primitive restart comparison occurs before the	basev-
	      ertex 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:framebuffer-
	      Texture2D, 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_AT-
	      TACHMENT 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 at-
	      tached. If Texture is not	zero, it must be the name of an	exist-
	      ing  texture  with type Textarget	, unless it is a cube map tex-
	      ture, in which case Textarget must be ?GL_TEXTURE_CUBE_MAP_POSI-
	      TIVE_X	     ?GL_TEXTURE_CUBE_MAP_NEGATIVE_X,	      ?GL_TEX-
	      TURE_CUBE_MAP_POSITIVE_Y,	  ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Y    ,
	      ?GL_TEXTURE_CUBE_MAP_POSITIVE_Z,	or  ?GL_TEXTURE_CUBE_MAP_NEGA-
	      TIVE_Z.

	      If Texture is non-zero, the specified Level of the  texture  ob-
	      ject  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_POSI-
	      TIVE_X	  ,	 ?GL_TEXTURE_CUBE_MAP_POSITIVE_Y,     ?GL_TEX-
	      TURE_CUBE_MAP_POSITIVE_Z,	  ?GL_TEXTURE_CUBE_MAP_NEGATIVE_X    ,
	      ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,	or  ?GL_TEXTURE_CUBE_MAP_NEGA-
	      TIVE_Z.

	      If Textarget is ?GL_TEXTURE_RECTANGLE,  ?GL_TEXTURE_2D_MULTISAM-
	      PLE,  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_POSI-
	      TIVE_Y,	  ?GL_TEXTURE_CUBE_MAP_POSITIVE_Z      ,      ?GL_TEX-
	      TURE_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 Tex-
	      target 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_NEGA-
	      TIVE_Y, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ,	or ?GL_TEXTURE_2D_MUL-
	      TISAMPLE.	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 dur-
	      ing instanced rendering

	      gl:vertexAttribDivisor modifies the rate at which	generic	vertex
	      attributes  advance  when	rendering multiple instances of	primi-
	      tives 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 in-
	      stanced 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	 shad-
	      ing  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	= [string()]

	      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(),	 inte-
       ger(),  integer(),  integer(),  integer(),  integer(), integer(), inte-
       ger(), integer(), integer(),  integer(),	 integer(),  integer(),	 inte-
       ger(), 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 Render-
	      buffer 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  render-
	      buffer 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 Ren-
	      derbuffer	to the renderbuffer target specified by	Target .  Tar-
	      get  must	 be  ?GL_RENDERBUFFER  . Renderbuffer is the name of a
	      renderbuffer object previously returned from a call  to  gl:gen-
	      Renderbuffers/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:bin-
	      dRenderbuffer/2  had  been executed with a Target	of ?GL_RENDER-
	      BUFFER 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  Render-
	      buffer 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 render-
	      buffer  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  Ren-
	      derbuffers  .  There  is no guarantee that the names form	a con-
	      tiguous 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:genRender-
	      buffers  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:renderbuffer-
	      StorageMultisample/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 for-
	      mat. Width and Height are	the dimensions,	in pixels, of the ren-
	      derbuffer.  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_REN-
	      DERBUFFER_WIDTH ,	?GL_RENDERBUFFER_HEIGHT,  ?GL_RENDERBUFFER_IN-
	      TERNAL_FORMAT,	 ?GL_RENDERBUFFER_RED_SIZE    ,	   ?GL_RENDER-
	      BUFFER_GREEN_SIZE,    ?GL_RENDERBUFFER_BLUE_SIZE,	   ?GL_RENDER-
	      BUFFER_ALPHA_SIZE	  ,  ?GL_RENDERBUFFER_DEPTH_SIZE,  ?GL_RENDER-
	      BUFFER_DEPTH_SIZE, ?GL_RENDERBUFFER_STENCIL_SIZE ,  or  ?GL_REN-
	      DERBUFFER_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 pix-
	      els,  the	 internal  format,  or	the number of samples, respec-
	      tively, of the image of the renderbuffer currently bound to Tar-
	      get .

	      If     Pname     is    ?GL_RENDERBUFFER_RED_SIZE,	   ?GL_RENDER-
	      BUFFER_GREEN_SIZE,    ?GL_RENDERBUFFER_BLUE_SIZE,	   ?GL_RENDER-
	      BUFFER_ALPHA_SIZE,  ?GL_RENDERBUFFER_DEPTH_SIZE ,	or ?GL_RENDER-
	      BUFFER_STENCIL_SIZE, then	Params will contain the	actual resolu-
	      tions  (not  the	resolutions specified when the image array was
	      defined) for the red, green, blue, alpha depth, or stencil  com-
	      ponents,	respectively,  of  the	image of the renderbuffer cur-
	      rently 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	Frame-
	      buffer 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 correspond-
	      ing 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:bindFrame-
	      buffer/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:genFrame-
	      buffers .

	      Framebuffer object names returned	 by  a	call  to  gl:genFrame-
	      buffers  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  de-
	      termined 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_FRAME-
	      BUFFER_ATTACHMENT_OBJECT_TYPE is ?GL_NONE	for the	color  attach-
	      ment point named by ?GL_READ_BUFFER.

	      ?GL_FRAMEBUFFER_UNSUPPORTED  is  returned	 if the	combination of
	      internal formats of the attached images violates an  implementa-
	      tion-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_RENDER-
	      BUFFER_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_SAM-
	      PLE_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, Render-
       buffer) -> 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. Ren-
	      derbuffer	is the name of the renderbuffer	object to  attach  and
	      must be either zero, or the name of an existing renderbuffer ob-
	      ject of type Renderbuffertarget .	If Renderbuffer	 is  not  zero
	      and  if  gl:framebufferRenderbuffer is successful, then the ren-
	      derbuffer	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  Ren-
	      derbuffer	. All other state values of the	attachment point spec-
	      ified by Attachment are set to their default values.  No	change
	      is  made to the state of the renderbuuffer object	and any	previ-
	      ous attachment to	the Attachment logical buffer  of  the	frame-
	      buffer 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) -> inte-
       ger()

	      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, iden-
	      tifying the depth	buffer,	or ?GL_STENCIL , identifying the sten-
	      cil buffer.

	      If a framebuffer object is bound,	then Attachment	must be	one of
	      ?GL_COLOR_ATTACHMENT  i,	?GL_DEPTH_ATTACHMENT,  ?GL_STENCIL_AT-
	      TACHMENT,	or ?GL_DEPTH_STENCIL_ATTACHMENT	. i  in	 ?GL_COLOR_AT-
	      TACHMENTi	  must	 be   in  the  range  zero  to	the  value  of
	      ?GL_MAX_COLOR_ATTACHMENTS	- 1.

	      If Attachment is ?GL_DEPTH_STENCIL_ATTACHMENT and	different  ob-
	      jects  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 re-
	      turned.

	      Upon successful return  from  gl:getFramebufferAttachmentParame-
	      teriv,  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 re-
	      turn 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_FRAME-
	      BUFFER_ATTACHMENT_GREEN_SIZE	,      ?GL_FRAMEBUFFER_ATTACH-
	      MENT_BLUE_SIZE,	   ?GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE     ,
	      ?GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE,  or   ?GL_FRAMEBUFFER_AT-
	      TACHMENT_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 attach-
	      ment,   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 re-
	      spectively. 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 attach-
	      ment, 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  sec-
	      tions 4.1.7 and 4.1.8. For the default framebuffer, color	encod-
	      ing is determined	by the	implementation.	 For  framebuffer  ob-
	      jects,  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 tex-
	      ture 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  tex-
	      ture,  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, regard-
	      less of their previous contents. All other mimap arrays, includ-
	      ing  the	level  base array, are left unchanged by this computa-
	      tion.

	      The internal formats of the  derived  mipmap  arrays  all	 match
	      those  of	 the level base	array. The contents of the derived ar-
	      rays 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	 indi-
	      cating   which   buffers	are  to	 be  copied.  The  values  are
	      ?GL_COLOR_BUFFER_BIT  ,  ?GL_DEPTH_BUFFER_BIT,   and   ?GL_STEN-
	      CIL_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 rectan-
	      gle 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  ob-
	      ject'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  for-
	      mat. Width and Height are	the dimensions,	in pixels, of the ren-
	      derbuffer. 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  im-
	      age, and must be less than or equal to the value of ?GL_MAX_SAM-
	      PLES. 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  ex-
	      isting 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 ba-
	      sic  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 indi-
	      cate 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  ex-
	      isting 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	previ-
	      ous 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 ar-
	      ray 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 de-
	      fault  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:genVertexAr-
	      rays .

	      Vertex array object names	returned by a call to  gl:genVertexAr-
	      rays 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  pur-
	      poses  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 =	[string()]

	      Retrieve the index of a named uniform block

	      gl:getUniformIndices retrieves the indices of a number  of  uni-
	      forms within Program .

	      Program  must be the name	of a program object for	which the com-
	      mand gl:linkProgram/1 must have been called  in  the  past,  al-
	      though  it  is not required that gl:linkProgram/1	must have suc-
	      ceeded. 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 iden-
	      tifying 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  ele-
	      ment  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 writ-
	      ten 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	neces-
	      sary 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 Pro-
	      gram  ,  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 com-
	      mand gl:linkProgram/1 must have been called  in  the  past,  al-
	      though  it  is not required that gl:linkProgram/1	must have suc-
	      ceeded. 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 Uniform-
	      BlockName	does not identify an active uniform block of Program ,
	      gl:getUniformBlockIndex  returns the special identifier, ?GL_IN-
	      VALID_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 com-
	      mand gl:linkProgram/1 must have been called  in  the  past,  al-
	      though  it  is not required that gl:linkProgram/1	must have suc-
	      ceeded. 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 implementa-
	      tion-dependent minimum total buffer object size,	in  basic  ma-
	      chine 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	excep-
	      tion  to this is the std140 uniform block	layout , which guaran-
	      tees specific packing behavior and does not require the applica-
	      tion  to query for offsets and strides. In this case the minimum
	      size may still be	queried, even though it	is determined  in  ad-
	      vance 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  Uniform-
	      BlockIndex is returned.

	      If  Pname	 is  ?GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES,	then a
	      list of the active uniform indices for the uniform block identi-
	      fied  by	UniformBlockIndex  is returned.	The number of elements
	      that will	 be  written  to  Params  is  the  value  of  ?GL_UNI-
	      FORM_BLOCK_ACTIVE_UNIFORMS for UniformBlockIndex .

	      If   Pname   is	?GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER,
	      ?GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER  ,  or  ?GL_UNI-
	      FORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER,	 then  a boolean value
	      indicating whether the  uniform  block  identified  by  Uniform-
	      BlockIndex  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  com-
	      mand  gl:linkProgram/1  must  have  been called in the past, al-
	      though it	is not required	that gl:linkProgram/1 must  have  suc-
	      ceeded.  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 Uni-
	      fomBlockIndex 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 bind-
	      ing point	UniformBlockBinding to extract the values of the  uni-
	      forms 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  num-
	      ber  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_AR-
	      RAY_BUFFER,   ?GL_PIXEL_PACK_BUFFER  ,  ?GL_PIXEL_UNPACK_BUFFER,
	      ?GL_TEXTURE_BUFFER,  ?GL_TRANSFORM_FEEDBACK_BUFFER  or  ?GL_UNI-
	      FORM_BUFFER. Any of these	targets	may be used, although the tar-
	      gets ?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 Readoff-
	      set  +  Size  must  not  exceeed the size	of the buffer bound to
	      Writetarget . If the same	buffer object is bound to  both	 Read-
	      target 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:drawEle-
	      ments/4  except  that  the ith element transferred by the	corre-
	      sponding draw call will be taken from element Indices [i]	+  Ba-
	      severtex 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, Ba-
       severtex) -> 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 Ba-
	      severtex match the corresponding arguments to gl:drawElementsBa-
	      seVertex/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:drawEle-
	      mentsBaseVertex/5	 .  The	i th element transferred by the	corre-
	      sponding draw call will be taken from element Indices [i]	+  Ba-
	      severtex 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	trans-
	      ferred 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 pro-
	      voking 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, caus-
	      ing 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	frame-
	      buffer  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 com-
	      mands 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 com-
	      mand. In either case, after gl:deleteSync	returns, the name Sync
	      is  invalid  and	can no longer be used to refer to the sync ob-
	      ject.

	      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 re-
	      turns  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	exten-
	      sions 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  de-
	      termine  whether	gl:waitSync  unblocked because the timeout ex-
	      pired 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	speci-
	      fies the name of the sync	object whose properties	to retrieve.

	      On success, gl:getSynciv replaces	up to BufSize integers in Val-
	      ues  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 con-
	      dition 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 im-
	      age.

	      Target  must  be	?GL_TEXTURE_2D_MULTISAMPLE  or	?GL_PROXY_TEX-
	      TURE_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 sam-
	      ples in the image	and must be in the range zero to  ?GL_MAX_SAM-
	      PLES - 1.

	      Internalformat  must be a	color-renderable, depth-renderable, or
	      stencil-renderable format.

	      If Fixedsamplelocations is ?GL_TRUE, the image will use  identi-
	      cal sample locations and the same	number of samples for all tex-
	      els 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  instruc-
	      tions 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  im-
	      age.

	      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  identi-
	      cal sample locations and the same	number of samples for all tex-
	      els 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  instruc-
	      tions 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_SAM-
	      PLE_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 =	[string()]

	      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  Pro-
	      gram  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 pur-
	      poses 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 ele-
	      ments 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:bindSam-
	      pler/2  is called	with unit set to the unit the sampler is bound
	      to and sampler zero. Unused names	in samplers are	 silently  ig-
	      nored, 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 oc-
	      curs, 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  su-
	      persedes	that of	the texture object bound to that texture unit.
	      If the sampler name zero is bound	to a texture  unit,  the  cur-
	      rently  bound  texture's	sampler	state becomes active. A	single
	      sampler object may be bound to multiple texture units simultane-
	      ously.

	      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	dimen-
	      sions 2 nA2 m, there are max(n m)+1 mipmaps. The first mipmap is
	      the original texture, with dimensions 2 nA2 m.  Each  subsequent
	      mipmap  has  dimensions 2(k-1)A2(l-1), where 2 kA2 l are the di-
	      mensions of the previous mipmap, until either  k=0  or  l=0.  At
	      that  point,  subsequent	mipmaps	 have  dimension  1A2(l-1)  or
	      2(k-1)A1 until the final mipmap, which has dimension 1A1.	To de-
	      fine  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 1A1
	      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 el-
	      ements  that  are	 closest to the	center of the pixel being tex-
	      tured. 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 el-
	      ements 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 el-
	      ements 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 ele-
	      ments to determine the texture value of the pixel	being rendered
	      and  can	produce	moire patterns or ragged transitions. The ini-
	      tial value of ?GL_TEXTURE_MIN_FILTER is  ?GL_NEAREST_MIPMAP_LIN-
	      EAR .

	      ?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 pro-
	      duce 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 el-
	      ements  that  are	 closest to the	center of the pixel being tex-
	      tured. 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 reso-
	      lution 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 coordi-
	      nate 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 coor-
	      dinate 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 coordi-
	      nate t to	either	?GL_CLAMP_TO_EDGE  ,  ?GL_MIRRORED_REPEAT,  or
	      ?GL_REPEAT.  See	the discussion under ?GL_TEXTURE_WRAP_S	. Ini-
	      tially, ?GL_TEXTURE_WRAP_T is set	to ?GL_REPEAT.

	      ?GL_TEXTURE_WRAP_R: Sets the wrap	parameter for texture  coordi-
	      nate  r  to  either  ?GL_CLAMP_TO_EDGE , ?GL_MIRRORED_REPEAT, or
	      ?GL_REPEAT. See the discussion under ?GL_TEXTURE_WRAP_S  .  Ini-
	      tially, ?GL_TEXTURE_WRAP_R is set	to ?GL_REPEAT.

	      ?GL_TEXTURE_BORDER_COLOR:	The data in Params specifies four val-
	      ues 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 substi-
	      tuted for	the non-existent texel data. If	the  texture  contains
	      depth   components,  the	first  component  of  ?GL_TEXTURE_BOR-
	      DER_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 ) Permissi-
	      ble 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_TEX-
	      TURE_COMPARE_FUNC	 for  details  of how the comparison is	evalu-
	      ated. The	result of the comparison is assigned to	the red	 chan-
	      nel.

	      ?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_TEX-
	      TURE. 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&ne; (D t))
	      ?GL_NOTEQUAL result={1.0 0.0 r&ne;(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 ob-
	      ject, 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	magni-
	      fication	filter,	 a  symbolic  constant.	 The  initial value is
	      ?GL_LINEAR.

	      ?GL_TEXTURE_MIN_FILTER: Returns the single-valued	texture	 mini-
	      fication	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	float-
	      ing-point	representation such that 1.0 maps to the most positive
	      representable  integer and -1.0 maps to the most negative	repre-
	      sentable integer.	The initial value is (0, 0, 0, 0).

	      ?GL_TEXTURE_COMPARE_MODE:	Returns	a single-valued	 texture  com-
	      parison	mode,  a  symbolic  constant.  The  initial  value  is
	      ?GL_NONE.	See gl:samplerParameteri/3 .

	      ?GL_TEXTURE_COMPARE_FUNC:	Returns	a single-valued	 texture  com-
	      parison  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  com-
	      mands  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  tar-
	      get  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;	}  DrawArraysIndirect-
	      Command;	const  DrawArraysIndirectCommand *cmd =	(const DrawAr-
	      raysIndirectCommand   *)indirect;	  glDrawArraysInstancedBaseIn-
	      stance(mode,  cmd->first,	cmd->count, cmd->primCount, cmd->base-
	      Instance);

	      If a buffer is bound to the ?GL_DRAW_INDIRECT_BUFFER binding  at
	      the  time	of a call to gl:drawArraysIndirect, Indirect is	inter-
	      preted 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:drawElementsIndi-
	      rect  behaves similarly to gl:drawElementsInstancedBaseVertexBa-
	      seInstance/7 , execpt that the parameters	to  gl:drawElementsIn-
	      stancedBaseVertexBaseInstance/7  are stored in memory at the ad-
	      dress 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  glDrawEle-
	      mentsIndirect(GLenum mode, GLenum	type, const void * indirect) {
	      const   DrawElementsIndirectCommand   *cmd   =  (const  DrawEle-
	      mentsIndirectCommand *)indirect; glDrawElementsInstancedBaseVer-
	      texBaseInstance(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 in-
	      terpreted	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	 reservedMust-
	      BeZero  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 sub-
	      routine  uniform	variable  Name	in  the	 shader	 stage of type
	      Shadertype attached to Program , with behavior otherwise identi-
	      cal 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 be-
	      tween zero and the value of ?GL_ACTIVE_SUBROUTINE_LOCATIONS  mi-
	      nus  one will be returned. Subroutine locations are assigned us-
	      ing 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 con-
	      tains the	name of	the program to which the shader	 is  attached.
	      Shadertype  specifies  the stage from which to query shader sub-
	      routine 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 mi-
	      nus  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  ac-
	      tive 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_SUBROU-
	      TINE_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	speci-
	      fied by Bufsize .	The length of the longest  subroutine  uniform
	      name  in Program and Shadertype is given by the value of ?GL_AC-
	      TIVE_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-termi-
	      nated 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_SUB-
	      ROUTINE_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(), inte-
       ger(),  integer(),  integer(),  integer(),  integer(), integer(), inte-
       ger(), 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_AC-
	      TIVE_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 spec-
	      ified shader stage

	      gl:getProgramStage  queries  a  parameter	 of a shader stage at-
	      tached 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  ad-
	      dress 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 subrou-
	      tines 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  ar-
	      ray  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	primi-
	      tives are	specified using	gl:drawArrays/3	or a similar function,
	      each patch will be made from Parameter control points, each rep-
	      resented by a vertex taken from the enabeld vertex  arrays.  Pa-
	      rameter 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_DE-
	      FAULT_INNER_LEVEL	, Values contains the address of an array con-
	      tiaining the default outer or inner tessellation levels, respec-
	      tively,  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	previ-
	      ously 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	trans-
	      form 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. Buf-
	      fer 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 ob-
	      jects 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  con-
	      tents.  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 ac-
	      quire 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  oc-
	      curs,  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:isTransform-
	      Feedback 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	trans-
	      form feedback operations are paused, transform feedback is still
	      considered active	and changing most transform feedback state re-
	      lated  to	 the object results in an error. However, a new	trans-
	      form 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	trans-
	      form feedback operations are paused, transform feedback is still
	      considered active	and changing most transform feedback state re-
	      lated  to	 the object results in an error. However, a new	trans-
	      form 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 feed-
	      back object

	      gl:drawTransformFeedback draws primitives	of a type specified by
	      Mode  using a count retrieved from the transform feedback	speci-
	      fied 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	speci-
	      fied 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  cap-
	      tured  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	bound-
	      aries of a query object. Query must be  a	 name  previously  re-
	      turned  from  a call to gl:genQueries/1 .	If a query object with
	      name Id does not yet exist it is created with  the  type	deter-
	      mined  by	 Target	 .  Target  must be one	of ?GL_SAMPLES_PASSED,
	      ?GL_ANY_SAMPLES_PASSED  ,	 ?GL_PRIMITIVES_GENERATED,  ?GL_TRANS-
	      FORM_FEEDBACK_PRIMITIVES_WRITTEN,	 or ?GL_TIME_ELAPSED . The be-
	      havior of	the query object depends on its	type and  is  as  fol-
	      lows.

	      Index  specifies	the  index of the query	target and must	be be-
	      tween 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:begin-
	      QueryIndexed 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_SAM-
	      PLE_BUFFERS  is  1, then the samples-passed count	is incremented
	      by the number of samples whose coverage bit is set. However, im-
	      plementations,  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 re-
	      sult  value. This	value can be queried by	calling	gl:getQueryOb-
	      jectiv/2 with Pname ?GL_QUERY_RESULT. When  Target  is  ?GL_SAM-
	      PLES_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	previ-
	      ously 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  in-
	      crement  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 ob-
	      ject'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_PRIMI-
	      TIVES_WRITTEN query binding. When	gl:beginQueryIndexed  is  exe-
	      cuted,  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 call-
	      ing gl:getQueryObjectiv/2	with Pname ?GL_QUERY_RESULT. When Tar-
	      get 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 ex-
	      ecuted,  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 ac-
	      tive,   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 com-
	      piler

	      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 BinaryFor-
	      mat 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::{inte-
       ger(), 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 pre-
	      cision 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(),   Bi-
       nary::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  com-
	      piled  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 re-
	      turned.

	      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:get-
	      ProgramBinary/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 per-
	      form an implicit linking operation. gl:linkProgram/1 and gl:pro-
	      gramBinary  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 be-
	      fore 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  in-
	      tention of the application to retrieve the program's binary rep-
	      resentation 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 individ-
	      ual  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_SEPA-
	      RABLE 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 as-
	      sociated with a specified	set of shader stages  to  the  program
	      pipeline	object given by	Pipeline . Pipeline specifies the pro-
	      gram 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_VER-
	      TEX_SHADER_BIT,  ?GL_TESS_CONTROL_SHADER_BIT,   ?GL_TESS_EVALUA-
	      TION_SHADER_BIT	,   ?GL_GEOMETRY_SHADER_BIT,   and   ?GL_FRAG-
	      MENT_SHADER_BIT.	   Additionally,     the     special	 value
	      ?GL_ALL_SHADER_BITS  may	be specified to	indicate that all exe-
	      cutables contained in Program should be installed	in Pipeline .

	      If Program refers	to a program object with a  valid  shader  at-
	      tached  for  an  indicated shader	stage, gl:useProgramStages in-
	      stalls the executable code for that stage	in the indicated  pro-
	      gram 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 Pipe-
	      line . 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 = [string()]

	      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:bindPro-
	      gramPipeline,  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, leav-
	      ing 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	 pipe-
	      line  object has no effect on rendering or uniform updates. When
	      a	bound program pipeline object is used for rendering,  individ-
	      ual 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 pipe-
	      line object names	in Pipelines . These names are marked as used,
	      for  the	purposes  of gl:genProgramPipelines only, but they ac-
	      quire 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:bindPro-
	      gramPipeline/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 parame-
	      ter 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 ob-
	      ject 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 ob-
	      ject is returned in Params .

	      If Pname is ?GL_INFO_LOG_LENGTH, the length of the info log, in-
	      cluding 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 vari-
	      ants of this function should be used to provide values for  uni-
	      form  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	other-
	      wise.

	      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:progra-
	      mUniform	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  ele-
	      ments  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	speci-
	      fied in the name of the command must match the data type for the
	      specified	 uniform  variable as described	previously for gl:pro-
	      gramUniform{1|2|3|4}{f|i|ui}.

	      For uniform variable arrays, each	element	of the array  is  con-
	      sidered  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	speci-
	      fied by Count

	      The		  commands		  gl:programUniformMa-
	      trix{2|3|4|2x3|3x2|2x4|4x2|3x4|4x3}fv are	used to	modify	a  ma-
	      trix  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 A 2 matrix (i.e., 4 values), the	number 3 indi-
	      cates a 3	A 3 matrix (i.e., 9 values), and the  number  4	 indi-
	      cates a 4	A 4 matrix (i.e., 16 values). Non-square matrix	dimen-
	      sionality	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 A	4 matrix with  2  col-
	      umns  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  ma-
	      trices  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 vali-
	      date the shader executables contained in	Pipeline  against  the
	      current GL state.	The implementation may use this	as an opportu-
	      nity 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 sta-
	      tus  is  set  to	?GL_TRUE  . The	validation status of a program
	      pipeline	object	may   be   queried   by	  calling   gl:getPro-
	      gramPipelineiv/2 with parameter ?GL_VALIDATE_STATUS.

	      If Pipeline is a name previously returned	from a call to gl:gen-
	      ProgramPipelines/1 but that has not yet been bound by a call  to
	      gl:bindProgramPipeline/1 , a new program pipeline	object is cre-
	      ated 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 pro-
	      gram pipeline object Pipeline . The info log, including its null
	      terminator, is written into the array of	characters  whose  ad-
	      dress  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 parame-
	      ters  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 view-
	      port, respectively. The viewport specifies the affine  transfor-
	      mation  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 de-
	      termined by calling  gl:getBooleanv/1  with  argument  ?GL_VIEW-
	      PORT_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_VIEW-
	      PORT_DIMS.

	      The precision with which the GL interprets  the  floating	 point
	      viewport	bounds	is  implementation-dependent and may be	deter-
	      mined by querying	the impementation-defined  constant  ?GL_VIEW-
	      PORT_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 }; glViewportAr-
	      rayv(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()],	  Mes-
       sageLog::[string()]}

	      Types:

		 Count = integer()
		 Bufsize = integer()

	      glGetDebugMessageLogARB

	      See external documentation.

       getGraphicsResetStatusARB() -> enum()

	      glGetGraphicsResetStatusARB

	      See external documentation.

       drawArraysInstancedBaseInstance(Mode, First, Count, Primcount,  Basein-
       stance) -> ok

	      Types:

		 Mode =	enum()
		 First = integer()
		 Count = integer()
		 Primcount = integer()
		 Baseinstance =	integer()

	      Draw  multiple  instances	of a range of elements with offset ap-
	      plied 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  In-
	      stanceID	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; glDrawAr-
	      rays(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 ver-
	      tex attribute arrays is  calculated  as:	|gl_  InstanceID/divi-
	      sor|&plus;  baseInstance.	Note that Baseinstance does not	affect
	      the shader-visible value of ?gl_InstanceID.

	      See external documentation.

       drawElementsInstancedBaseInstance(Mode,	Count,	Type,  Indices,	 Prim-
       count, 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  In-
	      stanceID	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 ver-
	      tex attribute arrays  is	calculated  as	|gl_  InstanceID/divi-
	      sor|&plus;  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  identi-
	      cally  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	Basev-
	      ertex 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 ver-
	      tex attribute arrays  is	calculated  as	|gl_  InstanceID/divi-
	      sor|&plus;  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)  ->	[inte-
       ger()]

	      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  im-
	      age 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 ex-
	      isting 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 ar-
	      ray texture, a cube map or cube map array	texture, or a  two-di-
	      mensional	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 en-
	      tire 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,  respec-
	      tively.  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 includ-
	      ing 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 FormatFor-
	      mat 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  de-
	      fined  in	 the OpenGL Specification. The matching	criterion used
	      for a given texture may be determined by calling gl:getTexParam-
	      eterfv/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  transac-
	      tions issued prior to the	command	relative to those issued after
	      the barrier. For the purposes of this ordering, memory  transac-
	      tions  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 af-
	      fected by	this bit is derived from the  buffer  object  bindings
	      used  for	 generic  vertex  attributes derived from the ?GL_VER-
	      TEX_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  af-
	      fected by	this bit are derived from the ?GL_ELEMENT_ARRAY_BUFFER
	      binding.

	      ?GL_UNIFORM_BARRIER_BIT: Shader uniforms sourced from buffer ob-
	      jects  after  the	 barrier  will reflect data written by shaders
	      prior to the barrier.

	      ?GL_TEXTURE_FETCH_BARRIER_BIT: Texture fetches from shaders, in-
	      cluding  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 ob-
	      jects 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_BUF-
	      FER binding.

	      ?GL_PIXEL_BUFFER_BARRIER_BIT: Reads and writes of	buffer objects
	      via the ?GL_PIXEL_PACK_BUFFER and	?GL_PIXEL_UNPACK_BUFFER	 bind-
	      ings (via	gl:readPixels/7	, gl:texSubImage1D/7 , etc.) after the
	      barrier will reflect data	written	by shaders prior to  the  bar-
	      rier.  Additionally,  buffer object writes issued	after the bar-
	      rier 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:compressed-
	      Tex(Sub)Image*, and reads	via gl:getTexImage/5 after the barrier
	      will reflect data	written	by shaders prior to the	barrier. Addi-
	      tionally,	 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:bufferSub-
	      Data/4 , gl:copyBufferSubData/5 ,	or gl:getBufferSubData/4 ,  or
	      to  buffer object	memory mapped by see glMapBuffer or see	glMap-
	      BufferRange 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 bar-
	      rier.

	      ?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	 feed-
	      back  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  af-
	      ter 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 exam-
	      ple, there may be	separate caches	for texture, vertex  fetching,
	      and  one	or more	caches for shader memory accesses. Implementa-
	      tions are	not required to	keep these caches coherent with	shader
	      memory  writes. Stores issued by one invocation may not be imme-
	      diately observable by other pipeline stages or other shader  in-
	      vocations	 because  the value stored may remain in a cache local
	      to the processor executing the store, or because data  overwrit-
	      ten  by  the  store is still in a	cache elsewhere	in the system.
	      When gl:memoryBarrier is called, the GL flushes  and/or  invali-
	      dates  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". Buf-
	      fer object or texture image memory accessed through  such	 vari-
	      ables may	be cached only if caches are automatically updated due
	      to stores	issued by any other shader invocation. If the same ad-
	      dress  is	 accessed  using  both coherent	and non-coherent vari-
	      ables, the accesses using	variables declared  as	coherent  will
	      observe the results stored using coherent	variables in other in-
	      vocations. 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 visi-
	      ble 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 us-
	      ing coherent variables or	calling	 MemoryBarrier().  Updates  to
	      the  read-only data via API calls	such as	BufferSubData will in-
	      validate shader caches implicitly	as required.

	      Data that	are shared between shader invocations at a fine	granu-
	      larity (e.g., written by one invocation, consumed	by another in-
	      vocation)	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	 ("de-
	      pendent  invocations") should use	coherent variables in the pro-
	      ducing 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_IM-
	      AGE_ACCESS_BARRIER_BIT  set in Barriers between passes is	neces-
	      sary.

	      Data written by the shader in one	rendering pass and read	by an-
	      other  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	Barri-
	      ers 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-dimen-
	      sional texture

	      gl:texStorage1D  specifies the storage requirements for all lev-
	      els 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  con-
	      tents  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	Inter-
	      nalformat	enumerant. Internalformat must be one of the sized in-
	      ternal formats given in Table 1 below, one of the	 sized	depth-
	      component	  formats  ?GL_DEPTH_COMPONENT32F  ,  ?GL_DEPTH_COMPO-
	      NENT24, 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 dis-
	      covered by calling  gl:getTexParameterfv/2  with	Pname  set  to
	      ?GL_TEXTURE_IMMUTABLE_FORMAT.  No	 further changes to the	dimen-
	      sions 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:texStor-
	      age1D)  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-dimen-
	      sional or	one-dimensional	array texture

	      gl:texStorage2D specifies	the storage requirements for all  lev-
	      els  of a	two-dimensional	texture	or one-dimensional texture ar-
	      ray simultaneously. Once a texture is specified with  this  com-
	      mand,  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_TEX-
	      TURE_RECTANGLE,  ?GL_PROXY_TEXTURE_RECTANGLE  or	?GL_PROXY_TEX-
	      TURE_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, internal-
	      format,  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  equiva-
	      lent  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:texS-
	      torage2D is equivalent to: for (i	= 0; i < levels; i++) {	glTex-
	      Image2D(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	Inter-
	      nalformat	enumerant. Internalformat must be one of the sized in-
	      ternal  formats  given in	Table 1	below, one of the sized	depth-
	      component	 formats  ?GL_DEPTH_COMPONENT32F  ,   ?GL_DEPTH_COMPO-
	      NENT24,  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  dis-
	      covered  by  calling  gl:getTexParameterfv/2  with  Pname	set to
	      ?GL_TEXTURE_IMMUTABLE_FORMAT. No further changes to  the	dimen-
	      sions  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:texStor-
	      age2D) 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-dimen-
	      sional, two-dimensional array or cube-map	array texture

	      gl:texStorage3D specifies	the storage requirements for all  lev-
	      els  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 im-
	      mutable 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_AR-
	      RAY,  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	Inter-
	      nalformat	enumerant. Internalformat must be one of the sized in-
	      ternal formats given in Table 1 below, one of the	 sized	depth-
	      component	  formats  ?GL_DEPTH_COMPONENT32F  ,  ?GL_DEPTH_COMPO-
	      NENT24, 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 dis-
	      covered by calling  gl:getTexParameterfv/2  with	Pname  set  to
	      ?GL_TEXTURE_IMMUTABLE_FORMAT.  No	 further changes to the	dimen-
	      sions 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:texStor-
	      age3D)  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.3.3				 gl(3)

NAME | DESCRIPTION | DATA TYPES | EXPORTS | AUTHORS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=gl&sektion=3&manpath=FreeBSD+12.1-RELEASE+and+Ports>

home | help