1gl(3)                      Erlang Module Definition                      gl(3)
2
3
4

NAME

6       gl -  Standard OpenGL api.
7

DESCRIPTION

9       Standard OpenGL api. See www.khronos.org
10
11       Booleans are represented by integers 0 and 1.
12

DATA TYPES

14         clamp() = float():
15
16
17           0.0..1.0
18
19         enum() = non_neg_integer():
20
21
22           See wx/include/gl.hrl
23
24         matrix() = matrix12() | matrix16():
25
26
27         matrix12()  =  {float(), float(), float(), float(), float(), float(),
28         float(), float(), float(), float(), float(), float()}:
29
30
31         matrix16() = {float(), float(), float(), float(),  float(),  float(),
32         float(),   float(),  float(),  float(),  float(),  float(),  float(),
33         float(), float(), float()}:
34
35
36         mem() = binary() | tuple():
37
38
39           Memory block
40
41         offset() = non_neg_integer():
42
43
44           Offset in memory block
45

EXPORTS

47       clearIndex(C) -> ok
48
49              Types:
50
51                 C = float()
52
53              Specify the clear value for the color index buffers
54
55              gl:clearIndex specifies the index used by  gl:clear/1  to  clear
56              the  color  index  buffers.  C is not clamped. Rather, C is con‐
57              verted to a fixed-point value with unspecified precision to  the
58              right  of  the  binary  point. The integer part of this value is
59              then masked with 2 m-1, where m is the number of bits in a color
60              index stored in the frame buffer.
61
62              See external documentation.
63
64       clearColor(Red, Green, Blue, Alpha) -> ok
65
66              Types:
67
68                 Red = clamp()
69                 Green = clamp()
70                 Blue = clamp()
71                 Alpha = clamp()
72
73              Specify clear values for the color buffers
74
75              gl:clearColor  specifies  the red, green, blue, and alpha values
76              used by gl:clear/1 to clear the color buffers. Values  specified
77              by gl:clearColor are clamped to the range [0 1].
78
79              See external documentation.
80
81       clear(Mask) -> ok
82
83              Types:
84
85                 Mask = integer()
86
87              Clear buffers to preset values
88
89              gl:clear  sets  the bitplane area of the window to values previ‐
90              ously selected by gl:clearColor , gl:clearDepth, and  gl:clearS‐
91              tencil.  Multiple color buffers can be cleared simultaneously by
92              selecting more than one buffer at a time using gl:drawBuffer/1 .
93
94              See external documentation.
95
96       indexMask(Mask) -> ok
97
98              Types:
99
100                 Mask = integer()
101
102              Control the writing of individual bits in the color  index  buf‐
103              fers
104
105              gl:indexMask  controls  the  writing  of  individual bits in the
106              color index buffers. The least significant  n  bits  of  Mask  ,
107              where n is the number of bits in a color index buffer, specify a
108              mask. Where a 1 (one) appears in  the  mask,  it's  possible  to
109              write  to  the  corresponding  bit in the color index buffer (or
110              buffers). Where a 0 (zero) appears,  the  corresponding  bit  is
111              write-protected.
112
113              See external documentation.
114
115       colorMask(Red, Green, Blue, Alpha) -> ok
116
117              Types:
118
119                 Red = 0 | 1
120                 Green = 0 | 1
121                 Blue = 0 | 1
122                 Alpha = 0 | 1
123
124              Enable and disable writing of frame buffer color components
125
126              gl:colorMask  and  gl:colorMaski  specify whether the individual
127              color components in the frame buffer can or cannot  be  written.
128              gl:colorMaski  sets the mask for a specific draw buffer, whereas
129              gl:colorMask sets the mask for  all  draw  buffers.  If  Red  is
130              ?GL_FALSE,  for  example, no change is made to the red component
131              of any pixel in any of the  color  buffers,  regardless  of  the
132              drawing operation attempted.
133
134              See external documentation.
135
136       alphaFunc(Func, Ref) -> ok
137
138              Types:
139
140                 Func = enum()
141                 Ref = clamp()
142
143              Specify the alpha test function
144
145              The  alpha test discards fragments depending on the outcome of a
146              comparison between an incoming fragment's alpha value and a con‐
147              stant  reference  value.  gl:alphaFunc  specifies  the reference
148              value and the comparison function. The comparison  is  performed
149              only if alpha testing is enabled. By default, it is not enabled.
150              (See gl:enable/1 and gl:enable/1 of ?GL_ALPHA_TEST.)
151
152              See external documentation.
153
154       blendFunc(Sfactor, Dfactor) -> ok
155
156              Types:
157
158                 Sfactor = enum()
159                 Dfactor = enum()
160
161              Specify pixel arithmetic
162
163              Pixels can be drawn using a function that  blends  the  incoming
164              (source)  RGBA  values  with the RGBA values that are already in
165              the frame buffer (the destination values). Blending is initially
166              disabled.   Use   gl:enable/1   and  gl:enable/1  with  argument
167              ?GL_BLEND to enable and disable blending.
168
169              See external documentation.
170
171       logicOp(Opcode) -> ok
172
173              Types:
174
175                 Opcode = enum()
176
177              Specify a logical pixel operation for rendering
178
179              gl:logicOp specifies a logical operation that, when enabled,  is
180              applied  between  the  incoming RGBA color and the RGBA color at
181              the corresponding location in the frame  buffer.  To  enable  or
182              disable  the logical operation, call gl:enable/1 and gl:enable/1
183              using the  symbolic  constant  ?GL_COLOR_LOGIC_OP.  The  initial
184              value is disabled.
185
186              See external documentation.
187
188       cullFace(Mode) -> ok
189
190              Types:
191
192                 Mode = enum()
193
194              Specify whether front- or back-facing facets can be culled
195
196              gl:cullFace  specifies  whether front- or back-facing facets are
197              culled (as specified by mode) when  facet  culling  is  enabled.
198              Facet culling is initially disabled. To enable and disable facet
199              culling, call the gl:enable/1 and gl:enable/1 commands with  the
200              argument  ?GL_CULL_FACE.  Facets include triangles, quadrilater‐
201              als, polygons, and rectangles.
202
203              See external documentation.
204
205       frontFace(Mode) -> ok
206
207              Types:
208
209                 Mode = enum()
210
211              Define front- and back-facing polygons
212
213              In a scene composed entirely of opaque  closed  surfaces,  back-
214              facing  polygons  are never visible. Eliminating these invisible
215              polygons has the obvious benefit of speeding up the rendering of
216              the  image.  To  enable  and  disable elimination of back-facing
217              polygons,  call  gl:enable/1  and  gl:enable/1   with   argument
218              ?GL_CULL_FACE.
219
220              See external documentation.
221
222       pointSize(Size) -> ok
223
224              Types:
225
226                 Size = float()
227
228              Specify the diameter of rasterized points
229
230              gl:pointSize  specifies  the  rasterized  diameter of points. If
231              point size mode is  disabled  (see  gl:enable/1  with  parameter
232              ?GL_PROGRAM_POINT_SIZE),  this  value  will be used to rasterize
233              points. Otherwise, the value written  to  the  shading  language
234              built-in variable gl_PointSize will be used.
235
236              See external documentation.
237
238       lineWidth(Width) -> ok
239
240              Types:
241
242                 Width = float()
243
244              Specify the width of rasterized lines
245
246              gl:lineWidth  specifies the rasterized width of both aliased and
247              antialiased lines. Using a line width other than 1 has different
248              effects,  depending  on whether line antialiasing is enabled. To
249              enable and  disable  line  antialiasing,  call  gl:enable/1  and
250              gl:enable/1  with argument ?GL_LINE_SMOOTH. Line antialiasing is
251              initially disabled.
252
253              See external documentation.
254
255       lineStipple(Factor, Pattern) -> ok
256
257              Types:
258
259                 Factor = integer()
260                 Pattern = integer()
261
262              Specify the line stipple pattern
263
264              Line stippling masks out certain fragments produced by  rasteri‐
265              zation;  those  fragments  will  not  be  drawn.  The masking is
266              achieved by using three parameters: the 16-bit line stipple pat‐
267              tern  Pattern , the repeat count Factor , and an integer stipple
268              counter s.
269
270              See external documentation.
271
272       polygonMode(Face, Mode) -> ok
273
274              Types:
275
276                 Face = enum()
277                 Mode = enum()
278
279              Select a polygon rasterization mode
280
281              gl:polygonMode controls the interpretation of polygons for  ras‐
282              terization.  Face describes which polygons Mode applies to: both
283              front and back-facing polygons (?GL_FRONT_AND_BACK ). The  poly‐
284              gon  mode  affects  only the final rasterization of polygons. In
285              particular, a polygon's vertices are  lit  and  the  polygon  is
286              clipped and possibly culled before these modes are applied.
287
288              See external documentation.
289
290       polygonOffset(Factor, Units) -> ok
291
292              Types:
293
294                 Factor = float()
295                 Units = float()
296
297              Set the scale and units used to calculate depth values
298
299              When    ?GL_POLYGON_OFFSET_FILL,   ?GL_POLYGON_OFFSET_LINE,   or
300              ?GL_POLYGON_OFFSET_POINT is enabled, each fragment's depth value
301              will be offset after it is interpolated from the depth values of
302              the appropriate vertices.  The  value  of  the  offset  is  fac‐
303              tor×DZ+r×units, where DZ is a measurement of the change in depth
304              relative to the screen area of the polygon, and r is the  small‐
305              est  value that is guaranteed to produce a resolvable offset for
306              a given implementation. The offset is  added  before  the  depth
307              test is performed and before the value is written into the depth
308              buffer.
309
310              See external documentation.
311
312       polygonStipple(Mask) -> ok
313
314              Types:
315
316                 Mask = binary()
317
318              Set the polygon stippling pattern
319
320              Polygon stippling, like line stippling (see gl:lineStipple/2  ),
321              masks  out certain fragments produced by rasterization, creating
322              a pattern. Stippling is independent of polygon antialiasing.
323
324              See external documentation.
325
326       getPolygonStipple() -> binary()
327
328              Return the polygon stipple pattern
329
330              gl:getPolygonStipple returns to Pattern a 32×32 polygon  stipple
331              pattern. The pattern is packed into memory as if gl:readPixels/7
332              with both height and width of 32, type of ?GL_BITMAP, and format
333              of  ?GL_COLOR_INDEX  were  called,  and the stipple pattern were
334              stored in an internal 32×32 color index buffer. Unlike  gl:read‐
335              Pixels/7  ,  however,  pixel transfer operations (shift, offset,
336              pixel map) are not applied to the returned stipple image.
337
338              See external documentation.
339
340       edgeFlag(Flag) -> ok
341
342              Types:
343
344                 Flag = 0 | 1
345
346              Flag edges as either boundary or nonboundary
347
348              Each vertex of a polygon, separate triangle, or separate quadri‐
349              lateral  specified between a gl:'begin'/1 / gl:'begin'/1 pair is
350              marked as the start of either a boundary or nonboundary edge. If
351              the  current edge flag is true when the vertex is specified, the
352              vertex is marked as the start of a boundary edge. Otherwise, the
353              vertex is marked as the start of a nonboundary edge. gl:edgeFlag
354              sets the edge flag bit to ?GL_TRUE if Flag is  ?GL_TRUE  and  to
355              ?GL_FALSE otherwise.
356
357              See external documentation.
358
359       edgeFlagv(Flag) -> ok
360
361              Types:
362
363                 Flag = {Flag::0 | 1}
364
365              Equivalent to edgeFlag(Flag).
366
367       scissor(X, Y, Width, Height) -> ok
368
369              Types:
370
371                 X = integer()
372                 Y = integer()
373                 Width = integer()
374                 Height = integer()
375
376              Define the scissor box
377
378              gl:scissor  defines a rectangle, called the scissor box, in win‐
379              dow coordinates. The first two arguments, X and Y , specify  the
380              lower left corner of the box. Width and Height specify the width
381              and height of the box.
382
383              See external documentation.
384
385       clipPlane(Plane, Equation) -> ok
386
387              Types:
388
389                 Plane = enum()
390                 Equation = {float(), float(), float(), float()}
391
392              Specify a plane against which all geometry is clipped
393
394              Geometry is always clipped against the boundaries of a six-plane
395              frustum  in  x, y , and z. gl:clipPlane allows the specification
396              of additional planes, not necessarily perpendicular to the x, y,
397              or  z  axis, against which all geometry is clipped. To determine
398              the maximum number of additional clipping planes,  call  gl:get‐
399              Booleanv/1  with  argument  ?GL_MAX_CLIP_PLANES. All implementa‐
400              tions support at least six such  clipping  planes.  Because  the
401              resulting  clipping  region  is  the intersection of the defined
402              half-spaces, it is always convex.
403
404              See external documentation.
405
406       getClipPlane(Plane) -> {float(), float(), float(), float()}
407
408              Types:
409
410                 Plane = enum()
411
412              Return the coefficients of the specified clipping plane
413
414              gl:getClipPlane returns in Equation the four coefficients of the
415              plane equation for Plane .
416
417              See external documentation.
418
419       drawBuffer(Mode) -> ok
420
421              Types:
422
423                 Mode = enum()
424
425              Specify which color buffers are to be drawn into
426
427              When  colors  are  written to the frame buffer, they are written
428              into the color buffers specified by gl:drawBuffer. The  specifi‐
429              cations are as follows:
430
431              See external documentation.
432
433       readBuffer(Mode) -> ok
434
435              Types:
436
437                 Mode = enum()
438
439              Select a color buffer source for pixels
440
441              gl:readBuffer  specifies a color buffer as the source for subse‐
442              quent  gl:readPixels/7  ,  gl:copyTexImage1D/7  ,  gl:copyTexIm‐
443              age2D/8  , gl:copyTexSubImage1D/6 , gl:copyTexSubImage2D/8 , and
444              gl:copyTexSubImage3D/9 commands. Mode accepts one of  twelve  or
445              more predefined values. In a fully configured system, ?GL_FRONT,
446              ?GL_LEFT, and ?GL_FRONT_LEFT all name  the  front  left  buffer,
447              ?GL_FRONT_RIGHT  and  ?GL_RIGHT name the front right buffer, and
448              ?GL_BACK_LEFT and ?GL_BACK name the back  left  buffer.  Further
449              more,  the  constants ?GL_COLOR_ATTACHMENTi may be used to indi‐
450              cate the ith color attachment where i ranges from  zero  to  the
451              value of ?GL_MAX_COLOR_ATTACHMENTS minus one.
452
453              See external documentation.
454
455       enable(Cap) -> ok
456
457              Types:
458
459                 Cap = enum()
460
461              Enable or disable server-side GL capabilities
462
463              gl:enable  and  gl:enable/1 enable and disable various capabili‐
464              ties. Use gl:isEnabled/1 or gl:getBooleanv/1  to  determine  the
465              current  setting  of  any capability. The initial value for each
466              capability with the exception of ?GL_DITHER and  ?GL_MULTISAMPLE
467              is ?GL_FALSE. The initial value for ?GL_DITHER and ?GL_MULTISAM‐
468              PLE is ?GL_TRUE.
469
470              See external documentation.
471
472       disable(Cap) -> ok
473
474              Types:
475
476                 Cap = enum()
477
478              See enable/1
479
480       isEnabled(Cap) -> 0 | 1
481
482              Types:
483
484                 Cap = enum()
485
486              Test whether a capability is enabled
487
488              gl:isEnabled returns ?GL_TRUE if Cap is  an  enabled  capability
489              and returns ?GL_FALSE otherwise. Boolean states that are indexed
490              may be tested with  gl:isEnabledi  .  For  gl:isEnabledi,  Index
491              specifies  the  index  of  the capability to test. Index must be
492              between zero and the count of indexed  capabilities  for  Cap  .
493              Initially  all  capabilities  except  ?GL_DITHER  are  disabled;
494              ?GL_DITHER is initially enabled.
495
496              See external documentation.
497
498       enableClientState(Cap) -> ok
499
500              Types:
501
502                 Cap = enum()
503
504              Enable or disable client-side capability
505
506              gl:enableClientState and gl:enableClientState/1 enable  or  dis‐
507              able   individual  client-side  capabilities.  By  default,  all
508              client-side capabilities are disabled. Both gl:enableClientState
509              and  gl:enableClientState/1  take a single argument, Cap , which
510              can assume one of the following values:
511
512              See external documentation.
513
514       disableClientState(Cap) -> ok
515
516              Types:
517
518                 Cap = enum()
519
520              See enableClientState/1
521
522       getBooleanv(Pname) -> [0 | 1]
523
524              Types:
525
526                 Pname = enum()
527
528              Return the value or values of a selected parameter
529
530              These four commands return values for simple state variables  in
531              GL.  Pname  is a symbolic constant indicating the state variable
532              to be returned, and Params is a pointer to an array of the indi‐
533              cated type in which to place the returned data.
534
535              See external documentation.
536
537       getDoublev(Pname) -> [float()]
538
539              Types:
540
541                 Pname = enum()
542
543              See getBooleanv/1
544
545       getFloatv(Pname) -> [float()]
546
547              Types:
548
549                 Pname = enum()
550
551              See getBooleanv/1
552
553       getIntegerv(Pname) -> [integer()]
554
555              Types:
556
557                 Pname = enum()
558
559              See getBooleanv/1
560
561       pushAttrib(Mask) -> ok
562
563              Types:
564
565                 Mask = integer()
566
567              Push and pop the server attribute stack
568
569              gl:pushAttrib  takes  one  argument, a mask that indicates which
570              groups of state variables to save on the attribute  stack.  Sym‐
571              bolic  constants are used to set bits in the mask. Mask is typi‐
572              cally constructed by specifying the  bitwise-or  of  several  of
573              these  constants  together. The special mask ?GL_ALL_ATTRIB_BITS
574              can be used to save all stackable states.
575
576              See external documentation.
577
578       popAttrib() -> ok
579
580              See pushAttrib/1
581
582       pushClientAttrib(Mask) -> ok
583
584              Types:
585
586                 Mask = integer()
587
588              Push and pop the client attribute stack
589
590              gl:pushClientAttrib takes one argument, a  mask  that  indicates
591              which  groups  of  client-state  variables to save on the client
592              attribute stack. Symbolic constants are used to set bits in  the
593              mask. Mask is typically constructed by specifying the bitwise-or
594              of  several  of  these  constants  together.  The  special  mask
595              ?GL_CLIENT_ALL_ATTRIB_BITS  can  be  used  to save all stackable
596              client state.
597
598              See external documentation.
599
600       popClientAttrib() -> ok
601
602              See pushClientAttrib/1
603
604       renderMode(Mode) -> integer()
605
606              Types:
607
608                 Mode = enum()
609
610              Set rasterization mode
611
612              gl:renderMode sets the rasterization mode. It  takes  one  argu‐
613              ment, Mode , which can assume one of three predefined values:
614
615              See external documentation.
616
617       getError() -> enum()
618
619              Return error information
620
621              gl:getError returns the value of the error flag. Each detectable
622              error is assigned a numeric code  and  symbolic  name.  When  an
623              error  occurs,  the  error  flag is set to the appropriate error
624              code value. No other errors are recorded  until  gl:getError  is
625              called,  the  error  code  is returned, and the flag is reset to
626              ?GL_NO_ERROR. If a call  to  gl:getError  returns  ?GL_NO_ERROR,
627              there  has  been  no  detectable  error  since  the last call to
628              gl:getError , or since the GL was initialized.
629
630              See external documentation.
631
632       getString(Name) -> string()
633
634              Types:
635
636                 Name = enum()
637
638              Return a string describing the current GL connection
639
640              gl:getString returns a pointer to  a  static  string  describing
641              some aspect of the current GL connection. Name can be one of the
642              following:
643
644              See external documentation.
645
646       finish() -> ok
647
648              Block until all GL execution is complete
649
650              gl:finish does not return until the effects  of  all  previously
651              called  GL  commands  are  complete.  Such  effects  include all
652              changes to GL state, all changes to connection  state,  and  all
653              changes to the frame buffer contents.
654
655              See external documentation.
656
657       flush() -> ok
658
659              Force execution of GL commands in finite time
660
661              Different  GL implementations buffer commands in several differ‐
662              ent locations, including network buffers and the graphics accel‐
663              erator  itself.  gl:flush  empties all of these buffers, causing
664              all issued commands to  be  executed  as  quickly  as  they  are
665              accepted  by  the actual rendering engine. Though this execution
666              may not be completed in any particular time period, it does com‐
667              plete in finite time.
668
669              See external documentation.
670
671       hint(Target, Mode) -> ok
672
673              Types:
674
675                 Target = enum()
676                 Mode = enum()
677
678              Specify implementation-specific hints
679
680              Certain aspects of GL behavior, when there is room for interpre‐
681              tation, can be controlled with hints. A hint is  specified  with
682              two  arguments.  Target  is  a  symbolic constant indicating the
683              behavior to be controlled, and Mode is another symbolic constant
684              indicating the desired behavior. The initial value for each Tar‐
685              get is ?GL_DONT_CARE . Mode can be one of the following:
686
687              See external documentation.
688
689       clearDepth(Depth) -> ok
690
691              Types:
692
693                 Depth = clamp()
694
695              Specify the clear value for the depth buffer
696
697              gl:clearDepth specifies the depth value used  by  gl:clear/1  to
698              clear  the  depth  buffer. Values specified by gl:clearDepth are
699              clamped to the range [0 1].
700
701              See external documentation.
702
703       depthFunc(Func) -> ok
704
705              Types:
706
707                 Func = enum()
708
709              Specify the value used for depth buffer comparisons
710
711              gl:depthFunc specifies the function used to compare each  incom‐
712              ing  pixel depth value with the depth value present in the depth
713              buffer. The comparison is performed only  if  depth  testing  is
714              enabled. (See gl:enable/1 and gl:enable/1 of ?GL_DEPTH_TEST .)
715
716              See external documentation.
717
718       depthMask(Flag) -> ok
719
720              Types:
721
722                 Flag = 0 | 1
723
724              Enable or disable writing into the depth buffer
725
726              gl:depthMask  specifies  whether the depth buffer is enabled for
727              writing. If Flag is ?GL_FALSE, depth buffer writing is disabled.
728              Otherwise,  it  is  enabled.  Initially, depth buffer writing is
729              enabled.
730
731              See external documentation.
732
733       depthRange(Near_val, Far_val) -> ok
734
735              Types:
736
737                 Near_val = clamp()
738                 Far_val = clamp()
739
740              Specify mapping of depth values from normalized  device  coordi‐
741              nates to window coordinates
742
743              After  clipping  and division by w, depth coordinates range from
744              -1 to 1, corresponding to the  near  and  far  clipping  planes.
745              gl:depthRange specifies a linear mapping of the normalized depth
746              coordinates in this range to window depth  coordinates.  Regard‐
747              less  of  the actual depth buffer implementation, window coordi‐
748              nate depth values are  treated  as  though  they  range  from  0
749              through  1 (like color components). Thus, the values accepted by
750              gl:depthRange are both clamped to this  range  before  they  are
751              accepted.
752
753              See external documentation.
754
755       clearAccum(Red, Green, Blue, Alpha) -> ok
756
757              Types:
758
759                 Red = float()
760                 Green = float()
761                 Blue = float()
762                 Alpha = float()
763
764              Specify clear values for the accumulation buffer
765
766              gl:clearAccum  specifies  the red, green, blue, and alpha values
767              used by gl:clear/1 to clear the accumulation buffer.
768
769              See external documentation.
770
771       accum(Op, Value) -> ok
772
773              Types:
774
775                 Op = enum()
776                 Value = float()
777
778              Operate on the accumulation buffer
779
780              The accumulation  buffer  is  an  extended-range  color  buffer.
781              Images  are  not  rendered into it. Rather, images rendered into
782              one of the color buffers are added to the contents of the  accu‐
783              mulation  buffer  after  rendering. Effects such as antialiasing
784              (of points, lines, and polygons),  motion  blur,  and  depth  of
785              field  can be created by accumulating images generated with dif‐
786              ferent transformation matrices.
787
788              See external documentation.
789
790       matrixMode(Mode) -> ok
791
792              Types:
793
794                 Mode = enum()
795
796              Specify which matrix is the current matrix
797
798              gl:matrixMode sets the current matrix mode. Mode can assume  one
799              of four values:
800
801              See external documentation.
802
803       ortho(Left, Right, Bottom, Top, Near_val, Far_val) -> ok
804
805              Types:
806
807                 Left = float()
808                 Right = float()
809                 Bottom = float()
810                 Top = float()
811                 Near_val = float()
812                 Far_val = float()
813
814              Multiply the current matrix with an orthographic matrix
815
816              gl:ortho  describes  a  transformation  that produces a parallel
817              projection. The current matrix (see gl:matrixMode/1 ) is  multi‐
818              plied by this matrix and the result replaces the current matrix,
819              as if gl:multMatrixd/1 were called with the following matrix  as
820              its argument:
821
822              See external documentation.
823
824       frustum(Left, Right, Bottom, Top, Near_val, Far_val) -> ok
825
826              Types:
827
828                 Left = float()
829                 Right = float()
830                 Bottom = float()
831                 Top = float()
832                 Near_val = float()
833                 Far_val = float()
834
835              Multiply the current matrix by a perspective matrix
836
837              gl:frustum  describes  a perspective matrix that produces a per‐
838              spective projection. The current matrix (see  gl:matrixMode/1  )
839              is multiplied by this matrix and the result replaces the current
840              matrix, as if gl:multMatrixd/1 were called  with  the  following
841              matrix as its argument:
842
843              See external documentation.
844
845       viewport(X, Y, Width, Height) -> ok
846
847              Types:
848
849                 X = integer()
850                 Y = integer()
851                 Width = integer()
852                 Height = integer()
853
854              Set the viewport
855
856              gl:viewport  specifies the affine transformation of x and y from
857              normalized device coordinates to window coordinates. Let (x nd y
858              nd)  be  normalized  device coordinates. Then the window coordi‐
859              nates (x w y w) are computed as follows:
860
861              See external documentation.
862
863       pushMatrix() -> ok
864
865              Push and pop the current matrix stack
866
867              There is a stack of matrices for each of the  matrix  modes.  In
868              ?GL_MODELVIEW mode, the stack depth is at least 32. In the other
869              modes, ?GL_COLOR, ?GL_PROJECTION , and ?GL_TEXTURE, the depth is
870              at  least 2. The current matrix in any mode is the matrix on the
871              top of the stack for that mode.
872
873              See external documentation.
874
875       popMatrix() -> ok
876
877              See pushMatrix/0
878
879       loadIdentity() -> ok
880
881              Replace the current matrix with the identity matrix
882
883              gl:loadIdentity replaces the current matrix  with  the  identity
884              matrix.  It  is  semantically  equivalent  to calling gl:loadMa‐
885              trixd/1 with the identity matrix
886
887              See external documentation.
888
889       loadMatrixd(M) -> ok
890
891              Types:
892
893                 M = matrix()
894
895              Replace the current matrix with the specified matrix
896
897              gl:loadMatrix replaces the current matrix  with  the  one  whose
898              elements  are specified by M . The current matrix is the projec‐
899              tion matrix, modelview matrix, or texture matrix,  depending  on
900              the current matrix mode (see gl:matrixMode/1 ).
901
902              See external documentation.
903
904       loadMatrixf(M) -> ok
905
906              Types:
907
908                 M = matrix()
909
910              See loadMatrixd/1
911
912       multMatrixd(M) -> ok
913
914              Types:
915
916                 M = matrix()
917
918              Multiply the current matrix with the specified matrix
919
920              gl:multMatrix  multiplies the current matrix with the one speci‐
921              fied using M , and replaces the current matrix with the product.
922
923              See external documentation.
924
925       multMatrixf(M) -> ok
926
927              Types:
928
929                 M = matrix()
930
931              See multMatrixd/1
932
933       rotated(Angle, X, Y, Z) -> ok
934
935              Types:
936
937                 Angle = float()
938                 X = float()
939                 Y = float()
940                 Z = float()
941
942              Multiply the current matrix by a rotation matrix
943
944              gl:rotate produces a rotation of Angle degrees around the vector
945              (x y z). The current matrix (see gl:matrixMode/1 ) is multiplied
946              by a rotation matrix with  the  product  replacing  the  current
947              matrix,  as  if  gl:multMatrixd/1 were called with the following
948              matrix as its argument:
949
950              See external documentation.
951
952       rotatef(Angle, X, Y, Z) -> ok
953
954              Types:
955
956                 Angle = float()
957                 X = float()
958                 Y = float()
959                 Z = float()
960
961              See rotated/4
962
963       scaled(X, Y, Z) -> ok
964
965              Types:
966
967                 X = float()
968                 Y = float()
969                 Z = float()
970
971              Multiply the current matrix by a general scaling matrix
972
973              gl:scale produces a nonuniform scaling along the  x,  y,  and  z
974              axes.  The  three  parameters  indicate the desired scale factor
975              along each of the three axes.
976
977              See external documentation.
978
979       scalef(X, Y, Z) -> ok
980
981              Types:
982
983                 X = float()
984                 Y = float()
985                 Z = float()
986
987              See scaled/3
988
989       translated(X, Y, Z) -> ok
990
991              Types:
992
993                 X = float()
994                 Y = float()
995                 Z = float()
996
997              Multiply the current matrix by a translation matrix
998
999              gl:translate produces a translation by  (x  y  z).  The  current
1000              matrix  (see gl:matrixMode/1 ) is multiplied by this translation
1001              matrix, with the product replacing the  current  matrix,  as  if
1002              gl:multMatrixd/1  were  called with the following matrix for its
1003              argument:
1004
1005              See external documentation.
1006
1007       translatef(X, Y, Z) -> ok
1008
1009              Types:
1010
1011                 X = float()
1012                 Y = float()
1013                 Z = float()
1014
1015              See translated/3
1016
1017       isList(List) -> 0 | 1
1018
1019              Types:
1020
1021                 List = integer()
1022
1023              Determine if a name corresponds to a display list
1024
1025              gl:isList returns ?GL_TRUE if List is the name of a display list
1026              and returns ?GL_FALSE if it is not, or if an error occurs.
1027
1028              See external documentation.
1029
1030       deleteLists(List, Range) -> ok
1031
1032              Types:
1033
1034                 List = integer()
1035                 Range = integer()
1036
1037              Delete a contiguous group of display lists
1038
1039              gl:deleteLists  causes a contiguous group of display lists to be
1040              deleted. List is the name  of  the  first  display  list  to  be
1041              deleted, and Range is the number of display lists to delete. All
1042              display lists d with list<= d<= list+range-1 are deleted.
1043
1044              See external documentation.
1045
1046       genLists(Range) -> integer()
1047
1048              Types:
1049
1050                 Range = integer()
1051
1052              Generate a contiguous set of empty display lists
1053
1054              gl:genLists has one argument, Range . It returns  an  integer  n
1055              such  that  Range  contiguous empty display lists, named n, n+1,
1056              ..., n+range-1, are created. If Range is 0, if there is no group
1057              of  Range  contiguous names available, or if any error is gener‐
1058              ated, no display lists are generated, and 0 is returned.
1059
1060              See external documentation.
1061
1062       newList(List, Mode) -> ok
1063
1064              Types:
1065
1066                 List = integer()
1067                 Mode = enum()
1068
1069              Create or replace a display list
1070
1071              Display lists are groups of GL commands that  have  been  stored
1072              for   subsequent  execution.  Display  lists  are  created  with
1073              gl:newList. All subsequent commands are placed  in  the  display
1074              list, in the order issued, until gl:endList/0 is called.
1075
1076              See external documentation.
1077
1078       endList() -> ok
1079
1080              glBeginList
1081
1082              See external documentation.
1083
1084       callList(List) -> ok
1085
1086              Types:
1087
1088                 List = integer()
1089
1090              Execute a display list
1091
1092              gl:callList  causes  the  named display list to be executed. The
1093              commands saved in the display list are executed in  order,  just
1094              as if they were called without using a display list. If List has
1095              not been defined as a display list, gl:callList is ignored.
1096
1097              See external documentation.
1098
1099       callLists(Lists) -> ok
1100
1101              Types:
1102
1103                 Lists = [integer()]
1104
1105              Execute a list of display lists
1106
1107              gl:callLists causes each display  list  in  the  list  of  names
1108              passed  as Lists to be executed. As a result, the commands saved
1109              in each display list are executed in order, just as if they were
1110              called without using a display list. Names of display lists that
1111              have not been defined are ignored.
1112
1113              See external documentation.
1114
1115       listBase(Base) -> ok
1116
1117              Types:
1118
1119                 Base = integer()
1120
1121              set the display-list base for
1122
1123              gl:callLists/1
1124
1125              gl:callLists/1 specifies an array of offsets. Display-list names
1126              are  generated  by adding Base to each offset. Names that refer‐
1127              ence valid display lists are executed; the others are ignored.
1128
1129              See external documentation.
1130
1131       begin(Mode) -> ok
1132
1133              Types:
1134
1135                 Mode = enum()
1136
1137              Delimit the vertices of a primitive or a group  of  like  primi‐
1138              tives
1139
1140              gl:'begin'  and  gl:'begin'/1 delimit the vertices that define a
1141              primitive or a group of like primitives.  gl:'begin'  accepts  a
1142              single argument that specifies in which of ten ways the vertices
1143              are interpreted. Taking n as an integer count starting  at  one,
1144              and N as the total number of vertices specified, the interpreta‐
1145              tions are as follows:
1146
1147              See external documentation.
1148
1149       end() -> ok
1150
1151              See 'begin'/1
1152
1153       vertex2d(X, Y) -> ok
1154
1155              Types:
1156
1157                 X = float()
1158                 Y = float()
1159
1160              Specify a vertex
1161
1162              gl:vertex commands are used within gl:'begin'/1  /  gl:'begin'/1
1163              pairs  to specify point, line, and polygon vertices. The current
1164              color, normal, texture coordinates, and fog coordinate are asso‐
1165              ciated with the vertex when gl:vertex is called.
1166
1167              See external documentation.
1168
1169       vertex2f(X, Y) -> ok
1170
1171              Types:
1172
1173                 X = float()
1174                 Y = float()
1175
1176              See vertex2d/2
1177
1178       vertex2i(X, Y) -> ok
1179
1180              Types:
1181
1182                 X = integer()
1183                 Y = integer()
1184
1185              See vertex2d/2
1186
1187       vertex2s(X, Y) -> ok
1188
1189              Types:
1190
1191                 X = integer()
1192                 Y = integer()
1193
1194              See vertex2d/2
1195
1196       vertex3d(X, Y, Z) -> ok
1197
1198              Types:
1199
1200                 X = float()
1201                 Y = float()
1202                 Z = float()
1203
1204              See vertex2d/2
1205
1206       vertex3f(X, Y, Z) -> ok
1207
1208              Types:
1209
1210                 X = float()
1211                 Y = float()
1212                 Z = float()
1213
1214              See vertex2d/2
1215
1216       vertex3i(X, Y, Z) -> ok
1217
1218              Types:
1219
1220                 X = integer()
1221                 Y = integer()
1222                 Z = integer()
1223
1224              See vertex2d/2
1225
1226       vertex3s(X, Y, Z) -> ok
1227
1228              Types:
1229
1230                 X = integer()
1231                 Y = integer()
1232                 Z = integer()
1233
1234              See vertex2d/2
1235
1236       vertex4d(X, Y, Z, W) -> ok
1237
1238              Types:
1239
1240                 X = float()
1241                 Y = float()
1242                 Z = float()
1243                 W = float()
1244
1245              See vertex2d/2
1246
1247       vertex4f(X, Y, Z, W) -> ok
1248
1249              Types:
1250
1251                 X = float()
1252                 Y = float()
1253                 Z = float()
1254                 W = float()
1255
1256              See vertex2d/2
1257
1258       vertex4i(X, Y, Z, W) -> ok
1259
1260              Types:
1261
1262                 X = integer()
1263                 Y = integer()
1264                 Z = integer()
1265                 W = integer()
1266
1267              See vertex2d/2
1268
1269       vertex4s(X, Y, Z, W) -> ok
1270
1271              Types:
1272
1273                 X = integer()
1274                 Y = integer()
1275                 Z = integer()
1276                 W = integer()
1277
1278              See vertex2d/2
1279
1280       vertex2dv(V) -> ok
1281
1282              Types:
1283
1284                 V = {X::float(), Y::float()}
1285
1286              Equivalent to vertex2d(X, Y).
1287
1288       vertex2fv(V) -> ok
1289
1290              Types:
1291
1292                 V = {X::float(), Y::float()}
1293
1294              Equivalent to vertex2f(X, Y).
1295
1296       vertex2iv(V) -> ok
1297
1298              Types:
1299
1300                 V = {X::integer(), Y::integer()}
1301
1302              Equivalent to vertex2i(X, Y).
1303
1304       vertex2sv(V) -> ok
1305
1306              Types:
1307
1308                 V = {X::integer(), Y::integer()}
1309
1310              Equivalent to vertex2s(X, Y).
1311
1312       vertex3dv(V) -> ok
1313
1314              Types:
1315
1316                 V = {X::float(), Y::float(), Z::float()}
1317
1318              Equivalent to vertex3d(X, Y, Z).
1319
1320       vertex3fv(V) -> ok
1321
1322              Types:
1323
1324                 V = {X::float(), Y::float(), Z::float()}
1325
1326              Equivalent to vertex3f(X, Y, Z).
1327
1328       vertex3iv(V) -> ok
1329
1330              Types:
1331
1332                 V = {X::integer(), Y::integer(), Z::integer()}
1333
1334              Equivalent to vertex3i(X, Y, Z).
1335
1336       vertex3sv(V) -> ok
1337
1338              Types:
1339
1340                 V = {X::integer(), Y::integer(), Z::integer()}
1341
1342              Equivalent to vertex3s(X, Y, Z).
1343
1344       vertex4dv(V) -> ok
1345
1346              Types:
1347
1348                 V = {X::float(), Y::float(), Z::float(), W::float()}
1349
1350              Equivalent to vertex4d(X, Y, Z, W).
1351
1352       vertex4fv(V) -> ok
1353
1354              Types:
1355
1356                 V = {X::float(), Y::float(), Z::float(), W::float()}
1357
1358              Equivalent to vertex4f(X, Y, Z, W).
1359
1360       vertex4iv(V) -> ok
1361
1362              Types:
1363
1364                 V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
1365
1366              Equivalent to vertex4i(X, Y, Z, W).
1367
1368       vertex4sv(V) -> ok
1369
1370              Types:
1371
1372                 V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
1373
1374              Equivalent to vertex4s(X, Y, Z, W).
1375
1376       normal3b(Nx, Ny, Nz) -> ok
1377
1378              Types:
1379
1380                 Nx = integer()
1381                 Ny = integer()
1382                 Nz = integer()
1383
1384              Set the current normal vector
1385
1386              The  current  normal  is  set  to the given coordinates whenever
1387              gl:normal is issued. Byte, short, or integer arguments are  con‐
1388              verted  to floating-point format with a linear mapping that maps
1389              the most positive representable integer value  to  1.0  and  the
1390              most negative representable integer value to -1.0.
1391
1392              See external documentation.
1393
1394       normal3d(Nx, Ny, Nz) -> ok
1395
1396              Types:
1397
1398                 Nx = float()
1399                 Ny = float()
1400                 Nz = float()
1401
1402              See normal3b/3
1403
1404       normal3f(Nx, Ny, Nz) -> ok
1405
1406              Types:
1407
1408                 Nx = float()
1409                 Ny = float()
1410                 Nz = float()
1411
1412              See normal3b/3
1413
1414       normal3i(Nx, Ny, Nz) -> ok
1415
1416              Types:
1417
1418                 Nx = integer()
1419                 Ny = integer()
1420                 Nz = integer()
1421
1422              See normal3b/3
1423
1424       normal3s(Nx, Ny, Nz) -> ok
1425
1426              Types:
1427
1428                 Nx = integer()
1429                 Ny = integer()
1430                 Nz = integer()
1431
1432              See normal3b/3
1433
1434       normal3bv(V) -> ok
1435
1436              Types:
1437
1438                 V = {Nx::integer(), Ny::integer(), Nz::integer()}
1439
1440              Equivalent to normal3b(Nx, Ny, Nz).
1441
1442       normal3dv(V) -> ok
1443
1444              Types:
1445
1446                 V = {Nx::float(), Ny::float(), Nz::float()}
1447
1448              Equivalent to normal3d(Nx, Ny, Nz).
1449
1450       normal3fv(V) -> ok
1451
1452              Types:
1453
1454                 V = {Nx::float(), Ny::float(), Nz::float()}
1455
1456              Equivalent to normal3f(Nx, Ny, Nz).
1457
1458       normal3iv(V) -> ok
1459
1460              Types:
1461
1462                 V = {Nx::integer(), Ny::integer(), Nz::integer()}
1463
1464              Equivalent to normal3i(Nx, Ny, Nz).
1465
1466       normal3sv(V) -> ok
1467
1468              Types:
1469
1470                 V = {Nx::integer(), Ny::integer(), Nz::integer()}
1471
1472              Equivalent to normal3s(Nx, Ny, Nz).
1473
1474       indexd(C) -> ok
1475
1476              Types:
1477
1478                 C = float()
1479
1480              Set the current color index
1481
1482              gl:index  updates  the  current  (single-valued) color index. It
1483              takes one argument, the new value for the current color index.
1484
1485              See external documentation.
1486
1487       indexf(C) -> ok
1488
1489              Types:
1490
1491                 C = float()
1492
1493              See indexd/1
1494
1495       indexi(C) -> ok
1496
1497              Types:
1498
1499                 C = integer()
1500
1501              See indexd/1
1502
1503       indexs(C) -> ok
1504
1505              Types:
1506
1507                 C = integer()
1508
1509              See indexd/1
1510
1511       indexub(C) -> ok
1512
1513              Types:
1514
1515                 C = integer()
1516
1517              See indexd/1
1518
1519       indexdv(C) -> ok
1520
1521              Types:
1522
1523                 C = {C::float()}
1524
1525              Equivalent to indexd(C).
1526
1527       indexfv(C) -> ok
1528
1529              Types:
1530
1531                 C = {C::float()}
1532
1533              Equivalent to indexf(C).
1534
1535       indexiv(C) -> ok
1536
1537              Types:
1538
1539                 C = {C::integer()}
1540
1541              Equivalent to indexi(C).
1542
1543       indexsv(C) -> ok
1544
1545              Types:
1546
1547                 C = {C::integer()}
1548
1549              Equivalent to indexs(C).
1550
1551       indexubv(C) -> ok
1552
1553              Types:
1554
1555                 C = {C::integer()}
1556
1557              Equivalent to indexub(C).
1558
1559       color3b(Red, Green, Blue) -> ok
1560
1561              Types:
1562
1563                 Red = integer()
1564                 Green = integer()
1565                 Blue = integer()
1566
1567              Set the current color
1568
1569              The GL stores both a current single-valued  color  index  and  a
1570              current  four-valued RGBA color. gl:color sets a new four-valued
1571              RGBA color. gl:color  has  two  major  variants:  gl:color3  and
1572              gl:color4.  gl:color3  variants specify new red, green, and blue
1573              values explicitly and set the current alpha value to  1.0  (full
1574              intensity) implicitly. gl:color4 variants specify all four color
1575              components explicitly.
1576
1577              See external documentation.
1578
1579       color3d(Red, Green, Blue) -> ok
1580
1581              Types:
1582
1583                 Red = float()
1584                 Green = float()
1585                 Blue = float()
1586
1587              See color3b/3
1588
1589       color3f(Red, Green, Blue) -> ok
1590
1591              Types:
1592
1593                 Red = float()
1594                 Green = float()
1595                 Blue = float()
1596
1597              See color3b/3
1598
1599       color3i(Red, Green, Blue) -> ok
1600
1601              Types:
1602
1603                 Red = integer()
1604                 Green = integer()
1605                 Blue = integer()
1606
1607              See color3b/3
1608
1609       color3s(Red, Green, Blue) -> ok
1610
1611              Types:
1612
1613                 Red = integer()
1614                 Green = integer()
1615                 Blue = integer()
1616
1617              See color3b/3
1618
1619       color3ub(Red, Green, Blue) -> ok
1620
1621              Types:
1622
1623                 Red = integer()
1624                 Green = integer()
1625                 Blue = integer()
1626
1627              See color3b/3
1628
1629       color3ui(Red, Green, Blue) -> ok
1630
1631              Types:
1632
1633                 Red = integer()
1634                 Green = integer()
1635                 Blue = integer()
1636
1637              See color3b/3
1638
1639       color3us(Red, Green, Blue) -> ok
1640
1641              Types:
1642
1643                 Red = integer()
1644                 Green = integer()
1645                 Blue = integer()
1646
1647              See color3b/3
1648
1649       color4b(Red, Green, Blue, Alpha) -> ok
1650
1651              Types:
1652
1653                 Red = integer()
1654                 Green = integer()
1655                 Blue = integer()
1656                 Alpha = integer()
1657
1658              See color3b/3
1659
1660       color4d(Red, Green, Blue, Alpha) -> ok
1661
1662              Types:
1663
1664                 Red = float()
1665                 Green = float()
1666                 Blue = float()
1667                 Alpha = float()
1668
1669              See color3b/3
1670
1671       color4f(Red, Green, Blue, Alpha) -> ok
1672
1673              Types:
1674
1675                 Red = float()
1676                 Green = float()
1677                 Blue = float()
1678                 Alpha = float()
1679
1680              See color3b/3
1681
1682       color4i(Red, Green, Blue, Alpha) -> ok
1683
1684              Types:
1685
1686                 Red = integer()
1687                 Green = integer()
1688                 Blue = integer()
1689                 Alpha = integer()
1690
1691              See color3b/3
1692
1693       color4s(Red, Green, Blue, Alpha) -> ok
1694
1695              Types:
1696
1697                 Red = integer()
1698                 Green = integer()
1699                 Blue = integer()
1700                 Alpha = integer()
1701
1702              See color3b/3
1703
1704       color4ub(Red, Green, Blue, Alpha) -> ok
1705
1706              Types:
1707
1708                 Red = integer()
1709                 Green = integer()
1710                 Blue = integer()
1711                 Alpha = integer()
1712
1713              See color3b/3
1714
1715       color4ui(Red, Green, Blue, Alpha) -> ok
1716
1717              Types:
1718
1719                 Red = integer()
1720                 Green = integer()
1721                 Blue = integer()
1722                 Alpha = integer()
1723
1724              See color3b/3
1725
1726       color4us(Red, Green, Blue, Alpha) -> ok
1727
1728              Types:
1729
1730                 Red = integer()
1731                 Green = integer()
1732                 Blue = integer()
1733                 Alpha = integer()
1734
1735              See color3b/3
1736
1737       color3bv(V) -> ok
1738
1739              Types:
1740
1741                 V = {Red::integer(), Green::integer(), Blue::integer()}
1742
1743              Equivalent to color3b(Red, Green, Blue).
1744
1745       color3dv(V) -> ok
1746
1747              Types:
1748
1749                 V = {Red::float(), Green::float(), Blue::float()}
1750
1751              Equivalent to color3d(Red, Green, Blue).
1752
1753       color3fv(V) -> ok
1754
1755              Types:
1756
1757                 V = {Red::float(), Green::float(), Blue::float()}
1758
1759              Equivalent to color3f(Red, Green, Blue).
1760
1761       color3iv(V) -> ok
1762
1763              Types:
1764
1765                 V = {Red::integer(), Green::integer(), Blue::integer()}
1766
1767              Equivalent to color3i(Red, Green, Blue).
1768
1769       color3sv(V) -> ok
1770
1771              Types:
1772
1773                 V = {Red::integer(), Green::integer(), Blue::integer()}
1774
1775              Equivalent to color3s(Red, Green, Blue).
1776
1777       color3ubv(V) -> ok
1778
1779              Types:
1780
1781                 V = {Red::integer(), Green::integer(), Blue::integer()}
1782
1783              Equivalent to color3ub(Red, Green, Blue).
1784
1785       color3uiv(V) -> ok
1786
1787              Types:
1788
1789                 V = {Red::integer(), Green::integer(), Blue::integer()}
1790
1791              Equivalent to color3ui(Red, Green, Blue).
1792
1793       color3usv(V) -> ok
1794
1795              Types:
1796
1797                 V = {Red::integer(), Green::integer(), Blue::integer()}
1798
1799              Equivalent to color3us(Red, Green, Blue).
1800
1801       color4bv(V) -> ok
1802
1803              Types:
1804
1805                 V  =  {Red::integer(),   Green::integer(),   Blue::integer(),
1806                 Alpha::integer()}
1807
1808              Equivalent to color4b(Red, Green, Blue, Alpha).
1809
1810       color4dv(V) -> ok
1811
1812              Types:
1813
1814                 V    =    {Red::float(),    Green::float(),    Blue::float(),
1815                 Alpha::float()}
1816
1817              Equivalent to color4d(Red, Green, Blue, Alpha).
1818
1819       color4fv(V) -> ok
1820
1821              Types:
1822
1823                 V    =    {Red::float(),    Green::float(),    Blue::float(),
1824                 Alpha::float()}
1825
1826              Equivalent to color4f(Red, Green, Blue, Alpha).
1827
1828       color4iv(V) -> ok
1829
1830              Types:
1831
1832                 V   =   {Red::integer(),  Green::integer(),  Blue::integer(),
1833                 Alpha::integer()}
1834
1835              Equivalent to color4i(Red, Green, Blue, Alpha).
1836
1837       color4sv(V) -> ok
1838
1839              Types:
1840
1841                 V  =  {Red::integer(),   Green::integer(),   Blue::integer(),
1842                 Alpha::integer()}
1843
1844              Equivalent to color4s(Red, Green, Blue, Alpha).
1845
1846       color4ubv(V) -> ok
1847
1848              Types:
1849
1850                 V   =   {Red::integer(),  Green::integer(),  Blue::integer(),
1851                 Alpha::integer()}
1852
1853              Equivalent to color4ub(Red, Green, Blue, Alpha).
1854
1855       color4uiv(V) -> ok
1856
1857              Types:
1858
1859                 V  =  {Red::integer(),   Green::integer(),   Blue::integer(),
1860                 Alpha::integer()}
1861
1862              Equivalent to color4ui(Red, Green, Blue, Alpha).
1863
1864       color4usv(V) -> ok
1865
1866              Types:
1867
1868                 V   =   {Red::integer(),  Green::integer(),  Blue::integer(),
1869                 Alpha::integer()}
1870
1871              Equivalent to color4us(Red, Green, Blue, Alpha).
1872
1873       texCoord1d(S) -> ok
1874
1875              Types:
1876
1877                 S = float()
1878
1879              Set the current texture coordinates
1880
1881              gl:texCoord specifies texture coordinates in one, two, three, or
1882              four  dimensions.  gl:texCoord1 sets the current texture coordi‐
1883              nates to (s 0 0 1); a call to gl:texCoord2 sets them to (s  t  0
1884              1). Similarly, gl:texCoord3 specifies the texture coordinates as
1885              (s t r 1), and gl:texCoord4 defines all four components  explic‐
1886              itly as (s t r q).
1887
1888              See external documentation.
1889
1890       texCoord1f(S) -> ok
1891
1892              Types:
1893
1894                 S = float()
1895
1896              See texCoord1d/1
1897
1898       texCoord1i(S) -> ok
1899
1900              Types:
1901
1902                 S = integer()
1903
1904              See texCoord1d/1
1905
1906       texCoord1s(S) -> ok
1907
1908              Types:
1909
1910                 S = integer()
1911
1912              See texCoord1d/1
1913
1914       texCoord2d(S, T) -> ok
1915
1916              Types:
1917
1918                 S = float()
1919                 T = float()
1920
1921              See texCoord1d/1
1922
1923       texCoord2f(S, T) -> ok
1924
1925              Types:
1926
1927                 S = float()
1928                 T = float()
1929
1930              See texCoord1d/1
1931
1932       texCoord2i(S, T) -> ok
1933
1934              Types:
1935
1936                 S = integer()
1937                 T = integer()
1938
1939              See texCoord1d/1
1940
1941       texCoord2s(S, T) -> ok
1942
1943              Types:
1944
1945                 S = integer()
1946                 T = integer()
1947
1948              See texCoord1d/1
1949
1950       texCoord3d(S, T, R) -> ok
1951
1952              Types:
1953
1954                 S = float()
1955                 T = float()
1956                 R = float()
1957
1958              See texCoord1d/1
1959
1960       texCoord3f(S, T, R) -> ok
1961
1962              Types:
1963
1964                 S = float()
1965                 T = float()
1966                 R = float()
1967
1968              See texCoord1d/1
1969
1970       texCoord3i(S, T, R) -> ok
1971
1972              Types:
1973
1974                 S = integer()
1975                 T = integer()
1976                 R = integer()
1977
1978              See texCoord1d/1
1979
1980       texCoord3s(S, T, R) -> ok
1981
1982              Types:
1983
1984                 S = integer()
1985                 T = integer()
1986                 R = integer()
1987
1988              See texCoord1d/1
1989
1990       texCoord4d(S, T, R, Q) -> ok
1991
1992              Types:
1993
1994                 S = float()
1995                 T = float()
1996                 R = float()
1997                 Q = float()
1998
1999              See texCoord1d/1
2000
2001       texCoord4f(S, T, R, Q) -> ok
2002
2003              Types:
2004
2005                 S = float()
2006                 T = float()
2007                 R = float()
2008                 Q = float()
2009
2010              See texCoord1d/1
2011
2012       texCoord4i(S, T, R, Q) -> ok
2013
2014              Types:
2015
2016                 S = integer()
2017                 T = integer()
2018                 R = integer()
2019                 Q = integer()
2020
2021              See texCoord1d/1
2022
2023       texCoord4s(S, T, R, Q) -> ok
2024
2025              Types:
2026
2027                 S = integer()
2028                 T = integer()
2029                 R = integer()
2030                 Q = integer()
2031
2032              See texCoord1d/1
2033
2034       texCoord1dv(V) -> ok
2035
2036              Types:
2037
2038                 V = {S::float()}
2039
2040              Equivalent to texCoord1d(S).
2041
2042       texCoord1fv(V) -> ok
2043
2044              Types:
2045
2046                 V = {S::float()}
2047
2048              Equivalent to texCoord1f(S).
2049
2050       texCoord1iv(V) -> ok
2051
2052              Types:
2053
2054                 V = {S::integer()}
2055
2056              Equivalent to texCoord1i(S).
2057
2058       texCoord1sv(V) -> ok
2059
2060              Types:
2061
2062                 V = {S::integer()}
2063
2064              Equivalent to texCoord1s(S).
2065
2066       texCoord2dv(V) -> ok
2067
2068              Types:
2069
2070                 V = {S::float(), T::float()}
2071
2072              Equivalent to texCoord2d(S, T).
2073
2074       texCoord2fv(V) -> ok
2075
2076              Types:
2077
2078                 V = {S::float(), T::float()}
2079
2080              Equivalent to texCoord2f(S, T).
2081
2082       texCoord2iv(V) -> ok
2083
2084              Types:
2085
2086                 V = {S::integer(), T::integer()}
2087
2088              Equivalent to texCoord2i(S, T).
2089
2090       texCoord2sv(V) -> ok
2091
2092              Types:
2093
2094                 V = {S::integer(), T::integer()}
2095
2096              Equivalent to texCoord2s(S, T).
2097
2098       texCoord3dv(V) -> ok
2099
2100              Types:
2101
2102                 V = {S::float(), T::float(), R::float()}
2103
2104              Equivalent to texCoord3d(S, T, R).
2105
2106       texCoord3fv(V) -> ok
2107
2108              Types:
2109
2110                 V = {S::float(), T::float(), R::float()}
2111
2112              Equivalent to texCoord3f(S, T, R).
2113
2114       texCoord3iv(V) -> ok
2115
2116              Types:
2117
2118                 V = {S::integer(), T::integer(), R::integer()}
2119
2120              Equivalent to texCoord3i(S, T, R).
2121
2122       texCoord3sv(V) -> ok
2123
2124              Types:
2125
2126                 V = {S::integer(), T::integer(), R::integer()}
2127
2128              Equivalent to texCoord3s(S, T, R).
2129
2130       texCoord4dv(V) -> ok
2131
2132              Types:
2133
2134                 V = {S::float(), T::float(), R::float(), Q::float()}
2135
2136              Equivalent to texCoord4d(S, T, R, Q).
2137
2138       texCoord4fv(V) -> ok
2139
2140              Types:
2141
2142                 V = {S::float(), T::float(), R::float(), Q::float()}
2143
2144              Equivalent to texCoord4f(S, T, R, Q).
2145
2146       texCoord4iv(V) -> ok
2147
2148              Types:
2149
2150                 V = {S::integer(), T::integer(), R::integer(), Q::integer()}
2151
2152              Equivalent to texCoord4i(S, T, R, Q).
2153
2154       texCoord4sv(V) -> ok
2155
2156              Types:
2157
2158                 V = {S::integer(), T::integer(), R::integer(), Q::integer()}
2159
2160              Equivalent to texCoord4s(S, T, R, Q).
2161
2162       rasterPos2d(X, Y) -> ok
2163
2164              Types:
2165
2166                 X = float()
2167                 Y = float()
2168
2169              Specify the raster position for pixel operations
2170
2171              The GL maintains a 3D position in window coordinates. This posi‐
2172              tion, called the raster position, is used to position pixel  and
2173              bitmap  write  operations.  It is maintained with subpixel accu‐
2174              racy. See gl:bitmap/7 , gl:drawPixels/5 , and gl:copyPixels/5 .
2175
2176              See external documentation.
2177
2178       rasterPos2f(X, Y) -> ok
2179
2180              Types:
2181
2182                 X = float()
2183                 Y = float()
2184
2185              See rasterPos2d/2
2186
2187       rasterPos2i(X, Y) -> ok
2188
2189              Types:
2190
2191                 X = integer()
2192                 Y = integer()
2193
2194              See rasterPos2d/2
2195
2196       rasterPos2s(X, Y) -> ok
2197
2198              Types:
2199
2200                 X = integer()
2201                 Y = integer()
2202
2203              See rasterPos2d/2
2204
2205       rasterPos3d(X, Y, Z) -> ok
2206
2207              Types:
2208
2209                 X = float()
2210                 Y = float()
2211                 Z = float()
2212
2213              See rasterPos2d/2
2214
2215       rasterPos3f(X, Y, Z) -> ok
2216
2217              Types:
2218
2219                 X = float()
2220                 Y = float()
2221                 Z = float()
2222
2223              See rasterPos2d/2
2224
2225       rasterPos3i(X, Y, Z) -> ok
2226
2227              Types:
2228
2229                 X = integer()
2230                 Y = integer()
2231                 Z = integer()
2232
2233              See rasterPos2d/2
2234
2235       rasterPos3s(X, Y, Z) -> ok
2236
2237              Types:
2238
2239                 X = integer()
2240                 Y = integer()
2241                 Z = integer()
2242
2243              See rasterPos2d/2
2244
2245       rasterPos4d(X, Y, Z, W) -> ok
2246
2247              Types:
2248
2249                 X = float()
2250                 Y = float()
2251                 Z = float()
2252                 W = float()
2253
2254              See rasterPos2d/2
2255
2256       rasterPos4f(X, Y, Z, W) -> ok
2257
2258              Types:
2259
2260                 X = float()
2261                 Y = float()
2262                 Z = float()
2263                 W = float()
2264
2265              See rasterPos2d/2
2266
2267       rasterPos4i(X, Y, Z, W) -> ok
2268
2269              Types:
2270
2271                 X = integer()
2272                 Y = integer()
2273                 Z = integer()
2274                 W = integer()
2275
2276              See rasterPos2d/2
2277
2278       rasterPos4s(X, Y, Z, W) -> ok
2279
2280              Types:
2281
2282                 X = integer()
2283                 Y = integer()
2284                 Z = integer()
2285                 W = integer()
2286
2287              See rasterPos2d/2
2288
2289       rasterPos2dv(V) -> ok
2290
2291              Types:
2292
2293                 V = {X::float(), Y::float()}
2294
2295              Equivalent to rasterPos2d(X, Y).
2296
2297       rasterPos2fv(V) -> ok
2298
2299              Types:
2300
2301                 V = {X::float(), Y::float()}
2302
2303              Equivalent to rasterPos2f(X, Y).
2304
2305       rasterPos2iv(V) -> ok
2306
2307              Types:
2308
2309                 V = {X::integer(), Y::integer()}
2310
2311              Equivalent to rasterPos2i(X, Y).
2312
2313       rasterPos2sv(V) -> ok
2314
2315              Types:
2316
2317                 V = {X::integer(), Y::integer()}
2318
2319              Equivalent to rasterPos2s(X, Y).
2320
2321       rasterPos3dv(V) -> ok
2322
2323              Types:
2324
2325                 V = {X::float(), Y::float(), Z::float()}
2326
2327              Equivalent to rasterPos3d(X, Y, Z).
2328
2329       rasterPos3fv(V) -> ok
2330
2331              Types:
2332
2333                 V = {X::float(), Y::float(), Z::float()}
2334
2335              Equivalent to rasterPos3f(X, Y, Z).
2336
2337       rasterPos3iv(V) -> ok
2338
2339              Types:
2340
2341                 V = {X::integer(), Y::integer(), Z::integer()}
2342
2343              Equivalent to rasterPos3i(X, Y, Z).
2344
2345       rasterPos3sv(V) -> ok
2346
2347              Types:
2348
2349                 V = {X::integer(), Y::integer(), Z::integer()}
2350
2351              Equivalent to rasterPos3s(X, Y, Z).
2352
2353       rasterPos4dv(V) -> ok
2354
2355              Types:
2356
2357                 V = {X::float(), Y::float(), Z::float(), W::float()}
2358
2359              Equivalent to rasterPos4d(X, Y, Z, W).
2360
2361       rasterPos4fv(V) -> ok
2362
2363              Types:
2364
2365                 V = {X::float(), Y::float(), Z::float(), W::float()}
2366
2367              Equivalent to rasterPos4f(X, Y, Z, W).
2368
2369       rasterPos4iv(V) -> ok
2370
2371              Types:
2372
2373                 V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
2374
2375              Equivalent to rasterPos4i(X, Y, Z, W).
2376
2377       rasterPos4sv(V) -> ok
2378
2379              Types:
2380
2381                 V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
2382
2383              Equivalent to rasterPos4s(X, Y, Z, W).
2384
2385       rectd(X1, Y1, X2, Y2) -> ok
2386
2387              Types:
2388
2389                 X1 = float()
2390                 Y1 = float()
2391                 X2 = float()
2392                 Y2 = float()
2393
2394              Draw a rectangle
2395
2396              gl:rect supports efficient specification of  rectangles  as  two
2397              corner  points.  Each  rectangle  command  takes four arguments,
2398              organized either as two consecutive pairs of (x  y)  coordinates
2399              or as two pointers to arrays, each containing an (x y) pair. The
2400              resulting rectangle is defined in the z=0 plane.
2401
2402              See external documentation.
2403
2404       rectf(X1, Y1, X2, Y2) -> ok
2405
2406              Types:
2407
2408                 X1 = float()
2409                 Y1 = float()
2410                 X2 = float()
2411                 Y2 = float()
2412
2413              See rectd/4
2414
2415       recti(X1, Y1, X2, Y2) -> ok
2416
2417              Types:
2418
2419                 X1 = integer()
2420                 Y1 = integer()
2421                 X2 = integer()
2422                 Y2 = integer()
2423
2424              See rectd/4
2425
2426       rects(X1, Y1, X2, Y2) -> ok
2427
2428              Types:
2429
2430                 X1 = integer()
2431                 Y1 = integer()
2432                 X2 = integer()
2433                 Y2 = integer()
2434
2435              See rectd/4
2436
2437       rectdv(V1, V2) -> ok
2438
2439              Types:
2440
2441                 V1 = {float(), float()}
2442                 V2 = {float(), float()}
2443
2444              See rectd/4
2445
2446       rectfv(V1, V2) -> ok
2447
2448              Types:
2449
2450                 V1 = {float(), float()}
2451                 V2 = {float(), float()}
2452
2453              See rectd/4
2454
2455       rectiv(V1, V2) -> ok
2456
2457              Types:
2458
2459                 V1 = {integer(), integer()}
2460                 V2 = {integer(), integer()}
2461
2462              See rectd/4
2463
2464       rectsv(V1, V2) -> ok
2465
2466              Types:
2467
2468                 V1 = {integer(), integer()}
2469                 V2 = {integer(), integer()}
2470
2471              See rectd/4
2472
2473       vertexPointer(Size, Type, Stride, Ptr) -> ok
2474
2475              Types:
2476
2477                 Size = integer()
2478                 Type = enum()
2479                 Stride = integer()
2480                 Ptr = offset() | mem()
2481
2482              Define an array of vertex data
2483
2484              gl:vertexPointer specifies the location and data  format  of  an
2485              array  of  vertex coordinates to use when rendering. Size speci‐
2486              fies the number of coordinates per vertex, and must be 2, 3,  or
2487              4.  Type  specifies the data type of each coordinate, and Stride
2488              specifies the byte stride from one vertex to the next,  allowing
2489              vertices  and  attributes  to  be  packed into a single array or
2490              stored in separate arrays. (Single-array  storage  may  be  more
2491              efficient on some implementations; see gl:interleavedArrays/3 .)
2492
2493              See external documentation.
2494
2495       normalPointer(Type, Stride, Ptr) -> ok
2496
2497              Types:
2498
2499                 Type = enum()
2500                 Stride = integer()
2501                 Ptr = offset() | mem()
2502
2503              Define an array of normals
2504
2505              gl:normalPointer  specifies  the  location and data format of an
2506              array of normals to use when rendering. Type specifies the  data
2507              type  of  each  normal coordinate, and Stride specifies the byte
2508              stride from one  normal  to  the  next,  allowing  vertices  and
2509              attributes  to  be packed into a single array or stored in sepa‐
2510              rate arrays. (Single-array storage may be more efficient on some
2511              implementations; see gl:interleavedArrays/3 .)
2512
2513              See external documentation.
2514
2515       colorPointer(Size, Type, Stride, Ptr) -> ok
2516
2517              Types:
2518
2519                 Size = integer()
2520                 Type = enum()
2521                 Stride = integer()
2522                 Ptr = offset() | mem()
2523
2524              Define an array of colors
2525
2526              gl:colorPointer  specifies  the  location  and data format of an
2527              array of color components to use when rendering. Size  specifies
2528              the  number  of  components  per color, and must be 3 or 4. Type
2529              specifies the data type of  each  color  component,  and  Stride
2530              specifies  the  byte stride from one color to the next, allowing
2531              vertices and attributes to be packed  into  a  single  array  or
2532              stored  in  separate  arrays.  (Single-array storage may be more
2533              efficient on some implementations; see gl:interleavedArrays/3 .)
2534
2535              See external documentation.
2536
2537       indexPointer(Type, Stride, Ptr) -> ok
2538
2539              Types:
2540
2541                 Type = enum()
2542                 Stride = integer()
2543                 Ptr = offset() | mem()
2544
2545              Define an array of color indexes
2546
2547              gl:indexPointer specifies the location and  data  format  of  an
2548              array of color indexes to use when rendering. Type specifies the
2549              data type of each color index  and  Stride  specifies  the  byte
2550              stride  from  one color index to the next, allowing vertices and
2551              attributes to be packed into a single array or stored  in  sepa‐
2552              rate arrays.
2553
2554              See external documentation.
2555
2556       texCoordPointer(Size, Type, Stride, Ptr) -> ok
2557
2558              Types:
2559
2560                 Size = integer()
2561                 Type = enum()
2562                 Stride = integer()
2563                 Ptr = offset() | mem()
2564
2565              Define an array of texture coordinates
2566
2567              gl:texCoordPointer  specifies the location and data format of an
2568              array of texture coordinates to use when rendering. Size  speci‐
2569              fies  the  number of coordinates per texture coordinate set, and
2570              must be 1, 2, 3, or 4. Type specifies the data type of each tex‐
2571              ture  coordinate,  and Stride specifies the byte stride from one
2572              texture coordinate  set  to  the  next,  allowing  vertices  and
2573              attributes  to  be packed into a single array or stored in sepa‐
2574              rate arrays. (Single-array storage may be more efficient on some
2575              implementations; see gl:interleavedArrays/3 .)
2576
2577              See external documentation.
2578
2579       edgeFlagPointer(Stride, Ptr) -> ok
2580
2581              Types:
2582
2583                 Stride = integer()
2584                 Ptr = offset() | mem()
2585
2586              Define an array of edge flags
2587
2588              gl:edgeFlagPointer  specifies the location and data format of an
2589              array of boolean edge flags to use when rendering. Stride speci‐
2590              fies  the  byte  stride from one edge flag to the next, allowing
2591              vertices and attributes to be packed  into  a  single  array  or
2592              stored in separate arrays.
2593
2594              See external documentation.
2595
2596       arrayElement(I) -> ok
2597
2598              Types:
2599
2600                 I = integer()
2601
2602              Render a vertex using the specified vertex array element
2603
2604              gl:arrayElement   commands   are   used  within  gl:'begin'/1  /
2605              gl:'begin'/1 pairs to specify  vertex  and  attribute  data  for
2606              point,  line,  and  polygon  primitives.  If ?GL_VERTEX_ARRAY is
2607              enabled when gl:arrayElement  is  called,  a  single  vertex  is
2608              drawn,  using vertex and attribute data taken from location I of
2609              the enabled arrays. If ?GL_VERTEX_ARRAY is not enabled, no draw‐
2610              ing  occurs  but  the  attributes  corresponding  to the enabled
2611              arrays are modified.
2612
2613              See external documentation.
2614
2615       drawArrays(Mode, First, Count) -> ok
2616
2617              Types:
2618
2619                 Mode = enum()
2620                 First = integer()
2621                 Count = integer()
2622
2623              Render primitives from array data
2624
2625              gl:drawArrays specifies multiple geometric primitives with  very
2626              few  subroutine calls. Instead of calling a GL procedure to pass
2627              each individual vertex, normal, texture coordinate,  edge  flag,
2628              or  color,  you can prespecify separate arrays of vertices, nor‐
2629              mals, and colors and use them to construct a sequence of  primi‐
2630              tives with a single call to gl:drawArrays .
2631
2632              See external documentation.
2633
2634       drawElements(Mode, Count, Type, Indices) -> ok
2635
2636              Types:
2637
2638                 Mode = enum()
2639                 Count = integer()
2640                 Type = enum()
2641                 Indices = offset() | mem()
2642
2643              Render primitives from array data
2644
2645              gl:drawElements  specifies  multiple  geometric  primitives with
2646              very few subroutine calls. Instead of calling a GL  function  to
2647              pass  each  individual  vertex, normal, texture coordinate, edge
2648              flag, or color, you can prespecify separate arrays of  vertices,
2649              normals,  and  so  on,  and  use them to construct a sequence of
2650              primitives with a single call to gl:drawElements .
2651
2652              See external documentation.
2653
2654       interleavedArrays(Format, Stride, Pointer) -> ok
2655
2656              Types:
2657
2658                 Format = enum()
2659                 Stride = integer()
2660                 Pointer = offset() | mem()
2661
2662              Simultaneously specify and enable several interleaved arrays
2663
2664              gl:interleavedArrays lets  you  specify  and  enable  individual
2665              color, normal, texture and vertex arrays whose elements are part
2666              of a larger aggregate array element. For  some  implementations,
2667              this is more efficient than specifying the arrays separately.
2668
2669              See external documentation.
2670
2671       shadeModel(Mode) -> ok
2672
2673              Types:
2674
2675                 Mode = enum()
2676
2677              Select flat or smooth shading
2678
2679              GL  primitives  can  have  either flat or smooth shading. Smooth
2680              shading, the default, causes the computed colors of vertices  to
2681              be  interpolated  as  the  primitive  is  rasterized,  typically
2682              assigning different colors to  each  resulting  pixel  fragment.
2683              Flat  shading  selects the computed color of just one vertex and
2684              assigns it to all the pixel fragments generated by rasterizing a
2685              single primitive. In either case, the computed color of a vertex
2686              is the result of lighting if lighting is enabled, or it  is  the
2687              current  color  at the time the vertex was specified if lighting
2688              is disabled.
2689
2690              See external documentation.
2691
2692       lightf(Light, Pname, Param) -> ok
2693
2694              Types:
2695
2696                 Light = enum()
2697                 Pname = enum()
2698                 Param = float()
2699
2700              Set light source parameters
2701
2702              gl:light sets the values of individual light source  parameters.
2703              Light  names  the  light  and  is  a  symbolic  name of the form
2704              ?GL_LIGHT  i,  where  i  ranges  from  0   to   the   value   of
2705              ?GL_MAX_LIGHTS  -  1.  Pname  specifies  one of ten light source
2706              parameters, again by symbolic name. Params is  either  a  single
2707              value or a pointer to an array that contains the new values.
2708
2709              See external documentation.
2710
2711       lighti(Light, Pname, Param) -> ok
2712
2713              Types:
2714
2715                 Light = enum()
2716                 Pname = enum()
2717                 Param = integer()
2718
2719              See lightf/3
2720
2721       lightfv(Light, Pname, Params) -> ok
2722
2723              Types:
2724
2725                 Light = enum()
2726                 Pname = enum()
2727                 Params = tuple()
2728
2729              See lightf/3
2730
2731       lightiv(Light, Pname, Params) -> ok
2732
2733              Types:
2734
2735                 Light = enum()
2736                 Pname = enum()
2737                 Params = tuple()
2738
2739              See lightf/3
2740
2741       getLightfv(Light, Pname) -> {float(), float(), float(), float()}
2742
2743              Types:
2744
2745                 Light = enum()
2746                 Pname = enum()
2747
2748              Return light source parameter values
2749
2750              gl:getLight  returns  in  Params  the value or values of a light
2751              source parameter. Light names the light and is a  symbolic  name
2752              of  the  form  ?GL_LIGHT i where i ranges from 0 to the value of
2753              ?GL_MAX_LIGHTS - 1. ?GL_MAX_LIGHTS is an  implementation  depen‐
2754              dent  constant  that  is  greater  than or equal to eight. Pname
2755              specifies one of ten light source parameters, again by  symbolic
2756              name.
2757
2758              See external documentation.
2759
2760       getLightiv(Light,  Pname)  ->  {integer(),  integer(), integer(), inte‐
2761       ger()}
2762
2763              Types:
2764
2765                 Light = enum()
2766                 Pname = enum()
2767
2768              See getLightfv/2
2769
2770       lightModelf(Pname, Param) -> ok
2771
2772              Types:
2773
2774                 Pname = enum()
2775                 Param = float()
2776
2777              Set the lighting model parameters
2778
2779              gl:lightModel sets the lighting model parameter. Pname  names  a
2780              parameter and Params gives the new value. There are three light‐
2781              ing model parameters:
2782
2783              See external documentation.
2784
2785       lightModeli(Pname, Param) -> ok
2786
2787              Types:
2788
2789                 Pname = enum()
2790                 Param = integer()
2791
2792              See lightModelf/2
2793
2794       lightModelfv(Pname, Params) -> ok
2795
2796              Types:
2797
2798                 Pname = enum()
2799                 Params = tuple()
2800
2801              See lightModelf/2
2802
2803       lightModeliv(Pname, Params) -> ok
2804
2805              Types:
2806
2807                 Pname = enum()
2808                 Params = tuple()
2809
2810              See lightModelf/2
2811
2812       materialf(Face, Pname, Param) -> ok
2813
2814              Types:
2815
2816                 Face = enum()
2817                 Pname = enum()
2818                 Param = float()
2819
2820              Specify material parameters for the lighting model
2821
2822              gl:material assigns values to material parameters. There are two
2823              matched  sets of material parameters. One, the front-facing set,
2824              is used to shade points, lines, bitmaps, and all polygons  (when
2825              two-sided  lighting  is disabled), or just front-facing polygons
2826              (when two-sided lighting is enabled). The other  set,  back-fac‐
2827              ing,  is  used to shade back-facing polygons only when two-sided
2828              lighting is enabled. Refer  to  the  gl:lightModelf/2  reference
2829              page for details concerning one- and two-sided lighting calcula‐
2830              tions.
2831
2832              See external documentation.
2833
2834       materiali(Face, Pname, Param) -> ok
2835
2836              Types:
2837
2838                 Face = enum()
2839                 Pname = enum()
2840                 Param = integer()
2841
2842              See materialf/3
2843
2844       materialfv(Face, Pname, Params) -> ok
2845
2846              Types:
2847
2848                 Face = enum()
2849                 Pname = enum()
2850                 Params = tuple()
2851
2852              See materialf/3
2853
2854       materialiv(Face, Pname, Params) -> ok
2855
2856              Types:
2857
2858                 Face = enum()
2859                 Pname = enum()
2860                 Params = tuple()
2861
2862              See materialf/3
2863
2864       getMaterialfv(Face, Pname) -> {float(), float(), float(), float()}
2865
2866              Types:
2867
2868                 Face = enum()
2869                 Pname = enum()
2870
2871              Return material parameters
2872
2873              gl:getMaterial returns in Params the value or values of  parame‐
2874              ter Pname of material Face . Six parameters are defined:
2875
2876              See external documentation.
2877
2878       getMaterialiv(Face,  Pname)  -> {integer(), integer(), integer(), inte‐
2879       ger()}
2880
2881              Types:
2882
2883                 Face = enum()
2884                 Pname = enum()
2885
2886              See getMaterialfv/2
2887
2888       colorMaterial(Face, Mode) -> ok
2889
2890              Types:
2891
2892                 Face = enum()
2893                 Mode = enum()
2894
2895              Cause a material color to track the current color
2896
2897              gl:colorMaterial specifies which material parameters  track  the
2898              current  color. When ?GL_COLOR_MATERIAL is enabled, the material
2899              parameter or parameters specified by Mode , of the  material  or
2900              materials  specified  by  Face  , track the current color at all
2901              times.
2902
2903              See external documentation.
2904
2905       pixelZoom(Xfactor, Yfactor) -> ok
2906
2907              Types:
2908
2909                 Xfactor = float()
2910                 Yfactor = float()
2911
2912              Specify the pixel zoom factors
2913
2914              gl:pixelZoom specifies values for the x and y zoom factors. Dur‐
2915              ing  the  execution of gl:drawPixels/5 or gl:copyPixels/5 , if (
2916              xr, yr) is the current raster position, and a given  element  is
2917              in  the mth row and nth column of the pixel rectangle, then pix‐
2918              els whose centers are in the rectangle with corners at
2919
2920              See external documentation.
2921
2922       pixelStoref(Pname, Param) -> ok
2923
2924              Types:
2925
2926                 Pname = enum()
2927                 Param = float()
2928
2929              Set pixel storage modes
2930
2931              gl:pixelStore sets pixel storage modes that affect the operation
2932              of  subsequent  gl:readPixels/7 as well as the unpacking of tex‐
2933              ture patterns (see gl:texImage1D/8 , gl:texImage2D/9 , gl:texIm‐
2934              age3D/10  ,  gl:texSubImage1D/7  ,  gl:texSubImage1D/7 , gl:tex‐
2935              SubImage1D/7 ), gl:compressedTexImage1D/7 ,  gl:compressedTexIm‐
2936              age2D/8  ,  gl:compressedTexImage3D/9  ,  gl:compressedTexSubIm‐
2937              age1D/7 , gl:compressedTexSubImage2D/9 or gl:compressedTexSubIm‐
2938              age1D/7 .
2939
2940              See external documentation.
2941
2942       pixelStorei(Pname, Param) -> ok
2943
2944              Types:
2945
2946                 Pname = enum()
2947                 Param = integer()
2948
2949              See pixelStoref/2
2950
2951       pixelTransferf(Pname, Param) -> ok
2952
2953              Types:
2954
2955                 Pname = enum()
2956                 Param = float()
2957
2958              Set pixel transfer modes
2959
2960              gl:pixelTransfer sets pixel transfer modes that affect the oper‐
2961              ation of  subsequent  gl:copyPixels/5  ,  gl:copyTexImage1D/7  ,
2962              gl:copyTexImage2D/8  , gl:copyTexSubImage1D/6 , gl:copyTexSubIm‐
2963              age2D/8 , gl:copyTexSubImage3D/9 , gl:drawPixels/5 , gl:readPix‐
2964              els/7  ,  gl:texImage1D/8 , gl:texImage2D/9 , gl:texImage3D/10 ,
2965              gl:texSubImage1D/7 , gl:texSubImage1D/7 , and gl:texSubImage1D/7
2966              commands.  Additionally, if the ARB_imaging subset is supported,
2967              the routines gl:colorTable/6 , gl:colorSubTable/6 ,  gl:convolu‐
2968              tionFilter1D/6  ,  gl:convolutionFilter2D/7  ,  gl:histogram/4 ,
2969              gl:minmax/3 , and gl:separableFilter2D/8 are also affected.  The
2970              algorithms that are specified by pixel transfer modes operate on
2971              pixels after they are read from the frame buffer  (  gl:copyPix‐
2972              els/5  gl:copyTexImage1D/7  ,  gl:copyTexImage2D/8 , gl:copyTex‐
2973              SubImage1D/6 , gl:copyTexSubImage2D/8 , gl:copyTexSubImage3D/9 ,
2974              and gl:readPixels/7 ), or unpacked from client memory ( gl:draw‐
2975              Pixels/5 , gl:texImage1D/8 , gl:texImage2D/9 ,  gl:texImage3D/10
2976              ,  gl:texSubImage1D/7  ,  gl:texSubImage1D/7  , and gl:texSubIm‐
2977              age1D/7 ). Pixel transfer operations happen in the  same  order,
2978              and  in the same manner, regardless of the command that resulted
2979              in the pixel  operation.  Pixel  storage  modes  (see  gl:pixel‐
2980              Storef/2  )  control  the  unpacking  of  pixels being read from
2981              client memory and the packing of pixels being written back  into
2982              client memory.
2983
2984              See external documentation.
2985
2986       pixelTransferi(Pname, Param) -> ok
2987
2988              Types:
2989
2990                 Pname = enum()
2991                 Param = integer()
2992
2993              See pixelTransferf/2
2994
2995       pixelMapfv(Map, Mapsize, Values) -> ok
2996
2997              Types:
2998
2999                 Map = enum()
3000                 Mapsize = integer()
3001                 Values = binary()
3002
3003              Set up pixel transfer maps
3004
3005              gl:pixelMap  sets  up  translation  tables,  or  maps,  used  by
3006              gl:copyPixels/5 , gl:copyTexImage1D/7  ,  gl:copyTexImage2D/8  ,
3007              gl:copyTexSubImage1D/6  ,  gl:copyTexSubImage2D/8  , gl:copyTex‐
3008              SubImage3D/9 , gl:drawPixels/5  ,  gl:readPixels/7  ,  gl:texIm‐
3009              age1D/8  ,  gl:texImage2D/9  ,  gl:texImage3D/10  , gl:texSubIm‐
3010              age1D/7 , gl:texSubImage1D/7 , and  gl:texSubImage1D/7  .  Addi‐
3011              tionally,  if  the ARB_imaging subset is supported, the routines
3012              gl:colorTable/6 , gl:colorSubTable/6 ,  gl:convolutionFilter1D/6
3013              ,  gl:convolutionFilter2D/7 , gl:histogram/4 , gl:minmax/3 , and
3014              gl:separableFilter2D/8 . Use of these  maps  is  described  com‐
3015              pletely in the gl:pixelTransferf/2 reference page, and partly in
3016              the reference pages for the pixel and  texture  image  commands.
3017              Only  the  specification of the maps is described in this refer‐
3018              ence page.
3019
3020              See external documentation.
3021
3022       pixelMapuiv(Map, Mapsize, Values) -> ok
3023
3024              Types:
3025
3026                 Map = enum()
3027                 Mapsize = integer()
3028                 Values = binary()
3029
3030              See pixelMapfv/3
3031
3032       pixelMapusv(Map, Mapsize, Values) -> ok
3033
3034              Types:
3035
3036                 Map = enum()
3037                 Mapsize = integer()
3038                 Values = binary()
3039
3040              See pixelMapfv/3
3041
3042       getPixelMapfv(Map, Values) -> ok
3043
3044              Types:
3045
3046                 Map = enum()
3047                 Values = mem()
3048
3049              Return the specified pixel map
3050
3051              See the gl:pixelMapfv/3 reference page for a description of  the
3052              acceptable  values for the Map parameter. gl:getPixelMap returns
3053              in Data the contents of the pixel map specified in Map  .  Pixel
3054              maps are used during the execution of gl:readPixels/7 , gl:draw‐
3055              Pixels/5 , gl:copyPixels/5 , gl:texImage1D/8 , gl:texImage2D/9 ,
3056              gl:texImage3D/10  ,  gl:texSubImage1D/7  ,  gl:texSubImage1D/7 ,
3057              gl:texSubImage1D/7 , gl:copyTexImage1D/7 , gl:copyTexImage2D/8 ,
3058              gl:copyTexSubImage1D/6  ,  gl:copyTexSubImage2D/8 , and gl:copy‐
3059              TexSubImage3D/9 . to map color indices, stencil  indices,  color
3060              components, and depth components to other values.
3061
3062              See external documentation.
3063
3064       getPixelMapuiv(Map, Values) -> ok
3065
3066              Types:
3067
3068                 Map = enum()
3069                 Values = mem()
3070
3071              See getPixelMapfv/2
3072
3073       getPixelMapusv(Map, Values) -> ok
3074
3075              Types:
3076
3077                 Map = enum()
3078                 Values = mem()
3079
3080              See getPixelMapfv/2
3081
3082       bitmap(Width, Height, Xorig, Yorig, Xmove, Ymove, Bitmap) -> ok
3083
3084              Types:
3085
3086                 Width = integer()
3087                 Height = integer()
3088                 Xorig = float()
3089                 Yorig = float()
3090                 Xmove = float()
3091                 Ymove = float()
3092                 Bitmap = offset() | mem()
3093
3094              Draw a bitmap
3095
3096              A bitmap is a binary image. When drawn, the bitmap is positioned
3097              relative to the current raster position, and frame buffer pixels
3098              corresponding to 1's in the bitmap are written using the current
3099              raster color or index. Frame buffer pixels corresponding to  0's
3100              in the bitmap are not modified.
3101
3102              See external documentation.
3103
3104       readPixels(X, Y, Width, Height, Format, Type, Pixels) -> ok
3105
3106              Types:
3107
3108                 X = integer()
3109                 Y = integer()
3110                 Width = integer()
3111                 Height = integer()
3112                 Format = enum()
3113                 Type = enum()
3114                 Pixels = mem()
3115
3116              Read a block of pixels from the frame buffer
3117
3118              gl:readPixels returns pixel data from the frame buffer, starting
3119              with the pixel whose lower left corner is at location ( X , Y ),
3120              into  client  memory starting at location Data . Several parame‐
3121              ters control the processing of  the  pixel  data  before  it  is
3122              placed into client memory. These parameters are set with gl:pix‐
3123              elStoref/2 .  This  reference  page  describes  the  effects  on
3124              gl:readPixels  of  most, but not all of the parameters specified
3125              by these three commands.
3126
3127              See external documentation.
3128
3129       drawPixels(Width, Height, Format, Type, Pixels) -> ok
3130
3131              Types:
3132
3133                 Width = integer()
3134                 Height = integer()
3135                 Format = enum()
3136                 Type = enum()
3137                 Pixels = offset() | mem()
3138
3139              Write a block of pixels to the frame buffer
3140
3141              gl:drawPixels reads pixel data from memory and  writes  it  into
3142              the  frame  buffer relative to the current raster position, pro‐
3143              vided that the raster position is valid. Use gl:rasterPos2d/2 or
3144              gl:windowPos2d/2 to set the current raster position; use gl:get‐
3145              Booleanv/1 with  argument  ?GL_CURRENT_RASTER_POSITION_VALID  to
3146              determine if the specified raster position is valid, and gl:get‐
3147              Booleanv/1 with argument  ?GL_CURRENT_RASTER_POSITION  to  query
3148              the raster position.
3149
3150              See external documentation.
3151
3152       copyPixels(X, Y, Width, Height, Type) -> ok
3153
3154              Types:
3155
3156                 X = integer()
3157                 Y = integer()
3158                 Width = integer()
3159                 Height = integer()
3160                 Type = enum()
3161
3162              Copy pixels in the frame buffer
3163
3164              gl:copyPixels  copies  a screen-aligned rectangle of pixels from
3165              the specified frame buffer location to a region relative to  the
3166              current  raster  position. Its operation is well defined only if
3167              the entire pixel source region is within the exposed portion  of
3168              the  window.  Results of copies from outside the window, or from
3169              regions of the window that are not exposed, are hardware  depen‐
3170              dent and undefined.
3171
3172              See external documentation.
3173
3174       stencilFunc(Func, Ref, Mask) -> ok
3175
3176              Types:
3177
3178                 Func = enum()
3179                 Ref = integer()
3180                 Mask = integer()
3181
3182              Set  front  and  back  function  and reference value for stencil
3183              testing
3184
3185              Stenciling, like depth-buffering, enables and  disables  drawing
3186              on  a per-pixel basis. Stencil planes are first drawn into using
3187              GL drawing primitives, then geometry  and  images  are  rendered
3188              using  the  stencil  planes  to mask out portions of the screen.
3189              Stenciling is typically used in multipass  rendering  algorithms
3190              to  achieve special effects, such as decals, outlining, and con‐
3191              structive solid geometry rendering.
3192
3193              See external documentation.
3194
3195       stencilMask(Mask) -> ok
3196
3197              Types:
3198
3199                 Mask = integer()
3200
3201              Control the front and back writing of  individual  bits  in  the
3202              stencil planes
3203
3204              gl:stencilMask  controls  the  writing of individual bits in the
3205              stencil planes. The least significant n bits of Mask ,  where  n
3206              is  the  number  of  bits in the stencil buffer, specify a mask.
3207              Where a 1 appears in the mask, it's possible  to  write  to  the
3208              corresponding  bit in the stencil buffer. Where a 0 appears, the
3209              corresponding bit is write-protected. Initially,  all  bits  are
3210              enabled for writing.
3211
3212              See external documentation.
3213
3214       stencilOp(Fail, Zfail, Zpass) -> ok
3215
3216              Types:
3217
3218                 Fail = enum()
3219                 Zfail = enum()
3220                 Zpass = enum()
3221
3222              Set front and back stencil test actions
3223
3224              Stenciling,  like  depth-buffering, enables and disables drawing
3225              on a per-pixel basis. You draw into the stencil planes using  GL
3226              drawing  primitives,  then render geometry and images, using the
3227              stencil planes to mask out portions of the screen. Stenciling is
3228              typically used in multipass rendering algorithms to achieve spe‐
3229              cial effects, such as decals, outlining, and constructive  solid
3230              geometry rendering.
3231
3232              See external documentation.
3233
3234       clearStencil(S) -> ok
3235
3236              Types:
3237
3238                 S = integer()
3239
3240              Specify the clear value for the stencil buffer
3241
3242              gl:clearStencil  specifies the index used by gl:clear/1 to clear
3243              the stencil buffer. S is masked with 2 m-1, where m is the  num‐
3244              ber of bits in the stencil buffer.
3245
3246              See external documentation.
3247
3248       texGend(Coord, Pname, Param) -> ok
3249
3250              Types:
3251
3252                 Coord = enum()
3253                 Pname = enum()
3254                 Param = float()
3255
3256              Control the generation of texture coordinates
3257
3258              gl:texGen  selects  a  texture-coordinate generation function or
3259              supplies coefficients for one of the functions. Coord names  one
3260              of  the (s, t, r, q ) texture coordinates; it must be one of the
3261              symbols ?GL_S, ?GL_T, ?GL_R , or ?GL_Q. Pname  must  be  one  of
3262              three     symbolic     constants:     ?GL_TEXTURE_GEN_MODE     ,
3263              ?GL_OBJECT_PLANE,  or  ?GL_EYE_PLANE.  If  Pname   is   ?GL_TEX‐
3264              TURE_GEN_MODE   ,   then   Params   chooses   a   mode,  one  of
3265              ?GL_OBJECT_LINEAR,  ?GL_EYE_LINEAR  ,  ?GL_SPHERE_MAP,  ?GL_NOR‐
3266              MAL_MAP,    or    ?GL_REFLECTION_MAP.   If   Pname   is   either
3267              ?GL_OBJECT_PLANE or ?GL_EYE_PLANE, Params contains  coefficients
3268              for the corresponding texture generation function.
3269
3270              See external documentation.
3271
3272       texGenf(Coord, Pname, Param) -> ok
3273
3274              Types:
3275
3276                 Coord = enum()
3277                 Pname = enum()
3278                 Param = float()
3279
3280              See texGend/3
3281
3282       texGeni(Coord, Pname, Param) -> ok
3283
3284              Types:
3285
3286                 Coord = enum()
3287                 Pname = enum()
3288                 Param = integer()
3289
3290              See texGend/3
3291
3292       texGendv(Coord, Pname, Params) -> ok
3293
3294              Types:
3295
3296                 Coord = enum()
3297                 Pname = enum()
3298                 Params = tuple()
3299
3300              See texGend/3
3301
3302       texGenfv(Coord, Pname, Params) -> ok
3303
3304              Types:
3305
3306                 Coord = enum()
3307                 Pname = enum()
3308                 Params = tuple()
3309
3310              See texGend/3
3311
3312       texGeniv(Coord, Pname, Params) -> ok
3313
3314              Types:
3315
3316                 Coord = enum()
3317                 Pname = enum()
3318                 Params = tuple()
3319
3320              See texGend/3
3321
3322       getTexGendv(Coord, Pname) -> {float(), float(), float(), float()}
3323
3324              Types:
3325
3326                 Coord = enum()
3327                 Pname = enum()
3328
3329              Return texture coordinate generation parameters
3330
3331              gl:getTexGen  returns in Params selected parameters of a texture
3332              coordinate generation function that was specified using  gl:tex‐
3333              Gend/3  .  Coord  names  one of the (s, t, r, q) texture coordi‐
3334              nates, using the  symbolic  constant  ?GL_S,  ?GL_T,  ?GL_R,  or
3335              ?GL_Q.
3336
3337              See external documentation.
3338
3339       getTexGenfv(Coord, Pname) -> {float(), float(), float(), float()}
3340
3341              Types:
3342
3343                 Coord = enum()
3344                 Pname = enum()
3345
3346              See getTexGendv/2
3347
3348       getTexGeniv(Coord,  Pname)  ->  {integer(), integer(), integer(), inte‐
3349       ger()}
3350
3351              Types:
3352
3353                 Coord = enum()
3354                 Pname = enum()
3355
3356              See getTexGendv/2
3357
3358       texEnvf(Target, Pname, Param) -> ok
3359
3360              Types:
3361
3362                 Target = enum()
3363                 Pname = enum()
3364                 Param = float()
3365
3366              glTexEnvf
3367
3368              See external documentation.
3369
3370       texEnvi(Target, Pname, Param) -> ok
3371
3372              Types:
3373
3374                 Target = enum()
3375                 Pname = enum()
3376                 Param = integer()
3377
3378              glTexEnvi
3379
3380              See external documentation.
3381
3382       texEnvfv(Target, Pname, Params) -> ok
3383
3384              Types:
3385
3386                 Target = enum()
3387                 Pname = enum()
3388                 Params = tuple()
3389
3390              Set texture environment parameters
3391
3392              A texture environment specifies how texture  values  are  inter‐
3393              preted  when  a  fragment  is  textured. When Target is ?GL_TEX‐
3394              TURE_FILTER_CONTROL, Pname must be ?GL_TEXTURE_LOD_BIAS  .  When
3395              Target  is  ?GL_TEXTURE_ENV, Pname can be ?GL_TEXTURE_ENV_MODE ,
3396              ?GL_TEXTURE_ENV_COLOR,    ?GL_COMBINE_RGB,    ?GL_COMBINE_ALPHA,
3397              ?GL_RGB_SCALE  ,  ?GL_ALPHA_SCALE,  ?GL_SRC0_RGB,  ?GL_SRC1_RGB,
3398              ?GL_SRC2_RGB,    ?GL_SRC0_ALPHA     ,     ?GL_SRC1_ALPHA,     or
3399              ?GL_SRC2_ALPHA.
3400
3401              See external documentation.
3402
3403       texEnviv(Target, Pname, Params) -> ok
3404
3405              Types:
3406
3407                 Target = enum()
3408                 Pname = enum()
3409                 Params = tuple()
3410
3411              See texEnvfv/3
3412
3413       getTexEnvfv(Target, Pname) -> {float(), float(), float(), float()}
3414
3415              Types:
3416
3417                 Target = enum()
3418                 Pname = enum()
3419
3420              Return texture environment parameters
3421
3422              gl:getTexEnv  returns  in  Params  selected  values of a texture
3423              environment that was specified with gl:texEnvfv/3 . Target spec‐
3424              ifies a texture environment.
3425
3426              See external documentation.
3427
3428       getTexEnviv(Target,  Pname)  -> {integer(), integer(), integer(), inte‐
3429       ger()}
3430
3431              Types:
3432
3433                 Target = enum()
3434                 Pname = enum()
3435
3436              See getTexEnvfv/2
3437
3438       texParameterf(Target, Pname, Param) -> ok
3439
3440              Types:
3441
3442                 Target = enum()
3443                 Pname = enum()
3444                 Param = float()
3445
3446              Set texture parameters
3447
3448              gl:texParameter assigns the value or values  in  Params  to  the
3449              texture parameter specified as Pname . Target defines the target
3450              texture,  either  ?GL_TEXTURE_1D  ,   ?GL_TEXTURE_2D,   ?GL_TEX‐
3451              TURE_1D_ARRAY,  ?GL_TEXTURE_2D_ARRAY, ?GL_TEXTURE_RECTANGLE , or
3452              ?GL_TEXTURE_3D. The following symbols are accepted in Pname :
3453
3454              See external documentation.
3455
3456       texParameteri(Target, Pname, Param) -> ok
3457
3458              Types:
3459
3460                 Target = enum()
3461                 Pname = enum()
3462                 Param = integer()
3463
3464              See texParameterf/3
3465
3466       texParameterfv(Target, Pname, Params) -> ok
3467
3468              Types:
3469
3470                 Target = enum()
3471                 Pname = enum()
3472                 Params = tuple()
3473
3474              See texParameterf/3
3475
3476       texParameteriv(Target, Pname, Params) -> ok
3477
3478              Types:
3479
3480                 Target = enum()
3481                 Pname = enum()
3482                 Params = tuple()
3483
3484              See texParameterf/3
3485
3486       getTexParameterfv(Target,  Pname)  ->   {float(),   float(),   float(),
3487       float()}
3488
3489              Types:
3490
3491                 Target = enum()
3492                 Pname = enum()
3493
3494              Return texture parameter values
3495
3496              gl:getTexParameter  returns in Params the value or values of the
3497              texture parameter specified as Pname . Target defines the target
3498              texture.    ?GL_TEXTURE_1D,    ?GL_TEXTURE_2D,   ?GL_TEXTURE_3D,
3499              ?GL_TEXTURE_1D_ARRAY, ?GL_TEXTURE_2D_ARRAY , ?GL_TEXTURE_RECTAN‐
3500              GLE,  ?GL_TEXTURE_CUBE_MAP,  ?GL_TEXTURE_CUBE_MAP_ARRAY  specify
3501              one-, two-, or three-dimensional,  one-dimensional  array,  two-
3502              dimensional  array,  rectangle, cube-mapped or cube-mapped array
3503              texturing, respectively.  Pname  accepts  the  same  symbols  as
3504              gl:texParameterf/3 , with the same interpretations:
3505
3506              See external documentation.
3507
3508       getTexParameteriv(Target,  Pname)  -> {integer(), integer(), integer(),
3509       integer()}
3510
3511              Types:
3512
3513                 Target = enum()
3514                 Pname = enum()
3515
3516              See getTexParameterfv/2
3517
3518       getTexLevelParameterfv(Target, Level, Pname) -> {float()}
3519
3520              Types:
3521
3522                 Target = enum()
3523                 Level = integer()
3524                 Pname = enum()
3525
3526              Return texture parameter values for a specific level of detail
3527
3528              gl:getTexLevelParameter returns in Params texture parameter val‐
3529              ues  for  a specific level-of-detail value, specified as Level .
3530              Target  defines  the  target  texture,  either   ?GL_TEXTURE_1D,
3531              ?GL_TEXTURE_2D,     ?GL_TEXTURE_3D,    ?GL_PROXY_TEXTURE_1D    ,
3532              ?GL_PROXY_TEXTURE_2D,       ?GL_PROXY_TEXTURE_3D,       ?GL_TEX‐
3533              TURE_CUBE_MAP_POSITIVE_X    ,   ?GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
3534              ?GL_TEXTURE_CUBE_MAP_POSITIVE_Y, ?GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
3535              ,   ?GL_TEXTURE_CUBE_MAP_POSITIVE_Z,  ?GL_TEXTURE_CUBE_MAP_NEGA‐
3536              TIVE_Z, or ?GL_PROXY_TEXTURE_CUBE_MAP .
3537
3538              See external documentation.
3539
3540       getTexLevelParameteriv(Target, Level, Pname) -> {integer()}
3541
3542              Types:
3543
3544                 Target = enum()
3545                 Level = integer()
3546                 Pname = enum()
3547
3548              See getTexLevelParameterfv/3
3549
3550       texImage1D(Target, Level, InternalFormat, Width, Border, Format,  Type,
3551       Pixels) -> ok
3552
3553              Types:
3554
3555                 Target = enum()
3556                 Level = integer()
3557                 InternalFormat = integer()
3558                 Width = integer()
3559                 Border = integer()
3560                 Format = enum()
3561                 Type = enum()
3562                 Pixels = offset() | mem()
3563
3564              Specify a one-dimensional texture image
3565
3566              Texturing  maps a portion of a specified texture image onto each
3567              graphical primitive for which texturing is  enabled.  To  enable
3568              and  disable  one-dimensional  texturing,  call  gl:enable/1 and
3569              gl:enable/1 with argument ?GL_TEXTURE_1D.
3570
3571              See external documentation.
3572
3573       texImage2D(Target, Level, InternalFormat, Width, Height,  Border,  For‐
3574       mat, Type, Pixels) -> ok
3575
3576              Types:
3577
3578                 Target = enum()
3579                 Level = integer()
3580                 InternalFormat = integer()
3581                 Width = integer()
3582                 Height = integer()
3583                 Border = integer()
3584                 Format = enum()
3585                 Type = enum()
3586                 Pixels = offset() | mem()
3587
3588              Specify a two-dimensional texture image
3589
3590              Texturing  allows  elements  of  an  image  array  to be read by
3591              shaders.
3592
3593              See external documentation.
3594
3595       getTexImage(Target, Level, Format, Type, Pixels) -> ok
3596
3597              Types:
3598
3599                 Target = enum()
3600                 Level = integer()
3601                 Format = enum()
3602                 Type = enum()
3603                 Pixels = mem()
3604
3605              Return a texture image
3606
3607              gl:getTexImage returns a texture image into Img . Target  speci‐
3608              fies  whether  the  desired  texture  image  is one specified by
3609              gl:texImage1D/8  (?GL_TEXTURE_1D  ),  gl:texImage2D/9  (?GL_TEX‐
3610              TURE_1D_ARRAY,  ?GL_TEXTURE_RECTANGLE,  ?GL_TEXTURE_2D or any of
3611              ?GL_TEXTURE_CUBE_MAP_*),    or    gl:texImage3D/10     (?GL_TEX‐
3612              TURE_2D_ARRAY  ,  ?GL_TEXTURE_3D). Level specifies the level-of-
3613              detail number of the desired image. Format and Type specify  the
3614              format  and  type  of the desired image array. See the reference
3615              page for gl:texImage1D/8 for a  description  of  the  acceptable
3616              values for the Format and Type parameters, respectively.
3617
3618              See external documentation.
3619
3620       genTextures(N) -> [integer()]
3621
3622              Types:
3623
3624                 N = integer()
3625
3626              Generate texture names
3627
3628              gl:genTextures returns N texture names in Textures . There is no
3629              guarantee that the names form a contiguous set of integers; how‐
3630              ever,  it  is  guaranteed that none of the returned names was in
3631              use immediately before the call to gl:genTextures.
3632
3633              See external documentation.
3634
3635       deleteTextures(Textures) -> ok
3636
3637              Types:
3638
3639                 Textures = [integer()]
3640
3641              Delete named textures
3642
3643              gl:deleteTextures deletes N textures named by  the  elements  of
3644              the  array Textures . After a texture is deleted, it has no con‐
3645              tents or dimensionality, and its name is  free  for  reuse  (for
3646              example  by  gl:genTextures/1  ). If a texture that is currently
3647              bound is deleted, the binding reverts to  0  (the  default  tex‐
3648              ture).
3649
3650              See external documentation.
3651
3652       bindTexture(Target, Texture) -> ok
3653
3654              Types:
3655
3656                 Target = enum()
3657                 Texture = integer()
3658
3659              Bind a named texture to a texturing target
3660
3661              gl:bindTexture  lets  you create or use a named texture. Calling
3662              gl:bindTexture  with  Target  set  to  ?GL_TEXTURE_1D,  ?GL_TEX‐
3663              TURE_2D,  ?GL_TEXTURE_3D  ,  or  ?GL_TEXTURE_1D_ARRAY,  ?GL_TEX‐
3664              TURE_2D_ARRAY,  ?GL_TEXTURE_RECTANGLE  ,   ?GL_TEXTURE_CUBE_MAP,
3665              ?GL_TEXTURE_2D_MULTISAMPLE  or  ?GL_TEXTURE_2D_MULTISAMPLE_ARRAY
3666              and Texture set to the name of the new texture binds the texture
3667              name  to  the  target.  When a texture is bound to a target, the
3668              previous binding for that target is automatically broken.
3669
3670              See external documentation.
3671
3672       prioritizeTextures(Textures, Priorities) -> ok
3673
3674              Types:
3675
3676                 Textures = [integer()]
3677                 Priorities = [clamp()]
3678
3679              Set texture residence priority
3680
3681              gl:prioritizeTextures assigns the N texture priorities given  in
3682              Priorities to the N textures named in Textures .
3683
3684              See external documentation.
3685
3686       areTexturesResident(Textures) -> {0 | 1, Residences::[0 | 1]}
3687
3688              Types:
3689
3690                 Textures = [integer()]
3691
3692              Determine if textures are loaded in texture memory
3693
3694              GL  establishes  a  working set of textures that are resident in
3695              texture memory. These textures can be bound to a texture  target
3696              much more efficiently than textures that are not resident.
3697
3698              See external documentation.
3699
3700       isTexture(Texture) -> 0 | 1
3701
3702              Types:
3703
3704                 Texture = integer()
3705
3706              Determine if a name corresponds to a texture
3707
3708              gl:isTexture  returns  ?GL_TRUE if Texture is currently the name
3709              of a texture. If Texture is zero, or is a non-zero value that is
3710              not  currently  the  name  of  a texture, or if an error occurs,
3711              gl:isTexture returns ?GL_FALSE.
3712
3713              See external documentation.
3714
3715       texSubImage1D(Target, Level, Xoffset, Width, Format, Type,  Pixels)  ->
3716       ok
3717
3718              Types:
3719
3720                 Target = enum()
3721                 Level = integer()
3722                 Xoffset = integer()
3723                 Width = integer()
3724                 Format = enum()
3725                 Type = enum()
3726                 Pixels = offset() | mem()
3727
3728              glTexSubImage
3729
3730              See external documentation.
3731
3732       texSubImage2D(Target,  Level,  Xoffset, Yoffset, Width, Height, Format,
3733       Type, Pixels) -> ok
3734
3735              Types:
3736
3737                 Target = enum()
3738                 Level = integer()
3739                 Xoffset = integer()
3740                 Yoffset = integer()
3741                 Width = integer()
3742                 Height = integer()
3743                 Format = enum()
3744                 Type = enum()
3745                 Pixels = offset() | mem()
3746
3747              glTexSubImage
3748
3749              See external documentation.
3750
3751       copyTexImage1D(Target, Level, Internalformat, X, Y, Width,  Border)  ->
3752       ok
3753
3754              Types:
3755
3756                 Target = enum()
3757                 Level = integer()
3758                 Internalformat = enum()
3759                 X = integer()
3760                 Y = integer()
3761                 Width = integer()
3762                 Border = integer()
3763
3764              Copy pixels into a 1D texture image
3765
3766              gl:copyTexImage1D  defines  a one-dimensional texture image with
3767              pixels from the current ?GL_READ_BUFFER.
3768
3769              See external documentation.
3770
3771       copyTexImage2D(Target, Level, Internalformat, X, Y, Width, Height, Bor‐
3772       der) -> ok
3773
3774              Types:
3775
3776                 Target = enum()
3777                 Level = integer()
3778                 Internalformat = enum()
3779                 X = integer()
3780                 Y = integer()
3781                 Width = integer()
3782                 Height = integer()
3783                 Border = integer()
3784
3785              Copy pixels into a 2D texture image
3786
3787              gl:copyTexImage2D  defines  a  two-dimensional texture image, or
3788              cube-map  texture   image   with   pixels   from   the   current
3789              ?GL_READ_BUFFER.
3790
3791              See external documentation.
3792
3793       copyTexSubImage1D(Target, Level, Xoffset, X, Y, Width) -> ok
3794
3795              Types:
3796
3797                 Target = enum()
3798                 Level = integer()
3799                 Xoffset = integer()
3800                 X = integer()
3801                 Y = integer()
3802                 Width = integer()
3803
3804              Copy a one-dimensional texture subimage
3805
3806              gl:copyTexSubImage1D  replaces  a  portion  of a one-dimensional
3807              texture image  with  pixels  from  the  current  ?GL_READ_BUFFER
3808              (rather  than  from main memory, as is the case for gl:texSubIm‐
3809              age1D/7 ).
3810
3811              See external documentation.
3812
3813       copyTexSubImage2D(Target, Level, Xoffset, Yoffset, X, Y, Width, Height)
3814       -> ok
3815
3816              Types:
3817
3818                 Target = enum()
3819                 Level = integer()
3820                 Xoffset = integer()
3821                 Yoffset = integer()
3822                 X = integer()
3823                 Y = integer()
3824                 Width = integer()
3825                 Height = integer()
3826
3827              Copy a two-dimensional texture subimage
3828
3829              gl:copyTexSubImage2D  replaces  a  rectangular portion of a two-
3830              dimensional texture image or cube-map texture image with  pixels
3831              from  the current ?GL_READ_BUFFER (rather than from main memory,
3832              as is the case for gl:texSubImage1D/7 ).
3833
3834              See external documentation.
3835
3836       map1d(Target, U1, U2, Stride, Order, Points) -> ok
3837
3838              Types:
3839
3840                 Target = enum()
3841                 U1 = float()
3842                 U2 = float()
3843                 Stride = integer()
3844                 Order = integer()
3845                 Points = binary()
3846
3847              glMap
3848
3849              See external documentation.
3850
3851       map1f(Target, U1, U2, Stride, Order, Points) -> ok
3852
3853              Types:
3854
3855                 Target = enum()
3856                 U1 = float()
3857                 U2 = float()
3858                 Stride = integer()
3859                 Order = integer()
3860                 Points = binary()
3861
3862              glMap
3863
3864              See external documentation.
3865
3866       map2d(Target, U1, U2, Ustride, Uorder, V1, V2, Vstride, Vorder, Points)
3867       -> ok
3868
3869              Types:
3870
3871                 Target = enum()
3872                 U1 = float()
3873                 U2 = float()
3874                 Ustride = integer()
3875                 Uorder = integer()
3876                 V1 = float()
3877                 V2 = float()
3878                 Vstride = integer()
3879                 Vorder = integer()
3880                 Points = binary()
3881
3882              glMap
3883
3884              See external documentation.
3885
3886       map2f(Target, U1, U2, Ustride, Uorder, V1, V2, Vstride, Vorder, Points)
3887       -> ok
3888
3889              Types:
3890
3891                 Target = enum()
3892                 U1 = float()
3893                 U2 = float()
3894                 Ustride = integer()
3895                 Uorder = integer()
3896                 V1 = float()
3897                 V2 = float()
3898                 Vstride = integer()
3899                 Vorder = integer()
3900                 Points = binary()
3901
3902              glMap
3903
3904              See external documentation.
3905
3906       getMapdv(Target, Query, V) -> ok
3907
3908              Types:
3909
3910                 Target = enum()
3911                 Query = enum()
3912                 V = mem()
3913
3914              Return evaluator parameters
3915
3916              gl:map1d/6 and gl:map1d/6 define evaluators.  gl:getMap  returns
3917              evaluator parameters. Target chooses a map, Query selects a spe‐
3918              cific parameter, and V points to storage where the  values  will
3919              be returned.
3920
3921              See external documentation.
3922
3923       getMapfv(Target, Query, V) -> ok
3924
3925              Types:
3926
3927                 Target = enum()
3928                 Query = enum()
3929                 V = mem()
3930
3931              See getMapdv/3
3932
3933       getMapiv(Target, Query, V) -> ok
3934
3935              Types:
3936
3937                 Target = enum()
3938                 Query = enum()
3939                 V = mem()
3940
3941              See getMapdv/3
3942
3943       evalCoord1d(U) -> ok
3944
3945              Types:
3946
3947                 U = float()
3948
3949              Evaluate enabled one- and two-dimensional maps
3950
3951              gl:evalCoord1 evaluates enabled one-dimensional maps at argument
3952              U . gl:evalCoord2 does the same for two-dimensional  maps  using
3953              two  domain  values,  U and V . To define a map, call gl:map1d/6
3954              and gl:map1d/6 ; to enable and disable it, call gl:enable/1  and
3955              gl:enable/1 .
3956
3957              See external documentation.
3958
3959       evalCoord1f(U) -> ok
3960
3961              Types:
3962
3963                 U = float()
3964
3965              See evalCoord1d/1
3966
3967       evalCoord1dv(U) -> ok
3968
3969              Types:
3970
3971                 U = {U::float()}
3972
3973              Equivalent to evalCoord1d(U).
3974
3975       evalCoord1fv(U) -> ok
3976
3977              Types:
3978
3979                 U = {U::float()}
3980
3981              Equivalent to evalCoord1f(U).
3982
3983       evalCoord2d(U, V) -> ok
3984
3985              Types:
3986
3987                 U = float()
3988                 V = float()
3989
3990              See evalCoord1d/1
3991
3992       evalCoord2f(U, V) -> ok
3993
3994              Types:
3995
3996                 U = float()
3997                 V = float()
3998
3999              See evalCoord1d/1
4000
4001       evalCoord2dv(U) -> ok
4002
4003              Types:
4004
4005                 U = {U::float(), V::float()}
4006
4007              Equivalent to evalCoord2d(U, V).
4008
4009       evalCoord2fv(U) -> ok
4010
4011              Types:
4012
4013                 U = {U::float(), V::float()}
4014
4015              Equivalent to evalCoord2f(U, V).
4016
4017       mapGrid1d(Un, U1, U2) -> ok
4018
4019              Types:
4020
4021                 Un = integer()
4022                 U1 = float()
4023                 U2 = float()
4024
4025              Define a one- or two-dimensional mesh
4026
4027              gl:mapGrid  and  gl:evalMesh1/3 are used together to efficiently
4028              generate and evaluate a series of evenly-spaced map domain  val‐
4029              ues.  gl:evalMesh1/3  steps through the integer domain of a one-
4030              or two-dimensional grid, whose range is the domain of the evalu‐
4031              ation maps specified by gl:map1d/6 and gl:map1d/6 .
4032
4033              See external documentation.
4034
4035       mapGrid1f(Un, U1, U2) -> ok
4036
4037              Types:
4038
4039                 Un = integer()
4040                 U1 = float()
4041                 U2 = float()
4042
4043              See mapGrid1d/3
4044
4045       mapGrid2d(Un, U1, U2, Vn, V1, V2) -> ok
4046
4047              Types:
4048
4049                 Un = integer()
4050                 U1 = float()
4051                 U2 = float()
4052                 Vn = integer()
4053                 V1 = float()
4054                 V2 = float()
4055
4056              See mapGrid1d/3
4057
4058       mapGrid2f(Un, U1, U2, Vn, V1, V2) -> ok
4059
4060              Types:
4061
4062                 Un = integer()
4063                 U1 = float()
4064                 U2 = float()
4065                 Vn = integer()
4066                 V1 = float()
4067                 V2 = float()
4068
4069              See mapGrid1d/3
4070
4071       evalPoint1(I) -> ok
4072
4073              Types:
4074
4075                 I = integer()
4076
4077              Generate and evaluate a single point in a mesh
4078
4079              gl:mapGrid1d/3  and  gl:evalMesh1/3  are used in tandem to effi‐
4080              ciently generate and evaluate a  series  of  evenly  spaced  map
4081              domain  values.  gl:evalPoint  can  be used to evaluate a single
4082              grid  point  in  the  same  gridspace  that  is   traversed   by
4083              gl:evalMesh1/3  . Calling gl:evalPoint1 is equivalent to calling
4084              glEvalCoord1( i.&Delta; u+u 1 ); where &Delta; u=(u 2-u 1)/n
4085
4086              See external documentation.
4087
4088       evalPoint2(I, J) -> ok
4089
4090              Types:
4091
4092                 I = integer()
4093                 J = integer()
4094
4095              See evalPoint1/1
4096
4097       evalMesh1(Mode, I1, I2) -> ok
4098
4099              Types:
4100
4101                 Mode = enum()
4102                 I1 = integer()
4103                 I2 = integer()
4104
4105              Compute a one- or two-dimensional grid of points or lines
4106
4107              gl:mapGrid1d/3 and gl:evalMesh are used in tandem to efficiently
4108              generate  and evaluate a series of evenly-spaced map domain val‐
4109              ues. gl:evalMesh steps through the integer domain of a  one-  or
4110              two-dimensional  grid,  whose range is the domain of the evalua‐
4111              tion maps specified by gl:map1d/6 and gl:map1d/6 .  Mode  deter‐
4112              mines  whether  the  resulting vertices are connected as points,
4113              lines, or filled polygons.
4114
4115              See external documentation.
4116
4117       evalMesh2(Mode, I1, I2, J1, J2) -> ok
4118
4119              Types:
4120
4121                 Mode = enum()
4122                 I1 = integer()
4123                 I2 = integer()
4124                 J1 = integer()
4125                 J2 = integer()
4126
4127              See evalMesh1/3
4128
4129       fogf(Pname, Param) -> ok
4130
4131              Types:
4132
4133                 Pname = enum()
4134                 Param = float()
4135
4136              Specify fog parameters
4137
4138              Fog is initially disabled. While enabled, fog affects rasterized
4139              geometry, bitmaps, and pixel blocks, but not buffer clear opera‐
4140              tions.  To  enable  and  disable  fog,  call   gl:enable/1   and
4141              gl:enable/1 with argument ?GL_FOG.
4142
4143              See external documentation.
4144
4145       fogi(Pname, Param) -> ok
4146
4147              Types:
4148
4149                 Pname = enum()
4150                 Param = integer()
4151
4152              See fogf/2
4153
4154       fogfv(Pname, Params) -> ok
4155
4156              Types:
4157
4158                 Pname = enum()
4159                 Params = tuple()
4160
4161              See fogf/2
4162
4163       fogiv(Pname, Params) -> ok
4164
4165              Types:
4166
4167                 Pname = enum()
4168                 Params = tuple()
4169
4170              See fogf/2
4171
4172       feedbackBuffer(Size, Type, Buffer) -> ok
4173
4174              Types:
4175
4176                 Size = integer()
4177                 Type = enum()
4178                 Buffer = mem()
4179
4180              Controls feedback mode
4181
4182              The gl:feedbackBuffer function controls feedback. Feedback, like
4183              selection, is a GL mode. The mode is selected by calling gl:ren‐
4184              derMode/1 with ?GL_FEEDBACK. When the GL is in feedback mode, no
4185              pixels are produced by rasterization. Instead, information about
4186              primitives  that  would  have been rasterized is fed back to the
4187              application using the GL.
4188
4189              See external documentation.
4190
4191       passThrough(Token) -> ok
4192
4193              Types:
4194
4195                 Token = float()
4196
4197              Place a marker in the feedback buffer
4198
4199              See external documentation.
4200
4201       selectBuffer(Size, Buffer) -> ok
4202
4203              Types:
4204
4205                 Size = integer()
4206                 Buffer = mem()
4207
4208              Establish a buffer for selection mode values
4209
4210              gl:selectBuffer has two arguments: Buffer is  a  pointer  to  an
4211              array  of  unsigned integers, and Size indicates the size of the
4212              array. Buffer returns values from the name stack  (see  gl:init‐
4213              Names/0  ,  gl:loadName/1  ,  gl:pushName/1 ) when the rendering
4214              mode is ?GL_SELECT (see gl:renderMode/1 ). gl:selectBuffer  must
4215              be  issued  before selection mode is enabled, and it must not be
4216              issued while the rendering mode is ?GL_SELECT.
4217
4218              See external documentation.
4219
4220       initNames() -> ok
4221
4222              Initialize the name stack
4223
4224              The name stack is used during selection mode to  allow  sets  of
4225              rendering  commands to be uniquely identified. It consists of an
4226              ordered set of unsigned integers. gl:initNames causes  the  name
4227              stack to be initialized to its default empty state.
4228
4229              See external documentation.
4230
4231       loadName(Name) -> ok
4232
4233              Types:
4234
4235                 Name = integer()
4236
4237              Load a name onto the name stack
4238
4239              The  name  stack  is used during selection mode to allow sets of
4240              rendering commands to be uniquely identified. It consists of  an
4241              ordered set of unsigned integers and is initially empty.
4242
4243              See external documentation.
4244
4245       pushName(Name) -> ok
4246
4247              Types:
4248
4249                 Name = integer()
4250
4251              Push and pop the name stack
4252
4253              The  name  stack  is used during selection mode to allow sets of
4254              rendering commands to be uniquely identified. It consists of  an
4255              ordered set of unsigned integers and is initially empty.
4256
4257              See external documentation.
4258
4259       popName() -> ok
4260
4261              See pushName/1
4262
4263       blendColor(Red, Green, Blue, Alpha) -> ok
4264
4265              Types:
4266
4267                 Red = clamp()
4268                 Green = clamp()
4269                 Blue = clamp()
4270                 Alpha = clamp()
4271
4272              Set the blend color
4273
4274              The ?GL_BLEND_COLOR may be used to calculate the source and des‐
4275              tination blending factors. The color components are  clamped  to
4276              the  range  [0  1] before being stored. See gl:blendFunc/2 for a
4277              complete description of the blending operations.  Initially  the
4278              ?GL_BLEND_COLOR is set to (0, 0, 0, 0).
4279
4280              See external documentation.
4281
4282       blendEquation(Mode) -> ok
4283
4284              Types:
4285
4286                 Mode = enum()
4287
4288              Specify  the  equation  used for both the RGB blend equation and
4289              the Alpha blend equation
4290
4291              The blend equations determine how a new  pixel  (the  ''source''
4292              color)  is combined with a pixel already in the framebuffer (the
4293              ''destination'' color). This function sets both  the  RGB  blend
4294              equation  and  the  alpha  blend  equation to a single equation.
4295              gl:blendEquationi specifies the blend equation for a single draw
4296              buffer  whereas gl:blendEquation sets the blend equation for all
4297              draw buffers.
4298
4299              See external documentation.
4300
4301       drawRangeElements(Mode, Start, End, Count, Type, Indices) -> ok
4302
4303              Types:
4304
4305                 Mode = enum()
4306                 Start = integer()
4307                 End = integer()
4308                 Count = integer()
4309                 Type = enum()
4310                 Indices = offset() | mem()
4311
4312              Render primitives from array data
4313
4314              gl:drawRangeElements is a restricted form of gl:drawElements/4 .
4315              Mode , Start , End , and Count match the corresponding arguments
4316              to gl:drawElements/4 , with the additional constraint  that  all
4317              values  in  the  arrays  Count  must lie between Start and End ,
4318              inclusive.
4319
4320              See external documentation.
4321
4322       texImage3D(Target, Level, InternalFormat, Width, Height, Depth, Border,
4323       Format, Type, Pixels) -> ok
4324
4325              Types:
4326
4327                 Target = enum()
4328                 Level = integer()
4329                 InternalFormat = integer()
4330                 Width = integer()
4331                 Height = integer()
4332                 Depth = integer()
4333                 Border = integer()
4334                 Format = enum()
4335                 Type = enum()
4336                 Pixels = offset() | mem()
4337
4338              Specify a three-dimensional texture image
4339
4340              Texturing  maps a portion of a specified texture image onto each
4341              graphical primitive for which texturing is  enabled.  To  enable
4342              and  disable  three-dimensional  texturing, call gl:enable/1 and
4343              gl:enable/1 with argument ?GL_TEXTURE_3D.
4344
4345              See external documentation.
4346
4347       texSubImage3D(Target, Level, Xoffset, Yoffset, Zoffset, Width,  Height,
4348       Depth, Format, Type, Pixels) -> ok
4349
4350              Types:
4351
4352                 Target = enum()
4353                 Level = integer()
4354                 Xoffset = integer()
4355                 Yoffset = integer()
4356                 Zoffset = integer()
4357                 Width = integer()
4358                 Height = integer()
4359                 Depth = integer()
4360                 Format = enum()
4361                 Type = enum()
4362                 Pixels = offset() | mem()
4363
4364              glTexSubImage
4365
4366              See external documentation.
4367
4368       copyTexSubImage3D(Target,  Level,  Xoffset,  Yoffset,  Zoffset,  X,  Y,
4369       Width, Height) -> ok
4370
4371              Types:
4372
4373                 Target = enum()
4374                 Level = integer()
4375                 Xoffset = integer()
4376                 Yoffset = integer()
4377                 Zoffset = integer()
4378                 X = integer()
4379                 Y = integer()
4380                 Width = integer()
4381                 Height = integer()
4382
4383              Copy a three-dimensional texture subimage
4384
4385              gl:copyTexSubImage3D replaces a rectangular portion of a  three-
4386              dimensional   texture   image   with  pixels  from  the  current
4387              ?GL_READ_BUFFER (rather than from main memory, as  is  the  case
4388              for gl:texSubImage1D/7 ).
4389
4390              See external documentation.
4391
4392       colorTable(Target, Internalformat, Width, Format, Type, Table) -> ok
4393
4394              Types:
4395
4396                 Target = enum()
4397                 Internalformat = enum()
4398                 Width = integer()
4399                 Format = enum()
4400                 Type = enum()
4401                 Table = offset() | mem()
4402
4403              Define a color lookup table
4404
4405              gl:colorTable  may  be used in two ways: to test the actual size
4406              and color resolution of a lookup table given a particular set of
4407              parameters, or to load the contents of a color lookup table. Use
4408              the targets ?GL_PROXY_* for the first case and the other targets
4409              for the second case.
4410
4411              See external documentation.
4412
4413       colorTableParameterfv(Target, Pname, Params) -> ok
4414
4415              Types:
4416
4417                 Target = enum()
4418                 Pname = enum()
4419                 Params = {float(), float(), float(), float()}
4420
4421              Set color lookup table parameters
4422
4423              gl:colorTableParameter  is used to specify the scale factors and
4424              bias terms applied to color components when they are loaded into
4425              a  color table. Target indicates which color table the scale and
4426              bias  terms  apply  to;  it  must  be  set  to  ?GL_COLOR_TABLE,
4427              ?GL_POST_CONVOLUTION_COLOR_TABLE               ,              or
4428              ?GL_POST_COLOR_MATRIX_COLOR_TABLE.
4429
4430              See external documentation.
4431
4432       colorTableParameteriv(Target, Pname, Params) -> ok
4433
4434              Types:
4435
4436                 Target = enum()
4437                 Pname = enum()
4438                 Params = {integer(), integer(), integer(), integer()}
4439
4440              See colorTableParameterfv/3
4441
4442       copyColorTable(Target, Internalformat, X, Y, Width) -> ok
4443
4444              Types:
4445
4446                 Target = enum()
4447                 Internalformat = enum()
4448                 X = integer()
4449                 Y = integer()
4450                 Width = integer()
4451
4452              Copy pixels into a color table
4453
4454              gl:copyColorTable loads a color table with pixels from the  cur‐
4455              rent  ?GL_READ_BUFFER  (rather  than from main memory, as is the
4456              case for gl:colorTable/6 ).
4457
4458              See external documentation.
4459
4460       getColorTable(Target, Format, Type, Table) -> ok
4461
4462              Types:
4463
4464                 Target = enum()
4465                 Format = enum()
4466                 Type = enum()
4467                 Table = mem()
4468
4469              Retrieve contents of a color lookup table
4470
4471              gl:getColorTable returns in Table the contents of the color  ta‐
4472              ble  specified by Target . No pixel transfer operations are per‐
4473              formed, but pixel storage modes that are applicable to  gl:read‐
4474              Pixels/7 are performed.
4475
4476              See external documentation.
4477
4478       getColorTableParameterfv(Target,  Pname) -> {float(), float(), float(),
4479       float()}
4480
4481              Types:
4482
4483                 Target = enum()
4484                 Pname = enum()
4485
4486              Get color lookup table parameters
4487
4488              Returns parameters specific to color table Target .
4489
4490              See external documentation.
4491
4492       getColorTableParameteriv(Target, Pname) -> {integer(), integer(), inte‐
4493       ger(), integer()}
4494
4495              Types:
4496
4497                 Target = enum()
4498                 Pname = enum()
4499
4500              See getColorTableParameterfv/2
4501
4502       colorSubTable(Target, Start, Count, Format, Type, Data) -> ok
4503
4504              Types:
4505
4506                 Target = enum()
4507                 Start = integer()
4508                 Count = integer()
4509                 Format = enum()
4510                 Type = enum()
4511                 Data = offset() | mem()
4512
4513              Respecify a portion of a color table
4514
4515              gl:colorSubTable  is used to respecify a contiguous portion of a
4516              color table previously defined using gl:colorTable/6 . The  pix‐
4517              els referenced by Data replace the portion of the existing table
4518              from indices Start to start+count-1, inclusive. This region  may
4519              not  include any entries outside the range of the color table as
4520              it was originally specified. It is not an  error  to  specify  a
4521              subtexture  with  width  of  0,  but such a specification has no
4522              effect.
4523
4524              See external documentation.
4525
4526       copyColorSubTable(Target, Start, X, Y, Width) -> ok
4527
4528              Types:
4529
4530                 Target = enum()
4531                 Start = integer()
4532                 X = integer()
4533                 Y = integer()
4534                 Width = integer()
4535
4536              Respecify a portion of a color table
4537
4538              gl:copyColorSubTable is used to respecify a  contiguous  portion
4539              of  a color table previously defined using gl:colorTable/6 . The
4540              pixels copied from the framebuffer replace the  portion  of  the
4541              existing  table from indices Start to start+x-1, inclusive. This
4542              region may not include any entries  outside  the  range  of  the
4543              color  table, as was originally specified. It is not an error to
4544              specify a subtexture with width of 0, but such  a  specification
4545              has no effect.
4546
4547              See external documentation.
4548
4549       convolutionFilter1D(Target, Internalformat, Width, Format, Type, Image)
4550       -> ok
4551
4552              Types:
4553
4554                 Target = enum()
4555                 Internalformat = enum()
4556                 Width = integer()
4557                 Format = enum()
4558                 Type = enum()
4559                 Image = offset() | mem()
4560
4561              Define a one-dimensional convolution filter
4562
4563              gl:convolutionFilter1D builds a one-dimensional convolution fil‐
4564              ter kernel from an array of pixels.
4565
4566              See external documentation.
4567
4568       convolutionFilter2D(Target,   Internalformat,  Width,  Height,  Format,
4569       Type, Image) -> ok
4570
4571              Types:
4572
4573                 Target = enum()
4574                 Internalformat = enum()
4575                 Width = integer()
4576                 Height = integer()
4577                 Format = enum()
4578                 Type = enum()
4579                 Image = offset() | mem()
4580
4581              Define a two-dimensional convolution filter
4582
4583              gl:convolutionFilter2D builds a two-dimensional convolution fil‐
4584              ter kernel from an array of pixels.
4585
4586              See external documentation.
4587
4588       convolutionParameterf(Target, Pname, Params) -> ok
4589
4590              Types:
4591
4592                 Target = enum()
4593                 Pname = enum()
4594                 Params = tuple()
4595
4596              Set convolution parameters
4597
4598              gl:convolutionParameter  sets the value of a convolution parame‐
4599              ter.
4600
4601              See external documentation.
4602
4603       convolutionParameterfv(Target::enum(), Pname::enum(), Params) -> ok
4604
4605              Types:
4606
4607                 Params = {Params::tuple()}
4608
4609              Equivalent to convolutionParameterf(Target, Pname, Params).
4610
4611       convolutionParameteri(Target, Pname, Params) -> ok
4612
4613              Types:
4614
4615                 Target = enum()
4616                 Pname = enum()
4617                 Params = tuple()
4618
4619              See convolutionParameterf/3
4620
4621       convolutionParameteriv(Target::enum(), Pname::enum(), Params) -> ok
4622
4623              Types:
4624
4625                 Params = {Params::tuple()}
4626
4627              Equivalent to convolutionParameteri(Target, Pname, Params).
4628
4629       copyConvolutionFilter1D(Target, Internalformat, X, Y, Width) -> ok
4630
4631              Types:
4632
4633                 Target = enum()
4634                 Internalformat = enum()
4635                 X = integer()
4636                 Y = integer()
4637                 Width = integer()
4638
4639              Copy pixels into a one-dimensional convolution filter
4640
4641              gl:copyConvolutionFilter1D defines a one-dimensional convolution
4642              filter  kernel  with  pixels  from  the  current ?GL_READ_BUFFER
4643              (rather than from main memory, as is the  case  for  gl:convolu‐
4644              tionFilter1D/6 ).
4645
4646              See external documentation.
4647
4648       copyConvolutionFilter2D(Target, Internalformat, X, Y, Width, Height) ->
4649       ok
4650
4651              Types:
4652
4653                 Target = enum()
4654                 Internalformat = enum()
4655                 X = integer()
4656                 Y = integer()
4657                 Width = integer()
4658                 Height = integer()
4659
4660              Copy pixels into a two-dimensional convolution filter
4661
4662              gl:copyConvolutionFilter2D defines a two-dimensional convolution
4663              filter  kernel  with  pixels  from  the  current ?GL_READ_BUFFER
4664              (rather than from main memory, as is the  case  for  gl:convolu‐
4665              tionFilter2D/7 ).
4666
4667              See external documentation.
4668
4669       getConvolutionFilter(Target, Format, Type, Image) -> ok
4670
4671              Types:
4672
4673                 Target = enum()
4674                 Format = enum()
4675                 Type = enum()
4676                 Image = mem()
4677
4678              Get current 1D or 2D convolution filter kernel
4679
4680              gl:getConvolutionFilter returns the current 1D or 2D convolution
4681              filter kernel as an image. The one- or two-dimensional image  is
4682              placed  in  Image  according to the specifications in Format and
4683              Type . No pixel transfer operations are performed on this image,
4684              but the relevant pixel storage modes are applied.
4685
4686              See external documentation.
4687
4688       getConvolutionParameterfv(Target, Pname) -> {float(), float(), float(),
4689       float()}
4690
4691              Types:
4692
4693                 Target = enum()
4694                 Pname = enum()
4695
4696              Get convolution parameters
4697
4698              gl:getConvolutionParameter  retrieves  convolution   parameters.
4699              Target  determines  which  convolution  filter is queried. Pname
4700              determines which parameter is returned:
4701
4702              See external documentation.
4703
4704       getConvolutionParameteriv(Target,  Pname)  ->  {integer(),   integer(),
4705       integer(), integer()}
4706
4707              Types:
4708
4709                 Target = enum()
4710                 Pname = enum()
4711
4712              See getConvolutionParameterfv/2
4713
4714       separableFilter2D(Target,  Internalformat, Width, Height, Format, Type,
4715       Row, Column) -> ok
4716
4717              Types:
4718
4719                 Target = enum()
4720                 Internalformat = enum()
4721                 Width = integer()
4722                 Height = integer()
4723                 Format = enum()
4724                 Type = enum()
4725                 Row = offset() | mem()
4726                 Column = offset() | mem()
4727
4728              Define a separable two-dimensional convolution filter
4729
4730              gl:separableFilter2D builds a two-dimensional separable convolu‐
4731              tion filter kernel from two arrays of pixels.
4732
4733              See external documentation.
4734
4735       getHistogram(Target, Reset, Format, Type, Values) -> ok
4736
4737              Types:
4738
4739                 Target = enum()
4740                 Reset = 0 | 1
4741                 Format = enum()
4742                 Type = enum()
4743                 Values = mem()
4744
4745              Get histogram table
4746
4747              gl:getHistogram  returns  the  current histogram table as a one-
4748              dimensional image with the same width as the histogram. No pixel
4749              transfer operations are performed on this image, but pixel stor‐
4750              age modes that are applicable to 1D images are honored.
4751
4752              See external documentation.
4753
4754       getHistogramParameterfv(Target, Pname) -> {float()}
4755
4756              Types:
4757
4758                 Target = enum()
4759                 Pname = enum()
4760
4761              Get histogram parameters
4762
4763              gl:getHistogramParameter is used to query parameter  values  for
4764              the current histogram or for a proxy. The histogram state infor‐
4765              mation may be queried by calling gl:getHistogramParameter with a
4766              Target  of  ?GL_HISTOGRAM (to obtain information for the current
4767              histogram table) or ?GL_PROXY_HISTOGRAM (to  obtain  information
4768              from  the  most  recent  proxy request) and one of the following
4769              values for the Pname argument:
4770
4771              See external documentation.
4772
4773       getHistogramParameteriv(Target, Pname) -> {integer()}
4774
4775              Types:
4776
4777                 Target = enum()
4778                 Pname = enum()
4779
4780              See getHistogramParameterfv/2
4781
4782       getMinmax(Target, Reset, Format, Types, Values) -> ok
4783
4784              Types:
4785
4786                 Target = enum()
4787                 Reset = 0 | 1
4788                 Format = enum()
4789                 Types = enum()
4790                 Values = mem()
4791
4792              Get minimum and maximum pixel values
4793
4794              gl:getMinmax returns the accumulated minimum and  maximum  pixel
4795              values  (computed on a per-component basis) in a one-dimensional
4796              image of width 2. The first set of return values are the minima,
4797              and  the  second set of return values are the maxima. The format
4798              of the return values is determined by Format , and their type is
4799              determined by Types .
4800
4801              See external documentation.
4802
4803       getMinmaxParameterfv(Target, Pname) -> {float()}
4804
4805              Types:
4806
4807                 Target = enum()
4808                 Pname = enum()
4809
4810              Get minmax parameters
4811
4812              gl:getMinmaxParameter  retrieves parameters for the current min‐
4813              max table by setting Pname to one of the following values:
4814
4815              See external documentation.
4816
4817       getMinmaxParameteriv(Target, Pname) -> {integer()}
4818
4819              Types:
4820
4821                 Target = enum()
4822                 Pname = enum()
4823
4824              See getMinmaxParameterfv/2
4825
4826       histogram(Target, Width, Internalformat, Sink) -> ok
4827
4828              Types:
4829
4830                 Target = enum()
4831                 Width = integer()
4832                 Internalformat = enum()
4833                 Sink = 0 | 1
4834
4835              Define histogram table
4836
4837              When ?GL_HISTOGRAM is enabled, RGBA color  components  are  con‐
4838              verted  to  histogram  table  indices  by  clamping to the range
4839              [0,1], multiplying by the width  of  the  histogram  table,  and
4840              rounding  to  the nearest integer. The table entries selected by
4841              the RGBA indices are then incremented. (If the  internal  format
4842              of  the  histogram  table  includes  luminance,  then  the index
4843              derived from the R color component determines the luminance  ta‐
4844              ble  entry  to  be  incremented.)  If a histogram table entry is
4845              incremented beyond its maximum value,  then  its  value  becomes
4846              undefined. (This is not an error.)
4847
4848              See external documentation.
4849
4850       minmax(Target, Internalformat, Sink) -> ok
4851
4852              Types:
4853
4854                 Target = enum()
4855                 Internalformat = enum()
4856                 Sink = 0 | 1
4857
4858              Define minmax table
4859
4860              When ?GL_MINMAX is enabled, the RGBA components of incoming pix‐
4861              els are compared to the minimum and maximum values for each com‐
4862              ponent,  which  are stored in the two-element minmax table. (The
4863              first element stores the minima, and the second  element  stores
4864              the  maxima.)  If  a  pixel component is greater than the corre‐
4865              sponding component in the maximum element, then the maximum ele‐
4866              ment  is updated with the pixel component value. If a pixel com‐
4867              ponent is less than the corresponding component in  the  minimum
4868              element, then the minimum element is updated with the pixel com‐
4869              ponent value. (In both cases, if the internal format of the min‐
4870              max  table  includes  luminance,  then  the R color component of
4871              incoming pixels is used for comparison.)  The  contents  of  the
4872              minmax table may be retrieved at a later time by calling gl:get‐
4873              Minmax/5 . The minmax operation is enabled or disabled by  call‐
4874              ing  gl:enable/1 or gl:enable/1 , respectively, with an argument
4875              of ?GL_MINMAX .
4876
4877              See external documentation.
4878
4879       resetHistogram(Target) -> ok
4880
4881              Types:
4882
4883                 Target = enum()
4884
4885              Reset histogram table entries to zero
4886
4887              gl:resetHistogram resets all the elements of  the  current  his‐
4888              togram table to zero.
4889
4890              See external documentation.
4891
4892       resetMinmax(Target) -> ok
4893
4894              Types:
4895
4896                 Target = enum()
4897
4898              Reset minmax table entries to initial values
4899
4900              gl:resetMinmax  resets  the elements of the current minmax table
4901              to their initial values: the maximum element receives the  mini‐
4902              mum  possible component values, and the minimum element receives
4903              the maximum possible component values.
4904
4905              See external documentation.
4906
4907       activeTexture(Texture) -> ok
4908
4909              Types:
4910
4911                 Texture = enum()
4912
4913              Select active texture unit
4914
4915              gl:activeTexture selects which texture unit  subsequent  texture
4916              state  calls  will affect. The number of texture units an imple‐
4917              mentation supports is implementation dependent, but must  be  at
4918              least 80.
4919
4920              See external documentation.
4921
4922       sampleCoverage(Value, Invert) -> ok
4923
4924              Types:
4925
4926                 Value = clamp()
4927                 Invert = 0 | 1
4928
4929              Specify multisample coverage parameters
4930
4931              Multisampling  samples  a pixel multiple times at various imple‐
4932              mentation-dependent subpixel locations to generate  antialiasing
4933              effects.  Multisampling transparently antialiases points, lines,
4934              polygons, and images if it is enabled.
4935
4936              See external documentation.
4937
4938       compressedTexImage3D(Target,  Level,  Internalformat,  Width,   Height,
4939       Depth, Border, ImageSize, Data) -> ok
4940
4941              Types:
4942
4943                 Target = enum()
4944                 Level = integer()
4945                 Internalformat = enum()
4946                 Width = integer()
4947                 Height = integer()
4948                 Depth = integer()
4949                 Border = integer()
4950                 ImageSize = integer()
4951                 Data = offset() | mem()
4952
4953              Specify a three-dimensional texture image in a compressed format
4954
4955              Texturing  allows  elements  of  an  image  array  to be read by
4956              shaders.
4957
4958              See external documentation.
4959
4960       compressedTexImage2D(Target, Level, Internalformat, Width, Height, Bor‐
4961       der, ImageSize, Data) -> ok
4962
4963              Types:
4964
4965                 Target = enum()
4966                 Level = integer()
4967                 Internalformat = enum()
4968                 Width = integer()
4969                 Height = integer()
4970                 Border = integer()
4971                 ImageSize = integer()
4972                 Data = offset() | mem()
4973
4974              Specify a two-dimensional texture image in a compressed format
4975
4976              Texturing  allows  elements  of  an  image  array  to be read by
4977              shaders.
4978
4979              See external documentation.
4980
4981       compressedTexImage1D(Target, Level, Internalformat, Width, Border, Ima‐
4982       geSize, Data) -> ok
4983
4984              Types:
4985
4986                 Target = enum()
4987                 Level = integer()
4988                 Internalformat = enum()
4989                 Width = integer()
4990                 Border = integer()
4991                 ImageSize = integer()
4992                 Data = offset() | mem()
4993
4994              Specify a one-dimensional texture image in a compressed format
4995
4996              Texturing  allows  elements  of  an  image  array  to be read by
4997              shaders.
4998
4999              See external documentation.
5000
5001       compressedTexSubImage3D(Target,  Level,  Xoffset,   Yoffset,   Zoffset,
5002       Width, Height, Depth, Format, ImageSize, Data) -> ok
5003
5004              Types:
5005
5006                 Target = enum()
5007                 Level = integer()
5008                 Xoffset = integer()
5009                 Yoffset = integer()
5010                 Zoffset = integer()
5011                 Width = integer()
5012                 Height = integer()
5013                 Depth = integer()
5014                 Format = enum()
5015                 ImageSize = integer()
5016                 Data = offset() | mem()
5017
5018              Specify  a  three-dimensional  texture  subimage in a compressed
5019              format
5020
5021              Texturing allows elements of  an  image  array  to  be  read  by
5022              shaders.
5023
5024              See external documentation.
5025
5026       compressedTexSubImage2D(Target, Level, Xoffset, Yoffset, Width, Height,
5027       Format, ImageSize, Data) -> ok
5028
5029              Types:
5030
5031                 Target = enum()
5032                 Level = integer()
5033                 Xoffset = integer()
5034                 Yoffset = integer()
5035                 Width = integer()
5036                 Height = integer()
5037                 Format = enum()
5038                 ImageSize = integer()
5039                 Data = offset() | mem()
5040
5041              Specify a two-dimensional texture subimage in a compressed  for‐
5042              mat
5043
5044              Texturing  allows  elements  of  an  image  array  to be read by
5045              shaders.
5046
5047              See external documentation.
5048
5049       compressedTexSubImage1D(Target, Level, Xoffset, Width,  Format,  Image‐
5050       Size, Data) -> ok
5051
5052              Types:
5053
5054                 Target = enum()
5055                 Level = integer()
5056                 Xoffset = integer()
5057                 Width = integer()
5058                 Format = enum()
5059                 ImageSize = integer()
5060                 Data = offset() | mem()
5061
5062              Specify  a one-dimensional texture subimage in a compressed for‐
5063              mat
5064
5065              Texturing allows elements of  an  image  array  to  be  read  by
5066              shaders.
5067
5068              See external documentation.
5069
5070       getCompressedTexImage(Target, Lod, Img) -> ok
5071
5072              Types:
5073
5074                 Target = enum()
5075                 Lod = integer()
5076                 Img = mem()
5077
5078              Return a compressed texture image
5079
5080              gl:getCompressedTexImage  returns  the  compressed texture image
5081              associated with Target and Lod into Img . Img should be an array
5082              of  ?GL_TEXTURE_COMPRESSED_IMAGE_SIZE  bytes.  Target  specifies
5083              whether the desired texture image was one specified by gl:texIm‐
5084              age1D/8 (?GL_TEXTURE_1D), gl:texImage2D/9 (?GL_TEXTURE_2D or any
5085              of  ?GL_TEXTURE_CUBE_MAP_*  ),  or  gl:texImage3D/10   (?GL_TEX‐
5086              TURE_3D).  Lod  specifies  the  level-of-detail  number  of  the
5087              desired image.
5088
5089              See external documentation.
5090
5091       clientActiveTexture(Texture) -> ok
5092
5093              Types:
5094
5095                 Texture = enum()
5096
5097              Select active texture unit
5098
5099              gl:clientActiveTexture selects the  vertex  array  client  state
5100              parameters  to be modified by gl:texCoordPointer/4 , and enabled
5101              or   disabled   with   gl:enableClientState/1   or    gl:enable‐
5102              ClientState/1  ,  respectively,  when called with a parameter of
5103              ?GL_TEXTURE_COORD_ARRAY .
5104
5105              See external documentation.
5106
5107       multiTexCoord1d(Target, S) -> ok
5108
5109              Types:
5110
5111                 Target = enum()
5112                 S = float()
5113
5114              Set the current texture coordinates
5115
5116              gl:multiTexCoord specifies  texture  coordinates  in  one,  two,
5117              three,  or  four  dimensions. gl:multiTexCoord1 sets the current
5118              texture coordinates to (s 0 0 1); a  call  to  gl:multiTexCoord2
5119              sets  them  to (s t 0 1). Similarly, gl:multiTexCoord3 specifies
5120              the texture coordinates as (s  t  r  1),  and  gl:multiTexCoord4
5121              defines all four components explicitly as (s t r q).
5122
5123              See external documentation.
5124
5125       multiTexCoord1dv(Target::enum(), V) -> ok
5126
5127              Types:
5128
5129                 V = {S::float()}
5130
5131              Equivalent to multiTexCoord1d(Target, S).
5132
5133       multiTexCoord1f(Target, S) -> ok
5134
5135              Types:
5136
5137                 Target = enum()
5138                 S = float()
5139
5140              See multiTexCoord1d/2
5141
5142       multiTexCoord1fv(Target::enum(), V) -> ok
5143
5144              Types:
5145
5146                 V = {S::float()}
5147
5148              Equivalent to multiTexCoord1f(Target, S).
5149
5150       multiTexCoord1i(Target, S) -> ok
5151
5152              Types:
5153
5154                 Target = enum()
5155                 S = integer()
5156
5157              See multiTexCoord1d/2
5158
5159       multiTexCoord1iv(Target::enum(), V) -> ok
5160
5161              Types:
5162
5163                 V = {S::integer()}
5164
5165              Equivalent to multiTexCoord1i(Target, S).
5166
5167       multiTexCoord1s(Target, S) -> ok
5168
5169              Types:
5170
5171                 Target = enum()
5172                 S = integer()
5173
5174              See multiTexCoord1d/2
5175
5176       multiTexCoord1sv(Target::enum(), V) -> ok
5177
5178              Types:
5179
5180                 V = {S::integer()}
5181
5182              Equivalent to multiTexCoord1s(Target, S).
5183
5184       multiTexCoord2d(Target, S, T) -> ok
5185
5186              Types:
5187
5188                 Target = enum()
5189                 S = float()
5190                 T = float()
5191
5192              See multiTexCoord1d/2
5193
5194       multiTexCoord2dv(Target::enum(), V) -> ok
5195
5196              Types:
5197
5198                 V = {S::float(), T::float()}
5199
5200              Equivalent to multiTexCoord2d(Target, S, T).
5201
5202       multiTexCoord2f(Target, S, T) -> ok
5203
5204              Types:
5205
5206                 Target = enum()
5207                 S = float()
5208                 T = float()
5209
5210              See multiTexCoord1d/2
5211
5212       multiTexCoord2fv(Target::enum(), V) -> ok
5213
5214              Types:
5215
5216                 V = {S::float(), T::float()}
5217
5218              Equivalent to multiTexCoord2f(Target, S, T).
5219
5220       multiTexCoord2i(Target, S, T) -> ok
5221
5222              Types:
5223
5224                 Target = enum()
5225                 S = integer()
5226                 T = integer()
5227
5228              See multiTexCoord1d/2
5229
5230       multiTexCoord2iv(Target::enum(), V) -> ok
5231
5232              Types:
5233
5234                 V = {S::integer(), T::integer()}
5235
5236              Equivalent to multiTexCoord2i(Target, S, T).
5237
5238       multiTexCoord2s(Target, S, T) -> ok
5239
5240              Types:
5241
5242                 Target = enum()
5243                 S = integer()
5244                 T = integer()
5245
5246              See multiTexCoord1d/2
5247
5248       multiTexCoord2sv(Target::enum(), V) -> ok
5249
5250              Types:
5251
5252                 V = {S::integer(), T::integer()}
5253
5254              Equivalent to multiTexCoord2s(Target, S, T).
5255
5256       multiTexCoord3d(Target, S, T, R) -> ok
5257
5258              Types:
5259
5260                 Target = enum()
5261                 S = float()
5262                 T = float()
5263                 R = float()
5264
5265              See multiTexCoord1d/2
5266
5267       multiTexCoord3dv(Target::enum(), V) -> ok
5268
5269              Types:
5270
5271                 V = {S::float(), T::float(), R::float()}
5272
5273              Equivalent to multiTexCoord3d(Target, S, T, R).
5274
5275       multiTexCoord3f(Target, S, T, R) -> ok
5276
5277              Types:
5278
5279                 Target = enum()
5280                 S = float()
5281                 T = float()
5282                 R = float()
5283
5284              See multiTexCoord1d/2
5285
5286       multiTexCoord3fv(Target::enum(), V) -> ok
5287
5288              Types:
5289
5290                 V = {S::float(), T::float(), R::float()}
5291
5292              Equivalent to multiTexCoord3f(Target, S, T, R).
5293
5294       multiTexCoord3i(Target, S, T, R) -> ok
5295
5296              Types:
5297
5298                 Target = enum()
5299                 S = integer()
5300                 T = integer()
5301                 R = integer()
5302
5303              See multiTexCoord1d/2
5304
5305       multiTexCoord3iv(Target::enum(), V) -> ok
5306
5307              Types:
5308
5309                 V = {S::integer(), T::integer(), R::integer()}
5310
5311              Equivalent to multiTexCoord3i(Target, S, T, R).
5312
5313       multiTexCoord3s(Target, S, T, R) -> ok
5314
5315              Types:
5316
5317                 Target = enum()
5318                 S = integer()
5319                 T = integer()
5320                 R = integer()
5321
5322              See multiTexCoord1d/2
5323
5324       multiTexCoord3sv(Target::enum(), V) -> ok
5325
5326              Types:
5327
5328                 V = {S::integer(), T::integer(), R::integer()}
5329
5330              Equivalent to multiTexCoord3s(Target, S, T, R).
5331
5332       multiTexCoord4d(Target, S, T, R, Q) -> ok
5333
5334              Types:
5335
5336                 Target = enum()
5337                 S = float()
5338                 T = float()
5339                 R = float()
5340                 Q = float()
5341
5342              See multiTexCoord1d/2
5343
5344       multiTexCoord4dv(Target::enum(), V) -> ok
5345
5346              Types:
5347
5348                 V = {S::float(), T::float(), R::float(), Q::float()}
5349
5350              Equivalent to multiTexCoord4d(Target, S, T, R, Q).
5351
5352       multiTexCoord4f(Target, S, T, R, Q) -> ok
5353
5354              Types:
5355
5356                 Target = enum()
5357                 S = float()
5358                 T = float()
5359                 R = float()
5360                 Q = float()
5361
5362              See multiTexCoord1d/2
5363
5364       multiTexCoord4fv(Target::enum(), V) -> ok
5365
5366              Types:
5367
5368                 V = {S::float(), T::float(), R::float(), Q::float()}
5369
5370              Equivalent to multiTexCoord4f(Target, S, T, R, Q).
5371
5372       multiTexCoord4i(Target, S, T, R, Q) -> ok
5373
5374              Types:
5375
5376                 Target = enum()
5377                 S = integer()
5378                 T = integer()
5379                 R = integer()
5380                 Q = integer()
5381
5382              See multiTexCoord1d/2
5383
5384       multiTexCoord4iv(Target::enum(), V) -> ok
5385
5386              Types:
5387
5388                 V = {S::integer(), T::integer(), R::integer(), Q::integer()}
5389
5390              Equivalent to multiTexCoord4i(Target, S, T, R, Q).
5391
5392       multiTexCoord4s(Target, S, T, R, Q) -> ok
5393
5394              Types:
5395
5396                 Target = enum()
5397                 S = integer()
5398                 T = integer()
5399                 R = integer()
5400                 Q = integer()
5401
5402              See multiTexCoord1d/2
5403
5404       multiTexCoord4sv(Target::enum(), V) -> ok
5405
5406              Types:
5407
5408                 V = {S::integer(), T::integer(), R::integer(), Q::integer()}
5409
5410              Equivalent to multiTexCoord4s(Target, S, T, R, Q).
5411
5412       loadTransposeMatrixf(M) -> ok
5413
5414              Types:
5415
5416                 M = matrix()
5417
5418              Replace  the current matrix with the specified row-major ordered
5419              matrix
5420
5421              gl:loadTransposeMatrix replaces the current matrix with the  one
5422              whose  elements  are  specified by M . The current matrix is the
5423              projection matrix, modelview matrix, or texture matrix,  depend‐
5424              ing on the current matrix mode (see gl:matrixMode/1 ).
5425
5426              See external documentation.
5427
5428       loadTransposeMatrixd(M) -> ok
5429
5430              Types:
5431
5432                 M = matrix()
5433
5434              See loadTransposeMatrixf/1
5435
5436       multTransposeMatrixf(M) -> ok
5437
5438              Types:
5439
5440                 M = matrix()
5441
5442              Multiply the current matrix with the specified row-major ordered
5443              matrix
5444
5445              gl:multTransposeMatrix multiplies the current  matrix  with  the
5446              one specified using M , and replaces the current matrix with the
5447              product.
5448
5449              See external documentation.
5450
5451       multTransposeMatrixd(M) -> ok
5452
5453              Types:
5454
5455                 M = matrix()
5456
5457              See multTransposeMatrixf/1
5458
5459       blendFuncSeparate(SfactorRGB, DfactorRGB,  SfactorAlpha,  DfactorAlpha)
5460       -> ok
5461
5462              Types:
5463
5464                 SfactorRGB = enum()
5465                 DfactorRGB = enum()
5466                 SfactorAlpha = enum()
5467                 DfactorAlpha = enum()
5468
5469              Specify pixel arithmetic for RGB and alpha components separately
5470
5471              Pixels  can  be  drawn using a function that blends the incoming
5472              (source) RGBA values with the RGBA values that  are  already  in
5473              the frame buffer (the destination values). Blending is initially
5474              disabled.  Use  gl:enable/1  and   gl:enable/1   with   argument
5475              ?GL_BLEND to enable and disable blending.
5476
5477              See external documentation.
5478
5479       multiDrawArrays(Mode, First, Count) -> ok
5480
5481              Types:
5482
5483                 Mode = enum()
5484                 First = [integer()] | mem()
5485                 Count = [integer()] | mem()
5486
5487              Render multiple sets of primitives from array data
5488
5489              gl:multiDrawArrays  specifies  multiple sets of geometric primi‐
5490              tives with very few subroutine calls. Instead of  calling  a  GL
5491              procedure  to pass each individual vertex, normal, texture coor‐
5492              dinate, edge flag, or color, you can prespecify separate  arrays
5493              of  vertices,  normals,  and  colors and use them to construct a
5494              sequence of primitives with a single call to gl:multiDrawArrays.
5495
5496              See external documentation.
5497
5498       pointParameterf(Pname, Param) -> ok
5499
5500              Types:
5501
5502                 Pname = enum()
5503                 Param = float()
5504
5505              Specify point parameters
5506
5507              The following values are accepted for Pname :
5508
5509              See external documentation.
5510
5511       pointParameterfv(Pname, Params) -> ok
5512
5513              Types:
5514
5515                 Pname = enum()
5516                 Params = tuple()
5517
5518              See pointParameterf/2
5519
5520       pointParameteri(Pname, Param) -> ok
5521
5522              Types:
5523
5524                 Pname = enum()
5525                 Param = integer()
5526
5527              See pointParameterf/2
5528
5529       pointParameteriv(Pname, Params) -> ok
5530
5531              Types:
5532
5533                 Pname = enum()
5534                 Params = tuple()
5535
5536              See pointParameterf/2
5537
5538       fogCoordf(Coord) -> ok
5539
5540              Types:
5541
5542                 Coord = float()
5543
5544              Set the current fog coordinates
5545
5546              gl:fogCoord specifies the fog coordinate that is associated with
5547              each vertex and the current raster position. The value specified
5548              is interpolated  and  used  in  computing  the  fog  color  (see
5549              gl:fogf/2 ).
5550
5551              See external documentation.
5552
5553       fogCoordfv(Coord) -> ok
5554
5555              Types:
5556
5557                 Coord = {Coord::float()}
5558
5559              Equivalent to fogCoordf(Coord).
5560
5561       fogCoordd(Coord) -> ok
5562
5563              Types:
5564
5565                 Coord = float()
5566
5567              See fogCoordf/1
5568
5569       fogCoorddv(Coord) -> ok
5570
5571              Types:
5572
5573                 Coord = {Coord::float()}
5574
5575              Equivalent to fogCoordd(Coord).
5576
5577       fogCoordPointer(Type, Stride, Pointer) -> ok
5578
5579              Types:
5580
5581                 Type = enum()
5582                 Stride = integer()
5583                 Pointer = offset() | mem()
5584
5585              Define an array of fog coordinates
5586
5587              gl:fogCoordPointer  specifies the location and data format of an
5588              array of fog coordinates to use when rendering.  Type  specifies
5589              the  data  type of each fog coordinate, and Stride specifies the
5590              byte stride from one fog coordinate to the next,  allowing  ver‐
5591              tices  and attributes to be packed into a single array or stored
5592              in separate arrays.
5593
5594              See external documentation.
5595
5596       secondaryColor3b(Red, Green, Blue) -> ok
5597
5598              Types:
5599
5600                 Red = integer()
5601                 Green = integer()
5602                 Blue = integer()
5603
5604              Set the current secondary color
5605
5606              The GL stores both a primary four-valued RGBA color and  a  sec‐
5607              ondary four-valued RGBA color (where alpha is always set to 0.0)
5608              that is associated with every vertex.
5609
5610              See external documentation.
5611
5612       secondaryColor3bv(V) -> ok
5613
5614              Types:
5615
5616                 V = {Red::integer(), Green::integer(), Blue::integer()}
5617
5618              Equivalent to secondaryColor3b(Red, Green, Blue).
5619
5620       secondaryColor3d(Red, Green, Blue) -> ok
5621
5622              Types:
5623
5624                 Red = float()
5625                 Green = float()
5626                 Blue = float()
5627
5628              See secondaryColor3b/3
5629
5630       secondaryColor3dv(V) -> ok
5631
5632              Types:
5633
5634                 V = {Red::float(), Green::float(), Blue::float()}
5635
5636              Equivalent to secondaryColor3d(Red, Green, Blue).
5637
5638       secondaryColor3f(Red, Green, Blue) -> ok
5639
5640              Types:
5641
5642                 Red = float()
5643                 Green = float()
5644                 Blue = float()
5645
5646              See secondaryColor3b/3
5647
5648       secondaryColor3fv(V) -> ok
5649
5650              Types:
5651
5652                 V = {Red::float(), Green::float(), Blue::float()}
5653
5654              Equivalent to secondaryColor3f(Red, Green, Blue).
5655
5656       secondaryColor3i(Red, Green, Blue) -> ok
5657
5658              Types:
5659
5660                 Red = integer()
5661                 Green = integer()
5662                 Blue = integer()
5663
5664              See secondaryColor3b/3
5665
5666       secondaryColor3iv(V) -> ok
5667
5668              Types:
5669
5670                 V = {Red::integer(), Green::integer(), Blue::integer()}
5671
5672              Equivalent to secondaryColor3i(Red, Green, Blue).
5673
5674       secondaryColor3s(Red, Green, Blue) -> ok
5675
5676              Types:
5677
5678                 Red = integer()
5679                 Green = integer()
5680                 Blue = integer()
5681
5682              See secondaryColor3b/3
5683
5684       secondaryColor3sv(V) -> ok
5685
5686              Types:
5687
5688                 V = {Red::integer(), Green::integer(), Blue::integer()}
5689
5690              Equivalent to secondaryColor3s(Red, Green, Blue).
5691
5692       secondaryColor3ub(Red, Green, Blue) -> ok
5693
5694              Types:
5695
5696                 Red = integer()
5697                 Green = integer()
5698                 Blue = integer()
5699
5700              See secondaryColor3b/3
5701
5702       secondaryColor3ubv(V) -> ok
5703
5704              Types:
5705
5706                 V = {Red::integer(), Green::integer(), Blue::integer()}
5707
5708              Equivalent to secondaryColor3ub(Red, Green, Blue).
5709
5710       secondaryColor3ui(Red, Green, Blue) -> ok
5711
5712              Types:
5713
5714                 Red = integer()
5715                 Green = integer()
5716                 Blue = integer()
5717
5718              See secondaryColor3b/3
5719
5720       secondaryColor3uiv(V) -> ok
5721
5722              Types:
5723
5724                 V = {Red::integer(), Green::integer(), Blue::integer()}
5725
5726              Equivalent to secondaryColor3ui(Red, Green, Blue).
5727
5728       secondaryColor3us(Red, Green, Blue) -> ok
5729
5730              Types:
5731
5732                 Red = integer()
5733                 Green = integer()
5734                 Blue = integer()
5735
5736              See secondaryColor3b/3
5737
5738       secondaryColor3usv(V) -> ok
5739
5740              Types:
5741
5742                 V = {Red::integer(), Green::integer(), Blue::integer()}
5743
5744              Equivalent to secondaryColor3us(Red, Green, Blue).
5745
5746       secondaryColorPointer(Size, Type, Stride, Pointer) -> ok
5747
5748              Types:
5749
5750                 Size = integer()
5751                 Type = enum()
5752                 Stride = integer()
5753                 Pointer = offset() | mem()
5754
5755              Define an array of secondary colors
5756
5757              gl:secondaryColorPointer specifies the location and data  format
5758              of  an  array  of  color  components to use when rendering. Size
5759              specifies the number of components per color,  and  must  be  3.
5760              Type specifies the data type of each color component, and Stride
5761              specifies the byte stride from one color to the  next,  allowing
5762              vertices  and  attributes  to  be  packed into a single array or
5763              stored in separate arrays.
5764
5765              See external documentation.
5766
5767       windowPos2d(X, Y) -> ok
5768
5769              Types:
5770
5771                 X = float()
5772                 Y = float()
5773
5774              Specify the raster position  in  window  coordinates  for  pixel
5775              operations
5776
5777              The GL maintains a 3D position in window coordinates. This posi‐
5778              tion, called the raster position, is used to position pixel  and
5779              bitmap  write  operations.  It is maintained with subpixel accu‐
5780              racy. See gl:bitmap/7 , gl:drawPixels/5 , and gl:copyPixels/5 .
5781
5782              See external documentation.
5783
5784       windowPos2dv(V) -> ok
5785
5786              Types:
5787
5788                 V = {X::float(), Y::float()}
5789
5790              Equivalent to windowPos2d(X, Y).
5791
5792       windowPos2f(X, Y) -> ok
5793
5794              Types:
5795
5796                 X = float()
5797                 Y = float()
5798
5799              See windowPos2d/2
5800
5801       windowPos2fv(V) -> ok
5802
5803              Types:
5804
5805                 V = {X::float(), Y::float()}
5806
5807              Equivalent to windowPos2f(X, Y).
5808
5809       windowPos2i(X, Y) -> ok
5810
5811              Types:
5812
5813                 X = integer()
5814                 Y = integer()
5815
5816              See windowPos2d/2
5817
5818       windowPos2iv(V) -> ok
5819
5820              Types:
5821
5822                 V = {X::integer(), Y::integer()}
5823
5824              Equivalent to windowPos2i(X, Y).
5825
5826       windowPos2s(X, Y) -> ok
5827
5828              Types:
5829
5830                 X = integer()
5831                 Y = integer()
5832
5833              See windowPos2d/2
5834
5835       windowPos2sv(V) -> ok
5836
5837              Types:
5838
5839                 V = {X::integer(), Y::integer()}
5840
5841              Equivalent to windowPos2s(X, Y).
5842
5843       windowPos3d(X, Y, Z) -> ok
5844
5845              Types:
5846
5847                 X = float()
5848                 Y = float()
5849                 Z = float()
5850
5851              See windowPos2d/2
5852
5853       windowPos3dv(V) -> ok
5854
5855              Types:
5856
5857                 V = {X::float(), Y::float(), Z::float()}
5858
5859              Equivalent to windowPos3d(X, Y, Z).
5860
5861       windowPos3f(X, Y, Z) -> ok
5862
5863              Types:
5864
5865                 X = float()
5866                 Y = float()
5867                 Z = float()
5868
5869              See windowPos2d/2
5870
5871       windowPos3fv(V) -> ok
5872
5873              Types:
5874
5875                 V = {X::float(), Y::float(), Z::float()}
5876
5877              Equivalent to windowPos3f(X, Y, Z).
5878
5879       windowPos3i(X, Y, Z) -> ok
5880
5881              Types:
5882
5883                 X = integer()
5884                 Y = integer()
5885                 Z = integer()
5886
5887              See windowPos2d/2
5888
5889       windowPos3iv(V) -> ok
5890
5891              Types:
5892
5893                 V = {X::integer(), Y::integer(), Z::integer()}
5894
5895              Equivalent to windowPos3i(X, Y, Z).
5896
5897       windowPos3s(X, Y, Z) -> ok
5898
5899              Types:
5900
5901                 X = integer()
5902                 Y = integer()
5903                 Z = integer()
5904
5905              See windowPos2d/2
5906
5907       windowPos3sv(V) -> ok
5908
5909              Types:
5910
5911                 V = {X::integer(), Y::integer(), Z::integer()}
5912
5913              Equivalent to windowPos3s(X, Y, Z).
5914
5915       genQueries(N) -> [integer()]
5916
5917              Types:
5918
5919                 N = integer()
5920
5921              Generate query object names
5922
5923              gl:genQueries returns N query object names in Ids . There is  no
5924              guarantee that the names form a contiguous set of integers; how‐
5925              ever, it is guaranteed that none of the returned  names  was  in
5926              use immediately before the call to gl:genQueries.
5927
5928              See external documentation.
5929
5930       deleteQueries(Ids) -> ok
5931
5932              Types:
5933
5934                 Ids = [integer()]
5935
5936              Delete named query objects
5937
5938              gl:deleteQueries  deletes  N query objects named by the elements
5939              of the array Ids . After a query object is deleted,  it  has  no
5940              contents, and its name is free for reuse (for example by gl:gen‐
5941              Queries/1 ).
5942
5943              See external documentation.
5944
5945       isQuery(Id) -> 0 | 1
5946
5947              Types:
5948
5949                 Id = integer()
5950
5951              Determine if a name corresponds to a query object
5952
5953              gl:isQuery returns ?GL_TRUE if Id is currently  the  name  of  a
5954              query  object. If Id is zero, or is a non-zero value that is not
5955              currently the name of a query object, or  if  an  error  occurs,
5956              gl:isQuery returns ?GL_FALSE.
5957
5958              See external documentation.
5959
5960       beginQuery(Target, Id) -> ok
5961
5962              Types:
5963
5964                 Target = enum()
5965                 Id = integer()
5966
5967              Delimit the boundaries of a query object
5968
5969              gl:beginQuery  and  gl:beginQuery/2  delimit the boundaries of a
5970              query object. Query must be a name previously  returned  from  a
5971              call  to  gl:genQueries/1  . If a query object with name Id does
5972              not yet exist it is created with the type determined by Target .
5973              Target   must   be   one   of  ?GL_SAMPLES_PASSED,  ?GL_ANY_SAM‐
5974              PLES_PASSED,  ?GL_PRIMITIVES_GENERATED   ,   ?GL_TRANSFORM_FEED‐
5975              BACK_PRIMITIVES_WRITTEN,  or  ?GL_TIME_ELAPSED.  The behavior of
5976              the query object depends on its type and is as follows.
5977
5978              See external documentation.
5979
5980       endQuery(Target) -> ok
5981
5982              Types:
5983
5984                 Target = enum()
5985
5986              See beginQuery/2
5987
5988       getQueryiv(Target, Pname) -> integer()
5989
5990              Types:
5991
5992                 Target = enum()
5993                 Pname = enum()
5994
5995              glGetQuery
5996
5997              See external documentation.
5998
5999       getQueryObjectiv(Id, Pname) -> integer()
6000
6001              Types:
6002
6003                 Id = integer()
6004                 Pname = enum()
6005
6006              Return parameters of a query object
6007
6008              gl:getQueryObject returns in Params a selected parameter of  the
6009              query object specified by Id .
6010
6011              See external documentation.
6012
6013       getQueryObjectuiv(Id, Pname) -> integer()
6014
6015              Types:
6016
6017                 Id = integer()
6018                 Pname = enum()
6019
6020              See getQueryObjectiv/2
6021
6022       bindBuffer(Target, Buffer) -> ok
6023
6024              Types:
6025
6026                 Target = enum()
6027                 Buffer = integer()
6028
6029              Bind a named buffer object
6030
6031              gl:bindBuffer  binds  a  buffer  object  to the specified buffer
6032              binding point. Calling gl:bindBuffer with Target set to  one  of
6033              the  accepted symbolic constants and Buffer set to the name of a
6034              buffer object binds that buffer object name to the target. If no
6035              buffer  object with name Buffer exists, one is created with that
6036              name. When a buffer object is bound to a  target,  the  previous
6037              binding for that target is automatically broken.
6038
6039              See external documentation.
6040
6041       deleteBuffers(Buffers) -> ok
6042
6043              Types:
6044
6045                 Buffers = [integer()]
6046
6047              Delete named buffer objects
6048
6049              gl:deleteBuffers  deletes N buffer objects named by the elements
6050              of the array Buffers . After a buffer object is deleted, it  has
6051              no  contents,  and  its  name  is free for reuse (for example by
6052              gl:genBuffers/1 ). If a buffer object that is currently bound is
6053              deleted,  the  binding  reverts  to 0 (the absence of any buffer
6054              object).
6055
6056              See external documentation.
6057
6058       genBuffers(N) -> [integer()]
6059
6060              Types:
6061
6062                 N = integer()
6063
6064              Generate buffer object names
6065
6066              gl:genBuffers returns N buffer object names in Buffers  .  There
6067              is  no  guarantee  that the names form a contiguous set of inte‐
6068              gers; however, it is guaranteed that none of the returned  names
6069              was in use immediately before the call to gl:genBuffers .
6070
6071              See external documentation.
6072
6073       isBuffer(Buffer) -> 0 | 1
6074
6075              Types:
6076
6077                 Buffer = integer()
6078
6079              Determine if a name corresponds to a buffer object
6080
6081              gl:isBuffer  returns ?GL_TRUE if Buffer is currently the name of
6082              a buffer object. If Buffer is zero, or is a non-zero value  that
6083              is  not  currently  the  name of a buffer object, or if an error
6084              occurs, gl:isBuffer returns ?GL_FALSE .
6085
6086              See external documentation.
6087
6088       bufferData(Target, Size, Data, Usage) -> ok
6089
6090              Types:
6091
6092                 Target = enum()
6093                 Size = integer()
6094                 Data = offset() | mem()
6095                 Usage = enum()
6096
6097              Creates and initializes a buffer object's data store
6098
6099              gl:bufferData creates a new data store  for  the  buffer  object
6100              currently  bound  to  Target  .  Any  pre-existing data store is
6101              deleted. The new data store is created with the  specified  Size
6102              in  bytes  and  Usage  . If Data is not ?NULL, the data store is
6103              initialized with data from this pointer. In its  initial  state,
6104              the new data store is not mapped, it has a ?NULL mapped pointer,
6105              and its mapped access is ?GL_READ_WRITE .
6106
6107              See external documentation.
6108
6109       bufferSubData(Target, Offset, Size, Data) -> ok
6110
6111              Types:
6112
6113                 Target = enum()
6114                 Offset = integer()
6115                 Size = integer()
6116                 Data = offset() | mem()
6117
6118              Updates a subset of a buffer object's data store
6119
6120              gl:bufferSubData redefines some or all of the data store for the
6121              buffer  object currently bound to Target . Data starting at byte
6122              offset Offset and extending for Size bytes is copied to the data
6123              store from the memory pointed to by Data . An error is thrown if
6124              Offset and Size together define a range beyond the bounds of the
6125              buffer object's data store.
6126
6127              See external documentation.
6128
6129       getBufferSubData(Target, Offset, Size, Data) -> ok
6130
6131              Types:
6132
6133                 Target = enum()
6134                 Offset = integer()
6135                 Size = integer()
6136                 Data = mem()
6137
6138              Returns a subset of a buffer object's data store
6139
6140              gl:getBufferSubData  returns  some  or  all of the data from the
6141              buffer object currently bound to Target . Data starting at  byte
6142              offset  Offset  and  extending for Size bytes is copied from the
6143              data store to the memory pointed to by Data . An error is thrown
6144              if  the buffer object is currently mapped, or if Offset and Size
6145              together define a range beyond the bounds of the buffer object's
6146              data store.
6147
6148              See external documentation.
6149
6150       getBufferParameteriv(Target, Pname) -> integer()
6151
6152              Types:
6153
6154                 Target = enum()
6155                 Pname = enum()
6156
6157              Return parameters of a buffer object
6158
6159              gl:getBufferParameteriv  returns in Data a selected parameter of
6160              the buffer object specified by Target .
6161
6162              See external documentation.
6163
6164       blendEquationSeparate(ModeRGB, ModeAlpha) -> ok
6165
6166              Types:
6167
6168                 ModeRGB = enum()
6169                 ModeAlpha = enum()
6170
6171              Set the RGB blend equation and the alpha  blend  equation  sepa‐
6172              rately
6173
6174              The  blend  equations determines how a new pixel (the ''source''
6175              color) is combined with a pixel already in the framebuffer  (the
6176              ''destination'' color). These functions specifie one blend equa‐
6177              tion for the RGB-color components and one blend equation for the
6178              alpha  component.  gl:blendEquationSeparatei specifies the blend
6179              equations for a single draw buffer whereas gl:blendEquationSepa‐
6180              rate sets the blend equations for all draw buffers.
6181
6182              See external documentation.
6183
6184       drawBuffers(Bufs) -> ok
6185
6186              Types:
6187
6188                 Bufs = [enum()]
6189
6190              Specifies a list of color buffers to be drawn into
6191
6192              gl:drawBuffers  defines  an  array of buffers into which outputs
6193              from the fragment shader data will be  written.  If  a  fragment
6194              shader  writes  a value to one or more user defined output vari‐
6195              ables, then the value of each variable will be written into  the
6196              buffer  specified at a location within Bufs corresponding to the
6197              location assigned to that user defined output. The  draw  buffer
6198              used for user defined outputs assigned to locations greater than
6199              or equal to N is implicitly set to ?GL_NONE and any data written
6200              to such an output is discarded.
6201
6202              See external documentation.
6203
6204       stencilOpSeparate(Face, Sfail, Dpfail, Dppass) -> ok
6205
6206              Types:
6207
6208                 Face = enum()
6209                 Sfail = enum()
6210                 Dpfail = enum()
6211                 Dppass = enum()
6212
6213              Set front and/or back stencil test actions
6214
6215              Stenciling,  like  depth-buffering, enables and disables drawing
6216              on a per-pixel basis. You draw into the stencil planes using  GL
6217              drawing  primitives,  then render geometry and images, using the
6218              stencil planes to mask out portions of the screen. Stenciling is
6219              typically used in multipass rendering algorithms to achieve spe‐
6220              cial effects, such as decals, outlining, and constructive  solid
6221              geometry rendering.
6222
6223              See external documentation.
6224
6225       stencilFuncSeparate(Face, Func, Ref, Mask) -> ok
6226
6227              Types:
6228
6229                 Face = enum()
6230                 Func = enum()
6231                 Ref = integer()
6232                 Mask = integer()
6233
6234              Set  front  and/or back function and reference value for stencil
6235              testing
6236
6237              Stenciling, like depth-buffering, enables and  disables  drawing
6238              on  a per-pixel basis. You draw into the stencil planes using GL
6239              drawing primitives, then render geometry and images,  using  the
6240              stencil planes to mask out portions of the screen. Stenciling is
6241              typically used in multipass rendering algorithms to achieve spe‐
6242              cial  effects, such as decals, outlining, and constructive solid
6243              geometry rendering.
6244
6245              See external documentation.
6246
6247       stencilMaskSeparate(Face, Mask) -> ok
6248
6249              Types:
6250
6251                 Face = enum()
6252                 Mask = integer()
6253
6254              Control the front and/or back writing of individual bits in  the
6255              stencil planes
6256
6257              gl:stencilMaskSeparate  controls  the writing of individual bits
6258              in the stencil planes. The least significant n bits  of  Mask  ,
6259              where  n  is the number of bits in the stencil buffer, specify a
6260              mask. Where a 1 appears in the mask, it's possible to  write  to
6261              the  corresponding bit in the stencil buffer. Where a 0 appears,
6262              the corresponding bit is write-protected.  Initially,  all  bits
6263              are enabled for writing.
6264
6265              See external documentation.
6266
6267       attachShader(Program, Shader) -> ok
6268
6269              Types:
6270
6271                 Program = integer()
6272                 Shader = integer()
6273
6274              Attaches a shader object to a program object
6275
6276              In  order  to  create a complete shader program, there must be a
6277              way to specify the list of things that will be linked  together.
6278              Program  objects  provide this mechanism. Shaders that are to be
6279              linked together in a program object must first  be  attached  to
6280              that  program object. gl:attachShader attaches the shader object
6281              specified by Shader to the program object specified by Program .
6282              This  indicates  that Shader will be included in link operations
6283              that will be performed on Program .
6284
6285              See external documentation.
6286
6287       bindAttribLocation(Program, Index, Name) -> ok
6288
6289              Types:
6290
6291                 Program = integer()
6292                 Index = integer()
6293                 Name = string()
6294
6295              Associates  a  generic  vertex  attribute  index  with  a  named
6296              attribute variable
6297
6298              gl:bindAttribLocation   is  used  to  associate  a  user-defined
6299              attribute variable in the program object  specified  by  Program
6300              with  a  generic  vertex  attribute index. The name of the user-
6301              defined attribute variable is passed as a null terminated string
6302              in Name . The generic vertex attribute index to be bound to this
6303              variable is specified by Index . When Program is  made  part  of
6304              current  state, values provided via the generic vertex attribute
6305              Index will modify the value of the user-defined attribute  vari‐
6306              able specified by Name .
6307
6308              See external documentation.
6309
6310       compileShader(Shader) -> ok
6311
6312              Types:
6313
6314                 Shader = integer()
6315
6316              Compiles a shader object
6317
6318              gl:compileShader compiles the source code strings that have been
6319              stored in the shader object specified by Shader .
6320
6321              See external documentation.
6322
6323       createProgram() -> integer()
6324
6325              Creates a program object
6326
6327              gl:createProgram creates an empty program object and  returns  a
6328              non-zero  value  by which it can be referenced. A program object
6329              is an object to which shader objects can be attached. This  pro‐
6330              vides  a  mechanism  to  specify the shader objects that will be
6331              linked to create a program. It also provides a means for  check‐
6332              ing the compatibility of the shaders that will be used to create
6333              a program (for instance, checking the  compatibility  between  a
6334              vertex  shader  and a fragment shader). When no longer needed as
6335              part of a program object, shader objects can be detached.
6336
6337              See external documentation.
6338
6339       createShader(Type) -> integer()
6340
6341              Types:
6342
6343                 Type = enum()
6344
6345              Creates a shader object
6346
6347              gl:createShader creates an empty shader  object  and  returns  a
6348              non-zero value by which it can be referenced. A shader object is
6349              used to maintain the source code strings that define  a  shader.
6350              ShaderType  indicates  the  type  of  shader to be created. Five
6351              types of  shader  are  supported.  A  shader  of  type  ?GL_VER‐
6352              TEX_SHADER  is  a shader that is intended to run on the program‐
6353              mable vertex processor. A shader of type ?GL_TESS_CONTROL_SHADER
6354              is  a shader that is intended to run on the programmable tessel‐
6355              lation  processor  in  the  control  stage.  A  shader  of  type
6356              ?GL_TESS_EVALUATION_SHADER  is  a shader that is intended to run
6357              on the programmable tessellation  processor  in  the  evaluation
6358              stage.  A shader of type ?GL_GEOMETRY_SHADER is a shader that is
6359              intended to run on the programmable geometry processor. A shader
6360              of  type ?GL_FRAGMENT_SHADER is a shader that is intended to run
6361              on the programmable fragment processor.
6362
6363              See external documentation.
6364
6365       deleteProgram(Program) -> ok
6366
6367              Types:
6368
6369                 Program = integer()
6370
6371              Deletes a program object
6372
6373              gl:deleteProgram frees the memory and invalidates the name asso‐
6374              ciated  with  the program object specified by Program. This com‐
6375              mand effectively undoes the effects of a call  to  gl:createPro‐
6376              gram/0 .
6377
6378              See external documentation.
6379
6380       deleteShader(Shader) -> ok
6381
6382              Types:
6383
6384                 Shader = integer()
6385
6386              Deletes a shader object
6387
6388              gl:deleteShader  frees the memory and invalidates the name asso‐
6389              ciated with the shader object specified by Shader . This command
6390              effectively undoes the effects of a call to gl:createShader/1 .
6391
6392              See external documentation.
6393
6394       detachShader(Program, Shader) -> ok
6395
6396              Types:
6397
6398                 Program = integer()
6399                 Shader = integer()
6400
6401              Detaches  a  shader  object from a program object to which it is
6402              attached
6403
6404              gl:detachShader detaches the shader object specified  by  Shader
6405              from  the program object specified by Program . This command can
6406              be used to undo the effect of the command gl:attachShader/2 .
6407
6408              See external documentation.
6409
6410       disableVertexAttribArray(Index) -> ok
6411
6412              Types:
6413
6414                 Index = integer()
6415
6416              Enable or disable a generic vertex attribute array
6417
6418              gl:enableVertexAttribArray enables the generic vertex  attribute
6419              array  specified by Index . gl:disableVertexAttribArray disables
6420              the generic vertex attribute  array  specified  by  Index  .  By
6421              default,  all  client-side  capabilities are disabled, including
6422              all generic vertex attribute arrays. If enabled, the  values  in
6423              the generic vertex attribute array will be accessed and used for
6424              rendering when calls are made to vertex array commands  such  as
6425              gl:drawArrays/3  ,  gl:drawElements/4 , gl:drawRangeElements/6 ,
6426              see glMultiDrawElements , or gl:multiDrawArrays/3 .
6427
6428              See external documentation.
6429
6430       enableVertexAttribArray(Index) -> ok
6431
6432              Types:
6433
6434                 Index = integer()
6435
6436              See disableVertexAttribArray/1
6437
6438       getActiveAttrib(Program,   Index,   BufSize)    ->    {Size::integer(),
6439       Type::enum(), Name::string()}
6440
6441              Types:
6442
6443                 Program = integer()
6444                 Index = integer()
6445                 BufSize = integer()
6446
6447              Returns  information  about an active attribute variable for the
6448              specified program object
6449
6450              gl:getActiveAttrib returns information about an active attribute
6451              variable in the program object specified by Program . The number
6452              of active attributes  can  be  obtained  by  calling  gl:getPro‐
6453              gramiv/2  with the value ?GL_ACTIVE_ATTRIBUTES. A value of 0 for
6454              Index selects the first active attribute  variable.  Permissible
6455              values  for Index range from 0 to the number of active attribute
6456              variables minus 1.
6457
6458              See external documentation.
6459
6460       getActiveUniform(Program,   Index,   BufSize)   ->    {Size::integer(),
6461       Type::enum(), Name::string()}
6462
6463              Types:
6464
6465                 Program = integer()
6466                 Index = integer()
6467                 BufSize = integer()
6468
6469              Returns  information  about  an  active uniform variable for the
6470              specified program object
6471
6472              gl:getActiveUniform returns information about an active  uniform
6473              variable in the program object specified by Program . The number
6474              of active uniform variables can be obtained by  calling  gl:get‐
6475              Programiv/2 with the value ?GL_ACTIVE_UNIFORMS. A value of 0 for
6476              Index selects the first  active  uniform  variable.  Permissible
6477              values  for  Index  range from 0 to the number of active uniform
6478              variables minus 1.
6479
6480              See external documentation.
6481
6482       getAttachedShaders(Program, MaxCount) -> [integer()]
6483
6484              Types:
6485
6486                 Program = integer()
6487                 MaxCount = integer()
6488
6489              Returns the handles of the shader objects attached to a  program
6490              object
6491
6492              gl:getAttachedShaders  returns  the  names of the shader objects
6493              attached to Program . The  names  of  shader  objects  that  are
6494              attached to Program will be returned in Shaders. The actual num‐
6495              ber of shader names written into Shaders is returned  in  Count.
6496              If  no  shader objects are attached to Program , Count is set to
6497              0. The maximum number of shader names that may  be  returned  in
6498              Shaders is specified by MaxCount .
6499
6500              See external documentation.
6501
6502       getAttribLocation(Program, Name) -> integer()
6503
6504              Types:
6505
6506                 Program = integer()
6507                 Name = string()
6508
6509              Returns the location of an attribute variable
6510
6511              gl:getAttribLocation   queries  the  previously  linked  program
6512              object specified by Program for the attribute variable specified
6513              by  Name  and  returns the index of the generic vertex attribute
6514              that is bound to that attribute variable. If Name  is  a  matrix
6515              attribute  variable, the index of the first column of the matrix
6516              is returned. If the named attribute variable is  not  an  active
6517              attribute in the specified program object or if Name starts with
6518              the reserved prefix "gl_", a value of -1 is returned.
6519
6520              See external documentation.
6521
6522       getProgramiv(Program, Pname) -> integer()
6523
6524              Types:
6525
6526                 Program = integer()
6527                 Pname = enum()
6528
6529              Returns a parameter from a program object
6530
6531              gl:getProgram returns in Params the value of a parameter  for  a
6532              specific program object. The following parameters are defined:
6533
6534              See external documentation.
6535
6536       getProgramInfoLog(Program, BufSize) -> string()
6537
6538              Types:
6539
6540                 Program = integer()
6541                 BufSize = integer()
6542
6543              Returns the information log for a program object
6544
6545              gl:getProgramInfoLog  returns the information log for the speci‐
6546              fied program object. The information log for a program object is
6547              modified  when  the  program  object is linked or validated. The
6548              string that is returned will be null terminated.
6549
6550              See external documentation.
6551
6552       getShaderiv(Shader, Pname) -> integer()
6553
6554              Types:
6555
6556                 Shader = integer()
6557                 Pname = enum()
6558
6559              Returns a parameter from a shader object
6560
6561              gl:getShader returns in Params the value of a  parameter  for  a
6562              specific shader object. The following parameters are defined:
6563
6564              See external documentation.
6565
6566       getShaderInfoLog(Shader, BufSize) -> string()
6567
6568              Types:
6569
6570                 Shader = integer()
6571                 BufSize = integer()
6572
6573              Returns the information log for a shader object
6574
6575              gl:getShaderInfoLog  returns  the information log for the speci‐
6576              fied shader object. The information log for a shader  object  is
6577              modified  when  the  shader  is  compiled.  The  string  that is
6578              returned will be null terminated.
6579
6580              See external documentation.
6581
6582       getShaderSource(Shader, BufSize) -> string()
6583
6584              Types:
6585
6586                 Shader = integer()
6587                 BufSize = integer()
6588
6589              Returns the source code string from a shader object
6590
6591              gl:getShaderSource returns the concatenation of the source  code
6592              strings  from the shader object specified by Shader . The source
6593              code strings for a shader object are the result  of  a  previous
6594              call  to gl:shaderSource/2 . The string returned by the function
6595              will be null terminated.
6596
6597              See external documentation.
6598
6599       getUniformLocation(Program, Name) -> integer()
6600
6601              Types:
6602
6603                 Program = integer()
6604                 Name = string()
6605
6606              Returns the location of a uniform variable
6607
6608              gl:getUniformLocation returns an  integer  that  represents  the
6609              location of a specific uniform variable within a program object.
6610              Name must be a null terminated string  that  contains  no  white
6611              space.  Name  must be an active uniform variable name in Program
6612              that is not a structure, an array of structures, or a  subcompo‐
6613              nent  of  a vector or a matrix. This function returns -1 if Name
6614              does not correspond to an active uniform variable in  Program  ,
6615              if  Name  starts  with  the reserved prefix "gl_", or if Name is
6616              associated with an atomic counter or a named uniform block.
6617
6618              See external documentation.
6619
6620       getUniformfv(Program, Location) -> matrix()
6621
6622              Types:
6623
6624                 Program = integer()
6625                 Location = integer()
6626
6627              Returns the value of a uniform variable
6628
6629              gl:getUniform returns in Params the value(s)  of  the  specified
6630              uniform  variable. The type of the uniform variable specified by
6631              Location determines the number of values returned. If  the  uni‐
6632              form  variable  is  defined  in the shader as a boolean, int, or
6633              float, a single value will be returned. If it is  defined  as  a
6634              vec2,  ivec2,  or  bvec2,  two values will be returned. If it is
6635              defined as a  vec3,  ivec3,  or  bvec3,  three  values  will  be
6636              returned, and so on. To query values stored in uniform variables
6637              declared as arrays, call gl:getUniform for each element  of  the
6638              array.  To  query values stored in uniform variables declared as
6639              structures, call gl:getUniform for each field in the  structure.
6640              The  values  for  uniform variables declared as a matrix will be
6641              returned in column major order.
6642
6643              See external documentation.
6644
6645       getUniformiv(Program, Location) ->  {integer(),  integer(),  integer(),
6646       integer(), integer(), integer(), integer(), integer(), integer(), inte‐
6647       ger(), integer(), integer(),  integer(),  integer(),  integer(),  inte‐
6648       ger()}
6649
6650              Types:
6651
6652                 Program = integer()
6653                 Location = integer()
6654
6655              See getUniformfv/2
6656
6657       getVertexAttribdv(Index, Pname) -> {float(), float(), float(), float()}
6658
6659              Types:
6660
6661                 Index = integer()
6662                 Pname = enum()
6663
6664              Return a generic vertex attribute parameter
6665
6666              gl:getVertexAttrib returns in Params the value of a generic ver‐
6667              tex attribute parameter. The  generic  vertex  attribute  to  be
6668              queried  is specified by Index , and the parameter to be queried
6669              is specified by Pname .
6670
6671              See external documentation.
6672
6673       getVertexAttribfv(Index, Pname) -> {float(), float(), float(), float()}
6674
6675              Types:
6676
6677                 Index = integer()
6678                 Pname = enum()
6679
6680              See getVertexAttribdv/2
6681
6682       getVertexAttribiv(Index, Pname) ->  {integer(),  integer(),  integer(),
6683       integer()}
6684
6685              Types:
6686
6687                 Index = integer()
6688                 Pname = enum()
6689
6690              See getVertexAttribdv/2
6691
6692       isProgram(Program) -> 0 | 1
6693
6694              Types:
6695
6696                 Program = integer()
6697
6698              Determines if a name corresponds to a program object
6699
6700              gl:isProgram  returns  ?GL_TRUE if Program is the name of a pro‐
6701              gram object previously created with gl:createProgram/0  and  not
6702              yet  deleted  with  gl:deleteProgram/1 . If Program is zero or a
6703              non-zero value that is not the name of a program object,  or  if
6704              an error occurs, gl:isProgram returns ?GL_FALSE.
6705
6706              See external documentation.
6707
6708       isShader(Shader) -> 0 | 1
6709
6710              Types:
6711
6712                 Shader = integer()
6713
6714              Determines if a name corresponds to a shader object
6715
6716              gl:isShader  returns  ?GL_TRUE if Shader is the name of a shader
6717              object previously created with  gl:createShader/1  and  not  yet
6718              deleted with gl:deleteShader/1 . If Shader is zero or a non-zero
6719              value that is not the name of a shader object, or  if  an  error
6720              occurs, gl:isShader returns ?GL_FALSE.
6721
6722              See external documentation.
6723
6724       linkProgram(Program) -> ok
6725
6726              Types:
6727
6728                 Program = integer()
6729
6730              Links a program object
6731
6732              gl:linkProgram  links  the program object specified by Program .
6733              If any shader objects of type ?GL_VERTEX_SHADER are attached  to
6734              Program  ,  they  will be used to create an executable that will
6735              run on the programmable vertex processor. If any shader  objects
6736              of  type ?GL_GEOMETRY_SHADER are attached to Program , they will
6737              be used to create an executable that will run  on  the  program‐
6738              mable   geometry  processor.  If  any  shader  objects  of  type
6739              ?GL_FRAGMENT_SHADER are attached to Program , they will be  used
6740              to  create an executable that will run on the programmable frag‐
6741              ment processor.
6742
6743              See external documentation.
6744
6745       shaderSource(Shader, String) -> ok
6746
6747              Types:
6748
6749                 Shader = integer()
6750                 String = iolist()
6751
6752              Replaces the source code in a shader object
6753
6754              gl:shaderSource sets the source code in  Shader  to  the  source
6755              code  in  the  array of strings specified by String . Any source
6756              code previously  stored  in  the  shader  object  is  completely
6757              replaced.  The  number  of  strings in the array is specified by
6758              Count . If Length is ?NULL, each string is assumed  to  be  null
6759              terminated.  If Length is a value other than ?NULL, it points to
6760              an array containing a string length for each of the  correspond‐
6761              ing  elements  of  String . Each element in the Length array may
6762              contain the length of the corresponding string (the null charac‐
6763              ter is not counted as part of the string length) or a value less
6764              than 0 to indicate that  the  string  is  null  terminated.  The
6765              source code strings are not scanned or parsed at this time; they
6766              are simply copied into the specified shader object.
6767
6768              See external documentation.
6769
6770       useProgram(Program) -> ok
6771
6772              Types:
6773
6774                 Program = integer()
6775
6776              Installs a program object as part of current rendering state
6777
6778              gl:useProgram installs the program object specified  by  Program
6779              as  part of current rendering state. One or more executables are
6780              created in a program object  by  successfully  attaching  shader
6781              objects  to  it  with gl:attachShader/2 , successfully compiling
6782              the shader objects with gl:compileShader/1  ,  and  successfully
6783              linking the program object with gl:linkProgram/1 .
6784
6785              See external documentation.
6786
6787       uniform1f(Location, V0) -> ok
6788
6789              Types:
6790
6791                 Location = integer()
6792                 V0 = float()
6793
6794              Specify  the value of a uniform variable for the current program
6795              object
6796
6797              gl:uniform modifies the value of a uniform variable or a uniform
6798              variable array. The location of the uniform variable to be modi‐
6799              fied is specified by Location , which should be a value returned
6800              by  gl:getUniformLocation/2 . gl:uniform operates on the program
6801              object that was made part of current state by calling gl:usePro‐
6802              gram/1 .
6803
6804              See external documentation.
6805
6806       uniform2f(Location, V0, V1) -> ok
6807
6808              Types:
6809
6810                 Location = integer()
6811                 V0 = float()
6812                 V1 = float()
6813
6814              See uniform1f/2
6815
6816       uniform3f(Location, V0, V1, V2) -> ok
6817
6818              Types:
6819
6820                 Location = integer()
6821                 V0 = float()
6822                 V1 = float()
6823                 V2 = float()
6824
6825              See uniform1f/2
6826
6827       uniform4f(Location, V0, V1, V2, V3) -> ok
6828
6829              Types:
6830
6831                 Location = integer()
6832                 V0 = float()
6833                 V1 = float()
6834                 V2 = float()
6835                 V3 = float()
6836
6837              See uniform1f/2
6838
6839       uniform1i(Location, V0) -> ok
6840
6841              Types:
6842
6843                 Location = integer()
6844                 V0 = integer()
6845
6846              See uniform1f/2
6847
6848       uniform2i(Location, V0, V1) -> ok
6849
6850              Types:
6851
6852                 Location = integer()
6853                 V0 = integer()
6854                 V1 = integer()
6855
6856              See uniform1f/2
6857
6858       uniform3i(Location, V0, V1, V2) -> ok
6859
6860              Types:
6861
6862                 Location = integer()
6863                 V0 = integer()
6864                 V1 = integer()
6865                 V2 = integer()
6866
6867              See uniform1f/2
6868
6869       uniform4i(Location, V0, V1, V2, V3) -> ok
6870
6871              Types:
6872
6873                 Location = integer()
6874                 V0 = integer()
6875                 V1 = integer()
6876                 V2 = integer()
6877                 V3 = integer()
6878
6879              See uniform1f/2
6880
6881       uniform1fv(Location, Value) -> ok
6882
6883              Types:
6884
6885                 Location = integer()
6886                 Value = [float()]
6887
6888              See uniform1f/2
6889
6890       uniform2fv(Location, Value) -> ok
6891
6892              Types:
6893
6894                 Location = integer()
6895                 Value = [{float(), float()}]
6896
6897              See uniform1f/2
6898
6899       uniform3fv(Location, Value) -> ok
6900
6901              Types:
6902
6903                 Location = integer()
6904                 Value = [{float(), float(), float()}]
6905
6906              See uniform1f/2
6907
6908       uniform4fv(Location, Value) -> ok
6909
6910              Types:
6911
6912                 Location = integer()
6913                 Value = [{float(), float(), float(), float()}]
6914
6915              See uniform1f/2
6916
6917       uniform1iv(Location, Value) -> ok
6918
6919              Types:
6920
6921                 Location = integer()
6922                 Value = [integer()]
6923
6924              See uniform1f/2
6925
6926       uniform2iv(Location, Value) -> ok
6927
6928              Types:
6929
6930                 Location = integer()
6931                 Value = [{integer(), integer()}]
6932
6933              See uniform1f/2
6934
6935       uniform3iv(Location, Value) -> ok
6936
6937              Types:
6938
6939                 Location = integer()
6940                 Value = [{integer(), integer(), integer()}]
6941
6942              See uniform1f/2
6943
6944       uniform4iv(Location, Value) -> ok
6945
6946              Types:
6947
6948                 Location = integer()
6949                 Value = [{integer(), integer(), integer(), integer()}]
6950
6951              See uniform1f/2
6952
6953       uniformMatrix2fv(Location, Transpose, Value) -> ok
6954
6955              Types:
6956
6957                 Location = integer()
6958                 Transpose = 0 | 1
6959                 Value = [{float(), float(), float(), float()}]
6960
6961              See uniform1f/2
6962
6963       uniformMatrix3fv(Location, Transpose, Value) -> ok
6964
6965              Types:
6966
6967                 Location = integer()
6968                 Transpose = 0 | 1
6969                 Value   =  [{float(),  float(),  float(),  float(),  float(),
6970                 float(), float(), float(), float()}]
6971
6972              See uniform1f/2
6973
6974       uniformMatrix4fv(Location, Transpose, Value) -> ok
6975
6976              Types:
6977
6978                 Location = integer()
6979                 Transpose = 0 | 1
6980                 Value  =  [{float(),  float(),  float(),  float(),   float(),
6981                 float(),   float(),   float(),   float(),  float(),  float(),
6982                 float(), float(), float(), float(), float()}]
6983
6984              See uniform1f/2
6985
6986       validateProgram(Program) -> ok
6987
6988              Types:
6989
6990                 Program = integer()
6991
6992              Validates a program object
6993
6994              gl:validateProgram checks to see whether  the  executables  con‐
6995              tained  in  Program  can execute given the current OpenGL state.
6996              The information generated by  the  validation  process  will  be
6997              stored in Program 's information log. The validation information
6998              may consist of an empty string, or it may be a string containing
6999              information  about how the current program object interacts with
7000              the rest of current OpenGL state. This provides a way for OpenGL
7001              implementers  to  convey  more information about why the current
7002              program is inefficient, suboptimal, failing to execute,  and  so
7003              on.
7004
7005              See external documentation.
7006
7007       vertexAttrib1d(Index, X) -> ok
7008
7009              Types:
7010
7011                 Index = integer()
7012                 X = float()
7013
7014              Specifies the value of a generic vertex attribute
7015
7016              The gl:vertexAttrib family of entry points allows an application
7017              to pass generic vertex attributes in numbered locations.
7018
7019              See external documentation.
7020
7021       vertexAttrib1dv(Index::integer(), V) -> ok
7022
7023              Types:
7024
7025                 V = {X::float()}
7026
7027              Equivalent to vertexAttrib1d(Index, X).
7028
7029       vertexAttrib1f(Index, X) -> ok
7030
7031              Types:
7032
7033                 Index = integer()
7034                 X = float()
7035
7036              See vertexAttrib1d/2
7037
7038       vertexAttrib1fv(Index::integer(), V) -> ok
7039
7040              Types:
7041
7042                 V = {X::float()}
7043
7044              Equivalent to vertexAttrib1f(Index, X).
7045
7046       vertexAttrib1s(Index, X) -> ok
7047
7048              Types:
7049
7050                 Index = integer()
7051                 X = integer()
7052
7053              See vertexAttrib1d/2
7054
7055       vertexAttrib1sv(Index::integer(), V) -> ok
7056
7057              Types:
7058
7059                 V = {X::integer()}
7060
7061              Equivalent to vertexAttrib1s(Index, X).
7062
7063       vertexAttrib2d(Index, X, Y) -> ok
7064
7065              Types:
7066
7067                 Index = integer()
7068                 X = float()
7069                 Y = float()
7070
7071              See vertexAttrib1d/2
7072
7073       vertexAttrib2dv(Index::integer(), V) -> ok
7074
7075              Types:
7076
7077                 V = {X::float(), Y::float()}
7078
7079              Equivalent to vertexAttrib2d(Index, X, Y).
7080
7081       vertexAttrib2f(Index, X, Y) -> ok
7082
7083              Types:
7084
7085                 Index = integer()
7086                 X = float()
7087                 Y = float()
7088
7089              See vertexAttrib1d/2
7090
7091       vertexAttrib2fv(Index::integer(), V) -> ok
7092
7093              Types:
7094
7095                 V = {X::float(), Y::float()}
7096
7097              Equivalent to vertexAttrib2f(Index, X, Y).
7098
7099       vertexAttrib2s(Index, X, Y) -> ok
7100
7101              Types:
7102
7103                 Index = integer()
7104                 X = integer()
7105                 Y = integer()
7106
7107              See vertexAttrib1d/2
7108
7109       vertexAttrib2sv(Index::integer(), V) -> ok
7110
7111              Types:
7112
7113                 V = {X::integer(), Y::integer()}
7114
7115              Equivalent to vertexAttrib2s(Index, X, Y).
7116
7117       vertexAttrib3d(Index, X, Y, Z) -> ok
7118
7119              Types:
7120
7121                 Index = integer()
7122                 X = float()
7123                 Y = float()
7124                 Z = float()
7125
7126              See vertexAttrib1d/2
7127
7128       vertexAttrib3dv(Index::integer(), V) -> ok
7129
7130              Types:
7131
7132                 V = {X::float(), Y::float(), Z::float()}
7133
7134              Equivalent to vertexAttrib3d(Index, X, Y, Z).
7135
7136       vertexAttrib3f(Index, X, Y, Z) -> ok
7137
7138              Types:
7139
7140                 Index = integer()
7141                 X = float()
7142                 Y = float()
7143                 Z = float()
7144
7145              See vertexAttrib1d/2
7146
7147       vertexAttrib3fv(Index::integer(), V) -> ok
7148
7149              Types:
7150
7151                 V = {X::float(), Y::float(), Z::float()}
7152
7153              Equivalent to vertexAttrib3f(Index, X, Y, Z).
7154
7155       vertexAttrib3s(Index, X, Y, Z) -> ok
7156
7157              Types:
7158
7159                 Index = integer()
7160                 X = integer()
7161                 Y = integer()
7162                 Z = integer()
7163
7164              See vertexAttrib1d/2
7165
7166       vertexAttrib3sv(Index::integer(), V) -> ok
7167
7168              Types:
7169
7170                 V = {X::integer(), Y::integer(), Z::integer()}
7171
7172              Equivalent to vertexAttrib3s(Index, X, Y, Z).
7173
7174       vertexAttrib4Nbv(Index, V) -> ok
7175
7176              Types:
7177
7178                 Index = integer()
7179                 V = {integer(), integer(), integer(), integer()}
7180
7181              See vertexAttrib1d/2
7182
7183       vertexAttrib4Niv(Index, V) -> ok
7184
7185              Types:
7186
7187                 Index = integer()
7188                 V = {integer(), integer(), integer(), integer()}
7189
7190              See vertexAttrib1d/2
7191
7192       vertexAttrib4Nsv(Index, V) -> ok
7193
7194              Types:
7195
7196                 Index = integer()
7197                 V = {integer(), integer(), integer(), integer()}
7198
7199              See vertexAttrib1d/2
7200
7201       vertexAttrib4Nub(Index, X, Y, Z, W) -> ok
7202
7203              Types:
7204
7205                 Index = integer()
7206                 X = integer()
7207                 Y = integer()
7208                 Z = integer()
7209                 W = integer()
7210
7211              See vertexAttrib1d/2
7212
7213       vertexAttrib4Nubv(Index::integer(), V) -> ok
7214
7215              Types:
7216
7217                 V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
7218
7219              Equivalent to vertexAttrib4Nub(Index, X, Y, Z, W).
7220
7221       vertexAttrib4Nuiv(Index, V) -> ok
7222
7223              Types:
7224
7225                 Index = integer()
7226                 V = {integer(), integer(), integer(), integer()}
7227
7228              See vertexAttrib1d/2
7229
7230       vertexAttrib4Nusv(Index, V) -> ok
7231
7232              Types:
7233
7234                 Index = integer()
7235                 V = {integer(), integer(), integer(), integer()}
7236
7237              See vertexAttrib1d/2
7238
7239       vertexAttrib4bv(Index, V) -> ok
7240
7241              Types:
7242
7243                 Index = integer()
7244                 V = {integer(), integer(), integer(), integer()}
7245
7246              See vertexAttrib1d/2
7247
7248       vertexAttrib4d(Index, X, Y, Z, W) -> ok
7249
7250              Types:
7251
7252                 Index = integer()
7253                 X = float()
7254                 Y = float()
7255                 Z = float()
7256                 W = float()
7257
7258              See vertexAttrib1d/2
7259
7260       vertexAttrib4dv(Index::integer(), V) -> ok
7261
7262              Types:
7263
7264                 V = {X::float(), Y::float(), Z::float(), W::float()}
7265
7266              Equivalent to vertexAttrib4d(Index, X, Y, Z, W).
7267
7268       vertexAttrib4f(Index, X, Y, Z, W) -> ok
7269
7270              Types:
7271
7272                 Index = integer()
7273                 X = float()
7274                 Y = float()
7275                 Z = float()
7276                 W = float()
7277
7278              See vertexAttrib1d/2
7279
7280       vertexAttrib4fv(Index::integer(), V) -> ok
7281
7282              Types:
7283
7284                 V = {X::float(), Y::float(), Z::float(), W::float()}
7285
7286              Equivalent to vertexAttrib4f(Index, X, Y, Z, W).
7287
7288       vertexAttrib4iv(Index, V) -> ok
7289
7290              Types:
7291
7292                 Index = integer()
7293                 V = {integer(), integer(), integer(), integer()}
7294
7295              See vertexAttrib1d/2
7296
7297       vertexAttrib4s(Index, X, Y, Z, W) -> ok
7298
7299              Types:
7300
7301                 Index = integer()
7302                 X = integer()
7303                 Y = integer()
7304                 Z = integer()
7305                 W = integer()
7306
7307              See vertexAttrib1d/2
7308
7309       vertexAttrib4sv(Index::integer(), V) -> ok
7310
7311              Types:
7312
7313                 V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
7314
7315              Equivalent to vertexAttrib4s(Index, X, Y, Z, W).
7316
7317       vertexAttrib4ubv(Index, V) -> ok
7318
7319              Types:
7320
7321                 Index = integer()
7322                 V = {integer(), integer(), integer(), integer()}
7323
7324              See vertexAttrib1d/2
7325
7326       vertexAttrib4uiv(Index, V) -> ok
7327
7328              Types:
7329
7330                 Index = integer()
7331                 V = {integer(), integer(), integer(), integer()}
7332
7333              See vertexAttrib1d/2
7334
7335       vertexAttrib4usv(Index, V) -> ok
7336
7337              Types:
7338
7339                 Index = integer()
7340                 V = {integer(), integer(), integer(), integer()}
7341
7342              See vertexAttrib1d/2
7343
7344       vertexAttribPointer(Index, Size, Type, Normalized, Stride, Pointer)  ->
7345       ok
7346
7347              Types:
7348
7349                 Index = integer()
7350                 Size = integer()
7351                 Type = enum()
7352                 Normalized = 0 | 1
7353                 Stride = integer()
7354                 Pointer = offset() | mem()
7355
7356              Define an array of generic vertex attribute data
7357
7358              gl:vertexAttribPointer, gl:vertexAttribIPointer and gl:vertexAt‐
7359              tribLPointer specify the location and data format of  the  array
7360              of  generic vertex attributes at index Index to use when render‐
7361              ing. Size specifies the number of components per  attribute  and
7362              must be 1, 2, 3, 4, or ?GL_BGRA. Type specifies the data type of
7363              each component, and Stride specifies the byte  stride  from  one
7364              attribute  to  the  next, allowing vertices and attributes to be
7365              packed into a single array or stored in separate arrays.
7366
7367              See external documentation.
7368
7369       uniformMatrix2x3fv(Location, Transpose, Value) -> ok
7370
7371              Types:
7372
7373                 Location = integer()
7374                 Transpose = 0 | 1
7375                 Value  =  [{float(),  float(),  float(),  float(),   float(),
7376                 float()}]
7377
7378              See uniform1f/2
7379
7380       uniformMatrix3x2fv(Location, Transpose, Value) -> ok
7381
7382              Types:
7383
7384                 Location = integer()
7385                 Transpose = 0 | 1
7386                 Value   =  [{float(),  float(),  float(),  float(),  float(),
7387                 float()}]
7388
7389              See uniform1f/2
7390
7391       uniformMatrix2x4fv(Location, Transpose, Value) -> ok
7392
7393              Types:
7394
7395                 Location = integer()
7396                 Transpose = 0 | 1
7397                 Value  =  [{float(),  float(),  float(),  float(),   float(),
7398                 float(), float(), float()}]
7399
7400              See uniform1f/2
7401
7402       uniformMatrix4x2fv(Location, Transpose, Value) -> ok
7403
7404              Types:
7405
7406                 Location = integer()
7407                 Transpose = 0 | 1
7408                 Value   =  [{float(),  float(),  float(),  float(),  float(),
7409                 float(), float(), float()}]
7410
7411              See uniform1f/2
7412
7413       uniformMatrix3x4fv(Location, Transpose, Value) -> ok
7414
7415              Types:
7416
7417                 Location = integer()
7418                 Transpose = 0 | 1
7419                 Value  =  [{float(),  float(),  float(),  float(),   float(),
7420                 float(),   float(),   float(),   float(),  float(),  float(),
7421                 float()}]
7422
7423              See uniform1f/2
7424
7425       uniformMatrix4x3fv(Location, Transpose, Value) -> ok
7426
7427              Types:
7428
7429                 Location = integer()
7430                 Transpose = 0 | 1
7431                 Value  =  [{float(),  float(),  float(),  float(),   float(),
7432                 float(),   float(),   float(),   float(),  float(),  float(),
7433                 float()}]
7434
7435              See uniform1f/2
7436
7437       colorMaski(Index, R, G, B, A) -> ok
7438
7439              Types:
7440
7441                 Index = integer()
7442                 R = 0 | 1
7443                 G = 0 | 1
7444                 B = 0 | 1
7445                 A = 0 | 1
7446
7447              glColorMaski
7448
7449              See external documentation.
7450
7451       getBooleani_v(Target, Index) -> [0 | 1]
7452
7453              Types:
7454
7455                 Target = enum()
7456                 Index = integer()
7457
7458              See getBooleanv/1
7459
7460       getIntegeri_v(Target, Index) -> [integer()]
7461
7462              Types:
7463
7464                 Target = enum()
7465                 Index = integer()
7466
7467              See getBooleanv/1
7468
7469       enablei(Target, Index) -> ok
7470
7471              Types:
7472
7473                 Target = enum()
7474                 Index = integer()
7475
7476              See enable/1
7477
7478       disablei(Target, Index) -> ok
7479
7480              Types:
7481
7482                 Target = enum()
7483                 Index = integer()
7484
7485              glEnablei
7486
7487              See external documentation.
7488
7489       isEnabledi(Target, Index) -> 0 | 1
7490
7491              Types:
7492
7493                 Target = enum()
7494                 Index = integer()
7495
7496              glIsEnabledi
7497
7498              See external documentation.
7499
7500       beginTransformFeedback(PrimitiveMode) -> ok
7501
7502              Types:
7503
7504                 PrimitiveMode = enum()
7505
7506              Start transform feedback operation
7507
7508              Transform feedback mode captures the values of varying variables
7509              written  by  the  vertex  shader  (or,  if  active, the geometry
7510              shader). Transform feedback is said to be active after a call to
7511              gl:beginTransformFeedback  until  a subsequent call to gl:begin‐
7512              TransformFeedback/1  .  Transform  feedback  commands  must   be
7513              paired.
7514
7515              See external documentation.
7516
7517       endTransformFeedback() -> ok
7518
7519              See beginTransformFeedback/1
7520
7521       bindBufferRange(Target, Index, Buffer, Offset, Size) -> ok
7522
7523              Types:
7524
7525                 Target = enum()
7526                 Index = integer()
7527                 Buffer = integer()
7528                 Offset = integer()
7529                 Size = integer()
7530
7531              Bind a range within a buffer object to an indexed buffer target
7532
7533              gl:bindBufferRange binds a range the buffer object Buffer repre‐
7534              sented by Offset and Size to the binding point at index Index of
7535              the  array  of  targets specified by Target . Each Target repre‐
7536              sents an indexed array of buffer binding points, as  well  as  a
7537              single  general  binding  point that can be used by other buffer
7538              manipulation functions such as  gl:bindBuffer/2  or  see  glMap‐
7539              Buffer.  In addition to binding a range of Buffer to the indexed
7540              buffer binding target, gl:bindBufferBase also binds the range to
7541              the generic buffer binding point specified by Target .
7542
7543              See external documentation.
7544
7545       bindBufferBase(Target, Index, Buffer) -> ok
7546
7547              Types:
7548
7549                 Target = enum()
7550                 Index = integer()
7551                 Buffer = integer()
7552
7553              Bind a buffer object to an indexed buffer target
7554
7555              gl:bindBufferBase  binds the buffer object Buffer to the binding
7556              point at index Index of the array of targets specified by Target
7557              .  Each  Target  represents  an  indexed array of buffer binding
7558              points, as well as a single general binding point  that  can  be
7559              used  by  other  buffer  manipulation functions such as gl:bind‐
7560              Buffer/2 or see glMapBuffer. In addition to  binding  Buffer  to
7561              the  indexed buffer binding target, gl:bindBufferBase also binds
7562              Buffer to the generic buffer binding point specified by Target .
7563
7564              See external documentation.
7565
7566       transformFeedbackVaryings(Program, Varyings, BufferMode) -> ok
7567
7568              Types:
7569
7570                 Program = integer()
7571                 Varyings = iolist()
7572                 BufferMode = enum()
7573
7574              Specify values to record in transform feedback buffers
7575
7576              The names of  the  vertex  or  geometry  shader  outputs  to  be
7577              recorded   in   transform  feedback  mode  are  specified  using
7578              gl:transformFeedbackVaryings. When a geometry shader is  active,
7579              transform  feedback  records  the  values  of  selected geometry
7580              shader output variables from the  emitted  vertices.  Otherwise,
7581              the values of the selected vertex shader outputs are recorded.
7582
7583              See external documentation.
7584
7585       getTransformFeedbackVarying(Program,  Index,  BufSize)  -> {Size::inte‐
7586       ger(), Type::enum(), Name::string()}
7587
7588              Types:
7589
7590                 Program = integer()
7591                 Index = integer()
7592                 BufSize = integer()
7593
7594              Retrieve information about varying variables selected for trans‐
7595              form feedback
7596
7597              Information  about the set of varying variables in a linked pro‐
7598              gram that will be captured  during  transform  feedback  may  be
7599              retrieved  by  calling  gl:getTransformFeedbackVarying.  gl:get‐
7600              TransformFeedbackVarying provides information about the  varying
7601              variable  selected  by  Index  . An Index of 0 selects the first
7602              varying variable specified  in  the  Varyings  array  passed  to
7603              gl:transformFeedbackVaryings/3  ,  and  an  Index  of ?GL_TRANS‐
7604              FORM_FEEDBACK_VARYINGS-1 selects the last such variable.
7605
7606              See external documentation.
7607
7608       clampColor(Target, Clamp) -> ok
7609
7610              Types:
7611
7612                 Target = enum()
7613                 Clamp = enum()
7614
7615              specify whether data read via
7616
7617              gl:readPixels/7 should be clamped
7618
7619              gl:clampColor controls color clamping that is  performed  during
7620              gl:readPixels/7  . Target must be ?GL_CLAMP_READ_COLOR. If Clamp
7621              is ?GL_TRUE,  read  color  clamping  is  enabled;  if  Clamp  is
7622              ?GL_FALSE,   read  color  clamping  is  disabled.  If  Clamp  is
7623              ?GL_FIXED_ONLY, read color  clamping  is  enabled  only  if  the
7624              selected  read  buffer  has  fixed point components and disabled
7625              otherwise.
7626
7627              See external documentation.
7628
7629       beginConditionalRender(Id, Mode) -> ok
7630
7631              Types:
7632
7633                 Id = integer()
7634                 Mode = enum()
7635
7636              Start conditional rendering
7637
7638              Conditional rendering is started using gl:beginConditionalRender
7639              and  ended  using  gl:endConditionalRender  . During conditional
7640              rendering, all vertex array commands, as well as gl:clear/1  and
7641              gl:clearBufferiv/3  have  no  effect if the (?GL_SAMPLES_PASSED)
7642              result of the query object Id is zero, or if  the  (?GL_ANY_SAM‐
7643              PLES_PASSED)  result is ?GL_FALSE . The results of commands set‐
7644              ting the current vertex state, such as  gl:vertexAttrib1d/2  are
7645              undefined.  If the (?GL_SAMPLES_PASSED) result is non-zero or if
7646              the (?GL_ANY_SAMPLES_PASSED ) result is ?GL_TRUE, such  commands
7647              are not discarded. The Id parameter to gl:beginConditionalRender
7648              must be the name of a query object previously  returned  from  a
7649              call  to gl:genQueries/1 . Mode specifies how the results of the
7650              query object are to be interpreted. If Mode  is  ?GL_QUERY_WAIT,
7651              the  GL  waits  for the results of the query to be available and
7652              then uses the results to determine if subsequent rendering  com‐
7653              mands  are  discarded.  If Mode is ?GL_QUERY_NO_WAIT, the GL may
7654              choose to unconditionally execute the subsequent rendering  com‐
7655              mands without waiting for the query to complete.
7656
7657              See external documentation.
7658
7659       endConditionalRender() -> ok
7660
7661              See beginConditionalRender/2
7662
7663       vertexAttribIPointer(Index, Size, Type, Stride, Pointer) -> ok
7664
7665              Types:
7666
7667                 Index = integer()
7668                 Size = integer()
7669                 Type = enum()
7670                 Stride = integer()
7671                 Pointer = offset() | mem()
7672
7673              glVertexAttribIPointer
7674
7675              See external documentation.
7676
7677       getVertexAttribIiv(Index,  Pname)  -> {integer(), integer(), integer(),
7678       integer()}
7679
7680              Types:
7681
7682                 Index = integer()
7683                 Pname = enum()
7684
7685              See getVertexAttribdv/2
7686
7687       getVertexAttribIuiv(Index, Pname) -> {integer(), integer(),  integer(),
7688       integer()}
7689
7690              Types:
7691
7692                 Index = integer()
7693                 Pname = enum()
7694
7695              glGetVertexAttribI
7696
7697              See external documentation.
7698
7699       vertexAttribI1i(Index, X) -> ok
7700
7701              Types:
7702
7703                 Index = integer()
7704                 X = integer()
7705
7706              See vertexAttrib1d/2
7707
7708       vertexAttribI2i(Index, X, Y) -> ok
7709
7710              Types:
7711
7712                 Index = integer()
7713                 X = integer()
7714                 Y = integer()
7715
7716              See vertexAttrib1d/2
7717
7718       vertexAttribI3i(Index, X, Y, Z) -> ok
7719
7720              Types:
7721
7722                 Index = integer()
7723                 X = integer()
7724                 Y = integer()
7725                 Z = integer()
7726
7727              See vertexAttrib1d/2
7728
7729       vertexAttribI4i(Index, X, Y, Z, W) -> ok
7730
7731              Types:
7732
7733                 Index = integer()
7734                 X = integer()
7735                 Y = integer()
7736                 Z = integer()
7737                 W = integer()
7738
7739              See vertexAttrib1d/2
7740
7741       vertexAttribI1ui(Index, X) -> ok
7742
7743              Types:
7744
7745                 Index = integer()
7746                 X = integer()
7747
7748              See vertexAttrib1d/2
7749
7750       vertexAttribI2ui(Index, X, Y) -> ok
7751
7752              Types:
7753
7754                 Index = integer()
7755                 X = integer()
7756                 Y = integer()
7757
7758              See vertexAttrib1d/2
7759
7760       vertexAttribI3ui(Index, X, Y, Z) -> ok
7761
7762              Types:
7763
7764                 Index = integer()
7765                 X = integer()
7766                 Y = integer()
7767                 Z = integer()
7768
7769              See vertexAttrib1d/2
7770
7771       vertexAttribI4ui(Index, X, Y, Z, W) -> ok
7772
7773              Types:
7774
7775                 Index = integer()
7776                 X = integer()
7777                 Y = integer()
7778                 Z = integer()
7779                 W = integer()
7780
7781              See vertexAttrib1d/2
7782
7783       vertexAttribI1iv(Index::integer(), V) -> ok
7784
7785              Types:
7786
7787                 V = {X::integer()}
7788
7789              Equivalent to vertexAttribI1i(Index, X).
7790
7791       vertexAttribI2iv(Index::integer(), V) -> ok
7792
7793              Types:
7794
7795                 V = {X::integer(), Y::integer()}
7796
7797              Equivalent to vertexAttribI2i(Index, X, Y).
7798
7799       vertexAttribI3iv(Index::integer(), V) -> ok
7800
7801              Types:
7802
7803                 V = {X::integer(), Y::integer(), Z::integer()}
7804
7805              Equivalent to vertexAttribI3i(Index, X, Y, Z).
7806
7807       vertexAttribI4iv(Index::integer(), V) -> ok
7808
7809              Types:
7810
7811                 V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
7812
7813              Equivalent to vertexAttribI4i(Index, X, Y, Z, W).
7814
7815       vertexAttribI1uiv(Index::integer(), V) -> ok
7816
7817              Types:
7818
7819                 V = {X::integer()}
7820
7821              Equivalent to vertexAttribI1ui(Index, X).
7822
7823       vertexAttribI2uiv(Index::integer(), V) -> ok
7824
7825              Types:
7826
7827                 V = {X::integer(), Y::integer()}
7828
7829              Equivalent to vertexAttribI2ui(Index, X, Y).
7830
7831       vertexAttribI3uiv(Index::integer(), V) -> ok
7832
7833              Types:
7834
7835                 V = {X::integer(), Y::integer(), Z::integer()}
7836
7837              Equivalent to vertexAttribI3ui(Index, X, Y, Z).
7838
7839       vertexAttribI4uiv(Index::integer(), V) -> ok
7840
7841              Types:
7842
7843                 V = {X::integer(), Y::integer(), Z::integer(), W::integer()}
7844
7845              Equivalent to vertexAttribI4ui(Index, X, Y, Z, W).
7846
7847       vertexAttribI4bv(Index, V) -> ok
7848
7849              Types:
7850
7851                 Index = integer()
7852                 V = {integer(), integer(), integer(), integer()}
7853
7854              See vertexAttrib1d/2
7855
7856       vertexAttribI4sv(Index, V) -> ok
7857
7858              Types:
7859
7860                 Index = integer()
7861                 V = {integer(), integer(), integer(), integer()}
7862
7863              See vertexAttrib1d/2
7864
7865       vertexAttribI4ubv(Index, V) -> ok
7866
7867              Types:
7868
7869                 Index = integer()
7870                 V = {integer(), integer(), integer(), integer()}
7871
7872              See vertexAttrib1d/2
7873
7874       vertexAttribI4usv(Index, V) -> ok
7875
7876              Types:
7877
7878                 Index = integer()
7879                 V = {integer(), integer(), integer(), integer()}
7880
7881              See vertexAttrib1d/2
7882
7883       getUniformuiv(Program,  Location)  -> {integer(), integer(), integer(),
7884       integer(), integer(), integer(), integer(), integer(), integer(), inte‐
7885       ger(),  integer(),  integer(),  integer(),  integer(), integer(), inte‐
7886       ger()}
7887
7888              Types:
7889
7890                 Program = integer()
7891                 Location = integer()
7892
7893              See getUniformfv/2
7894
7895       bindFragDataLocation(Program, Color, Name) -> ok
7896
7897              Types:
7898
7899                 Program = integer()
7900                 Color = integer()
7901                 Name = string()
7902
7903              Bind a user-defined varying out variable to  a  fragment  shader
7904              color number
7905
7906              gl:bindFragDataLocation  explicitly specifies the binding of the
7907              user-defined varying out variable Name to fragment shader  color
7908              number  ColorNumber for program Program . If Name was bound pre‐
7909              viously, its assigned binding is  replaced  with  ColorNumber  .
7910              Name  must be a null-terminated string. ColorNumber must be less
7911              than ?GL_MAX_DRAW_BUFFERS .
7912
7913              See external documentation.
7914
7915       getFragDataLocation(Program, Name) -> integer()
7916
7917              Types:
7918
7919                 Program = integer()
7920                 Name = string()
7921
7922              Query the bindings of color numbers to user-defined varying  out
7923              variables
7924
7925              gl:getFragDataLocation retrieves the assigned color number bind‐
7926              ing for the user-defined varying out variable Name  for  program
7927              Program . Program must have previously been linked. Name must be
7928              a null-terminated string. If Name is not the name of  an  active
7929              user-defined varying out fragment shader variable within Program
7930              , -1 will be returned.
7931
7932              See external documentation.
7933
7934       uniform1ui(Location, V0) -> ok
7935
7936              Types:
7937
7938                 Location = integer()
7939                 V0 = integer()
7940
7941              See uniform1f/2
7942
7943       uniform2ui(Location, V0, V1) -> ok
7944
7945              Types:
7946
7947                 Location = integer()
7948                 V0 = integer()
7949                 V1 = integer()
7950
7951              See uniform1f/2
7952
7953       uniform3ui(Location, V0, V1, V2) -> ok
7954
7955              Types:
7956
7957                 Location = integer()
7958                 V0 = integer()
7959                 V1 = integer()
7960                 V2 = integer()
7961
7962              See uniform1f/2
7963
7964       uniform4ui(Location, V0, V1, V2, V3) -> ok
7965
7966              Types:
7967
7968                 Location = integer()
7969                 V0 = integer()
7970                 V1 = integer()
7971                 V2 = integer()
7972                 V3 = integer()
7973
7974              See uniform1f/2
7975
7976       uniform1uiv(Location, Value) -> ok
7977
7978              Types:
7979
7980                 Location = integer()
7981                 Value = [integer()]
7982
7983              See uniform1f/2
7984
7985       uniform2uiv(Location, Value) -> ok
7986
7987              Types:
7988
7989                 Location = integer()
7990                 Value = [{integer(), integer()}]
7991
7992              See uniform1f/2
7993
7994       uniform3uiv(Location, Value) -> ok
7995
7996              Types:
7997
7998                 Location = integer()
7999                 Value = [{integer(), integer(), integer()}]
8000
8001              See uniform1f/2
8002
8003       uniform4uiv(Location, Value) -> ok
8004
8005              Types:
8006
8007                 Location = integer()
8008                 Value = [{integer(), integer(), integer(), integer()}]
8009
8010              See uniform1f/2
8011
8012       texParameterIiv(Target, Pname, Params) -> ok
8013
8014              Types:
8015
8016                 Target = enum()
8017                 Pname = enum()
8018                 Params = tuple()
8019
8020              See texParameterf/3
8021
8022       texParameterIuiv(Target, Pname, Params) -> ok
8023
8024              Types:
8025
8026                 Target = enum()
8027                 Pname = enum()
8028                 Params = tuple()
8029
8030              glTexParameterI
8031
8032              See external documentation.
8033
8034       getTexParameterIiv(Target, Pname) -> {integer(), integer(),  integer(),
8035       integer()}
8036
8037              Types:
8038
8039                 Target = enum()
8040                 Pname = enum()
8041
8042              See getTexParameterfv/2
8043
8044       getTexParameterIuiv(Target, Pname) -> {integer(), integer(), integer(),
8045       integer()}
8046
8047              Types:
8048
8049                 Target = enum()
8050                 Pname = enum()
8051
8052              glGetTexParameterI
8053
8054              See external documentation.
8055
8056       clearBufferiv(Buffer, Drawbuffer, Value) -> ok
8057
8058              Types:
8059
8060                 Buffer = enum()
8061                 Drawbuffer = integer()
8062                 Value = tuple()
8063
8064              Clear individual buffers of the currently bound draw framebuffer
8065
8066              gl:clearBuffer* clears the specified  buffer  to  the  specified
8067              value(s).  If  Buffer  is  ?GL_COLOR,  a  particular draw buffer
8068              ?GL_DRAWBUFFER I is specified by passing I as  DrawBuffer  .  In
8069              this  case, Value points to a four-element vector specifying the
8070              R, G, B and A color to clear that draw buffer to. If  Buffer  is
8071              one    of   ?GL_FRONT,   ?GL_BACK,   ?GL_LEFT,   ?GL_RIGHT,   or
8072              ?GL_FRONT_AND_BACK , identifying multiple buffers, each selected
8073              buffer is cleared to the same value. Clamping and conversion for
8074              fixed-point color buffers are performed in the same  fashion  as
8075              gl:clearColor/4 .
8076
8077              See external documentation.
8078
8079       clearBufferuiv(Buffer, Drawbuffer, Value) -> ok
8080
8081              Types:
8082
8083                 Buffer = enum()
8084                 Drawbuffer = integer()
8085                 Value = tuple()
8086
8087              See clearBufferiv/3
8088
8089       clearBufferfv(Buffer, Drawbuffer, Value) -> ok
8090
8091              Types:
8092
8093                 Buffer = enum()
8094                 Drawbuffer = integer()
8095                 Value = tuple()
8096
8097              See clearBufferiv/3
8098
8099       clearBufferfi(Buffer, Drawbuffer, Depth, Stencil) -> ok
8100
8101              Types:
8102
8103                 Buffer = enum()
8104                 Drawbuffer = integer()
8105                 Depth = float()
8106                 Stencil = integer()
8107
8108              glClearBufferfi
8109
8110              See external documentation.
8111
8112       getStringi(Name, Index) -> string()
8113
8114              Types:
8115
8116                 Name = enum()
8117                 Index = integer()
8118
8119              See getString/1
8120
8121       drawArraysInstanced(Mode, First, Count, Primcount) -> ok
8122
8123              Types:
8124
8125                 Mode = enum()
8126                 First = integer()
8127                 Count = integer()
8128                 Primcount = integer()
8129
8130              glDrawArraysInstance
8131
8132              See external documentation.
8133
8134       drawElementsInstanced(Mode, Count, Type, Indices, Primcount) -> ok
8135
8136              Types:
8137
8138                 Mode = enum()
8139                 Count = integer()
8140                 Type = enum()
8141                 Indices = offset() | mem()
8142                 Primcount = integer()
8143
8144              glDrawElementsInstance
8145
8146              See external documentation.
8147
8148       texBuffer(Target, Internalformat, Buffer) -> ok
8149
8150              Types:
8151
8152                 Target = enum()
8153                 Internalformat = enum()
8154                 Buffer = integer()
8155
8156              Attach the storage for a buffer object to the active buffer tex‐
8157              ture
8158
8159              gl:texBuffer attaches the storage for the  buffer  object  named
8160              Buffer  to the active buffer texture, and specifies the internal
8161              format for the texel array found in the attached buffer  object.
8162              If Buffer is zero, any buffer object attached to the buffer tex‐
8163              ture is detached and no new buffer object is attached. If Buffer
8164              is  non-zero,  it must be the name of an existing buffer object.
8165              Target must be ?GL_TEXTURE_BUFFER . Internalformat specifies the
8166              storage  format, and must be one of the following sized internal
8167              formats:
8168
8169              See external documentation.
8170
8171       primitiveRestartIndex(Index) -> ok
8172
8173              Types:
8174
8175                 Index = integer()
8176
8177              Specify the primitive restart index
8178
8179              gl:primitiveRestartIndex specifies a vertex array  element  that
8180              is  treated specially when primitive restarting is enabled. This
8181              is known as the primitive restart index.
8182
8183              See external documentation.
8184
8185       getInteger64i_v(Target, Index) -> [integer()]
8186
8187              Types:
8188
8189                 Target = enum()
8190                 Index = integer()
8191
8192              See getBooleanv/1
8193
8194       getBufferParameteri64v(Target, Pname) -> [integer()]
8195
8196              Types:
8197
8198                 Target = enum()
8199                 Pname = enum()
8200
8201              glGetBufferParameteri64v
8202
8203              See external documentation.
8204
8205       framebufferTexture(Target, Attachment, Texture, Level) -> ok
8206
8207              Types:
8208
8209                 Target = enum()
8210                 Attachment = enum()
8211                 Texture = integer()
8212                 Level = integer()
8213
8214              Attach a level of a texture object as a logical  buffer  to  the
8215              currently bound framebuffer object
8216
8217              gl:framebufferTexture,  gl:framebufferTexture1D, gl:framebuffer‐
8218              Texture2D, and gl:framebufferTexture attach  a  selected  mipmap
8219              level or image of a texture object as one of the logical buffers
8220              of the framebuffer object currently bound  to  Target  .  Target
8221              must    be    ?GL_DRAW_FRAMEBUFFER,   ?GL_READ_FRAMEBUFFER,   or
8222              ?GL_FRAMEBUFFER   .    ?GL_FRAMEBUFFER    is    equivalent    to
8223              ?GL_DRAW_FRAMEBUFFER.
8224
8225              See external documentation.
8226
8227       vertexAttribDivisor(Index, Divisor) -> ok
8228
8229              Types:
8230
8231                 Index = integer()
8232                 Divisor = integer()
8233
8234              Modify  the rate at which generic vertex attributes advance dur‐
8235              ing instanced rendering
8236
8237              gl:vertexAttribDivisor modifies the rate at which generic vertex
8238              attributes  advance  when rendering multiple instances of primi‐
8239              tives in a single draw call. If Divisor is zero,  the  attribute
8240              at  slot Index advances once per vertex. If Divisor is non-zero,
8241              the attribute advances once per Divisor instances of the  set(s)
8242              of  vertices  being  rendered.  An  attribute  is referred to as
8243              instanced if its ?GL_VERTEX_ATTRIB_ARRAY_DIVISOR value  is  non-
8244              zero.
8245
8246              See external documentation.
8247
8248       minSampleShading(Value) -> ok
8249
8250              Types:
8251
8252                 Value = clamp()
8253
8254              Specifies minimum rate at which sample shaing takes place
8255
8256              gl:minSampleShading  specifies  the  rate  at  which samples are
8257              shaded within a covered pixel. Sample-rate shading is enabled by
8258              calling  gl:enable/1  with the parameter ?GL_SAMPLE_SHADING . If
8259              ?GL_MULTISAMPLE or ?GL_SAMPLE_SHADING is disabled, sample  shad‐
8260              ing  has no effect. Otherwise, an implementation must provide at
8261              least as many unique color values for each covered  fragment  as
8262              specified  by  Value times Samples where Samples is the value of
8263              ?GL_SAMPLES for the current framebuffer. At least 1  sample  for
8264              each covered fragment is generated.
8265
8266              See external documentation.
8267
8268       blendEquationi(Buf, Mode) -> ok
8269
8270              Types:
8271
8272                 Buf = integer()
8273                 Mode = enum()
8274
8275              See blendEquation/1
8276
8277       blendEquationSeparatei(Buf, ModeRGB, ModeAlpha) -> ok
8278
8279              Types:
8280
8281                 Buf = integer()
8282                 ModeRGB = enum()
8283                 ModeAlpha = enum()
8284
8285              See blendEquationSeparate/2
8286
8287       blendFunci(Buf, Src, Dst) -> ok
8288
8289              Types:
8290
8291                 Buf = integer()
8292                 Src = enum()
8293                 Dst = enum()
8294
8295              glBlendFunci
8296
8297              See external documentation.
8298
8299       blendFuncSeparatei(Buf, SrcRGB, DstRGB, SrcAlpha, DstAlpha) -> ok
8300
8301              Types:
8302
8303                 Buf = integer()
8304                 SrcRGB = enum()
8305                 DstRGB = enum()
8306                 SrcAlpha = enum()
8307                 DstAlpha = enum()
8308
8309              See blendFuncSeparate/4
8310
8311       loadTransposeMatrixfARB(M) -> ok
8312
8313              Types:
8314
8315                 M = matrix()
8316
8317              glLoadTransposeMatrixARB
8318
8319              See external documentation.
8320
8321       loadTransposeMatrixdARB(M) -> ok
8322
8323              Types:
8324
8325                 M = matrix()
8326
8327              glLoadTransposeMatrixARB
8328
8329              See external documentation.
8330
8331       multTransposeMatrixfARB(M) -> ok
8332
8333              Types:
8334
8335                 M = matrix()
8336
8337              glMultTransposeMatrixARB
8338
8339              See external documentation.
8340
8341       multTransposeMatrixdARB(M) -> ok
8342
8343              Types:
8344
8345                 M = matrix()
8346
8347              glMultTransposeMatrixARB
8348
8349              See external documentation.
8350
8351       weightbvARB(Weights) -> ok
8352
8353              Types:
8354
8355                 Weights = [integer()]
8356
8357              glWeightARB
8358
8359              See external documentation.
8360
8361       weightsvARB(Weights) -> ok
8362
8363              Types:
8364
8365                 Weights = [integer()]
8366
8367              glWeightARB
8368
8369              See external documentation.
8370
8371       weightivARB(Weights) -> ok
8372
8373              Types:
8374
8375                 Weights = [integer()]
8376
8377              glWeightARB
8378
8379              See external documentation.
8380
8381       weightfvARB(Weights) -> ok
8382
8383              Types:
8384
8385                 Weights = [float()]
8386
8387              glWeightARB
8388
8389              See external documentation.
8390
8391       weightdvARB(Weights) -> ok
8392
8393              Types:
8394
8395                 Weights = [float()]
8396
8397              glWeightARB
8398
8399              See external documentation.
8400
8401       weightubvARB(Weights) -> ok
8402
8403              Types:
8404
8405                 Weights = [integer()]
8406
8407              glWeightARB
8408
8409              See external documentation.
8410
8411       weightusvARB(Weights) -> ok
8412
8413              Types:
8414
8415                 Weights = [integer()]
8416
8417              glWeightARB
8418
8419              See external documentation.
8420
8421       weightuivARB(Weights) -> ok
8422
8423              Types:
8424
8425                 Weights = [integer()]
8426
8427              glWeightARB
8428
8429              See external documentation.
8430
8431       vertexBlendARB(Count) -> ok
8432
8433              Types:
8434
8435                 Count = integer()
8436
8437              glVertexBlenARB
8438
8439              See external documentation.
8440
8441       currentPaletteMatrixARB(Index) -> ok
8442
8443              Types:
8444
8445                 Index = integer()
8446
8447              glCurrentPaletteMatrixARB
8448
8449              See external documentation.
8450
8451       matrixIndexubvARB(Indices) -> ok
8452
8453              Types:
8454
8455                 Indices = [integer()]
8456
8457              glMatrixIndexARB
8458
8459              See external documentation.
8460
8461       matrixIndexusvARB(Indices) -> ok
8462
8463              Types:
8464
8465                 Indices = [integer()]
8466
8467              glMatrixIndexARB
8468
8469              See external documentation.
8470
8471       matrixIndexuivARB(Indices) -> ok
8472
8473              Types:
8474
8475                 Indices = [integer()]
8476
8477              glMatrixIndexARB
8478
8479              See external documentation.
8480
8481       programStringARB(Target, Format, String) -> ok
8482
8483              Types:
8484
8485                 Target = enum()
8486                 Format = enum()
8487                 String = string()
8488
8489              glProgramStringARB
8490
8491              See external documentation.
8492
8493       bindProgramARB(Target, Program) -> ok
8494
8495              Types:
8496
8497                 Target = enum()
8498                 Program = integer()
8499
8500              glBindProgramARB
8501
8502              See external documentation.
8503
8504       deleteProgramsARB(Programs) -> ok
8505
8506              Types:
8507
8508                 Programs = [integer()]
8509
8510              glDeleteProgramsARB
8511
8512              See external documentation.
8513
8514       genProgramsARB(N) -> [integer()]
8515
8516              Types:
8517
8518                 N = integer()
8519
8520              glGenProgramsARB
8521
8522              See external documentation.
8523
8524       programEnvParameter4dARB(Target, Index, X, Y, Z, W) -> ok
8525
8526              Types:
8527
8528                 Target = enum()
8529                 Index = integer()
8530                 X = float()
8531                 Y = float()
8532                 Z = float()
8533                 W = float()
8534
8535              glProgramEnvParameterARB
8536
8537              See external documentation.
8538
8539       programEnvParameter4dvARB(Target, Index, Params) -> ok
8540
8541              Types:
8542
8543                 Target = enum()
8544                 Index = integer()
8545                 Params = {float(), float(), float(), float()}
8546
8547              glProgramEnvParameterARB
8548
8549              See external documentation.
8550
8551       programEnvParameter4fARB(Target, Index, X, Y, Z, W) -> ok
8552
8553              Types:
8554
8555                 Target = enum()
8556                 Index = integer()
8557                 X = float()
8558                 Y = float()
8559                 Z = float()
8560                 W = float()
8561
8562              glProgramEnvParameterARB
8563
8564              See external documentation.
8565
8566       programEnvParameter4fvARB(Target, Index, Params) -> ok
8567
8568              Types:
8569
8570                 Target = enum()
8571                 Index = integer()
8572                 Params = {float(), float(), float(), float()}
8573
8574              glProgramEnvParameterARB
8575
8576              See external documentation.
8577
8578       programLocalParameter4dARB(Target, Index, X, Y, Z, W) -> ok
8579
8580              Types:
8581
8582                 Target = enum()
8583                 Index = integer()
8584                 X = float()
8585                 Y = float()
8586                 Z = float()
8587                 W = float()
8588
8589              glProgramLocalParameterARB
8590
8591              See external documentation.
8592
8593       programLocalParameter4dvARB(Target, Index, Params) -> ok
8594
8595              Types:
8596
8597                 Target = enum()
8598                 Index = integer()
8599                 Params = {float(), float(), float(), float()}
8600
8601              glProgramLocalParameterARB
8602
8603              See external documentation.
8604
8605       programLocalParameter4fARB(Target, Index, X, Y, Z, W) -> ok
8606
8607              Types:
8608
8609                 Target = enum()
8610                 Index = integer()
8611                 X = float()
8612                 Y = float()
8613                 Z = float()
8614                 W = float()
8615
8616              glProgramLocalParameterARB
8617
8618              See external documentation.
8619
8620       programLocalParameter4fvARB(Target, Index, Params) -> ok
8621
8622              Types:
8623
8624                 Target = enum()
8625                 Index = integer()
8626                 Params = {float(), float(), float(), float()}
8627
8628              glProgramLocalParameterARB
8629
8630              See external documentation.
8631
8632       getProgramEnvParameterdvARB(Target,   Index)   ->   {float(),  float(),
8633       float(), float()}
8634
8635              Types:
8636
8637                 Target = enum()
8638                 Index = integer()
8639
8640              glGetProgramEnvParameterARB
8641
8642              See external documentation.
8643
8644       getProgramEnvParameterfvARB(Target,  Index)   ->   {float(),   float(),
8645       float(), float()}
8646
8647              Types:
8648
8649                 Target = enum()
8650                 Index = integer()
8651
8652              glGetProgramEnvParameterARB
8653
8654              See external documentation.
8655
8656       getProgramLocalParameterdvARB(Target,   Index)  ->  {float(),  float(),
8657       float(), float()}
8658
8659              Types:
8660
8661                 Target = enum()
8662                 Index = integer()
8663
8664              glGetProgramLocalParameterARB
8665
8666              See external documentation.
8667
8668       getProgramLocalParameterfvARB(Target,  Index)  ->  {float(),   float(),
8669       float(), float()}
8670
8671              Types:
8672
8673                 Target = enum()
8674                 Index = integer()
8675
8676              glGetProgramLocalParameterARB
8677
8678              See external documentation.
8679
8680       getProgramStringARB(Target, Pname, String) -> ok
8681
8682              Types:
8683
8684                 Target = enum()
8685                 Pname = enum()
8686                 String = mem()
8687
8688              glGetProgramStringARB
8689
8690              See external documentation.
8691
8692       getBufferParameterivARB(Target, Pname) -> [integer()]
8693
8694              Types:
8695
8696                 Target = enum()
8697                 Pname = enum()
8698
8699              glGetBufferParameterARB
8700
8701              See external documentation.
8702
8703       deleteObjectARB(Obj) -> ok
8704
8705              Types:
8706
8707                 Obj = integer()
8708
8709              glDeleteObjectARB
8710
8711              See external documentation.
8712
8713       getHandleARB(Pname) -> integer()
8714
8715              Types:
8716
8717                 Pname = enum()
8718
8719              glGetHandleARB
8720
8721              See external documentation.
8722
8723       detachObjectARB(ContainerObj, AttachedObj) -> ok
8724
8725              Types:
8726
8727                 ContainerObj = integer()
8728                 AttachedObj = integer()
8729
8730              glDetachObjectARB
8731
8732              See external documentation.
8733
8734       createShaderObjectARB(ShaderType) -> integer()
8735
8736              Types:
8737
8738                 ShaderType = enum()
8739
8740              glCreateShaderObjectARB
8741
8742              See external documentation.
8743
8744       shaderSourceARB(ShaderObj, String) -> ok
8745
8746              Types:
8747
8748                 ShaderObj = integer()
8749                 String = iolist()
8750
8751              glShaderSourceARB
8752
8753              See external documentation.
8754
8755       compileShaderARB(ShaderObj) -> ok
8756
8757              Types:
8758
8759                 ShaderObj = integer()
8760
8761              glCompileShaderARB
8762
8763              See external documentation.
8764
8765       createProgramObjectARB() -> integer()
8766
8767              glCreateProgramObjectARB
8768
8769              See external documentation.
8770
8771       attachObjectARB(ContainerObj, Obj) -> ok
8772
8773              Types:
8774
8775                 ContainerObj = integer()
8776                 Obj = integer()
8777
8778              glAttachObjectARB
8779
8780              See external documentation.
8781
8782       linkProgramARB(ProgramObj) -> ok
8783
8784              Types:
8785
8786                 ProgramObj = integer()
8787
8788              glLinkProgramARB
8789
8790              See external documentation.
8791
8792       useProgramObjectARB(ProgramObj) -> ok
8793
8794              Types:
8795
8796                 ProgramObj = integer()
8797
8798              glUseProgramObjectARB
8799
8800              See external documentation.
8801
8802       validateProgramARB(ProgramObj) -> ok
8803
8804              Types:
8805
8806                 ProgramObj = integer()
8807
8808              glValidateProgramARB
8809
8810              See external documentation.
8811
8812       getObjectParameterfvARB(Obj, Pname) -> float()
8813
8814              Types:
8815
8816                 Obj = integer()
8817                 Pname = enum()
8818
8819              glGetObjectParameterARB
8820
8821              See external documentation.
8822
8823       getObjectParameterivARB(Obj, Pname) -> integer()
8824
8825              Types:
8826
8827                 Obj = integer()
8828                 Pname = enum()
8829
8830              glGetObjectParameterARB
8831
8832              See external documentation.
8833
8834       getInfoLogARB(Obj, MaxLength) -> string()
8835
8836              Types:
8837
8838                 Obj = integer()
8839                 MaxLength = integer()
8840
8841              glGetInfoLogARB
8842
8843              See external documentation.
8844
8845       getAttachedObjectsARB(ContainerObj, MaxCount) -> [integer()]
8846
8847              Types:
8848
8849                 ContainerObj = integer()
8850                 MaxCount = integer()
8851
8852              glGetAttachedObjectsARB
8853
8854              See external documentation.
8855
8856       getUniformLocationARB(ProgramObj, Name) -> integer()
8857
8858              Types:
8859
8860                 ProgramObj = integer()
8861                 Name = string()
8862
8863              glGetUniformLocationARB
8864
8865              See external documentation.
8866
8867       getActiveUniformARB(ProgramObj,  Index, MaxLength) -> {Size::integer(),
8868       Type::enum(), Name::string()}
8869
8870              Types:
8871
8872                 ProgramObj = integer()
8873                 Index = integer()
8874                 MaxLength = integer()
8875
8876              glGetActiveUniformARB
8877
8878              See external documentation.
8879
8880       getUniformfvARB(ProgramObj, Location) -> matrix()
8881
8882              Types:
8883
8884                 ProgramObj = integer()
8885                 Location = integer()
8886
8887              glGetUniformARB
8888
8889              See external documentation.
8890
8891       getUniformivARB(ProgramObj, Location) -> {integer(),  integer(),  inte‐
8892       ger(),  integer(),  integer(),  integer(),  integer(), integer(), inte‐
8893       ger(), integer(), integer(),  integer(),  integer(),  integer(),  inte‐
8894       ger(), integer()}
8895
8896              Types:
8897
8898                 ProgramObj = integer()
8899                 Location = integer()
8900
8901              glGetUniformARB
8902
8903              See external documentation.
8904
8905       getShaderSourceARB(Obj, MaxLength) -> string()
8906
8907              Types:
8908
8909                 Obj = integer()
8910                 MaxLength = integer()
8911
8912              glGetShaderSourceARB
8913
8914              See external documentation.
8915
8916       bindAttribLocationARB(ProgramObj, Index, Name) -> ok
8917
8918              Types:
8919
8920                 ProgramObj = integer()
8921                 Index = integer()
8922                 Name = string()
8923
8924              glBindAttribLocationARB
8925
8926              See external documentation.
8927
8928       getActiveAttribARB(ProgramObj,  Index,  MaxLength) -> {Size::integer(),
8929       Type::enum(), Name::string()}
8930
8931              Types:
8932
8933                 ProgramObj = integer()
8934                 Index = integer()
8935                 MaxLength = integer()
8936
8937              glGetActiveAttribARB
8938
8939              See external documentation.
8940
8941       getAttribLocationARB(ProgramObj, Name) -> integer()
8942
8943              Types:
8944
8945                 ProgramObj = integer()
8946                 Name = string()
8947
8948              glGetAttribLocationARB
8949
8950              See external documentation.
8951
8952       isRenderbuffer(Renderbuffer) -> 0 | 1
8953
8954              Types:
8955
8956                 Renderbuffer = integer()
8957
8958              Determine if a name corresponds to a renderbuffer object
8959
8960              gl:isRenderbuffer returns ?GL_TRUE if Renderbuffer is  currently
8961              the  name  of a renderbuffer object. If Renderbuffer is zero, or
8962              if Renderbuffer is not the name of a renderbuffer object, or  if
8963              an error occurs, gl:isRenderbuffer returns ?GL_FALSE. If Render‐
8964              buffer is a name returned by gl:genRenderbuffers/1 , by that has
8965              not  yet  been  bound through a call to gl:bindRenderbuffer/2 or
8966              gl:framebufferRenderbuffer/4 , then the name is  not  a  render‐
8967              buffer object and gl:isRenderbuffer returns ?GL_FALSE .
8968
8969              See external documentation.
8970
8971       bindRenderbuffer(Target, Renderbuffer) -> ok
8972
8973              Types:
8974
8975                 Target = enum()
8976                 Renderbuffer = integer()
8977
8978              Bind a renderbuffer to a renderbuffer target
8979
8980              gl:bindRenderbuffer binds the renderbuffer object with name Ren‐
8981              derbuffer to the renderbuffer target specified by Target .  Tar‐
8982              get  must  be  ?GL_RENDERBUFFER  . Renderbuffer is the name of a
8983              renderbuffer object previously returned from a call  to  gl:gen‐
8984              Renderbuffers/1  ,  or  zero  to break the existing binding of a
8985              renderbuffer object to Target .
8986
8987              See external documentation.
8988
8989       deleteRenderbuffers(Renderbuffers) -> ok
8990
8991              Types:
8992
8993                 Renderbuffers = [integer()]
8994
8995              Delete renderbuffer objects
8996
8997              gl:deleteRenderbuffers deletes the N renderbuffer objects  whose
8998              names  are  stored in the array addressed by Renderbuffers . The
8999              name zero is reserved by the GL and is silently ignored,  should
9000              it  occur  in  Renderbuffers , as are other unused names. Once a
9001              renderbuffer object is deleted, its name is again unused and  it
9002              has  no  contents.  If a renderbuffer that is currently bound to
9003              the target ?GL_RENDERBUFFER is deleted, it is as though  gl:bin‐
9004              dRenderbuffer/2  had  been executed with a Target of ?GL_RENDER‐
9005              BUFFER and a Name of zero.
9006
9007              See external documentation.
9008
9009       genRenderbuffers(N) -> [integer()]
9010
9011              Types:
9012
9013                 N = integer()
9014
9015              Generate renderbuffer object names
9016
9017              gl:genRenderbuffers returns N renderbuffer object names in  Ren‐
9018              derbuffers  .  There  is no guarantee that the names form a con‐
9019              tiguous set of integers; however, it is guaranteed that none  of
9020              the  returned  names  was  in use immediately before the call to
9021              gl:genRenderbuffers .
9022
9023              See external documentation.
9024
9025       renderbufferStorage(Target, Internalformat, Width, Height) -> ok
9026
9027              Types:
9028
9029                 Target = enum()
9030                 Internalformat = enum()
9031                 Width = integer()
9032                 Height = integer()
9033
9034              Establish data storage, format and dimensions of a  renderbuffer
9035              object's image
9036
9037              gl:renderbufferStorage is equivalent to calling gl:renderbuffer‐
9038              StorageMultisample/5 with the Samples set to zero.
9039
9040              See external documentation.
9041
9042       getRenderbufferParameteriv(Target, Pname) -> integer()
9043
9044              Types:
9045
9046                 Target = enum()
9047                 Pname = enum()
9048
9049              Retrieve information about a bound renderbuffer object
9050
9051              gl:getRenderbufferParameteriv  retrieves  information  about   a
9052              bound  renderbuffer  object.  Target specifies the target of the
9053              query operation and must be ?GL_RENDERBUFFER .  Pname  specifies
9054              the  parameter  whose value to query and must be one of ?GL_REN‐
9055              DERBUFFER_WIDTH    ,    ?GL_RENDERBUFFER_HEIGHT,     ?GL_RENDER‐
9056              BUFFER_INTERNAL_FORMAT,  ?GL_RENDERBUFFER_RED_SIZE , ?GL_RENDER‐
9057              BUFFER_GREEN_SIZE,    ?GL_RENDERBUFFER_BLUE_SIZE,    ?GL_RENDER‐
9058              BUFFER_ALPHA_SIZE   ,  ?GL_RENDERBUFFER_DEPTH_SIZE,  ?GL_RENDER‐
9059              BUFFER_DEPTH_SIZE, ?GL_RENDERBUFFER_STENCIL_SIZE ,  or  ?GL_REN‐
9060              DERBUFFER_SAMPLES.
9061
9062              See external documentation.
9063
9064       isFramebuffer(Framebuffer) -> 0 | 1
9065
9066              Types:
9067
9068                 Framebuffer = integer()
9069
9070              Determine if a name corresponds to a framebuffer object
9071
9072              gl:isFramebuffer  returns  ?GL_TRUE  if Framebuffer is currently
9073              the name of a framebuffer object. If Framebuffer is zero, or  if
9074              ?framebuffer  is  not the name of a framebuffer object, or if an
9075              error occurs, gl:isFramebuffer returns ?GL_FALSE. If Framebuffer
9076              is a name returned by gl:genFramebuffers/1 , by that has not yet
9077              been bound through a call to  gl:bindFramebuffer/2  ,  then  the
9078              name  is  not  a framebuffer object and gl:isFramebuffer returns
9079              ?GL_FALSE.
9080
9081              See external documentation.
9082
9083       bindFramebuffer(Target, Framebuffer) -> ok
9084
9085              Types:
9086
9087                 Target = enum()
9088                 Framebuffer = integer()
9089
9090              Bind a framebuffer to a framebuffer target
9091
9092              gl:bindFramebuffer binds the framebuffer object with name Frame‐
9093              buffer  to  the  framebuffer target specified by Target . Target
9094              must be either ?GL_DRAW_FRAMEBUFFER  ,  ?GL_READ_FRAMEBUFFER  or
9095              ?GL_FRAMEBUFFER.   If   a   framebuffer   object   is  bound  to
9096              ?GL_DRAW_FRAMEBUFFER or  ?GL_READ_FRAMEBUFFER,  it  becomes  the
9097              target for rendering or readback operations, respectively, until
9098              it is deleted or another framebuffer is bound to the correspond‐
9099              ing  bind  point.  Calling gl:bindFramebuffer with Target set to
9100              ?GL_FRAMEBUFFER binds Framebuffer to  both  the  read  and  draw
9101              framebuffer  targets.  Framebuffer  is the name of a framebuffer
9102              object previously returned from a call to gl:genFramebuffers/1 ,
9103              or zero to break the existing binding of a framebuffer object to
9104              Target .
9105
9106              See external documentation.
9107
9108       deleteFramebuffers(Framebuffers) -> ok
9109
9110              Types:
9111
9112                 Framebuffers = [integer()]
9113
9114              Delete framebuffer objects
9115
9116              gl:deleteFramebuffers deletes the N  framebuffer  objects  whose
9117              names  are  stored  in the array addressed by Framebuffers . The
9118              name zero is reserved by the GL and is silently ignored,  should
9119              it  occur  in  Framebuffers  , as are other unused names. Once a
9120              framebuffer object is deleted, its name is again unused  and  it
9121              has  no attachments. If a framebuffer that is currently bound to
9122              one   or   more   of   the   targets   ?GL_DRAW_FRAMEBUFFER   or
9123              ?GL_READ_FRAMEBUFFER  is  deleted, it is as though gl:bindFrame‐
9124              buffer/2 had been executed with  the  corresponding  Target  and
9125              Framebuffer zero.
9126
9127              See external documentation.
9128
9129       genFramebuffers(N) -> [integer()]
9130
9131              Types:
9132
9133                 N = integer()
9134
9135              Generate framebuffer object names
9136
9137              gl:genFramebuffers  returns  N framebuffer object names in Ids .
9138              There is no guarantee that the names form a  contiguous  set  of
9139              integers;  however,  it  is guaranteed that none of the returned
9140              names was in use immediately before  the  call  to  gl:genFrame‐
9141              buffers .
9142
9143              See external documentation.
9144
9145       checkFramebufferStatus(Target) -> enum()
9146
9147              Types:
9148
9149                 Target = enum()
9150
9151              Check the completeness status of a framebuffer
9152
9153              gl:checkFramebufferStatus queries the completeness status of the
9154              framebuffer object currently bound to Target .  Target  must  be
9155              ?GL_DRAW_FRAMEBUFFER,  ?GL_READ_FRAMEBUFFER  or ?GL_FRAMEBUFFER.
9156              ?GL_FRAMEBUFFER is equivalent to ?GL_DRAW_FRAMEBUFFER .
9157
9158              See external documentation.
9159
9160       framebufferTexture1D(Target, Attachment, Textarget, Texture, Level)  ->
9161       ok
9162
9163              Types:
9164
9165                 Target = enum()
9166                 Attachment = enum()
9167                 Textarget = enum()
9168                 Texture = integer()
9169                 Level = integer()
9170
9171              See framebufferTexture/4
9172
9173       framebufferTexture2D(Target,  Attachment, Textarget, Texture, Level) ->
9174       ok
9175
9176              Types:
9177
9178                 Target = enum()
9179                 Attachment = enum()
9180                 Textarget = enum()
9181                 Texture = integer()
9182                 Level = integer()
9183
9184              See framebufferTexture/4
9185
9186       framebufferTexture3D(Target,  Attachment,  Textarget,  Texture,  Level,
9187       Zoffset) -> ok
9188
9189              Types:
9190
9191                 Target = enum()
9192                 Attachment = enum()
9193                 Textarget = enum()
9194                 Texture = integer()
9195                 Level = integer()
9196                 Zoffset = integer()
9197
9198              See framebufferTexture/4
9199
9200       framebufferRenderbuffer(Target, Attachment, Renderbuffertarget, Render‐
9201       buffer) -> ok
9202
9203              Types:
9204
9205                 Target = enum()
9206                 Attachment = enum()
9207                 Renderbuffertarget = enum()
9208                 Renderbuffer = integer()
9209
9210              Attach a renderbuffer as a logical buffer to the currently bound
9211              framebuffer object
9212
9213              gl:framebufferRenderbuffer attaches a renderbuffer as one of the
9214              logical buffers of the currently bound framebuffer object.  Ren‐
9215              derbuffer  is  the name of the renderbuffer object to attach and
9216              must be either zero, or the name  of  an  existing  renderbuffer
9217              object  of type Renderbuffertarget . If Renderbuffer is not zero
9218              and if gl:framebufferRenderbuffer is successful, then  the  ren‐
9219              derbuffer  name  Renderbuffer will be used as the logical buffer
9220              identified by Attachment of the framebuffer currently  bound  to
9221              Target .
9222
9223              See external documentation.
9224
9225       getFramebufferAttachmentParameteriv(Target, Attachment, Pname) -> inte‐
9226       ger()
9227
9228              Types:
9229
9230                 Target = enum()
9231                 Attachment = enum()
9232                 Pname = enum()
9233
9234              Retrieve information about attachments of  a  bound  framebuffer
9235              object
9236
9237              gl:getFramebufferAttachmentParameter  returns  information about
9238              attachments of a bound framebuffer object. Target specifies  the
9239              framebuffer  binding  point  and  must  be ?GL_DRAW_FRAMEBUFFER,
9240              ?GL_READ_FRAMEBUFFER  or  ?GL_FRAMEBUFFER.  ?GL_FRAMEBUFFER   is
9241              equivalent to ?GL_DRAW_FRAMEBUFFER.
9242
9243              See external documentation.
9244
9245       generateMipmap(Target) -> ok
9246
9247              Types:
9248
9249                 Target = enum()
9250
9251              Generate mipmaps for a specified texture target
9252
9253              gl:generateMipmap  generates mipmaps for the texture attached to
9254              Target of the active texture unit.  For  cube  map  textures,  a
9255              ?GL_INVALID_OPERATION error is generated if the texture attached
9256              to Target is not cube complete.
9257
9258              See external documentation.
9259
9260       blitFramebuffer(SrcX0, SrcY0, SrcX1, SrcY1, DstX0, DstY0, DstX1, DstY1,
9261       Mask, Filter) -> ok
9262
9263              Types:
9264
9265                 SrcX0 = integer()
9266                 SrcY0 = integer()
9267                 SrcX1 = integer()
9268                 SrcY1 = integer()
9269                 DstX0 = integer()
9270                 DstY0 = integer()
9271                 DstX1 = integer()
9272                 DstY1 = integer()
9273                 Mask = integer()
9274                 Filter = enum()
9275
9276              Copy  a  block  of  pixels from the read framebuffer to the draw
9277              framebuffer
9278
9279              gl:blitFramebuffer transfers a rectangle of  pixel  values  from
9280              one region of the read framebuffer to another region in the draw
9281              framebuffer. Mask is the bitwise OR of a number of values  indi‐
9282              cating   which   buffers  are  to  be  copied.  The  values  are
9283              ?GL_COLOR_BUFFER_BIT  ,  ?GL_DEPTH_BUFFER_BIT,   and   ?GL_STEN‐
9284              CIL_BUFFER_BIT.  The  pixels  corresponding to these buffers are
9285              copied from the source rectangle  bounded  by  the  locations  (
9286              SrcX0 ; SrcY0 ) and ( SrcX1 ; SrcY1 ) to the destination rectan‐
9287              gle bounded by the locations ( DstX0 ; DstY0 )  and  (  DstX1  ;
9288              DstY1  ). The lower bounds of the rectangle are inclusive, while
9289              the upper bounds are exclusive.
9290
9291              See external documentation.
9292
9293       renderbufferStorageMultisample(Target, Samples, Internalformat,  Width,
9294       Height) -> ok
9295
9296              Types:
9297
9298                 Target = enum()
9299                 Samples = integer()
9300                 Internalformat = enum()
9301                 Width = integer()
9302                 Height = integer()
9303
9304              Establish data storage, format, dimensions and sample count of a
9305              renderbuffer object's image
9306
9307              gl:renderbufferStorageMultisample establishes the data  storage,
9308              format,  dimensions  and  number  of  samples  of a renderbuffer
9309              object's image.
9310
9311              See external documentation.
9312
9313       framebufferTextureLayer(Target, Attachment, Texture, Level,  Layer)  ->
9314       ok
9315
9316              Types:
9317
9318                 Target = enum()
9319                 Attachment = enum()
9320                 Texture = integer()
9321                 Level = integer()
9322                 Layer = integer()
9323
9324              See framebufferTexture/4
9325
9326       framebufferTextureFaceARB(Target,  Attachment, Texture, Level, Face) ->
9327       ok
9328
9329              Types:
9330
9331                 Target = enum()
9332                 Attachment = enum()
9333                 Texture = integer()
9334                 Level = integer()
9335                 Face = enum()
9336
9337              See framebufferTexture/4
9338
9339       flushMappedBufferRange(Target, Offset, Length) -> ok
9340
9341              Types:
9342
9343                 Target = enum()
9344                 Offset = integer()
9345                 Length = integer()
9346
9347              Indicate modifications to a range of a mapped buffer
9348
9349              gl:flushMappedBufferRange indicates that modifications have been
9350              made  to  a range of a mapped buffer. The buffer must previously
9351              have been mapped with the  ?GL_MAP_FLUSH_EXPLICIT  flag.  Offset
9352              and  Length  indicate  the  modified subrange of the mapping, in
9353              basic units. The specified subrange to flush is relative to  the
9354              start   of   the   currently   mapped   range   of  the  buffer.
9355              gl:flushMappedBufferRange may be called multiple times to  indi‐
9356              cate distinct subranges of the mapping which require flushing.
9357
9358              See external documentation.
9359
9360       bindVertexArray(Array) -> ok
9361
9362              Types:
9363
9364                 Array = integer()
9365
9366              Bind a vertex array object
9367
9368              gl:bindVertexArray binds the vertex array object with name Array
9369              . Array is the name of a vertex array object previously returned
9370              from  a  call  to  gl:genVertexArrays/1  ,  or zero to break the
9371              existing vertex array object binding.
9372
9373              See external documentation.
9374
9375       deleteVertexArrays(Arrays) -> ok
9376
9377              Types:
9378
9379                 Arrays = [integer()]
9380
9381              Delete vertex array objects
9382
9383              gl:deleteVertexArrays deletes N vertex array objects whose names
9384              are  stored  in  the  array  addressed by Arrays . Once a vertex
9385              array object is deleted it has no contents and its name is again
9386              unused.  If  a  vertex  array  object that is currently bound is
9387              deleted, the binding for that object reverts  to  zero  and  the
9388              default vertex array becomes current. Unused names in Arrays are
9389              silently ignored, as is the value zero.
9390
9391              See external documentation.
9392
9393       genVertexArrays(N) -> [integer()]
9394
9395              Types:
9396
9397                 N = integer()
9398
9399              Generate vertex array object names
9400
9401              gl:genVertexArrays returns N vertex array object names in Arrays
9402              .  There is no guarantee that the names form a contiguous set of
9403              integers; however, it is guaranteed that none  of  the  returned
9404              names  was in use immediately before the call to gl:genVertexAr‐
9405              rays .
9406
9407              See external documentation.
9408
9409       isVertexArray(Array) -> 0 | 1
9410
9411              Types:
9412
9413                 Array = integer()
9414
9415              Determine if a name corresponds to a vertex array object
9416
9417              gl:isVertexArray returns ?GL_TRUE if Array is currently the name
9418              of  a  renderbuffer object. If Renderbuffer is zero, or if Array
9419              is not the name of a renderbuffer object, or if an error occurs,
9420              gl:isVertexArray returns ?GL_FALSE . If Array is a name returned
9421              by gl:genVertexArrays/1 , by that has not yet been bound through
9422              a  call  to gl:bindVertexArray/1 , then the name is not a vertex
9423              array object and gl:isVertexArray returns ?GL_FALSE.
9424
9425              See external documentation.
9426
9427       getUniformIndices(Program, UniformNames) -> [integer()]
9428
9429              Types:
9430
9431                 Program = integer()
9432                 UniformNames = iolist()
9433
9434              Retrieve the index of a named uniform block
9435
9436              gl:getUniformIndices retrieves the indices of a number  of  uni‐
9437              forms within Program .
9438
9439              See external documentation.
9440
9441       getActiveUniformsiv(Program, UniformIndices, Pname) -> [integer()]
9442
9443              Types:
9444
9445                 Program = integer()
9446                 UniformIndices = [integer()]
9447                 Pname = enum()
9448
9449              glGetActiveUniforms
9450
9451              See external documentation.
9452
9453       getActiveUniformName(Program, UniformIndex, BufSize) -> string()
9454
9455              Types:
9456
9457                 Program = integer()
9458                 UniformIndex = integer()
9459                 BufSize = integer()
9460
9461              Query the name of an active uniform
9462
9463              gl:getActiveUniformName  returns  the name of the active uniform
9464              at UniformIndex within Program . If UniformName is not NULL,  up
9465              to BufSize characters (including a nul-terminator) will be writ‐
9466              ten into the array whose address is specified by  UniformName  .
9467              If  Length  is  not NULL, the number of characters that were (or
9468              would have been) written into  UniformName  (not  including  the
9469              nul-terminator)  will be placed in the variable whose address is
9470              specified in Length . If Length is NULL, no length is  returned.
9471              The  length  of  the longest uniform name in Program is given by
9472              the value of ?GL_ACTIVE_UNIFORM_MAX_LENGTH, which can be queried
9473              with gl:getProgramiv/2 .
9474
9475              See external documentation.
9476
9477       getUniformBlockIndex(Program, UniformBlockName) -> integer()
9478
9479              Types:
9480
9481                 Program = integer()
9482                 UniformBlockName = string()
9483
9484              Retrieve the index of a named uniform block
9485
9486              gl:getUniformBlockIndex  retrieves  the index of a uniform block
9487              within Program .
9488
9489              See external documentation.
9490
9491       getActiveUniformBlockiv(Program, UniformBlockIndex, Pname,  Params)  ->
9492       ok
9493
9494              Types:
9495
9496                 Program = integer()
9497                 UniformBlockIndex = integer()
9498                 Pname = enum()
9499                 Params = mem()
9500
9501              Query information about an active uniform block
9502
9503              gl:getActiveUniformBlockiv retrieves information about an active
9504              uniform block within Program .
9505
9506              See external documentation.
9507
9508       getActiveUniformBlockName(Program,   UniformBlockIndex,   BufSize)   ->
9509       string()
9510
9511              Types:
9512
9513                 Program = integer()
9514                 UniformBlockIndex = integer()
9515                 BufSize = integer()
9516
9517              Retrieve the name of an active uniform block
9518
9519              gl:getActiveUniformBlockName  retrieves  the  name of the active
9520              uniform block at UniformBlockIndex within Program .
9521
9522              See external documentation.
9523
9524       uniformBlockBinding(Program, UniformBlockIndex, UniformBlockBinding) ->
9525       ok
9526
9527              Types:
9528
9529                 Program = integer()
9530                 UniformBlockIndex = integer()
9531                 UniformBlockBinding = integer()
9532
9533              Assign a binding point to an active uniform block
9534
9535              Binding  points  for  active  uniform  blocks are assigned using
9536              gl:uniformBlockBinding.  Each  of  a  program's  active  uniform
9537              blocks has a corresponding uniform buffer binding point. Program
9538              is  the  name  of  a  program  object  for  which  the   command
9539              gl:linkProgram/1 has been issued in the past.
9540
9541              See external documentation.
9542
9543       copyBufferSubData(ReadTarget,   WriteTarget,  ReadOffset,  WriteOffset,
9544       Size) -> ok
9545
9546              Types:
9547
9548                 ReadTarget = enum()
9549                 WriteTarget = enum()
9550                 ReadOffset = integer()
9551                 WriteOffset = integer()
9552                 Size = integer()
9553
9554              Copy part of the data store of a buffer object to the data store
9555              of another buffer object
9556
9557              gl:copyBufferSubData  copies  part of the data store attached to
9558              Readtarget to the data store attached to Writetarget . The  num‐
9559              ber  of basic machine units indicated by Size is copied from the
9560              source, at offset Readoffset to the destination at Writeoffset ,
9561              also in basic machine units.
9562
9563              See external documentation.
9564
9565       drawElementsBaseVertex(Mode, Count, Type, Indices, Basevertex) -> ok
9566
9567              Types:
9568
9569                 Mode = enum()
9570                 Count = integer()
9571                 Type = enum()
9572                 Indices = offset() | mem()
9573                 Basevertex = integer()
9574
9575              Render primitives from array data with a per-element offset
9576
9577              gl:drawElementsBaseVertex  behaves  identically  to  gl:drawEle‐
9578              ments/4 except that the ith element transferred  by  the  corre‐
9579              sponding  draw  call  will  be  taken from element Indices [i] +
9580              Basevertex of each enabled array.  If  the  resulting  value  is
9581              larger  than  the maximum value representable by Type , it is as
9582              if the calculation were upconverted to 32-bit unsigned  integers
9583              (with  wrapping  on overflow conditions). The operation is unde‐
9584              fined if the sum would be negative.
9585
9586              See external documentation.
9587
9588       drawRangeElementsBaseVertex(Mode, Start,  End,  Count,  Type,  Indices,
9589       Basevertex) -> ok
9590
9591              Types:
9592
9593                 Mode = enum()
9594                 Start = integer()
9595                 End = integer()
9596                 Count = integer()
9597                 Type = enum()
9598                 Indices = offset() | mem()
9599                 Basevertex = integer()
9600
9601              Render primitives from array data with a per-element offset
9602
9603              gl:drawRangeElementsBaseVertex   is   a   restricted   form   of
9604              gl:drawElementsBaseVertex/5 . Mode , Start ,  End  ,  Count  and
9605              Basevertex match the corresponding arguments to gl:drawElements‐
9606              BaseVertex/5 , with the additional constraint that all values in
9607              the  array  Indices  must lie between Start and End , inclusive,
9608              prior to adding Basevertex .  Index  values  lying  outside  the
9609              range [ Start , End ] are treated in the same way as gl:drawEle‐
9610              mentsBaseVertex/5 . The i th element transferred by  the  corre‐
9611              sponding  draw  call  will  be  taken from element Indices [i] +
9612              Basevertex of each enabled array.  If  the  resulting  value  is
9613              larger  than  the maximum value representable by Type , it is as
9614              if the calculation were upconverted to 32-bit unsigned  integers
9615              (with  wrapping  on overflow conditions). The operation is unde‐
9616              fined if the sum would be negative.
9617
9618              See external documentation.
9619
9620       drawElementsInstancedBaseVertex(Mode, Count, Type, Indices,  Primcount,
9621       Basevertex) -> ok
9622
9623              Types:
9624
9625                 Mode = enum()
9626                 Count = integer()
9627                 Type = enum()
9628                 Indices = offset() | mem()
9629                 Primcount = integer()
9630                 Basevertex = integer()
9631
9632              Render multiple instances of a set of primitives from array data
9633              with a per-element offset
9634
9635              gl:drawElementsInstancedBaseVertex   behaves   identically    to
9636              gl:drawElementsInstanced/5  except  that  the ith element trans‐
9637              ferred by the corresponding draw call will be taken from element
9638              Indices [i] + Basevertex of each enabled array. If the resulting
9639              value is larger than the maximum value representable by  Type  ,
9640              it  is as if the calculation were upconverted to 32-bit unsigned
9641              integers (with wrapping on overflow conditions).  The  operation
9642              is undefined if the sum would be negative.
9643
9644              See external documentation.
9645
9646       provokingVertex(Mode) -> ok
9647
9648              Types:
9649
9650                 Mode = enum()
9651
9652              Specifiy  the  vertex  to be used as the source of data for flat
9653              shaded varyings
9654
9655              Flatshading a vertex shader varying output means to  assign  all
9656              vetices  of  the  primitive  the same value for that output. The
9657              vertex from which these values is derived is known as  the  pro‐
9658              voking  vertex  and gl:provokingVertex specifies which vertex is
9659              to be used as the source of data for flat shaded varyings.
9660
9661              See external documentation.
9662
9663       fenceSync(Condition, Flags) -> integer()
9664
9665              Types:
9666
9667                 Condition = enum()
9668                 Flags = integer()
9669
9670              Create a new sync object and  insert  it  into  the  GL  command
9671              stream
9672
9673              gl:fenceSync  creates  a  new fence sync object, inserts a fence
9674              command into the GL command stream and associates it  with  that
9675              sync  object,  and  returns a non-zero name corresponding to the
9676              sync object.
9677
9678              See external documentation.
9679
9680       isSync(Sync) -> 0 | 1
9681
9682              Types:
9683
9684                 Sync = integer()
9685
9686              Determine if a name corresponds to a sync object
9687
9688              gl:isSync returns ?GL_TRUE if Sync is currently the  name  of  a
9689              sync  object. If Sync is not the name of a sync object, or if an
9690              error occurs, gl:isSync returns ?GL_FALSE. Note that zero is not
9691              the name of a sync object.
9692
9693              See external documentation.
9694
9695       deleteSync(Sync) -> ok
9696
9697              Types:
9698
9699                 Sync = integer()
9700
9701              Delete a sync object
9702
9703              gl:deleteSync deletes the sync object specified by Sync . If the
9704              fence command corresponding to the  specified  sync  object  has
9705              completed,  or  if  no gl:waitSync/3 or gl:clientWaitSync/3 com‐
9706              mands are blocking on Sync , the object is deleted  immediately.
9707              Otherwise, Sync is flagged for deletion and will be deleted when
9708              it is no longer associated with any  fence  command  and  is  no
9709              longer  blocking  any  gl:waitSync/3 or gl:clientWaitSync/3 com‐
9710              mand. In either case, after gl:deleteSync returns, the name Sync
9711              is  invalid  and  can  no  longer  be  used to refer to the sync
9712              object.
9713
9714              See external documentation.
9715
9716       clientWaitSync(Sync, Flags, Timeout) -> enum()
9717
9718              Types:
9719
9720                 Sync = integer()
9721                 Flags = integer()
9722                 Timeout = integer()
9723
9724              Block and wait for a sync object to become signaled
9725
9726              gl:clientWaitSync causes the client to block and  wait  for  the
9727              sync  object  specified  by  Sync to become signaled. If Sync is
9728              signaled when  gl:clientWaitSync  is  called,  gl:clientWaitSync
9729              returns  immediately, otherwise it will block and wait for up to
9730              Timeout nanoseconds for Sync to become signaled.
9731
9732              See external documentation.
9733
9734       waitSync(Sync, Flags, Timeout) -> ok
9735
9736              Types:
9737
9738                 Sync = integer()
9739                 Flags = integer()
9740                 Timeout = integer()
9741
9742              Instruct the GL server to block until the specified sync  object
9743              becomes signaled
9744
9745              gl:waitSync  causes  the  GL server to block and wait until Sync
9746              becomes signaled. Sync is the name of an  existing  sync  object
9747              upon which to wait. Flags and Timeout are currently not used and
9748              must be set to zero and the special value ?GL_TIMEOUT_IGNORED  ,
9749              respectively
9750
9751              Flags and Timeout are placeholders for anticipated future exten‐
9752              sions of sync object capabilities. They must have these reserved
9753              values  in  order that existing code calling gl:waitSync operate
9754              properly in the presence of such extensions.
9755
9756              See external documentation.
9757
9758       getInteger64v(Pname) -> [integer()]
9759
9760              Types:
9761
9762                 Pname = enum()
9763
9764              See getBooleanv/1
9765
9766       getSynciv(Sync, Pname, BufSize) -> [integer()]
9767
9768              Types:
9769
9770                 Sync = integer()
9771                 Pname = enum()
9772                 BufSize = integer()
9773
9774              Query the properties of a sync object
9775
9776              gl:getSynciv retrieves properties of a sync object. Sync  speci‐
9777              fies the name of the sync object whose properties to retrieve.
9778
9779              See external documentation.
9780
9781       texImage2DMultisample(Target,  Samples,  Internalformat, Width, Height,
9782       Fixedsamplelocations) -> ok
9783
9784              Types:
9785
9786                 Target = enum()
9787                 Samples = integer()
9788                 Internalformat = integer()
9789                 Width = integer()
9790                 Height = integer()
9791                 Fixedsamplelocations = 0 | 1
9792
9793              Establish the data storage, format, dimensions,  and  number  of
9794              samples of a multisample texture's image
9795
9796              gl:texImage2DMultisample  establishes  the data storage, format,
9797              dimensions and number of  samples  of  a  multisample  texture's
9798              image.
9799
9800              See external documentation.
9801
9802       texImage3DMultisample(Target,  Samples,  Internalformat, Width, Height,
9803       Depth, Fixedsamplelocations) -> ok
9804
9805              Types:
9806
9807                 Target = enum()
9808                 Samples = integer()
9809                 Internalformat = integer()
9810                 Width = integer()
9811                 Height = integer()
9812                 Depth = integer()
9813                 Fixedsamplelocations = 0 | 1
9814
9815              Establish the data storage, format, dimensions,  and  number  of
9816              samples of a multisample texture's image
9817
9818              gl:texImage3DMultisample  establishes  the data storage, format,
9819              dimensions and number of  samples  of  a  multisample  texture's
9820              image.
9821
9822              See external documentation.
9823
9824       getMultisamplefv(Pname, Index) -> {float(), float()}
9825
9826              Types:
9827
9828                 Pname = enum()
9829                 Index = integer()
9830
9831              Retrieve the location of a sample
9832
9833              gl:getMultisamplefv  queries  the  location  of  a given sample.
9834              Pname specifies the sample parameter to  retrieve  and  must  be
9835              ?GL_SAMPLE_POSITION.  Index  corresponds to the sample for which
9836              the location should be returned. The sample location is returned
9837              as two floating-point values in Val[0] and Val[1] , each between
9838              0 and 1, corresponding to the X and Y locations respectively  in
9839              the  GL  pixel space of that sample. (0.5, 0.5) this corresponds
9840              to the pixel center. Index must be between zero and the value of
9841              ?GL_SAMPLES - 1.
9842
9843              See external documentation.
9844
9845       sampleMaski(Index, Mask) -> ok
9846
9847              Types:
9848
9849                 Index = integer()
9850                 Mask = integer()
9851
9852              Set the value of a sub-word of the sample mask
9853
9854              gl:sampleMaski sets one 32-bit sub-word of the multi-word sample
9855              mask, ?GL_SAMPLE_MASK_VALUE .
9856
9857              See external documentation.
9858
9859       namedStringARB(Type, Name, String) -> ok
9860
9861              Types:
9862
9863                 Type = enum()
9864                 Name = string()
9865                 String = string()
9866
9867              glNamedStringARB
9868
9869              See external documentation.
9870
9871       deleteNamedStringARB(Name) -> ok
9872
9873              Types:
9874
9875                 Name = string()
9876
9877              glDeleteNamedStringARB
9878
9879              See external documentation.
9880
9881       compileShaderIncludeARB(Shader, Path) -> ok
9882
9883              Types:
9884
9885                 Shader = integer()
9886                 Path = iolist()
9887
9888              glCompileShaderIncludeARB
9889
9890              See external documentation.
9891
9892       isNamedStringARB(Name) -> 0 | 1
9893
9894              Types:
9895
9896                 Name = string()
9897
9898              glIsNamedStringARB
9899
9900              See external documentation.
9901
9902       getNamedStringARB(Name, BufSize) -> string()
9903
9904              Types:
9905
9906                 Name = string()
9907                 BufSize = integer()
9908
9909              glGetNamedStringARB
9910
9911              See external documentation.
9912
9913       getNamedStringivARB(Name, Pname) -> integer()
9914
9915              Types:
9916
9917                 Name = string()
9918                 Pname = enum()
9919
9920              glGetNamedStringARB
9921
9922              See external documentation.
9923
9924       bindFragDataLocationIndexed(Program, ColorNumber, Index, Name) -> ok
9925
9926              Types:
9927
9928                 Program = integer()
9929                 ColorNumber = integer()
9930                 Index = integer()
9931                 Name = string()
9932
9933              glBindFragDataLocationIndexe
9934
9935              See external documentation.
9936
9937       getFragDataIndex(Program, Name) -> integer()
9938
9939              Types:
9940
9941                 Program = integer()
9942                 Name = string()
9943
9944              Query the bindings of color indices to user-defined varying  out
9945              variables
9946
9947              gl:getFragDataIndex  returns  the index of the fragment color to
9948              which the variable Name was bound when the program  object  Pro‐
9949              gram  was  last linked. If Name is not a varying out variable of
9950              Program , or if an error occurs, -1 will be returned.
9951
9952              See external documentation.
9953
9954       genSamplers(Count) -> [integer()]
9955
9956              Types:
9957
9958                 Count = integer()
9959
9960              Generate sampler object names
9961
9962              gl:genSamplers returns N sampler  object  names  in  Samplers  .
9963              There  is  no  guarantee that the names form a contiguous set of
9964              integers; however, it is guaranteed that none  of  the  returned
9965              names was in use immediately before the call to gl:genSamplers .
9966
9967              See external documentation.
9968
9969       deleteSamplers(Samplers) -> ok
9970
9971              Types:
9972
9973                 Samplers = [integer()]
9974
9975              Delete named sampler objects
9976
9977              gl:deleteSamplers  deletes  N  sampler objects named by the ele‐
9978              ments of the array Ids . After a sampler object is deleted,  its
9979              name  is  again  unused.  If  a sampler object that is currently
9980              bound to a sampler unit is deleted, it is as though  gl:bindSam‐
9981              pler/2  is called with unit set to the unit the sampler is bound
9982              to and sampler zero.  Unused  names  in  samplers  are  silently
9983              ignored, as is the reserved name zero.
9984
9985              See external documentation.
9986
9987       isSampler(Sampler) -> 0 | 1
9988
9989              Types:
9990
9991                 Sampler = integer()
9992
9993              Determine if a name corresponds to a sampler object
9994
9995              gl:isSampler  returns  ?GL_TRUE if Id is currently the name of a
9996              sampler object. If Id is zero, or is a non-zero  value  that  is
9997              not  currently  the  name  of  a  sampler object, or if an error
9998              occurs, gl:isSampler returns ?GL_FALSE.
9999
10000              See external documentation.
10001
10002       bindSampler(Unit, Sampler) -> ok
10003
10004              Types:
10005
10006                 Unit = integer()
10007                 Sampler = integer()
10008
10009              Bind a named sampler to a texturing target
10010
10011              gl:bindSampler binds Sampler to the texture unit at index Unit .
10012              Sampler  must be zero or the name of a sampler object previously
10013              returned from a call to gl:genSamplers/1 .  Unit  must  be  less
10014              than the value of ?GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS.
10015
10016              See external documentation.
10017
10018       samplerParameteri(Sampler, Pname, Param) -> ok
10019
10020              Types:
10021
10022                 Sampler = integer()
10023                 Pname = enum()
10024                 Param = integer()
10025
10026              Set sampler parameters
10027
10028              gl:samplerParameter assigns the value or values in Params to the
10029              sampler parameter specified as Pname  .  Sampler  specifies  the
10030              sampler object to be modified, and must be the name of a sampler
10031              object previously returned from a call to gl:genSamplers/1 . The
10032              following symbols are accepted in Pname :
10033
10034              See external documentation.
10035
10036       samplerParameteriv(Sampler, Pname, Param) -> ok
10037
10038              Types:
10039
10040                 Sampler = integer()
10041                 Pname = enum()
10042                 Param = [integer()]
10043
10044              See samplerParameteri/3
10045
10046       samplerParameterf(Sampler, Pname, Param) -> ok
10047
10048              Types:
10049
10050                 Sampler = integer()
10051                 Pname = enum()
10052                 Param = float()
10053
10054              See samplerParameteri/3
10055
10056       samplerParameterfv(Sampler, Pname, Param) -> ok
10057
10058              Types:
10059
10060                 Sampler = integer()
10061                 Pname = enum()
10062                 Param = [float()]
10063
10064              See samplerParameteri/3
10065
10066       samplerParameterIiv(Sampler, Pname, Param) -> ok
10067
10068              Types:
10069
10070                 Sampler = integer()
10071                 Pname = enum()
10072                 Param = [integer()]
10073
10074              See samplerParameteri/3
10075
10076       samplerParameterIuiv(Sampler, Pname, Param) -> ok
10077
10078              Types:
10079
10080                 Sampler = integer()
10081                 Pname = enum()
10082                 Param = [integer()]
10083
10084              glSamplerParameterI
10085
10086              See external documentation.
10087
10088       getSamplerParameteriv(Sampler, Pname) -> [integer()]
10089
10090              Types:
10091
10092                 Sampler = integer()
10093                 Pname = enum()
10094
10095              Return sampler parameter values
10096
10097              gl:getSamplerParameter  returns in Params the value or values of
10098              the sampler parameter specified as Pname . Sampler  defines  the
10099              target  sampler,  and  must  be  the name of an existing sampler
10100              object, returned from a  previous  call  to  gl:genSamplers/1  .
10101              Pname  accepts the same symbols as gl:samplerParameteri/3 , with
10102              the same interpretations:
10103
10104              See external documentation.
10105
10106       getSamplerParameterIiv(Sampler, Pname) -> [integer()]
10107
10108              Types:
10109
10110                 Sampler = integer()
10111                 Pname = enum()
10112
10113              See getSamplerParameteriv/2
10114
10115       getSamplerParameterfv(Sampler, Pname) -> [float()]
10116
10117              Types:
10118
10119                 Sampler = integer()
10120                 Pname = enum()
10121
10122              See getSamplerParameteriv/2
10123
10124       getSamplerParameterIuiv(Sampler, Pname) -> [integer()]
10125
10126              Types:
10127
10128                 Sampler = integer()
10129                 Pname = enum()
10130
10131              glGetSamplerParameterI
10132
10133              See external documentation.
10134
10135       queryCounter(Id, Target) -> ok
10136
10137              Types:
10138
10139                 Id = integer()
10140                 Target = enum()
10141
10142              Record the GL time into a query object after all  previous  com‐
10143              mands  have  reached  the GL server but have not yet necessarily
10144              executed.
10145
10146              gl:queryCounter causes the GL to record the  current  time  into
10147              the  query  object  named Id . Target must be ?GL_TIMESTAMP. The
10148              time is recorded after all previous commands on  the  GL  client
10149              and  server  state and the framebuffer have been fully realized.
10150              When the time is recorded, the query result for that  object  is
10151              marked  available.  gl:queryCounter  timer  queries  can be used
10152              within a gl:beginQuery/2 / gl:beginQuery/2 block where the  tar‐
10153              get  is  ?GL_TIME_ELAPSED  and  it does not affect the result of
10154              that query object.
10155
10156              See external documentation.
10157
10158       getQueryObjecti64v(Id, Pname) -> integer()
10159
10160              Types:
10161
10162                 Id = integer()
10163                 Pname = enum()
10164
10165              glGetQueryObjecti64v
10166
10167              See external documentation.
10168
10169       getQueryObjectui64v(Id, Pname) -> integer()
10170
10171              Types:
10172
10173                 Id = integer()
10174                 Pname = enum()
10175
10176              glGetQueryObjectui64v
10177
10178              See external documentation.
10179
10180       drawArraysIndirect(Mode, Indirect) -> ok
10181
10182              Types:
10183
10184                 Mode = enum()
10185                 Indirect = offset() | mem()
10186
10187              Render primitives from array data, taking parameters from memory
10188
10189              gl:drawArraysIndirect specifies  multiple  geometric  primitives
10190              with  very  few  subroutine calls. gl:drawArraysIndirect behaves
10191              similarly to gl:drawArraysInstancedBaseInstance/5 , execept that
10192              the   parameters   to  gl:drawArraysInstancedBaseInstance/5  are
10193              stored in memory at the address given by Indirect .
10194
10195              See external documentation.
10196
10197       drawElementsIndirect(Mode, Type, Indirect) -> ok
10198
10199              Types:
10200
10201                 Mode = enum()
10202                 Type = enum()
10203                 Indirect = offset() | mem()
10204
10205              Render indexed primitives from  array  data,  taking  parameters
10206              from memory
10207
10208              gl:drawElementsIndirect  specifies  multiple  indexed  geometric
10209              primitives with very few subroutine calls.  gl:drawElementsIndi‐
10210              rect  behaves similarly to gl:drawElementsInstancedBaseVertexBa‐
10211              seInstance/7 , execpt that the parameters to  gl:drawElementsIn‐
10212              stancedBaseVertexBaseInstance/7  are  stored  in  memory  at the
10213              address given by Indirect .
10214
10215              See external documentation.
10216
10217       uniform1d(Location, X) -> ok
10218
10219              Types:
10220
10221                 Location = integer()
10222                 X = float()
10223
10224              See uniform1f/2
10225
10226       uniform2d(Location, X, Y) -> ok
10227
10228              Types:
10229
10230                 Location = integer()
10231                 X = float()
10232                 Y = float()
10233
10234              See uniform1f/2
10235
10236       uniform3d(Location, X, Y, Z) -> ok
10237
10238              Types:
10239
10240                 Location = integer()
10241                 X = float()
10242                 Y = float()
10243                 Z = float()
10244
10245              See uniform1f/2
10246
10247       uniform4d(Location, X, Y, Z, W) -> ok
10248
10249              Types:
10250
10251                 Location = integer()
10252                 X = float()
10253                 Y = float()
10254                 Z = float()
10255                 W = float()
10256
10257              See uniform1f/2
10258
10259       uniform1dv(Location, Value) -> ok
10260
10261              Types:
10262
10263                 Location = integer()
10264                 Value = [float()]
10265
10266              See uniform1f/2
10267
10268       uniform2dv(Location, Value) -> ok
10269
10270              Types:
10271
10272                 Location = integer()
10273                 Value = [{float(), float()}]
10274
10275              See uniform1f/2
10276
10277       uniform3dv(Location, Value) -> ok
10278
10279              Types:
10280
10281                 Location = integer()
10282                 Value = [{float(), float(), float()}]
10283
10284              See uniform1f/2
10285
10286       uniform4dv(Location, Value) -> ok
10287
10288              Types:
10289
10290                 Location = integer()
10291                 Value = [{float(), float(), float(), float()}]
10292
10293              See uniform1f/2
10294
10295       uniformMatrix2dv(Location, Transpose, Value) -> ok
10296
10297              Types:
10298
10299                 Location = integer()
10300                 Transpose = 0 | 1
10301                 Value = [{float(), float(), float(), float()}]
10302
10303              See uniform1f/2
10304
10305       uniformMatrix3dv(Location, Transpose, Value) -> ok
10306
10307              Types:
10308
10309                 Location = integer()
10310                 Transpose = 0 | 1
10311                 Value  =  [{float(),  float(),  float(),  float(),   float(),
10312                 float(), float(), float(), float()}]
10313
10314              See uniform1f/2
10315
10316       uniformMatrix4dv(Location, Transpose, Value) -> ok
10317
10318              Types:
10319
10320                 Location = integer()
10321                 Transpose = 0 | 1
10322                 Value   =  [{float(),  float(),  float(),  float(),  float(),
10323                 float(),  float(),  float(),   float(),   float(),   float(),
10324                 float(), float(), float(), float(), float()}]
10325
10326              See uniform1f/2
10327
10328       uniformMatrix2x3dv(Location, Transpose, Value) -> ok
10329
10330              Types:
10331
10332                 Location = integer()
10333                 Transpose = 0 | 1
10334                 Value   =  [{float(),  float(),  float(),  float(),  float(),
10335                 float()}]
10336
10337              See uniform1f/2
10338
10339       uniformMatrix2x4dv(Location, Transpose, Value) -> ok
10340
10341              Types:
10342
10343                 Location = integer()
10344                 Transpose = 0 | 1
10345                 Value  =  [{float(),  float(),  float(),  float(),   float(),
10346                 float(), float(), float()}]
10347
10348              See uniform1f/2
10349
10350       uniformMatrix3x2dv(Location, Transpose, Value) -> ok
10351
10352              Types:
10353
10354                 Location = integer()
10355                 Transpose = 0 | 1
10356                 Value   =  [{float(),  float(),  float(),  float(),  float(),
10357                 float()}]
10358
10359              See uniform1f/2
10360
10361       uniformMatrix3x4dv(Location, Transpose, Value) -> ok
10362
10363              Types:
10364
10365                 Location = integer()
10366                 Transpose = 0 | 1
10367                 Value  =  [{float(),  float(),  float(),  float(),   float(),
10368                 float(),   float(),   float(),   float(),  float(),  float(),
10369                 float()}]
10370
10371              See uniform1f/2
10372
10373       uniformMatrix4x2dv(Location, Transpose, Value) -> ok
10374
10375              Types:
10376
10377                 Location = integer()
10378                 Transpose = 0 | 1
10379                 Value  =  [{float(),  float(),  float(),  float(),   float(),
10380                 float(), float(), float()}]
10381
10382              See uniform1f/2
10383
10384       uniformMatrix4x3dv(Location, Transpose, Value) -> ok
10385
10386              Types:
10387
10388                 Location = integer()
10389                 Transpose = 0 | 1
10390                 Value   =  [{float(),  float(),  float(),  float(),  float(),
10391                 float(),  float(),  float(),   float(),   float(),   float(),
10392                 float()}]
10393
10394              See uniform1f/2
10395
10396       getUniformdv(Program, Location) -> matrix()
10397
10398              Types:
10399
10400                 Program = integer()
10401                 Location = integer()
10402
10403              See getUniformfv/2
10404
10405       getSubroutineUniformLocation(Program, Shadertype, Name) -> integer()
10406
10407              Types:
10408
10409                 Program = integer()
10410                 Shadertype = enum()
10411                 Name = string()
10412
10413              Retrieve  the location of a subroutine uniform of a given shader
10414              stage within a program
10415
10416              gl:getSubroutineUniformLocation returns the location of the sub‐
10417              routine  uniform  variable  Name  in  the  shader  stage of type
10418              Shadertype attached to Program , with behavior otherwise identi‐
10419              cal to gl:getUniformLocation/2 .
10420
10421              See external documentation.
10422
10423       getSubroutineIndex(Program, Shadertype, Name) -> integer()
10424
10425              Types:
10426
10427                 Program = integer()
10428                 Shadertype = enum()
10429                 Name = string()
10430
10431              Retrieve  the  index  of  a subroutine uniform of a given shader
10432              stage within a program
10433
10434              gl:getSubroutineIndex returns the index of a subroutine  uniform
10435              within a shader stage attached to a program object. Program con‐
10436              tains the name of the program to which the shader  is  attached.
10437              Shadertype  specifies  the stage from which to query shader sub‐
10438              routine index. Name contains the  null-terminated  name  of  the
10439              subroutine uniform whose name to query.
10440
10441              See external documentation.
10442
10443       getActiveSubroutineUniformName(Program,  Shadertype, Index, Bufsize) ->
10444       string()
10445
10446              Types:
10447
10448                 Program = integer()
10449                 Shadertype = enum()
10450                 Index = integer()
10451                 Bufsize = integer()
10452
10453              Query the name of an active shader subroutine uniform
10454
10455              gl:getActiveSubroutineUniformName  retrieves  the  name  of   an
10456              active  shader  subroutine uniform. Program contains the name of
10457              the program containing the  uniform.  Shadertype  specifies  the
10458              stage  for which which the uniform location, given by Index , is
10459              valid.  Index  must  be  between   zero   and   the   value   of
10460              ?GL_ACTIVE_SUBROUTINE_UNIFORMS minus one for the shader stage.
10461
10462              See external documentation.
10463
10464       getActiveSubroutineName(Program,   Shadertype,   Index,   Bufsize)   ->
10465       string()
10466
10467              Types:
10468
10469                 Program = integer()
10470                 Shadertype = enum()
10471                 Index = integer()
10472                 Bufsize = integer()
10473
10474              Query the name of an active shader subroutine
10475
10476              gl:getActiveSubroutineName queries the name of an active  shader
10477              subroutine  uniform  from  the program object given in Program .
10478              Index specifies the  index  of  the  shader  subroutine  uniform
10479              within  the  shader stage given by Stage , and must between zero
10480              and the value of ?GL_ACTIVE_SUBROUTINES minus one for the shader
10481              stage.
10482
10483              See external documentation.
10484
10485       uniformSubroutinesuiv(Shadertype, Indices) -> ok
10486
10487              Types:
10488
10489                 Shadertype = enum()
10490                 Indices = [integer()]
10491
10492              Load active subroutine uniforms
10493
10494              gl:uniformSubroutines  loads  all active subroutine uniforms for
10495              shader stage Shadertype of the current program  with  subroutine
10496              indices  from  Indices  , storing Indices[i] into the uniform at
10497              location I . Count must be equal to the value of ?GL_ACTIVE_SUB‐
10498              ROUTINE_UNIFORM_LOCATIONS  for  the  program currently in use at
10499              shader stage Shadertype . Furthermore,  all  values  in  Indices
10500              must  be  less  than the value of ?GL_ACTIVE_SUBROUTINES for the
10501              shader stage.
10502
10503              See external documentation.
10504
10505       getUniformSubroutineuiv(Shadertype, Location) -> {integer(), integer(),
10506       integer(), integer(), integer(), integer(), integer(), integer(), inte‐
10507       ger(), integer(), integer(),  integer(),  integer(),  integer(),  inte‐
10508       ger(), integer()}
10509
10510              Types:
10511
10512                 Shadertype = enum()
10513                 Location = integer()
10514
10515              Retrieve  the  value  of  a subroutine uniform of a given shader
10516              stage of the current program
10517
10518              gl:getUniformSubroutine retrieves the value  of  the  subroutine
10519              uniform  at location Location for shader stage Shadertype of the
10520              current program.  Location  must  be  less  than  the  value  of
10521              ?GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS for the shader currently
10522              in use at shader stage Shadertype . The value of the  subroutine
10523              uniform is returned in Values .
10524
10525              See external documentation.
10526
10527       getProgramStageiv(Program, Shadertype, Pname) -> integer()
10528
10529              Types:
10530
10531                 Program = integer()
10532                 Shadertype = enum()
10533                 Pname = enum()
10534
10535              Retrieve properties of a program object corresponding to a spec‐
10536              ified shader stage
10537
10538              gl:getProgramStage  queries  a  parameter  of  a  shader   stage
10539              attached  to  a program object. Program contains the name of the
10540              program to which the shader is  attached.  Shadertype  specifies
10541              the  stage  from  which  to query the parameter. Pname specifies
10542              which parameter should be queried. The value or  values  of  the
10543              parameter  to  be  queried  is  returned  in  the variable whose
10544              address is given in Values .
10545
10546              See external documentation.
10547
10548       patchParameteri(Pname, Value) -> ok
10549
10550              Types:
10551
10552                 Pname = enum()
10553                 Value = integer()
10554
10555              Specifies the parameters for patch primitives
10556
10557              gl:patchParameter specifies the parameters that will be used for
10558              patch  primitives.  Pname  specifies the parameter to modify and
10559              must be either ?GL_PATCH_VERTICES, ?GL_PATCH_DEFAULT_OUTER_LEVEL
10560              or  ?GL_PATCH_DEFAULT_INNER_LEVEL. For gl:patchParameteri, Value
10561              specifies the new value for the parameter specified by  Pname  .
10562              For  gl:patchParameterfv,  Values  specifies  the  address of an
10563              array containing the new values for the parameter  specified  by
10564              Pname .
10565
10566              See external documentation.
10567
10568       patchParameterfv(Pname, Values) -> ok
10569
10570              Types:
10571
10572                 Pname = enum()
10573                 Values = [float()]
10574
10575              See patchParameteri/2
10576
10577       bindTransformFeedback(Target, Id) -> ok
10578
10579              Types:
10580
10581                 Target = enum()
10582                 Id = integer()
10583
10584              Bind a transform feedback object
10585
10586              gl:bindTransformFeedback  binds  the  transform  feedback object
10587              with name Id to the current GL state. Id must be a  name  previ‐
10588              ously returned from a call to gl:genTransformFeedbacks/1 . If Id
10589              has not previously been bound, a new transform  feedback  object
10590              with  name  Id  and  initialized with with the default transform
10591              state vector is created.
10592
10593              See external documentation.
10594
10595       deleteTransformFeedbacks(Ids) -> ok
10596
10597              Types:
10598
10599                 Ids = [integer()]
10600
10601              Delete transform feedback objects
10602
10603              gl:deleteTransformFeedbacks deletes  the  N  transform  feedback
10604              objects  whose  names are stored in the array Ids . Unused names
10605              in Ids are ignored, as is the name zero. After a transform feed‐
10606              back  object  is deleted, its name is again unused and it has no
10607              contents. If an active transform feedback object is deleted, its
10608              name  immediately  becomes  unused, but the underlying object is
10609              not deleted until it is no longer active.
10610
10611              See external documentation.
10612
10613       genTransformFeedbacks(N) -> [integer()]
10614
10615              Types:
10616
10617                 N = integer()
10618
10619              Reserve transform feedback object names
10620
10621              gl:genTransformFeedbacks returns N previously  unused  transform
10622              feedback  object  names in Ids . These names are marked as used,
10623              for the purposes  of  gl:genTransformFeedbacks  only,  but  they
10624              acquire transform feedback state only when they are first bound.
10625
10626              See external documentation.
10627
10628       isTransformFeedback(Id) -> 0 | 1
10629
10630              Types:
10631
10632                 Id = integer()
10633
10634              Determine if a name corresponds to a transform feedback object
10635
10636              gl:isTransformFeedback  returns  ?GL_TRUE if Id is currently the
10637              name of a transform feedback object. If Id is zero, or if ?id is
10638              not  the  name  of  a  transform feedback object, or if an error
10639              occurs, gl:isTransformFeedback returns ?GL_FALSE.  If  Id  is  a
10640              name  returned  by gl:genTransformFeedbacks/1 , but that has not
10641              yet been bound through a call  to  gl:bindTransformFeedback/2  ,
10642              then the name is not a transform feedback object and gl:isTrans‐
10643              formFeedback returns ?GL_FALSE .
10644
10645              See external documentation.
10646
10647       pauseTransformFeedback() -> ok
10648
10649              Pause transform feedback operations
10650
10651              gl:pauseTransformFeedback pauses transform  feedback  operations
10652              on  the  currently active transform feedback object. When trans‐
10653              form feedback operations are paused, transform feedback is still
10654              considered  active  and  changing  most transform feedback state
10655              related to the object results in an error. However, a new trans‐
10656              form  feedback  object  may be bound while transform feedback is
10657              paused.
10658
10659              See external documentation.
10660
10661       resumeTransformFeedback() -> ok
10662
10663              Resume transform feedback operations
10664
10665              gl:resumeTransformFeedback resumes transform feedback operations
10666              on  the  currently active transform feedback object. When trans‐
10667              form feedback operations are paused, transform feedback is still
10668              considered  active  and  changing  most transform feedback state
10669              related to the object results in an error. However, a new trans‐
10670              form  feedback  object  may be bound while transform feedback is
10671              paused.
10672
10673              See external documentation.
10674
10675       drawTransformFeedback(Mode, Id) -> ok
10676
10677              Types:
10678
10679                 Mode = enum()
10680                 Id = integer()
10681
10682              Render primitives using a count derived from a  transform  feed‐
10683              back object
10684
10685              gl:drawTransformFeedback draws primitives of a type specified by
10686              Mode using a count retrieved from the transform feedback  speci‐
10687              fied  by  Id . Calling gl:drawTransformFeedback is equivalent to
10688              calling gl:drawArrays/3 with Mode as  specified,  First  set  to
10689              zero, and Count set to the number of vertices captured on vertex
10690              stream zero the last time transform feedback was active  on  the
10691              transform feedback object named by Id .
10692
10693              See external documentation.
10694
10695       drawTransformFeedbackStream(Mode, Id, Stream) -> ok
10696
10697              Types:
10698
10699                 Mode = enum()
10700                 Id = integer()
10701                 Stream = integer()
10702
10703              Render  primitives  using a count derived from a specifed stream
10704              of a transform feedback object
10705
10706              gl:drawTransformFeedbackStream draws primitives of a type speci‐
10707              fied by Mode using a count retrieved from the transform feedback
10708              stream specified by Stream  of  the  transform  feedback  object
10709              specified  by  Id  .  Calling  gl:drawTransformFeedbackStream is
10710              equivalent to calling gl:drawArrays/3 with  Mode  as  specified,
10711              First  set to zero, and Count set to the number of vertices cap‐
10712              tured on vertex stream Stream the last time  transform  feedback
10713              was active on the transform feedback object named by Id .
10714
10715              See external documentation.
10716
10717       beginQueryIndexed(Target, Index, Id) -> ok
10718
10719              Types:
10720
10721                 Target = enum()
10722                 Index = integer()
10723                 Id = integer()
10724
10725              glBeginQueryIndexe
10726
10727              See external documentation.
10728
10729       endQueryIndexed(Target, Index) -> ok
10730
10731              Types:
10732
10733                 Target = enum()
10734                 Index = integer()
10735
10736              Delimit the boundaries of a query object on an indexed target
10737
10738              gl:beginQueryIndexed and gl:endQueryIndexed/2 delimit the bound‐
10739              aries of a  query  object.  Query  must  be  a  name  previously
10740              returned from a call to gl:genQueries/1 . If a query object with
10741              name Id does not yet exist it is created with  the  type  deter‐
10742              mined  by  Target  .  Target  must be one of ?GL_SAMPLES_PASSED,
10743              ?GL_ANY_SAMPLES_PASSED  ,  ?GL_PRIMITIVES_GENERATED,  ?GL_TRANS‐
10744              FORM_FEEDBACK_PRIMITIVES_WRITTEN,   or  ?GL_TIME_ELAPSED  .  The
10745              behavior of the query object depends on its type and is as  fol‐
10746              lows.
10747
10748              See external documentation.
10749
10750       getQueryIndexediv(Target, Index, Pname) -> integer()
10751
10752              Types:
10753
10754                 Target = enum()
10755                 Index = integer()
10756                 Pname = enum()
10757
10758              Return parameters of an indexed query object target
10759
10760              gl:getQueryIndexediv  returns  in Params a selected parameter of
10761              the indexed query object target specified by Target and Index  .
10762              Index specifies the index of the query object target and must be
10763              between zero and a target-specific maxiumum.
10764
10765              See external documentation.
10766
10767       releaseShaderCompiler() -> ok
10768
10769              Release resources consumed by the implementation's  shader  com‐
10770              piler
10771
10772              gl:releaseShaderCompiler  provides  a hint to the implementation
10773              that it may free internal resources associated with  its  shader
10774              compiler.  gl:compileShader/1 may subsequently be called and the
10775              implementation may at that time reallocate resources  previously
10776              freed by the call to gl:releaseShaderCompiler.
10777
10778              See external documentation.
10779
10780       shaderBinary(Shaders, Binaryformat, Binary) -> ok
10781
10782              Types:
10783
10784                 Shaders = [integer()]
10785                 Binaryformat = enum()
10786                 Binary = binary()
10787
10788              Load pre-compiled shader binaries
10789
10790              gl:shaderBinary  loads  pre-compiled shader binary code into the
10791              Count shader objects whose handles are given in Shaders . Binary
10792              points  to  Length  bytes of binary shader code stored in client
10793              memory. BinaryFormat specifies the format  of  the  pre-compiled
10794              code.
10795
10796              See external documentation.
10797
10798       getShaderPrecisionFormat(Shadertype,  Precisiontype)  -> {Range::{inte‐
10799       ger(), integer()}, Precision::integer()}
10800
10801              Types:
10802
10803                 Shadertype = enum()
10804                 Precisiontype = enum()
10805
10806              Retrieve the range and precision for numeric  formats  supported
10807              by the shader compiler
10808
10809              gl:getShaderPrecisionFormat retrieves the numeric range and pre‐
10810              cision for the implementation's representation of quantities  in
10811              different  numeric  formats in specified shader type. ShaderType
10812              specifies the type of shader for which the numeric precision and
10813              range is to be retrieved and must be one of ?GL_VERTEX_SHADER or
10814              ?GL_FRAGMENT_SHADER. PrecisionType specifies the numeric  format
10815              to  query  and  must  be  one of ?GL_LOW_FLOAT, ?GL_MEDIUM_FLOAT
10816              ?GL_HIGH_FLOAT, ?GL_LOW_INT, ?GL_MEDIUM_INT, or ?GL_HIGH_INT.
10817
10818              See external documentation.
10819
10820       depthRangef(N, F) -> ok
10821
10822              Types:
10823
10824                 N = clamp()
10825                 F = clamp()
10826
10827              See depthRange/2
10828
10829       clearDepthf(D) -> ok
10830
10831              Types:
10832
10833                 D = clamp()
10834
10835              glClearDepthf
10836
10837              See external documentation.
10838
10839       getProgramBinary(Program,    BufSize)     ->     {BinaryFormat::enum(),
10840       Binary::binary()}
10841
10842              Types:
10843
10844                 Program = integer()
10845                 BufSize = integer()
10846
10847              Return  a  binary  representation of a program object's compiled
10848              and linked executable source
10849
10850              gl:getProgramBinary returns a binary representation of the  com‐
10851              piled  and linked executable for Program into the array of bytes
10852              whose address is specified in Binary .  The  maximum  number  of
10853              bytes  that may be written into Binary is specified by BufSize .
10854              If the program binary is greater in  size  than  BufSize  bytes,
10855              then an error is generated, otherwise the actual number of bytes
10856              written into Binary is returned in the variable whose address is
10857              given  by  Length  .  If  Length  is  ?NULL,  then  no length is
10858              returned.
10859
10860              See external documentation.
10861
10862       programBinary(Program, BinaryFormat, Binary) -> ok
10863
10864              Types:
10865
10866                 Program = integer()
10867                 BinaryFormat = enum()
10868                 Binary = binary()
10869
10870              Load a program object with a program binary
10871
10872              gl:programBinary loads a program object with  a  program  binary
10873              previously  returned  from  gl:getProgramBinary/2 . BinaryFormat
10874              and Binary must be those returned by a previous call to  gl:get‐
10875              ProgramBinary/2  ,  and  Length  must  be the length returned by
10876              gl:getProgramBinary/2 , or by gl:getProgramiv/2 when called with
10877              Pname  set to ?GL_PROGRAM_BINARY_LENGTH. If these conditions are
10878              not met, loading the program binary will  fail  and  Program  's
10879              ?GL_LINK_STATUS will be set to ?GL_FALSE.
10880
10881              See external documentation.
10882
10883       programParameteri(Program, Pname, Value) -> ok
10884
10885              Types:
10886
10887                 Program = integer()
10888                 Pname = enum()
10889                 Value = integer()
10890
10891              Specify a parameter for a program object
10892
10893              gl:programParameter  specifies  a  new  value  for the parameter
10894              nameed by Pname for the program object Program .
10895
10896              See external documentation.
10897
10898       useProgramStages(Pipeline, Stages, Program) -> ok
10899
10900              Types:
10901
10902                 Pipeline = integer()
10903                 Stages = integer()
10904                 Program = integer()
10905
10906              Bind stages of a program object to a program pipeline
10907
10908              gl:useProgramStages binds  executables  from  a  program  object
10909              associated  with a specified set of shader stages to the program
10910              pipeline object given by Pipeline . Pipeline specifies the  pro‐
10911              gram  pipeline  object  to which to bind the executables. Stages
10912              contains a logical combination of  bits  indicating  the  shader
10913              stages  to  use  within Program with the program pipeline object
10914              Pipeline . Stages must be  a  logical  combination  of  ?GL_VER‐
10915              TEX_SHADER_BIT,   ?GL_TESS_CONTROL_SHADER_BIT,  ?GL_TESS_EVALUA‐
10916              TION_SHADER_BIT   ,   ?GL_GEOMETRY_SHADER_BIT,   and   ?GL_FRAG‐
10917              MENT_SHADER_BIT.     Additionally,     the     special     value
10918              ?GL_ALL_SHADER_BITS may be specified to indicate that  all  exe‐
10919              cutables contained in Program should be installed in Pipeline .
10920
10921              See external documentation.
10922
10923       activeShaderProgram(Pipeline, Program) -> ok
10924
10925              Types:
10926
10927                 Pipeline = integer()
10928                 Program = integer()
10929
10930              Set the active program object for a program pipeline object
10931
10932              gl:activeShaderProgram  sets the linked program named by Program
10933              to be the active program for the program pipeline  object  Pipe‐
10934              line  . The active program in the active program pipeline object
10935              is the target of calls to gl:uniform1f/2  when  no  program  has
10936              been made current through a call to gl:useProgram/1 .
10937
10938              See external documentation.
10939
10940       createShaderProgramv(Type, Strings) -> integer()
10941
10942              Types:
10943
10944                 Type = enum()
10945                 Strings = iolist()
10946
10947              glCreateShaderProgramv
10948
10949              See external documentation.
10950
10951       bindProgramPipeline(Pipeline) -> ok
10952
10953              Types:
10954
10955                 Pipeline = integer()
10956
10957              Bind a program pipeline to the current context
10958
10959              gl:bindProgramPipeline  binds  a  program pipeline object to the
10960              current context. Pipeline must be  a  name  previously  returned
10961              from a call to gl:genProgramPipelines/1 . If no program pipeline
10962              exists with name Pipeline then a new pipeline object is  created
10963              with that name and initialized to the default state vector.
10964
10965              See external documentation.
10966
10967       deleteProgramPipelines(Pipelines) -> ok
10968
10969              Types:
10970
10971                 Pipelines = [integer()]
10972
10973              Delete program pipeline objects
10974
10975              gl:deleteProgramPipelines deletes the N program pipeline objects
10976              whose names are stored in the array Pipelines . Unused names  in
10977              Pipelines  are  ignored,  as  is  the name zero. After a program
10978              pipeline object is deleted, its name is again unused and it  has
10979              no  contents. If program pipeline object that is currently bound
10980              is deleted, the binding for that object reverts to zero  and  no
10981              program pipeline object becomes current.
10982
10983              See external documentation.
10984
10985       genProgramPipelines(N) -> [integer()]
10986
10987              Types:
10988
10989                 N = integer()
10990
10991              Reserve program pipeline object names
10992
10993              gl:genProgramPipelines returns N previously unused program pipe‐
10994              line object names in Pipelines . These names are marked as used,
10995              for  the  purposes  of  gl:genProgramPipelines  only,  but  they
10996              acquire program pipeline state only when they are first bound.
10997
10998              See external documentation.
10999
11000       isProgramPipeline(Pipeline) -> 0 | 1
11001
11002              Types:
11003
11004                 Pipeline = integer()
11005
11006              Determine if a name corresponds to a program pipeline object
11007
11008              gl:isProgramPipeline returns ?GL_TRUE if Pipeline  is  currently
11009              the  name  of a program pipeline object. If Pipeline is zero, or
11010              if ?pipeline is not the name of a program pipeline object, or if
11011              an  error  occurs,  gl:isProgramPipeline  returns  ?GL_FALSE. If
11012              Pipeline is a name returned by  gl:genProgramPipelines/1  ,  but
11013              that  has  not  yet  been  bound  through  a call to gl:bindPro‐
11014              gramPipeline/1 , then the name is not a program pipeline  object
11015              and gl:isProgramPipeline returns ?GL_FALSE .
11016
11017              See external documentation.
11018
11019       getProgramPipelineiv(Pipeline, Pname) -> integer()
11020
11021              Types:
11022
11023                 Pipeline = integer()
11024                 Pname = enum()
11025
11026              Retrieve properties of a program pipeline object
11027
11028              gl:getProgramPipelineiv retrieves the value of a property of the
11029              program pipeline object Pipeline . Pname specifies the  name  of
11030              the  parameter whose value to retrieve. The value of the parame‐
11031              ter is written to the variable whose address is given by  Params
11032              .
11033
11034              See external documentation.
11035
11036       programUniform1i(Program, Location, V0) -> ok
11037
11038              Types:
11039
11040                 Program = integer()
11041                 Location = integer()
11042                 V0 = integer()
11043
11044              Specify  the value of a uniform variable for a specified program
11045              object
11046
11047              gl:programUniform modifies the value of a uniform variable or  a
11048              uniform  variable array. The location of the uniform variable to
11049              be modified is specified by Location , which should be  a  value
11050              returned by gl:getUniformLocation/2 . gl:programUniform operates
11051              on the program object specified by Program .
11052
11053              See external documentation.
11054
11055       programUniform1iv(Program, Location, Value) -> ok
11056
11057              Types:
11058
11059                 Program = integer()
11060                 Location = integer()
11061                 Value = [integer()]
11062
11063              See programUniform1i/3
11064
11065       programUniform1f(Program, Location, V0) -> ok
11066
11067              Types:
11068
11069                 Program = integer()
11070                 Location = integer()
11071                 V0 = float()
11072
11073              See programUniform1i/3
11074
11075       programUniform1fv(Program, Location, Value) -> ok
11076
11077              Types:
11078
11079                 Program = integer()
11080                 Location = integer()
11081                 Value = [float()]
11082
11083              See programUniform1i/3
11084
11085       programUniform1d(Program, Location, V0) -> ok
11086
11087              Types:
11088
11089                 Program = integer()
11090                 Location = integer()
11091                 V0 = float()
11092
11093              See programUniform1i/3
11094
11095       programUniform1dv(Program, Location, Value) -> ok
11096
11097              Types:
11098
11099                 Program = integer()
11100                 Location = integer()
11101                 Value = [float()]
11102
11103              See programUniform1i/3
11104
11105       programUniform1ui(Program, Location, V0) -> ok
11106
11107              Types:
11108
11109                 Program = integer()
11110                 Location = integer()
11111                 V0 = integer()
11112
11113              See programUniform1i/3
11114
11115       programUniform1uiv(Program, Location, Value) -> ok
11116
11117              Types:
11118
11119                 Program = integer()
11120                 Location = integer()
11121                 Value = [integer()]
11122
11123              See programUniform1i/3
11124
11125       programUniform2i(Program, Location, V0, V1) -> ok
11126
11127              Types:
11128
11129                 Program = integer()
11130                 Location = integer()
11131                 V0 = integer()
11132                 V1 = integer()
11133
11134              See programUniform1i/3
11135
11136       programUniform2iv(Program, Location, Value) -> ok
11137
11138              Types:
11139
11140                 Program = integer()
11141                 Location = integer()
11142                 Value = [{integer(), integer()}]
11143
11144              See programUniform1i/3
11145
11146       programUniform2f(Program, Location, V0, V1) -> ok
11147
11148              Types:
11149
11150                 Program = integer()
11151                 Location = integer()
11152                 V0 = float()
11153                 V1 = float()
11154
11155              See programUniform1i/3
11156
11157       programUniform2fv(Program, Location, Value) -> ok
11158
11159              Types:
11160
11161                 Program = integer()
11162                 Location = integer()
11163                 Value = [{float(), float()}]
11164
11165              See programUniform1i/3
11166
11167       programUniform2d(Program, Location, V0, V1) -> ok
11168
11169              Types:
11170
11171                 Program = integer()
11172                 Location = integer()
11173                 V0 = float()
11174                 V1 = float()
11175
11176              See programUniform1i/3
11177
11178       programUniform2dv(Program, Location, Value) -> ok
11179
11180              Types:
11181
11182                 Program = integer()
11183                 Location = integer()
11184                 Value = [{float(), float()}]
11185
11186              See programUniform1i/3
11187
11188       programUniform2ui(Program, Location, V0, V1) -> ok
11189
11190              Types:
11191
11192                 Program = integer()
11193                 Location = integer()
11194                 V0 = integer()
11195                 V1 = integer()
11196
11197              See programUniform1i/3
11198
11199       programUniform2uiv(Program, Location, Value) -> ok
11200
11201              Types:
11202
11203                 Program = integer()
11204                 Location = integer()
11205                 Value = [{integer(), integer()}]
11206
11207              See programUniform1i/3
11208
11209       programUniform3i(Program, Location, V0, V1, V2) -> ok
11210
11211              Types:
11212
11213                 Program = integer()
11214                 Location = integer()
11215                 V0 = integer()
11216                 V1 = integer()
11217                 V2 = integer()
11218
11219              See programUniform1i/3
11220
11221       programUniform3iv(Program, Location, Value) -> ok
11222
11223              Types:
11224
11225                 Program = integer()
11226                 Location = integer()
11227                 Value = [{integer(), integer(), integer()}]
11228
11229              See programUniform1i/3
11230
11231       programUniform3f(Program, Location, V0, V1, V2) -> ok
11232
11233              Types:
11234
11235                 Program = integer()
11236                 Location = integer()
11237                 V0 = float()
11238                 V1 = float()
11239                 V2 = float()
11240
11241              See programUniform1i/3
11242
11243       programUniform3fv(Program, Location, Value) -> ok
11244
11245              Types:
11246
11247                 Program = integer()
11248                 Location = integer()
11249                 Value = [{float(), float(), float()}]
11250
11251              See programUniform1i/3
11252
11253       programUniform3d(Program, Location, V0, V1, V2) -> ok
11254
11255              Types:
11256
11257                 Program = integer()
11258                 Location = integer()
11259                 V0 = float()
11260                 V1 = float()
11261                 V2 = float()
11262
11263              See programUniform1i/3
11264
11265       programUniform3dv(Program, Location, Value) -> ok
11266
11267              Types:
11268
11269                 Program = integer()
11270                 Location = integer()
11271                 Value = [{float(), float(), float()}]
11272
11273              See programUniform1i/3
11274
11275       programUniform3ui(Program, Location, V0, V1, V2) -> ok
11276
11277              Types:
11278
11279                 Program = integer()
11280                 Location = integer()
11281                 V0 = integer()
11282                 V1 = integer()
11283                 V2 = integer()
11284
11285              See programUniform1i/3
11286
11287       programUniform3uiv(Program, Location, Value) -> ok
11288
11289              Types:
11290
11291                 Program = integer()
11292                 Location = integer()
11293                 Value = [{integer(), integer(), integer()}]
11294
11295              See programUniform1i/3
11296
11297       programUniform4i(Program, Location, V0, V1, V2, V3) -> ok
11298
11299              Types:
11300
11301                 Program = integer()
11302                 Location = integer()
11303                 V0 = integer()
11304                 V1 = integer()
11305                 V2 = integer()
11306                 V3 = integer()
11307
11308              See programUniform1i/3
11309
11310       programUniform4iv(Program, Location, Value) -> ok
11311
11312              Types:
11313
11314                 Program = integer()
11315                 Location = integer()
11316                 Value = [{integer(), integer(), integer(), integer()}]
11317
11318              See programUniform1i/3
11319
11320       programUniform4f(Program, Location, V0, V1, V2, V3) -> ok
11321
11322              Types:
11323
11324                 Program = integer()
11325                 Location = integer()
11326                 V0 = float()
11327                 V1 = float()
11328                 V2 = float()
11329                 V3 = float()
11330
11331              See programUniform1i/3
11332
11333       programUniform4fv(Program, Location, Value) -> ok
11334
11335              Types:
11336
11337                 Program = integer()
11338                 Location = integer()
11339                 Value = [{float(), float(), float(), float()}]
11340
11341              See programUniform1i/3
11342
11343       programUniform4d(Program, Location, V0, V1, V2, V3) -> ok
11344
11345              Types:
11346
11347                 Program = integer()
11348                 Location = integer()
11349                 V0 = float()
11350                 V1 = float()
11351                 V2 = float()
11352                 V3 = float()
11353
11354              See programUniform1i/3
11355
11356       programUniform4dv(Program, Location, Value) -> ok
11357
11358              Types:
11359
11360                 Program = integer()
11361                 Location = integer()
11362                 Value = [{float(), float(), float(), float()}]
11363
11364              See programUniform1i/3
11365
11366       programUniform4ui(Program, Location, V0, V1, V2, V3) -> ok
11367
11368              Types:
11369
11370                 Program = integer()
11371                 Location = integer()
11372                 V0 = integer()
11373                 V1 = integer()
11374                 V2 = integer()
11375                 V3 = integer()
11376
11377              See programUniform1i/3
11378
11379       programUniform4uiv(Program, Location, Value) -> ok
11380
11381              Types:
11382
11383                 Program = integer()
11384                 Location = integer()
11385                 Value = [{integer(), integer(), integer(), integer()}]
11386
11387              See programUniform1i/3
11388
11389       programUniformMatrix2fv(Program, Location, Transpose, Value) -> ok
11390
11391              Types:
11392
11393                 Program = integer()
11394                 Location = integer()
11395                 Transpose = 0 | 1
11396                 Value = [{float(), float(), float(), float()}]
11397
11398              See programUniform1i/3
11399
11400       programUniformMatrix3fv(Program, Location, Transpose, Value) -> ok
11401
11402              Types:
11403
11404                 Program = integer()
11405                 Location = integer()
11406                 Transpose = 0 | 1
11407                 Value  =  [{float(),  float(),  float(),  float(),   float(),
11408                 float(), float(), float(), float()}]
11409
11410              See programUniform1i/3
11411
11412       programUniformMatrix4fv(Program, Location, Transpose, Value) -> ok
11413
11414              Types:
11415
11416                 Program = integer()
11417                 Location = integer()
11418                 Transpose = 0 | 1
11419                 Value   =  [{float(),  float(),  float(),  float(),  float(),
11420                 float(),  float(),  float(),   float(),   float(),   float(),
11421                 float(), float(), float(), float(), float()}]
11422
11423              See programUniform1i/3
11424
11425       programUniformMatrix2dv(Program, Location, Transpose, Value) -> ok
11426
11427              Types:
11428
11429                 Program = integer()
11430                 Location = integer()
11431                 Transpose = 0 | 1
11432                 Value = [{float(), float(), float(), float()}]
11433
11434              See programUniform1i/3
11435
11436       programUniformMatrix3dv(Program, Location, Transpose, Value) -> ok
11437
11438              Types:
11439
11440                 Program = integer()
11441                 Location = integer()
11442                 Transpose = 0 | 1
11443                 Value   =  [{float(),  float(),  float(),  float(),  float(),
11444                 float(), float(), float(), float()}]
11445
11446              See programUniform1i/3
11447
11448       programUniformMatrix4dv(Program, Location, Transpose, Value) -> ok
11449
11450              Types:
11451
11452                 Program = integer()
11453                 Location = integer()
11454                 Transpose = 0 | 1
11455                 Value  =  [{float(),  float(),  float(),  float(),   float(),
11456                 float(),   float(),   float(),   float(),  float(),  float(),
11457                 float(), float(), float(), float(), float()}]
11458
11459              See programUniform1i/3
11460
11461       programUniformMatrix2x3fv(Program, Location, Transpose, Value) -> ok
11462
11463              Types:
11464
11465                 Program = integer()
11466                 Location = integer()
11467                 Transpose = 0 | 1
11468                 Value  =  [{float(),  float(),  float(),  float(),   float(),
11469                 float()}]
11470
11471              See programUniform1i/3
11472
11473       programUniformMatrix3x2fv(Program, Location, Transpose, Value) -> ok
11474
11475              Types:
11476
11477                 Program = integer()
11478                 Location = integer()
11479                 Transpose = 0 | 1
11480                 Value   =  [{float(),  float(),  float(),  float(),  float(),
11481                 float()}]
11482
11483              See programUniform1i/3
11484
11485       programUniformMatrix2x4fv(Program, Location, Transpose, Value) -> ok
11486
11487              Types:
11488
11489                 Program = integer()
11490                 Location = integer()
11491                 Transpose = 0 | 1
11492                 Value  =  [{float(),  float(),  float(),  float(),   float(),
11493                 float(), float(), float()}]
11494
11495              See programUniform1i/3
11496
11497       programUniformMatrix4x2fv(Program, Location, Transpose, Value) -> ok
11498
11499              Types:
11500
11501                 Program = integer()
11502                 Location = integer()
11503                 Transpose = 0 | 1
11504                 Value   =  [{float(),  float(),  float(),  float(),  float(),
11505                 float(), float(), float()}]
11506
11507              See programUniform1i/3
11508
11509       programUniformMatrix3x4fv(Program, Location, Transpose, Value) -> ok
11510
11511              Types:
11512
11513                 Program = integer()
11514                 Location = integer()
11515                 Transpose = 0 | 1
11516                 Value  =  [{float(),  float(),  float(),  float(),   float(),
11517                 float(),   float(),   float(),   float(),  float(),  float(),
11518                 float()}]
11519
11520              See programUniform1i/3
11521
11522       programUniformMatrix4x3fv(Program, Location, Transpose, Value) -> ok
11523
11524              Types:
11525
11526                 Program = integer()
11527                 Location = integer()
11528                 Transpose = 0 | 1
11529                 Value  =  [{float(),  float(),  float(),  float(),   float(),
11530                 float(),   float(),   float(),   float(),  float(),  float(),
11531                 float()}]
11532
11533              See programUniform1i/3
11534
11535       programUniformMatrix2x3dv(Program, Location, Transpose, Value) -> ok
11536
11537              Types:
11538
11539                 Program = integer()
11540                 Location = integer()
11541                 Transpose = 0 | 1
11542                 Value  =  [{float(),  float(),  float(),  float(),   float(),
11543                 float()}]
11544
11545              See programUniform1i/3
11546
11547       programUniformMatrix3x2dv(Program, Location, Transpose, Value) -> ok
11548
11549              Types:
11550
11551                 Program = integer()
11552                 Location = integer()
11553                 Transpose = 0 | 1
11554                 Value   =  [{float(),  float(),  float(),  float(),  float(),
11555                 float()}]
11556
11557              See programUniform1i/3
11558
11559       programUniformMatrix2x4dv(Program, Location, Transpose, Value) -> ok
11560
11561              Types:
11562
11563                 Program = integer()
11564                 Location = integer()
11565                 Transpose = 0 | 1
11566                 Value  =  [{float(),  float(),  float(),  float(),   float(),
11567                 float(), float(), float()}]
11568
11569              See programUniform1i/3
11570
11571       programUniformMatrix4x2dv(Program, Location, Transpose, Value) -> ok
11572
11573              Types:
11574
11575                 Program = integer()
11576                 Location = integer()
11577                 Transpose = 0 | 1
11578                 Value   =  [{float(),  float(),  float(),  float(),  float(),
11579                 float(), float(), float()}]
11580
11581              See programUniform1i/3
11582
11583       programUniformMatrix3x4dv(Program, Location, Transpose, Value) -> ok
11584
11585              Types:
11586
11587                 Program = integer()
11588                 Location = integer()
11589                 Transpose = 0 | 1
11590                 Value  =  [{float(),  float(),  float(),  float(),   float(),
11591                 float(),   float(),   float(),   float(),  float(),  float(),
11592                 float()}]
11593
11594              See programUniform1i/3
11595
11596       programUniformMatrix4x3dv(Program, Location, Transpose, Value) -> ok
11597
11598              Types:
11599
11600                 Program = integer()
11601                 Location = integer()
11602                 Transpose = 0 | 1
11603                 Value  =  [{float(),  float(),  float(),  float(),   float(),
11604                 float(),   float(),   float(),   float(),  float(),  float(),
11605                 float()}]
11606
11607              See programUniform1i/3
11608
11609       validateProgramPipeline(Pipeline) -> ok
11610
11611              Types:
11612
11613                 Pipeline = integer()
11614
11615              Validate a program pipeline object against current GL state
11616
11617              gl:validateProgramPipeline instructs the implementation to vali‐
11618              date  the  shader  executables contained in Pipeline against the
11619              current GL state. The implementation may use this as an opportu‐
11620              nity  to  perform  any internal shader modifications that may be
11621              required to ensure correct operation of  the  installed  shaders
11622              given the current GL state.
11623
11624              See external documentation.
11625
11626       getProgramPipelineInfoLog(Pipeline, BufSize) -> string()
11627
11628              Types:
11629
11630                 Pipeline = integer()
11631                 BufSize = integer()
11632
11633              Retrieve the info log string from a program pipeline object
11634
11635              gl:getProgramPipelineInfoLog retrieves the info log for the pro‐
11636              gram pipeline object Pipeline . The info log, including its null
11637              terminator,  is  written  into  the  array  of  characters whose
11638              address is given by InfoLog . The maximum number  of  characters
11639              that  may  be written into InfoLog is given by BufSize , and the
11640              actual number of characters written into InfoLog is returned  in
11641              the  integer  whose  address  is  given by Length . If Length is
11642              ?NULL, no length is returned.
11643
11644              See external documentation.
11645
11646       vertexAttribL1d(Index, X) -> ok
11647
11648              Types:
11649
11650                 Index = integer()
11651                 X = float()
11652
11653              glVertexAttribL
11654
11655              See external documentation.
11656
11657       vertexAttribL2d(Index, X, Y) -> ok
11658
11659              Types:
11660
11661                 Index = integer()
11662                 X = float()
11663                 Y = float()
11664
11665              glVertexAttribL
11666
11667              See external documentation.
11668
11669       vertexAttribL3d(Index, X, Y, Z) -> ok
11670
11671              Types:
11672
11673                 Index = integer()
11674                 X = float()
11675                 Y = float()
11676                 Z = float()
11677
11678              glVertexAttribL
11679
11680              See external documentation.
11681
11682       vertexAttribL4d(Index, X, Y, Z, W) -> ok
11683
11684              Types:
11685
11686                 Index = integer()
11687                 X = float()
11688                 Y = float()
11689                 Z = float()
11690                 W = float()
11691
11692              glVertexAttribL
11693
11694              See external documentation.
11695
11696       vertexAttribL1dv(Index::integer(), V) -> ok
11697
11698              Types:
11699
11700                 V = {X::float()}
11701
11702              Equivalent to vertexAttribL1d(Index, X).
11703
11704       vertexAttribL2dv(Index::integer(), V) -> ok
11705
11706              Types:
11707
11708                 V = {X::float(), Y::float()}
11709
11710              Equivalent to vertexAttribL2d(Index, X, Y).
11711
11712       vertexAttribL3dv(Index::integer(), V) -> ok
11713
11714              Types:
11715
11716                 V = {X::float(), Y::float(), Z::float()}
11717
11718              Equivalent to vertexAttribL3d(Index, X, Y, Z).
11719
11720       vertexAttribL4dv(Index::integer(), V) -> ok
11721
11722              Types:
11723
11724                 V = {X::float(), Y::float(), Z::float(), W::float()}
11725
11726              Equivalent to vertexAttribL4d(Index, X, Y, Z, W).
11727
11728       vertexAttribLPointer(Index, Size, Type, Stride, Pointer) -> ok
11729
11730              Types:
11731
11732                 Index = integer()
11733                 Size = integer()
11734                 Type = enum()
11735                 Stride = integer()
11736                 Pointer = offset() | mem()
11737
11738              glVertexAttribLPointer
11739
11740              See external documentation.
11741
11742       getVertexAttribLdv(Index,  Pname)  ->   {float(),   float(),   float(),
11743       float()}
11744
11745              Types:
11746
11747                 Index = integer()
11748                 Pname = enum()
11749
11750              glGetVertexAttribL
11751
11752              See external documentation.
11753
11754       viewportArrayv(First, V) -> ok
11755
11756              Types:
11757
11758                 First = integer()
11759                 V = [{float(), float(), float(), float()}]
11760
11761              glViewportArrayv
11762
11763              See external documentation.
11764
11765       viewportIndexedf(Index, X, Y, W, H) -> ok
11766
11767              Types:
11768
11769                 Index = integer()
11770                 X = float()
11771                 Y = float()
11772                 W = float()
11773                 H = float()
11774
11775              Set a specified viewport
11776
11777              gl:viewportIndexedf and gl:viewportIndexedfv specify the parame‐
11778              ters for a single viewport. Index specifies  the  index  of  the
11779              viewport  to  modify.  Index  must  be  less  than  the value of
11780              ?GL_MAX_VIEWPORTS. For gl:viewportIndexedf, X , Y , W  ,  and  H
11781              specify  the  left,  bottom, width and height of the viewport in
11782              pixels, respectively. For gl:viewportIndexedfv, V  contains  the
11783              address of an array of floating point values specifying the left
11784              ( x), bottom ( y), width ( w), and height ( h) of each viewport,
11785              in that order. x and y give the location of the viewport's lower
11786              left corner, and w and h give the width and height of the  view‐
11787              port,  respectively. The viewport specifies the affine transfor‐
11788              mation of x and y from normalized device coordinates  to  window
11789              coordinates.  Let  (x nd y nd) be normalized device coordinates.
11790              Then the window coordinates (x w y w) are computed as follows:
11791
11792              See external documentation.
11793
11794       viewportIndexedfv(Index, V) -> ok
11795
11796              Types:
11797
11798                 Index = integer()
11799                 V = {float(), float(), float(), float()}
11800
11801              See viewportIndexedf/5
11802
11803       scissorArrayv(First, V) -> ok
11804
11805              Types:
11806
11807                 First = integer()
11808                 V = [{integer(), integer(), integer(), integer()}]
11809
11810              glScissorArrayv
11811
11812              See external documentation.
11813
11814       scissorIndexed(Index, Left, Bottom, Width, Height) -> ok
11815
11816              Types:
11817
11818                 Index = integer()
11819                 Left = integer()
11820                 Bottom = integer()
11821                 Width = integer()
11822                 Height = integer()
11823
11824              glScissorIndexe
11825
11826              See external documentation.
11827
11828       scissorIndexedv(Index, V) -> ok
11829
11830              Types:
11831
11832                 Index = integer()
11833                 V = {integer(), integer(), integer(), integer()}
11834
11835              glScissorIndexe
11836
11837              See external documentation.
11838
11839       depthRangeArrayv(First, V) -> ok
11840
11841              Types:
11842
11843                 First = integer()
11844                 V = [{clamp(), clamp()}]
11845
11846              glDepthRangeArrayv
11847
11848              See external documentation.
11849
11850       depthRangeIndexed(Index, N, F) -> ok
11851
11852              Types:
11853
11854                 Index = integer()
11855                 N = clamp()
11856                 F = clamp()
11857
11858              glDepthRangeIndexe
11859
11860              See external documentation.
11861
11862       getFloati_v(Target, Index) -> [float()]
11863
11864              Types:
11865
11866                 Target = enum()
11867                 Index = integer()
11868
11869              See getBooleanv/1
11870
11871       getDoublei_v(Target, Index) -> [float()]
11872
11873              Types:
11874
11875                 Target = enum()
11876                 Index = integer()
11877
11878              See getBooleanv/1
11879
11880       debugMessageControlARB(Source, Type, Severity, Ids, Enabled) -> ok
11881
11882              Types:
11883
11884                 Source = enum()
11885                 Type = enum()
11886                 Severity = enum()
11887                 Ids = [integer()]
11888                 Enabled = 0 | 1
11889
11890              glDebugMessageControlARB
11891
11892              See external documentation.
11893
11894       debugMessageInsertARB(Source, Type, Id, Severity, Buf) -> ok
11895
11896              Types:
11897
11898                 Source = enum()
11899                 Type = enum()
11900                 Id = integer()
11901                 Severity = enum()
11902                 Buf = string()
11903
11904              glDebugMessageInsertARB
11905
11906              See external documentation.
11907
11908       getDebugMessageLogARB(Count, Bufsize) -> {integer(), Sources::[enum()],
11909       Types::[enum()],     Ids::[integer()],    Severities::[enum()],    Mes‐
11910       sageLog::[string()]}
11911
11912              Types:
11913
11914                 Count = integer()
11915                 Bufsize = integer()
11916
11917              glGetDebugMessageLogARB
11918
11919              See external documentation.
11920
11921       getGraphicsResetStatusARB() -> enum()
11922
11923              glGetGraphicsResetStatusARB
11924
11925              See external documentation.
11926
11927       drawArraysInstancedBaseInstance(Mode, First, Count, Primcount,  Basein‐
11928       stance) -> ok
11929
11930              Types:
11931
11932                 Mode = enum()
11933                 First = integer()
11934                 Count = integer()
11935                 Primcount = integer()
11936                 Baseinstance = integer()
11937
11938              Draw  multiple  instances  of  a  range  of elements with offset
11939              applied to instanced attributes
11940
11941              gl:drawArraysInstancedBaseInstance   behaves   identically    to
11942              gl:drawArrays/3  except that Primcount instances of the range of
11943              elements are executed and the  value  of  the  internal  counter
11944              InstanceID  advances for each iteration. InstanceID is an inter‐
11945              nal 32-bit integer counter that may be read by a  vertex  shader
11946              as ?gl_InstanceID .
11947
11948              See external documentation.
11949
11950       drawElementsInstancedBaseInstance(Mode,  Count,  Type,  Indices,  Prim‐
11951       count, Baseinstance) -> ok
11952
11953              Types:
11954
11955                 Mode = enum()
11956                 Count = integer()
11957                 Type = enum()
11958                 Indices = offset() | mem()
11959                 Primcount = integer()
11960                 Baseinstance = integer()
11961
11962              Draw multiple instances of a set of elements with offset applied
11963              to instanced attributes
11964
11965              gl:drawElementsInstancedBaseInstance   behaves   identically  to
11966              gl:drawElements/4 except that Primcount instances of the set  of
11967              elements  are  executed  and  the  value of the internal counter
11968              InstanceID advances for each iteration. InstanceID is an  inter‐
11969              nal  32-bit  integer counter that may be read by a vertex shader
11970              as ?gl_InstanceID .
11971
11972              See external documentation.
11973
11974       drawElementsInstancedBaseVertexBaseInstance(Mode, Count, Type, Indices,
11975       Primcount, Basevertex, Baseinstance) -> ok
11976
11977              Types:
11978
11979                 Mode = enum()
11980                 Count = integer()
11981                 Type = enum()
11982                 Indices = offset() | mem()
11983                 Primcount = integer()
11984                 Basevertex = integer()
11985                 Baseinstance = integer()
11986
11987              Render multiple instances of a set of primitives from array data
11988              with a per-element offset
11989
11990              gl:drawElementsInstancedBaseVertexBaseInstance  behaves  identi‐
11991              cally  to gl:drawElementsInstanced/5 except that the ith element
11992              transferred by the corresponding draw call will  be  taken  from
11993              element  Indices  [i] + Basevertex of each enabled array. If the
11994              resulting value is larger than the maximum  value  representable
11995              by Type , it is as if the calculation were upconverted to 32-bit
11996              unsigned integers (with wrapping on  overflow  conditions).  The
11997              operation  is undefined if the sum would be negative. The Basev‐
11998              ertex has no effect on the shader-visible value of ?gl_VertexID.
11999
12000              See external documentation.
12001
12002       drawTransformFeedbackInstanced(Mode, Id, Primcount) -> ok
12003
12004              Types:
12005
12006                 Mode = enum()
12007                 Id = integer()
12008                 Primcount = integer()
12009
12010              glDrawTransformFeedbackInstance
12011
12012              See external documentation.
12013
12014       drawTransformFeedbackStreamInstanced(Mode, Id, Stream, Primcount) -> ok
12015
12016              Types:
12017
12018                 Mode = enum()
12019                 Id = integer()
12020                 Stream = integer()
12021                 Primcount = integer()
12022
12023              glDrawTransformFeedbackStreamInstance
12024
12025              See external documentation.
12026
12027       getInternalformativ(Target, Internalformat, Pname, BufSize)  ->  [inte‐
12028       ger()]
12029
12030              Types:
12031
12032                 Target = enum()
12033                 Internalformat = enum()
12034                 Pname = enum()
12035                 BufSize = integer()
12036
12037              glGetInternalformat
12038
12039              See external documentation.
12040
12041       bindImageTexture(Unit,  Texture, Level, Layered, Layer, Access, Format)
12042       -> ok
12043
12044              Types:
12045
12046                 Unit = integer()
12047                 Texture = integer()
12048                 Level = integer()
12049                 Layered = 0 | 1
12050                 Layer = integer()
12051                 Access = enum()
12052                 Format = enum()
12053
12054              Bind a level of a texture to an image unit
12055
12056              gl:bindImageTexture binds a single level  of  a  texture  to  an
12057              image  unit  for  the  purpose  of  reading  and writing it from
12058              shaders. Unit specifies the zero-based index of the  image  unit
12059              to  which  to bind the texture level. Texture specifies the name
12060              of an existing texture object to bind to the image unit. If Tex‐
12061              ture  is  zero,  then  any existing binding to the image unit is
12062              broken. Level specifies the level of the texture to bind to  the
12063              image unit.
12064
12065              See external documentation.
12066
12067       memoryBarrier(Barriers) -> ok
12068
12069              Types:
12070
12071                 Barriers = integer()
12072
12073              Defines a barrier ordering memory transactions
12074
12075              gl:memoryBarrier  defines a barrier ordering the memory transac‐
12076              tions issued prior to the command relative to those issued after
12077              the  barrier. For the purposes of this ordering, memory transac‐
12078              tions performed by shaders are considered to be  issued  by  the
12079              rendering  command  that  triggered the execution of the shader.
12080              Barriers is a bitfield indicating the set of operations that are
12081              synchronized  with  shader stores; the bits used in Barriers are
12082              as follows:
12083
12084              See external documentation.
12085
12086       texStorage1D(Target, Levels, Internalformat, Width) -> ok
12087
12088              Types:
12089
12090                 Target = enum()
12091                 Levels = integer()
12092                 Internalformat = enum()
12093                 Width = integer()
12094
12095              Simultaneously specify storage for all levels  of  a  one-dimen‐
12096              sional texture
12097
12098              gl:texStorage1D  specifies the storage requirements for all lev‐
12099              els of a one-dimensional texture simultaneously. Once a  texture
12100              is specified with this command, the format and dimensions of all
12101              levels become immutable unless it is a proxy texture.  The  con‐
12102              tents  of  the image may still be modified, however, its storage
12103              requirements may not change. Such a texture is referred to as an
12104              immutable-format texture.
12105
12106              See external documentation.
12107
12108       texStorage2D(Target, Levels, Internalformat, Width, Height) -> ok
12109
12110              Types:
12111
12112                 Target = enum()
12113                 Levels = integer()
12114                 Internalformat = enum()
12115                 Width = integer()
12116                 Height = integer()
12117
12118              Simultaneously  specify  storage  for all levels of a two-dimen‐
12119              sional or one-dimensional array texture
12120
12121              gl:texStorage2D specifies the storage requirements for all  lev‐
12122              els  of  a  two-dimensional  texture  or one-dimensional texture
12123              array simultaneously. Once a texture is specified with this com‐
12124              mand,  the  format and dimensions of all levels become immutable
12125              unless it is a proxy texture. The  contents  of  the  image  may
12126              still  be  modified,  however,  its storage requirements may not
12127              change. Such a texture is referred  to  as  an  immutable-format
12128              texture.
12129
12130              See external documentation.
12131
12132       texStorage3D(Target,  Levels,  Internalformat, Width, Height, Depth) ->
12133       ok
12134
12135              Types:
12136
12137                 Target = enum()
12138                 Levels = integer()
12139                 Internalformat = enum()
12140                 Width = integer()
12141                 Height = integer()
12142                 Depth = integer()
12143
12144              Simultaneously specify storage for all levels of a  three-dimen‐
12145              sional, two-dimensional array or cube-map array texture
12146
12147              gl:texStorage3D  specifies the storage requirements for all lev‐
12148              els of a three-dimensional, two-dimensional  array  or  cube-map
12149              array  texture  simultaneously. Once a texture is specified with
12150              this command, the format and dimensions  of  all  levels  become
12151              immutable  unless  it  is  a  proxy texture. The contents of the
12152              image may still be modified, however, its  storage  requirements
12153              may  not  change. Such a texture is referred to as an immutable-
12154              format texture.
12155
12156              See external documentation.
12157
12158       depthBoundsEXT(Zmin, Zmax) -> ok
12159
12160              Types:
12161
12162                 Zmin = clamp()
12163                 Zmax = clamp()
12164
12165              glDepthBoundsEXT
12166
12167              See external documentation.
12168
12169       stencilClearTagEXT(StencilTagBits, StencilClearTag) -> ok
12170
12171              Types:
12172
12173                 StencilTagBits = integer()
12174                 StencilClearTag = integer()
12175
12176              glStencilClearTagEXT
12177
12178              See external documentation.
12179

AUTHORS

12181       <>
12182
12183
12184
12185                                   wx 1.8.3                              gl(3)
Impressum