C^}      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                              !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH I J KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                  ! !!!"!#!$!%!&!'!(!)!*!+!,!-!."/"0"1"2"3"4"5"6"7"8"9":";<=>?@ABCD#E$F$G$H$I$J$K%L%M%N%O%P%Q%R%S%T%U&V&W&X&Y'Z'['\']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p'q'r's't'u'v'w'x'y'z'{'|'}'~'''''''''''''''''(((()************+++++++,,----------------                              ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9.:.;.<.=.>.?.@.A.B.C.D.E.F.G.H.I.J.K.L.M.N.O.P.Q.R.S/T/U/V/W/X/Y/Z/[/\/]/^/_/`/a/b/c/defghijklmnopqrstuvwxyz{|}~0000000000000000000000000011111111111122 2 2 2 2 2222222222222222 !"#$%&'()*+,-./0123456789:;<3=3>3?3@3A3B3C3D3E3F3G3H3I3J3K3L3M3N3O3P3Q3R3S3T3U3V3W3X3Y3Z3[3\4]5^5_5`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u6v6w6xyz{|}~3333333333333333333333333333333333333333333333333333777777777     888888888888888888888888899999999::::::::::::::     ;;;;;;;;;; ;!;";#;$;%;&;';(;);*;+;,;-;.;/;0;1;2;3;4;5;6;7;8;9;:;;;<;=>?@ABCD<E<F<G<H<I<J<K<L=M=N=O>P>Q>R>S>T>U>V>W>X>Y>Z>[>\>]>^>_>`abcd e f g h i j k l m n o p q r s t u v w x y z { | } ~                                   ??????????????????????????????????????????????????????????????????????@@@@@@@@ @ @ @ @ @@AAAAAAAAAAAAAAAAA A!A"A#A$A%A&A'A(A)A*A+A,A-A.A/A0B1B2B3B4B5B6B7B8B9B:B;B<B=B>B?B@BABBBCBDBEBFBGBHBIBJBKBLBMBNBOBPBQBRBSBTBUBVBWXYZ[\]^_`abcdefghijCkClCmCnCoCpCqCrCsCtCuCvCwCxCyCzC{D|DuE(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableSafe+A color index.A fully-fledged RGBA color.A fog coordinate. 3Fully-fledged four-dimensional texture coordinates. Texture coordinates with q=1.Texture coordinates with r=0 and q=1.Texture coordinates with t=0, r=0, and q=1.D }~ ;   }~F(c) Sven Panne 2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone   G(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneH(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone# !"#$%&'()*+,-./01234567# !"#$%&'()*+,-./01234567  !"#$%&'()*+,-./01234567I(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone 89:;<=>?@ 89:;<=>?@89:;<=>?@J(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPK(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNonerQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~rQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~QnRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~L(c) Sven Panne 2013-2015BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneM(c) Sven Panne 2002-2015BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone PThe set of color buffers which are selected for reading and writing. Note that  can only be used with framebuffer objects, while the rest can only be used with the default framebuffer. Furthermore, OpenGL 3.0 deprecated auxiliary buffers, so avoid  in modern code.No color buffers are selected.-Only the front left color buffer is selected..Only the front right color buffer is selected.-Only the back left color buffer is selected.-Only the back right color buffer is selected.Only the front left and front right color buffers are selected. If there is no front right color buffer, only the front left color buffer is selected.Only the back left and back right color buffers are selected. If there is no back right color buffer, only the back left color buffer is selected.Only the front left and back left color buffers are selected. If there is no back left color buffer, only the front left color buffer is selected.Only the front right and back right color buffers are selected. If there is no back right color buffer, only the front right color buffer is selected.All the front and back color buffers (front left, front right, back left, back right) are selected. If there are no back color buffers, only the front left and front right color buffers are selected. If there are no right color buffers, only the front left and back left color buffers are selected. If there are no right or back color buffers, only the front left color buffer is selected.*Only the given auxiliary color buffer no. i is selected.cOnly the given color attachment of the bound framebufferobject is selected for reading or writing. N(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableSafe  O(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneP(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone++Q(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneR(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneOIdentifies a texture unit via its number, which must be in the range of (0 .. maxTextureUnit).S(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneT(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneGeneral GL/GLU error categories XGL/GLU errors consist of a general error category and a description of what went wrong.        (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone iWhen an error occurs, it is recorded in this state variable and no further errors are recorded. Reading   returns the currently recorded errors (there may be more than one due to a possibly distributed implementation) and resets the state variable to []9, re-enabling the recording of future errors. The value []D means that there has been no detectable error since the last time  + was read, or since the GL was initialized.        U(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableSafe   V(c) Sven Panne 2013-2015BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone       W(c) Sven Panne 2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone      X+(c) Sven Panne 2002-2009, Lars Corbijn 2013BSD3@Sven Panne <svenpanne@gmail.com>, Jason Dagit <dagitj@gmail.com>stableportableNoneB ? Float  Float Colorsfloat Evaluators float? Fogclampf Framebufferclampffloat RasterPosfloatfloatfloatfloat PerFragmentclampf TessellationfloatBoth indexed and unindexedboolint Framebufferint PerFragmentint Float3 Pointfloat clamp Evaluators!float2? Point"float#float LineSegments$float%float PerFragment&clampd Tessellation'float(sizei Evaluators)Float1 Rasterization*Float+ Float Colors,Float- Float Fog.float/float0float Framebuffer1clampf2float RasterPos3 float Point4float5float6float7float8float LineSegment9float:float PerFragment;clampf<clampf PixelTransfer=float>float?float@floatAfloatBfloatCfloatDfloatEfloatFfloatGfloatHfloatIfloatJfloatKfloatLfloatMfloatNfloatOfloatPfloatQfloatRfloatSfloatTfloatUfloatVfloat PolygonsWfloatXfloat Texture parametersYfloatZfloat[bool\enum]int^enum displaylist_enum`enumasizeibenum rendermodecenum framebufferbindingdinteintfint renderbufferbindingg int hinthenumienumjenumkenumlenummenumnenumoenumpenum vertexarrayqint Selction?rintsint ContextProfiletenum pixelStorageuboolvboolwboolxboolyintzint{int|int}int~intintintintintintint pixel mapintintintintintintintintintintsizei shader limitssizeisizeisizeisizeisizeisizeisizeisizei tessellationsizeisizeisizei coordtransenumsizeisizeisizeisizeisizeisizeisizeisizeisizeisizeienum VertexArraysintenumintenumintintenumintenumintintenumintintenumintintenumintintintenumsizeisizeiintboolint bufferObjectsintintintintintintintintintintintintintintintintintintintint int clipping sizei Colorssizeienumboolboolenumenumenumenumenumenumenum Evaluatorsintint Fog int => enumintintint => enum Framebuffersizeiboolboolsizeisizeisizeisizeisizeisizeisizeisizeisizeisizeienumsizeiintboolboolbool int Programint Transformfeedbackintintintintbool LineSegmentintint PerFragmentboolenumenumenum int int int int enumenumenumenumenumenumenumenumenumenumenumenumenumenumenumenumenumboolbool int!+int Polygons -- ^ enum"int#int$int%int&int'int(int)int*int+int ReadCopyPixels,enum Texture Objects-int/enum.int/enum/int/enum0int/enum1int/enum2int/enum3int/enum4int/enum5int/enum6int/enum7int/enum Antialiasing8sizei9sizei:sizei Sync Objects;int Query Objects< int GL Time= int Shader>bool?int@int Debug OutputAintBintCintDintEintFint ExtensionsGuintH(Helper function for the get*1 functions.I(Helper function for the get*2 functions.J(Helper function for the get*3 functions.K(Helper function for the get*4 functions.L(Helper function for the get*4 functions.MNOPQRSTUVWXYZ[\]^_`abcdef   ghi !"#$%&'j(klmnopqrstuvwxyz)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ{[\]^_`abcdefghijklmnopqrstuvwxyz{|}~|      !}"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG~H4Conversion from the casted value to the return value4Conversion from the casted value to the return valueI4Conversion from the casted value to the return valueJ4Conversion from the casted value to the return valueK4Conversion from the casted value to the return valueL4Conversion from the casted value to the return valueMNOPQRSTUVWXYZ[\]^_`abcdef   ghi !"#$%&'j(klmnopqrstuvwxyz)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ{[\]^_`abcdefghijklmnopqrstuvwxyz{|}~|      !}"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG~EMNOPQRSTUVWXYZ[\]^_`abcdef   ghi !"#$%&'j(klm nopqrstuvwxyz2)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ{[\]^_`abcdefghijklmnopqrstuvwxyz{|}~|      !}"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG~HIJKLY&(c) Sven Panne, Lars Corbijn 2009-2013BSD3@Sven Panne <svenpanne@gmail.com>, Jason Dagit <dagitj@gmail.com>stableportableNone Z(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone[(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone\(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone !" !" !"](c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableSafe^(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone#cA vertex can begin an edge which lies in the interior of its polygon or on the polygon's boundary.#$%#$%#$%_(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone        &MNOPQRSTUVWXYZ[\]^_`abcdef   ghi !"#$%&'j(klmnopqrstuvwxyz)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ{[\]^_`abcdefghijklmnopqrstuvwxyz{|}~|      !}"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG~     &        &`(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone3'  ()*+    '  ()*+ '  ()*+   a(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone ,-./    0,-./ 0,-./    0(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone            ! " # $ %123 &456789:; ' ( 123456789:; 123456789:;            ! " # $ %123 &456789:; ' ((c) Sven Panne 2006-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone<Contains the number of hardware units that can be used to access texture maps from the vertex processor. The minimum legal value is 0.=Contains the total number of hardware units that can be used to access texture maps from the fragment processor. The minimum legal value is 2.>HContains the total number of hardware units that can be used to access texture maps from the vertex processor and the fragment processor combined. Note: If the vertex shader and the fragment processing stage access the same texture image unit, then that counts as using two texture image units. The minimum legal value is 2.?aContains the number of texture coordinate sets that are available. The minimum legal value is 2.@Contains the number of individual components (i.e., floating-point, integer or boolean values) that are available for vertex shader uniform variables. The minimum legal value is 512.AContains the number of individual components (i.e., floating-point, integer or boolean values) that are available for fragment shader uniform variables. The minimum legal value is 64.BcContains the number of active vertex attributes that are available. The minimum legal value is 16.CxContains the number of individual floating-point values available for varying variables. The minimum legal value is 32. <=>?@ABC )<=>?@ABC<=>?@ABC <=>?@ABC )b(c) Sven Panne 2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone * + , - .DE / 0 1 * , - .DE / * + , - .DE / 0(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneFG 2FGFGFG 2c(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNones 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  HIJ k 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  HIJ  3 4 5` 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  HIJ (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone K LM KLMKLM   K LM (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone!NOPQRSTUVWXYZ[\]^_`abcdefgh i j NOPQRSTUVWXYZ[\]^_`abcdefghijRSTUVWXYZ[\]^_`abcdefghiNOPQjNOPQRSTUVWXYZ[\]^_`abcdefgh i j (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneu(A utility function to be used with e.g. p or s;, transforming a variable containing a string of the form major.minor[optional rest] into a variable containing a numeric major/minor version. If the string is malformed, which should never happen with a sane OpenGL implementation, it is transformed to (-1,-1).klmnopqrs t u klmnopqrstu nopqrsuklmtklmnopqrs t u (c) Sven Panne 2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableSafe+vA four-dimensional vector.xA three-dimensional vector.zA two-dimensional vector.|A one-dimensional vector.~(A fully-fledged four-dimensional vertex.A vertex with w=1.A vertex with z=0 and w=1.A vertex with y=0, z=0 and w=1.=vwxyz{|}~ vwxyz{|}~~|}z{xyvw5vwxyz{|}~ (c) Sven Panne 2015BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone<      .&.&"       d(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone   e(c) Sven Panne 2013-2015BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone   &(c) Sven Panne, Lars Corbijn 2011-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone  f(c) Sven Panne 2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone             &(c) Sven Panne, Lars Corbijn 2011-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone         g(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone   h(c) Sven Panne 2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone&                   ! " # $ % & ' ( ) * + , - . / 0 1#                   ! " # $ % & ' ( ) * + , - .                    ! " # $ % & ' ( ) * + , - . / 0 1(c) Sven Panne 2006-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone  2 3 4 5 2 3 4 5i(c) Sven Panne 2006-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone5 6 75 6 72 6 7(c) Sven Panne 2006-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone 8 9 : ;55 8 9 : ;j(c) Sven Panne 2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone < = > ? < = < = > ?(c) Sven Panne 2006-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone UTF8 encoded.( @ A B C D E F G H I J K      L M N O P Q R S TDE          DE @ A B C D E F G H I J K      L M N O P Q R S T (c) Sven Panne 2006-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone!(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone !"#$%&'()*+, U V W X- !"#$%&'()*+,-#$%&'()*+, !"- !"# $%&'()*+, U V W X-"(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone./012 Y Z [ \345 ]6789: ^ _ ` ./0123456789: 12./03456789:./012 Y Z [ \345 ]6789: ^ _ `(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone;< a=>? b c d e f@ABC,-./0;<=>?@ABC=>?;<@ABC,-./0 ;< a=>? b c d e f@ABC#(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneDDDD$(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneEE contains the rasterized width of both aliased and antialiased lines. The initial value is 1. Using a line width other than 1 has different effects, depending on whether line antialiasing is enabled (see G+). Line antialiasing is initially disabled.If line antialiasing is disabled, the actual width is determined by rounding the supplied width to the nearest integer. (If the rounding results in the value 0, it is as if the line width were 1.) If delta x >= delta y, i= pixels are filled in each column that is rasterized, where i is the rounded value of E . Otherwise, i3 pixels are filled in each row that is rasterized.If antialiasing is enabled, line rasterization produces a fragment for each pixel square that intersects the region lying within the rectangle having width equal to the current line width, length equal to the actual length of the line, and centered on the mathematical line segment. The coverage value for each fragment is the window coordinate area of the intersection of the rectangular region with the corresponding pixel square. This value is saved and used in the final rasterization step.Not all widths can be supported when line antialiasing is enabled. If an unsupported width is requested, the nearest supported width is used. Only width 1 is guaranteed to be supported; others depend on the implementation. Likewise, there is a range for aliased line widths as well. To query the range of supported widths of antialiased lines and the size difference between supported widths within the range, query I and JC, respectively. For aliased lines, query the supported range with H.The line width specified when E is set is always returned when it is queried. Clamping and rounding for aliased and antialiased lines have no effect on the specified value.\A non-antialiased line width may be clamped to an implementation-dependent maximum. Query H to determine the maximum width.An  k is generated if E. is set to a value less than or equal to zero.An  l is generated if E is set during m.FLine stippling masks out certain fragments produced by rasterization; those fragments will not be drawn. The masking is achieved by using three parameters: the repeat count (1st element of the F{ pair, clamped to the range [ 1 .. 256 ]), the 16-bit line stipple pattern (2nd element), and an integer stipple counter s. The counter s2 is reset to 0 at before the first action during m1 is called and before each line segment during mw is generated. It is incremented after each fragment of a unit width aliased line segment is generated or after each i fragments of an i( width line segment are generated. The i! fragments associated with count s are masked out if no pattern (( s / factor ) mod 16) is  g, otherwise these fragments are sent to the frame buffer. Bit zero of the pattern is the least significant bit, i.e. it is used first.tAntialiased lines are treated as a sequence of rectangles of height 1 for purposes of stippling. Whether rectangle s is rasterized or not depends on the fragment rule described for aliased lines, counting rectangles rather than groups of fragments.The initial value of F is  h#, i.e. line stippling is disabled.An  l is generated if F is set during m.GEControls whether line antialiasing is enabled. The initial state is I.H:The smallest and largest supported width of aliased lines.I>The smallest and largest supported width of antialiased lines.J[The antialiased line width granularity, i.e. the size difference between supported widths.EFGHIJEFGHIJEFGHIJEFGHIJ%(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone KK contains the rasterized diameter of both aliased and antialiased points. The initial value is 1. Using a point size other than 1 has different effects, depending on whether point antialiasing is enabled (see P$) or point sprites are enabled (see Q ). Both are initially disabled.hThe specified point size is multiplied with a distance attenuation factor and clamped to the specified Mp, and further clamped to the implementation-dependent point size range to produce the derived point size using   derivedSize = clamp (size * sqrt (1 / (a + b * d + c * d^2)))where d@ is the eye-coordinate distance from the eye to the vertex, and a, b, and c1 are the distance attenuation coefficients (see N).TIf multisampling is disabled, the computed point size is used as the point's width.]If multisampling is enabled, the point may be faded by modifying the point alpha value (see p<) instead of allowing the point width to go below a given OG. In this case, the width is further modified in the following manner:  width = if  derivedSize >=  threshold then  derivedSize else  threshold/The point alpha value is modified by computing:  alpha = if  derivedSize >=  threshold then 1 else ( derivedSize /  threshold)^2If point antialiasing is disabled, the actual size is determined by rounding the supplied size to the nearest integer. (If the rounding results in the value 0, it is as if the point size were 1.) If the rounded size is odd, then the center point (x, yA) of the pixel fragment that represents the point is computed as  (x, y) = (floor xw + 0.5, floor yw + 0.5)where xw and ywk indicate window coordinates. All pixels that lie within the square grid of the rounded size centered at (x, yA) make up the fragment. If the size is even, the center point is  (x, y) = (floor (xw + 0.5), floor (yw + 0.5))and the rasterized fragment's centers are the half-integer window coordinates within the square of the rounded size centered at (x, y). All pixel fragments produced in rasterizing a nonantialiased point are assigned the same associated data, that of the vertex corresponding to the point.If antialiasing is enabled, then point rasterization produces a fragment for each pixel square that intersects the region lying within the circle having diameter equal to the current point size and centered at the point's (xw, yw6). The coverage value for each fragment is the window coordinate area of the intersection of the circular region with the corresponding pixel square. This value is saved and used in the final rasterization step. The data associated with each fragment is the data associated with the point being rasterized.dNot all sizes are supported when point antialiasing is enabled. If an unsupported size is requested, the nearest supported size is used. Only size 1 is guaranteed to be supported; others depend on the implementation. To query the range of supported sizes for antialiased points and the size difference between supported sizes within the range, query S and TD, respectively. For aliased points, query the supported range with R.The point size specified when K is set is always returned when it is queried. Clamping and rounding for aliased and antialiased points have no effect on the specified value.A non-antialiased point size may be clamped to an implementation-dependent maximum. Although this maximum cannot be queried, it must be no less than the maximum value for antialiased points, rounded to the nearest integer value.An  k is generated if K. is set to a value less than or equal to zero.An  l is generated if K is set during m.M:The range to which the derived point size is clamped, see KV. Note that the size is further clamped to the implementation-dependent limits, see R and S. The initial range is (0, 1).An  k is generated if the lower or upper bound of the range is set to a value less than zero. If the lower bound is greater than the upper bound, the point size after clamping is undefined, but no error is generated.NMThe constant, linear, and quadratic distance attenuation coefficients, see K). The initial coefficients are (1, 0, 0).OOThe threshold for alpha attenuation of points when multisampling is used, see K. The initial threshold is 1.An  kA is generated if the threshold is set to a value less than zero.PFControls whether point antialiasing is enabled. The initial state is I.QBControls whether point sprites are enabled. The initial state is II. When point sprites are enabled, the state of point antialiasing (i.e. P ) is ignored.R:The smallest and largest supported size of aliased points.S>The smallest and largest supported size of antialiased points.TZThe antialiased point size granularity, i.e. the size difference between supported sizes. KLMNOPQRST KLMNOPQRST KLMNOPQRST KLMNOPQRST&(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneUVWX iUVWXUVWXUVWX i'(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone3hyCreate a new matrix of the given order (containing undefined elements) and call the action to fill it with 4x4 elements.i'Call the action with the given matrix. Note: The action is not( allowed to modify the matrix elements!sA matrix stack.t8The modelview matrix stack of the specified vertex unit.uThe projection matrix stack.vThe texture matrix stack.wThe color matrix stack.xThe matrix palette stack.y)A 2-dimensional size, measured in pixels.{-A 2-dimensional position, measured in pixels.}After clipping and division by w\, depth coordinates range from -1 to 1, corresponding to the near and far clipping planes. }, specifies a linear mapping of the normalized depth coordinates in this range to window depth coordinates. Regardless of the actual depth buffer implementation, window coordinate depth values are treated as though they range from 0 through 1 (like color components). Thus, the values accepted by }: are both clamped to this range before they are accepted.The initial setting of (0, 1) maps the near plane to 0 and the far plane to 1. With this mapping, the depth buffer range is fully utilized.tIt is not necessary that the near value be less than the far value. Reverse mappings such as (1, 0) are acceptable.~Controls the affine transformation from normalized device coordinates to window coordinates. The viewport state variable consists of the coordinates (x, yg) of the lower left corner of the viewport rectangle, (in pixels, initial value (0,0)), and the size (width, heightE) of the viewport. When a GL context is first attached to a window, width and height+ are set to the dimensions of that window.Let (xnd, yndB) be normalized device coordinates. Then the window coordinates (xw, yw) are computed as follows:xw = (xnd + 1) (width / 2) + xyw = (ynd + 1) (heigth / 2) + ycViewport width and height are silently clamped to a range that depends on the implementation, see .?The implementation-dependent maximum viewport width and height.cControls which matrix stack is the target for subsequent matrix operations. The initial value is (t 0).Push the current matrix stack down by one, duplicating the current matrix, excute the given action, and pop the current matrix stack, replacing the current matrix with the one below it on the stack (i.e. restoring it to its previous state). The returned value is that of the given action. Note that a round-trip to the server is probably required. For a more efficient version, see .7A more efficient, but potentially dangerous version of h: The given action is not allowed to throw an exception or change the current matrix mode permanently.If  contains J!, normal vectors specified with qD are scaled by a scaling factor derived from the modelview matrix.  requires that the originally specified normals were of unit length, and that the modelview matrix contains only uniform scales for proper results. The initial value of  is I.If  contains J!, normal vectors specified with qG are scaled to unit length after transformation. The initial value of  is I.]YZ[\]^ j k l m n o p q r s_`abcdef tghijkl u v w x ymnopqrstuvwxyz{|}~ z { | } ~     6YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~6}{|yz~stuvwxpqrlmnoghijkfde_`abcYZ[\]^5YZ[\]^ j k l m n o p q r s_`abcdef tghijkl u v w x ymnopqrstuvwxyz{|}~ z { | } ~     ((c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone  )(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone*(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone%The buffers which can be copied with .      (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone% !"#$%&'()*+,-./01234567% !"#$%&'()*+,-./01234567+(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone    ,&(c) Sven Panne, Lars Corbijn 2011-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone     (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone3The class of all types which can be used as a generic vertex attribute. NOTE: Do not use the methods of this class directly, they were only exported by accident and will be hidden in future versions of this package.Change the current color index.:The class of all types which can be used as a color index.#Change the current secondary color.Change the current color.>The class of all types which can be used as a color component."Change the current fog coordinate.?The class of all types which can be used as the fog coordinate.Change the current normal. Integral arguments are converted to floating-point with a linear mapping that maps the most positive representable integer value to 1.0, and the most negative representable integer value to -1.0.Normals specified with  or  need not have unit length. If 'r8 is enabled, then normals of any length specified with  or + are normalized after transformation. If 'sY is enabled, normals are scaled by a scaling factor derived from the modelview matrix. 's requires that the originally specified normals were of unit length, and that the modelview matrix contains only uniform scales for proper results. Normalization is initially disabled.DThe class of all types which can be used as a component of a normal.MChange the current texture coordinates of the current or given texture unit.AThe class of all types which can be used as a texture coordinate. Specify the (x, y, z, wL) coordinates of a four-dimensional vertex. This must only be done during m, otherwise the behaviour is unspecified. The current values of the auxiliary vertex attributes are associated with the vertex.QNote that there is no such thing as a "current vertex" which could be retrieved.@The class of all types which can be used as a vertex coordinate.!The current texture coordinates (s, t, r, q%) for the current texture unit (see 't9). The initial value is (0,0,0,1) for all texture units.The current normal (x, y, z3). The initial value is the unit vector (0, 0, 1).3The current fog coordinate. The initial value is 0.If  contains  P, the color buffers store RGBA value. If color indexes are stored, it contains  g.An implementation must support at least 2 texture units, but it may support up to 32 ones. This state variable can be used to query the actual implementation limit.              ^ ^  _              -(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone3'                                       (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneq       ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : !"#$ ; < =% > ?&' @ A B( C)* D E F+ G H, I J-./0 K L M N12 O34 P Q5 R S6 T U7 V W X Y8:      !"#$%&'()*+,-./012345678: !"#$%&'()*+,-./0123456   7  8J       ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : !"#$ ; < =% > ?&' @ A B( C)* D E F+ G H, I J-./0 K L M N12 O34 P Q5 R S6 T U7 V W X Y8.(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone% Z9:;<=>?@ABCDEFGHIJKLMNOPQ [ \ ] ^R _ ` a b c d9:;<=>?@ABCDEFGHIJKLMNOPQRLFGHIJKMNOPQDECBA@?>9:;<=R Z9:;<=>?@ABCDEFGHIJKLMNOPQ [ \ ] ^R _ ` a b c d/(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone*STUVWXYZ[\] e f g h i j k l m n o p q^ r s t_ u v w x y`a z {b | }cSTUVWXYZ[\]^_`abc^Z[\]_`aWXYbSTUVcSTUVWXYZ[\] e f g h i j k l m n o p q^ r s t_ u v w x y`a z {b | }c(c) Sven Panne 2002-2015BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone0d(An operation on the accumulation buffer.eObtains R, G, B, and A> values from the buffer currently selected for reading (see *u)). Each component value is divided by 2^n -1, where n is the number of bits allocated to each color component in the currently selected buffer. The result is a floating-point value in the range [0, 1], which is multiplied by the value given to w and added to the corresponding pixel component in the accumulation buffer, thereby updating the accumulation buffer.f Similar to e{, except that the current value in the accumulation buffer is not used in the calculation of the new value. That is, the R, G, B, and A= values from the currently selected buffer are divided by 2^n%-1, multiplied by the value given to a, and then stored in the corresponding accumulation buffer cell, overwriting the current value.gjTransfers accumulation buffer values to the color buffer or buffers currently selected for writing. Each R, G, B, and A0 component is multiplied by the value given to , then multiplied by 2^n -1, clamped to the range [0, 2^n-1], and stored in the corresponding display buffer cell. The only fragment operations that are applied to this transfer are pixel ownership, scissor, dithering, and color writemasks.hMultiplies each R, G, B, and A3 in the accumulation buffer by the value given to U and returns the scaled component to its corresponding accumulation buffer location.iAdds the value given to  to each R, G, B, and A in the accumulation buffer.j8Describes which buffer(s) to clear and the value to use.k<Clear the signed integer color buffer(s) at the given index.lFClear the fixed- or floating-point color buffer(s) at the given index.m6Clear the unsigned color buffer(s) at the given index.nClear the depth buffer.oClear the stencil buffer.p.Clear the depth buffer and the stencil buffer.q&The buffers which can be cleared with .r0The buffers currently enabled for color writing.sThe accumulation buffer.tThe stencil buffer.uThe depth buffer.vThe index of the draw buffer.wbWhen colors are written to the framebuffer, they are written into the color buffers specified by w.If more than one color buffer is selected for drawing, then blending or logical operations are computed and applied independently for each color buffer and can produce different results in each buffer.Monoscopic contexts include only left buffers, and stereoscopic contexts include both left and right buffers. Likewise, single-buffered contexts include only front buffers, and double-buffered contexts include both front and back buffers. The context is selected at GL initialization.The initial value is $ for single-buffered contexts, and  for double-buffered contexts.x#The direct-state-access version of w.yy defines the draw buffers to which all fragment colors are written. The draw buffers being defined correspond in order to the respective fragment colors. The draw buffer for fragment colors beyond those specified is set to . Except for s, a buffer may not appear more then once in the given list. Specifying a buffer more then once will result in an  l.7If fixed-function fragment shading is being performed, yK specifies a set of draw buffers into which the fragment color is written.If a fragment shader writes to  gl_FragColor, yS specifies a set of draw buffers into which the single fragment color defined by  gl_FragColor, is written. If a fragment shader writes to  gl_FragData, y] specifies a set of draw buffers into which each of the multiple fragment colors defined by  gl_FragDataA are separately written. If a fragment shader writes to neither  gl_FragColor nor  gl_FragDataw, the values of the fragment colors following shader execution are undefined, and may differ for each fragment color.z#The direct-state-access version of y.{{8 is a fast query function. For indices in the range 0..|]-1 its results is the same as selecting the corresponding element from the list returned by y?, but this function uses only one GL function call instead of | ones.|>Contains the maximum number of buffers that can activated via yu or which can be simultaneously written into from within a fragment shader using the special output variable array  gl_FragData5. This constant effectively defines the size of the  gl_FragData& array. The minimum legal value is 1.}[Controls the writing of individual bits in the color index buffers. The least significant n bits of its value, where n is the number of bits in a color index buffer, specify a mask. Where a 1 appears in the mask, it is possible to write to the corresponding bit in the color index buffer (or buffers). Where a 0 appears, the corresponding bit is write-protected.qThis mask is used only in color index mode, and it affects only the buffers currently selected for writing (see w0). Initially, all bits are enabled for writing.~rControls whether the individual color components in the framebuffer can or cannot be written. If the red flag is I, for example, no change is made to the red component of any pixel in any of the color buffers, regardless of the drawing operation attempted. Initially, all color components can be written.Changes to individual bits of components cannot be controlled. Rather, changes are either enabled or disabled for entire color components. Furthermore, this mask is used only in RGBA mode. is a version of ~1 that only applies to the specified draw buffer.PControls whether the depth buffer is enabled for writing. The initial state is J.VControls the writing of individual bits in the stencil planes. The least significant n bits of its value, where n is the number of bits in the stencil buffer, specify a mask. Where a 1 appears in the mask, it is possible to write to the corresponding bit in the stencil buffer. Where a 0 appears, the corresponding bit is write-protected. Initially, all bits are enabled for writing.A per-face version of .FSet the bitplane area of the window to values previously selected by , , , , and k. Multiple color buffers can be cleared simultaneously by selecting more than one buffer at a time using w.jThe pixel ownership test, the scissor test, dithering, and the buffer writemasks affect the operation of . The scissor box bounds the cleared region. Alpha function, blend function, logical operation, stenciling, texure mapping, and depth-buffering are ignored by .j takes a list of buffers, indicating which buffers are to be cleared. If a buffer is not present, then a ( directed at that buffer has no effect.eThe value to which each buffer is cleared depends on the setting of the clear value for that buffer.8Controls the red, green, blue, and alpha values used by : to clear the color buffers. Initially, all values are 0.Controls the index c used by $ to clear the color index buffers. c is not clamped. Rather, c is converted to a fixed-point value with unspecified precision to the right of the binary point. The integer part of this value is then masked with 2^m -1, where m^ is the number of bits in a color index stored in the framebuffer. Initially, the value is 0.!Controls the depth value used by 4 to clear the depth buffer. The initial value is 1. A variant of  with a  ~ argument.Controls the value s used by  to clear the stencil buffer. s is masked with 2^m -1, where mI is the number of bits in the stencil buffer. Initially, the value is 0.8Controls the red, green, blue, and alpha values used by 8 to clear the accumulation buffer. Values written into A are clamped to the range [-1, 1]. The initial values are all 0.Clear the given buffer(s).#The direct-state-access version of .AInvalidate a region of the attachments bound to the given target.#The direct-state-access version of . A version of  affecting the whole viewport.#The direct-state-access version of .EThe implementation and context dependent number of auxiliary buffers. ! if front and back buffers exist. ! if left and right buffers exist.The accumulation buffer is an extended-range color buffer. Images are not rendered into it. Rather, images rendered into one of the color buffers are added to the contents of the accumulation buffer after rendering. Effects such as antialiasing (of points, lines, and polygons), motion blur, and depth of field can be created by accumulating images generated with different transformation matrices.Each pixel in the accumulation buffer consists of red, green, blue, and alpha values. The number of bits per component in the accumulation buffer depends on the implementation (see ). Regardless of the number of bits per component, the range of values stored by each component is [-1, 1]. The accumulation buffer pixels are mapped one-to-one with frame buffer pixels. operates on the accumulation buffer. The first argument selects an accumulation buffer operation. The second argument, is a floating-point value to be used in that operation, see d.All accumulation buffer operations are limited to the area of the current scissor box and applied identically to the red, green, blue, and alpha components of each pixel. If an  operation results in a value outside the range [-1, 1], the contents of an accumulation buffer pixel component are undefined.&To clear the accumulation buffer, use ( to specify the clear value, then call & with the accumulation buffer enabled.>defghijklmnopqrstuvw  xy z { |}~   Bdefghijklmnopqrstuvwxyz{|}~Bwxyzv{|}~qrstujklmnopdefghi/defghijklmnopqrstuvw  xy z { |}~   (c) Sven Panne 2002-2015BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone<enable or disable blending based on the buffer bound to the i@'th drawBuffer that is the buffer fmap (!! i) (get drawBuffers)?   R89:;<=>?@ABCDEFGHIJKLMNOPR89:;<=>?@ABCDEFGHIJKLMNOP!   (c) Sven Panne 2006-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone binds a varying variable, specified by program and name, to a drawbuffer. The effects only take place after succesfull linking of the program. invalid arguments and conditions are - an index larger than maxDrawBufferIndex - names starting with gl_ linking failure will ocure when - one of the arguments was invalid - more than one varying varuable name is bound to the same index It's not an error to specify unused variables, those will be ingored.query the binding of a given variable, specified by program and name. The program has to be linked. The result is Nothing if an error occures or the name is not a name of a varying variable. If the program hasn't been linked an InvalidOperation error is generated.        0(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone4         1(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone4      2(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone3Convenience state variableConvenience state variable'                              (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone3  !"#$%&'()*+,-. / 01234 56 7 89:;QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;*+,-./ !"#$%&'()QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~0123456789:;  !"#$%&'()*+,-. / 01234 56 7 89:;v(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneG<=>?@ABCDEFGHIJKLMNOPQRSTU V W X Y Z  [                         !+<=>?@ABCDEFGHIJKLMNOPQRSTU V W X Y Z  [   ,<=>?@ABCDEFGHIJKLMNOPQRSTU V W X Y Z  [                         !4(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone\\\\5(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone]^_]^_]^_]^_6(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone4`abc " # $ % & ' ( ) * + , - . /defg 0 1hij 2klmnop 3qrst 4 5 6 7u 8 9 :vw ; < =`abcdefghijklmnopqrstuvwdefghijklmnopqrst`abcuvw"`abc " # $ % & ' ( ) * + , - . /defg 0 1hij 2klmnop 3qrst 4 5 6 7u 8 9 :vw ; < =(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone > ? @ A B C D E F G H I J Kx L M Nyz O{|  !"xyz{|  !"xyz{| > ? @ A B C D E F G H I J Kx L M Nyz O{|w(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone !"#$%&'()*+,-./01234567QRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"123456789:;KLM      !"#$%&'()*+,-./0123456789:;`abcdefghijklmnopqrstuvwxyz{|(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone} P~ Q R S T U}~~}} P~ Q R S T U3(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone8 V W X YT<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[TSTOPQRMNKLDEFGHIJ@ABC>?<=[ZYXWVU. V W X Y7&(c) Sven Panne, Lars Corbijn 2011-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone Z [ \ ] ^ _ ` a b   Z [ \ ] ^ _ ` a b &(c) Sven Panne, Lars Corbijn 2011-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone    8&(c) Sven Panne, Lars Corbijn 2011-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNonetries to retrieve the object that is bound to the attachment point of the given framebuffertarget. If the object type of it is None or the default, then  h" is returned, otherwise the bound  or 7 c d e f g h i j k l m n o p q r s t u v w x y z { | } ~   c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  x(c) Sven Panne 2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneD  9(c) Sven Panne 2006-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone3'      y(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNonew<=>?@ABCDE     :(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone"     z(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone    (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone9Note: OpenGL 3.1 deprecated this texture parameter, use { instead.#                            ;(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone\ !"#$%&'()*+,-./0123    4  56   78   9: ;<' !"#$%&'()*+,-./0123456789:;<',-./01234#$%&'()*+56 !"789:;<) !"#$%&'()*+,-./0123      4  56   78   9: ;<(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneCGenerate mipmaps for the specified texture target. Note that from OpenGL 3.1 onwards you should use this function instead of the texture parameter |.=> ?@ABC =>?@ABC >?@=ABC=> ?@ABC}(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\      !"#$%&'()*+,-./0123456789:;<=>?@ABC<(c) Sven Panne 2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone DEFGH IJKDEFGHIJKDEFGHIJKDEFGH IJK=(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone3LM and N support efficient specification of rectangles as two corner points. Each rectangle command takes four arguments, organized either as two consecutive pairs of (x, yB) coordinates, or as two pointers to arrays, each containing an (x, y3) pair. The resulting rectangle is defined in the z = 0 plane.M ( x1 y1) ( x2, y2)2 is exactly equivalent to the following sequence:  m ~ $ do  ( x1 y1)  ( x2 y1)  ( x2 y2)  ( x1 y2) Note that if the second vertex is above and to the right of the first vertex, the rectangle is constructed with a counterclockwise winding.LMN    LMNLMNLMN    >,(c) Sven Panne 2002-2013, Tobias Markus 2015BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneO3Specification of the way the vertices given during renderPrimitive; are interpreted. In the description of the constructors, n+ is an integer count starting at one, and N+ is the total number of vertices specified.P-Treats each vertex as a single point. Vertex n defines point n. N points are drawn.QHTreats each pair of vertices as an independent line segment. Vertices 2n-1 and 2n define line n. N/2 lines are drawn.RnDraws a connected group of line segments from the first vertex to the last, then back to the first. Vertices n and n+1 define line n2. The last line, however, is defined by vertices N and 1. N lines are drawn.SWDraws a connected group of line segments from the first vertex to the last. Vertices n and n+1 define line n. N-1 lines are drawn.TFTreats each triplet of vertices as an independent triangle. Vertices 3n-2, 3n-1, and 3n define triangle n. N/3 triangles are drawn.UDraws a connected group of triangles. One triangle is defined for each vertex presented after the first two vertices. For odd n , vertices n, n+1, and n+2 define triangle n . For even n , vertices n+1, n, and n+2 define triangle n. N-2 triangles are drawn.VDraws a connected group of triangles. One triangle is defined for each vertex presented after the first two vertices. Vertices 1, n +1, and n+2 define triangle n. N-2 triangles are drawn.WOTreats each group of four vertices as an independent quadrilateral. Vertices 4n-3, 4n-2, 4n -1, and 4n define quadrilateral n. N/4 quadrilaterals are drawn.XDraws a connected group of quadrilaterals. One quadrilateral is defined for each pair of vertices presented after the first pair. Vertices 2n-1, 2n, 2n +2, and 2n+1 define quadrilateral n. N/2-1 quadrilaterals are drawn. Note that the order in which vertices are used to construct a quadrilateral from strip data is different from that used with independent data.Y3Draws a single, convex polygon. Vertices 1 through N define this polygon.Z^Only used in conjunction with tessellation. The number of vertices per patch can be set with [.[[/ is the number of vertices per patch primitive.An  k is generated if [j is set to a value less than or equal to zero or greater than the implementation-dependent maximum value \.\<Contains the maximumum number of vertices in a single patch.]oContains the four default outer tessellation levels to be used when no tessellation control shader is present.^nContains the two default inner tessellation levels to be used when no tessellation control shader is present._0Contains the maximum allowed tessellation level.OPQRSTUVWXYZ[\]^_OPQRSTUVWXYZ[\]^_OPQRSTUVWXYZ[\]^_O PQRSTUVWXYZ[\]^_(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone      (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone`KDelimit the vertices that define a primitive or a group of like primitives.mOnly a subset of GL commands can be used in the delimited action: Those for specifying vertex coordinates (, ), vertex colors (, , , , ,  ), normal (q, ), texture coordinates (, , , ), and fog coordinates (, ). Additionally, , , , , , ,  ,  ,  ,  ,  ,  , ", ", and setting c^ are allowed. Writing the respective state variables is allowed in the delimited action, too.Regardless of the chosen OS, there is no limit to the number of vertices that can be defined during a single `C. Lines, triangles, quadrilaterals, and polygons that are incompletely specified are not drawn. Incomplete specification results when either too few vertices are provided to specify even a single primitive or when an incorrect multiple of vertices is specified. The incomplete primitive is ignored; the rest are drawn.The minimum specification of vertices for each primitive is as follows: 1 for a point, 2 for a line, 3 for a triangle, 4 for a quadrilateral, and 3 for a polygon. Modes that require a certain multiple of vertices are Q (2), T (3), W (4), and X (2).a7A more efficient, but potentially dangerous version of `9: The given action is not allowed to throw an exception.cYEach vertex of a polygon, separate triangle, or separate quadrilateral specified during `M is marked as the start of either a boundary or nonboundary (interior) edge.The vertices of connected triangles and connected quadrilaterals are always marked as boundary, regardless of the value of the edge flag.IBoundary and nonboundary edge flags on vertices are significant only if  is set to  or .RNote that the current edge flag can be updated at any time, in particular during `.`a bc#$%`abc`ab#$%c`a bc (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneddefghijklmnopqrstuvwxyz{|}~      ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A`HIJdefghijklmnopqrstuvwxyz{|}~`HIJyz{|}~jklmnopqrstuvwxihgfedLdefghijklmnopqrstuvwxy z{|}~      ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A?(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone:Convenience function for an exception-safe combination of  and .k B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e fFF= B C D E F  G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone% g h i j k l m n o p q r s t u v w x y z { | } ~   z { | } ~   g h i j k l m n o p q r s t u v w x y z { | } ~  (c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone>1       '()*+'()*+#        @&(c) Sven Panne, Lars Corbijn 2011-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone gMax number of seprate atributes or varyings than can be captured in transformfeedback, initial value 4 ZMax number of components to write to a single buffer in interleaved mod, initial value 64 SMax number of components per attribute or varying in seperate mode initial value 4 kSet all the transform feedbacks varyings for this program it overwrites any previous call to this function 2Get the currently used transformFeedbackBufferMode SThe number of varyings that are currently recorded when in transform feedback mode BThe maximum length of a varying's name for transform feedback mode?The name, datatype and size of the transform feedback varyings.                    A(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone $A triangulation of a complex polygon2A triangle, represented by three triangle verticesFA triangle vertex with additional information about the edge it begins_The contours of a complex polygon, represented by one or more non-intersecting simple contours'A simple, non-self-intersecting contourA general tessellator type.Before tessellation of a complex polygon, all its vertices are projected into a plane perpendicular to the given normal. If the given normal is  Normal3 0 0 0*, a fitting plane of all vertices is used.FThe relative tolerance under which two vertices can be combined (see ). Multiplication with the largest coordinate magnitude of all polygon vertices yields the maximum distance between two mergeable vertices.?Note that merging is optional and the tolerance is only a hint.ZA function combining given vertex properties into a property for a newly generated vertexFour vertex properties (cf. %-) with associated weigths summing up to 1.0.!mA complex (possibly concave) polygon, represented by one or more complex and possibly intersecting contours.#AA complex contour, which can be self-intersecting and/or concave.%{The basic building block in tessellation is a 3D vertex with an associated property, e.g. color, texture coordinates, etc.I  !"#$%&'()*+, -. / ! !"#$%&'()*+,-./!%&#$!" '()*+,-./:  !"#$%&'()*+, -. / B(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone;0123456789 :;<= >?@ABC D EFGHI JKL MNOPQ RS T U V '0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV'CDBEAF@G?H>IJKLMN=OPQ:;<RS456789TU0123V+0123456789  :;<= >?@ABC D EFGHI JKL MNOPQ RS T U V &(c) Sven Panne, Lars Corbijn 2004-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone3c:Convenience function for an exception-safe combination of a and b.h{Record the time after all previous commands on the GL client and server state and the framebuffer have been fully realizedisContains the GL time after all previous commands have reached the GL server but have not yet necessarily executed.$W XYZ[\]^_` abc de fg hi WXYZ[\]^_`abcdefghi_`XYZ[\]^abcdefWghiW   XYZ[\]^_` abc de fg hi C(c) Sven Panne 2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNonejklmnopqrstu v wxy z jklmnopqrstuvwxyzuvtrsmnopqwxyjklzjklmnopqrstu v wxy z D(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone{Different GL implementations buffer commands in several different locations, including network buffers and the graphics accelerator itself. { empties all of these buffers, causing all issued commands to be executed as quickly as they are accepted by the actual rendering engine. Though this execution may not be completed in any particular time period, it does complete in finite time.Because any GL program might be executed over a network, or on an accelerator that buffers commands, all programs should call {f whenever they count on having all of their previously issued commands completed. For example, call {D before waiting for user input that depends on the generated image. Note that {p can return at any time. It does not wait until the execution of all previously issued GL commands is complete.|| does not return until the effects of all previously called GL commands are complete. Such effects include all changes to GL state, all changes to connection state, and all changes to the frame buffer contents. Note that |% requires a round trip to the server.{|{|{|{|(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone}   FG9:;<=>?@ABCDEFGHIJKLMNOPQR]^_ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNoneF       ~ !"#$%&'()*+,-./0123456789:;<=  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012345678STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|(c) Sven Panne 2002-2013BSD3 Sven Panne <svenpanne@gmail.com>stableportableNone       ~ !"#$%&'()*+,-./0123456789:;<=  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|>EEEEEEEEEEEEEEEEEEFFFFFHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIJJJJJJJJJJJJJJJJKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK K K K K KKKKKKKKKKKKKKKKKKK K!K"K#K$K%K&K'K(K)K*K+K,K-K.K/K0K1K2K3K4K5K6K7K8K9K:K;K<K=K>K?K@KAKBKCKDKEKFKGKHKIKJKKKLKMKNKOKPKQKRKSKTKUKVKWKXKYKZL[L\L]L^M_M`MaMbMcMdMeMfMgMhMiMjMkOlOOOmPnPoPpPqPrPsPtPuPvPwPxPyPzP{P|P}P~PPPPPPPPPPPPPPPQQRRSSSSTTTTkTlTTTTTTTTT VVVVVVVVVVVWWWWYY[[[\\\^^^_`````aaaaabbccc         !"#$%&&'()*+,-./012d3e456789:;<=>?f@ A A B C D EgFgFhGHHIIJKiLiMiNiOiPiQiRiSiTiUiViWiXiYiZi[i\i]i^i_i`iaibicidieifigihiiijikiliminioipiqirisitiuiviwixiyizi{i|i}i~j      !!!!!!!!!!!!!!!"""""""""""""#$$$$$$%%%%%%%%%%&&&&'''''''''''''''''''''''''''''''''''''''''''''''t'''''s'r'(((()******** * *u* *  +++++++,, !"#$%&'()*+,-./0123456789:;<=>q?@ABCDEFGHIJKLMN-O-P-Q-R-S-T-U-V-W-X-Y-Z-[-\-]-^ _ ` a b c d e f g h i j k l m n o p q r s t u v v w x y z { | } ~               ..........................//////<///////////     p !"#$%&'()*+,-./010202030405060708090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H0I0J1K1L1M1N1O1P1Q1R1S1T1U1V2W2X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j2k2lmnmoopqrstuvwxxyz{|}~vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv455566666666666666666666666633333333333333333333333333333333333333333333333333337777777 7 7     8888888888888888 8!8"8#8$8%8&8'8(8)9*9+9,9-9.9.9/90:1:2:3:4:5:6:7:8:9:::;:<:=:>?@ABCDEFGHIJKLMNOPQRS|TUVW;X;Y;Z;[;\;];^;^;_;`;a;b;c;d;e;f;g;h;i;j;k;l;m;n;o;p;q;r;s;t;u;v;w;x;y;z;{;|;}~{<<<<<<<<===>>>>>>>>>>>~>>>>>>m                                                             ???????????????????????????????????????????? ? ? ? ? ??????????????????? ?!?"?#$%&'()*+,-./01123456789:@;@<@=@>@?@@@A@B@C@D@E@F@G@HAIAIAJAJAKAKALALAMANANAOAOAPAQARASASATATAUAUAVAVAWAXAYAZA[A\A]A^A_B`BaBbBcBdBeBfBgBhBiBjBkBlBmBnBoBpBqBrBsBtBuBvBwBxByBzB{B|B}B~BBBBBBBBCCCCCCCCCCCCCCCCCDDEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFGGGGGGGGHHIIJJKKKLMMMMMNNNNNNNNNNNNOOP P P P P PPPPPPQRRRSSTTTTTTT T!T"T#T$T%U&U'U(U)U*U+U,U-U.U/U0U1V2V3V4V5V6V7W8W9X:X;X<X=X>X?X@XAXBXCXDXEXFXGXHXIXJXKXLXMXNXOXPXQXRXSXTXUXVXWXXXYXZX[X\X]X^X_X`XaXbXcXdXeXfXgXhXiXjXkXlXmXnXoXpXqXrXsXtXuXvXwXxXyXzX{X|X}X~XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX X X X X XXXXXXXXXXXXXXXXXXX X!X"X#X$X%X&X'X(X)X*X+X,X-X.X/X0X1X2X3X4X5X6X7X8X9X:X;X<X=X>X?X@XAXBXCXDXEXFXGXHXIXJXKXLXMXNXOXPXQXRXSXTXUXVXWXXXYXZX[X\X]X^X_X`XaXbXcXdXeXfXgXhXiXjXkXlXmXnXoXpXqXrXsXtXuXvXwXxXyXzX{X|X}X~XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX X X X X X X X X X X X X X X Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y !Y "Z #Z $[ %\ &\ '] (] ) * + , * + -^ .^ /_ 0_ 1_ 2_ 3_ 4_ 5_ 6_ 7_ 8` 9` :` ;` <` =`x`z` >` ?a @a Aa Ba C D E F G H I J K L M N O P Q R S T U V W Xb Yb Zb [b \b ]b ^b _ ` a b cc dc ec fc gc hc ic jc kc lc mc nc oc pc qc rc sc tc uc vc wc xc yc zc {c |c }c ~c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c c                                                                           d3d d d d !d "e4e #e $e %e & ' ( ) *f@f +f ,f -f . / 0 1g 2g 3g 4g 5h 6h 7h 8h 9h :h ;h <h =h >h ?h;h @h Ah Bh Ch Dh Eh Fh Gh Hh Ih Jh Kh Lh Mh Nh Oh Ph QhGh Rh Sh Th Uh Vh Wh X Y Z [ \i ]i ^ _ ` a bjj cj dj e f g h i j k l m n o p q r s t u v w x y! z! {! |! }" ~" " " " " " "        *  & ' ' ' ' ' ' ' '' ' '' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( * * + + + + ,, , , , , , ,                                                                                             ! " # $ % & ' ( ) * + ,- -- .- /- 0- 1- 2- 3- 4- 5- 6- 7- 8- 9- :- ;- <- =- >- ?- @- A- B- C  D  E  F  G p  H  I  J  K   L  M  N  O  P  Q  R  S  T  U  V  W  X  Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { |. }. ~. . . . . . . .m. / // / / / / / / // /// / / / / / / / / / / /                       0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2W2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2                     v v v v v v v v v v !v "v #v $v %v &v 'v (v )v *v +v ,v -v .v /v 0v 1v 2v 3v 4v 5v 6v 7v 8v 9v :v ;v <v =v >6 ?6 @6 A6 B6 C6 D66 E6 F6 G6 H6 I6 J6 K6 L6 M6 N6 O6 P6 Q6 R6 S6 T6 U6 V6 W6 X6 Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p3 q3 r3 s3 t7 u7 u7 v7 v7 w7 x7 y7 z7 {8 |8 }8 ~8 8 8 8 8 8 8 8 8 88 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 : : : : : : : : : : : : : : : : : : : : z z z z z z z z z z z z~z z z?z zz z z z z z z z z z z z z z z          ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; !; "; #; $; %< &= '= (= )= * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T? U? V? W? X? Y?? Z? [? \? ]? ^? _? `? a? b? c? d? e? f? g? h? i? j? k? l? m? n? o? p? q? r? s? t? u? v? w? x y z { | } ~               2%+                  @ @ A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B B B B B B B B B B B B B B B B                 CC C C C CC                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 789:89;89<89=89>89?89?89@89@89A89B89C89D89E89F89G89HIOpenG_3p7WkqSWYGH9zaPfSEwek5'Graphics.Rendering.OpenGL.GL.VertexSpec1Graphics.Rendering.OpenGL.GL.Texturing.Parameters:Graphics.Rendering.OpenGL.GL.PixelRectangles.Rasterization(Graphics.Rendering.OpenGL.GL.PerFragment7Graphics.Rendering.OpenGL.GL.PixelRectangles.ColorTableBGraphics.Rendering.OpenGL.GL.FramebufferObjects.FramebufferObjects(Graphics.Rendering.OpenGL.GL.Framebuffer%Graphics.Rendering.OpenGL.GL.Polygons)Graphics.Rendering.OpenGL.GL.VertexArrays#Graphics.Rendering.OpenGL.GL.Colors$Graphics.Rendering.OpenGL.GLU.Errors;Graphics.Rendering.OpenGL.GL.FramebufferObjects.AttachmentsCGraphics.Rendering.OpenGL.GL.FramebufferObjects.RenderbufferObjects6Graphics.Rendering.OpenGL.GL.PixelRectangles.Histogram%Graphics.Rendering.OpenGL.GL.BeginEnd(Graphics.Rendering.OpenGL.GL.DebugOutput'Graphics.Rendering.OpenGL.GL.Evaluators&Graphics.Rendering.OpenGL.GL.Selection9Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelStorage+Graphics.Rendering.OpenGL.GL.Shaders.Limits2Graphics.Rendering.OpenGL.GL.Shaders.ShaderObjects,Graphics.Rendering.OpenGL.GLU.Initialization3Graphics.Rendering.OpenGL.GL.PixelRectangles.Minmax(Graphics.Rendering.OpenGL.GL.SavingState*Graphics.Rendering.OpenGL.GL.StringQueries#Graphics.Rendering.OpenGL.GL.Tensor)Graphics.Rendering.OpenGL.GL.QueryObjects.Graphics.Rendering.OpenGL.GL.Texturing.Objects3Graphics.Rendering.OpenGL.GL.Shaders.ProgramObjects4Graphics.Rendering.OpenGL.GL.Shaders.ProgramBinaries,Graphics.Rendering.OpenGL.GL.Shaders.Attribs3Graphics.Rendering.OpenGL.GL.Shaders.ShaderBinaries"Graphics.Rendering.OpenGL.GL.Hints)Graphics.Rendering.OpenGL.GL.DisplayLists%Graphics.Rendering.OpenGL.GL.ColorSum)Graphics.Rendering.OpenGL.GL.LineSegments#Graphics.Rendering.OpenGL.GL.Points)Graphics.Rendering.OpenGL.GL.Antialiasing'Graphics.Rendering.OpenGL.GL.CoordTrans%Graphics.Rendering.OpenGL.GL.Clipping$Graphics.Rendering.OpenGL.GL.Bitmaps+Graphics.Rendering.OpenGL.GL.ReadCopyPixels$Graphics.Rendering.OpenGL.GLU.Matrix/Graphics.Rendering.OpenGL.GL.VertexArrayObjects&Graphics.Rendering.OpenGL.GL.RasterPos&Graphics.Rendering.OpenGL.GLU.Quadrics Graphics.Rendering.OpenGL.GL.Fog%Graphics.Rendering.OpenGL.GL.Feedback:Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelTransfer5Graphics.Rendering.OpenGL.GL.PixelRectangles.PixelMap4Graphics.Rendering.OpenGL.GL.Texturing.Specification2Graphics.Rendering.OpenGL.GL.Texturing.Application(Graphics.Rendering.OpenGL.GLU.Mipmapping8Graphics.Rendering.OpenGL.GL.PixelRectangles.Convolution,Graphics.Rendering.OpenGL.GL.PixellikeObject7Graphics.Rendering.OpenGL.GL.FramebufferObjects.Queries,Graphics.Rendering.OpenGL.GL.Shaders.Uniform.Graphics.Rendering.OpenGL.GL.Texturing.Queries3Graphics.Rendering.OpenGL.GL.Texturing.Environments1Graphics.Rendering.OpenGL.GL.ConditionalRendering'Graphics.Rendering.OpenGL.GL.Rectangles*Graphics.Rendering.OpenGL.GL.PrimitiveMode*Graphics.Rendering.OpenGL.GL.BufferObjects.Graphics.Rendering.OpenGL.GL.TransformFeedback*Graphics.Rendering.OpenGL.GLU.Tessellation#Graphics.Rendering.OpenGL.GLU.NURBS(Graphics.Rendering.OpenGL.GL.SyncObjects(Graphics.Rendering.OpenGL.GL.FlushFinish-Graphics.Rendering.OpenGL.GL.VertexAttributes-Graphics.Rendering.OpenGL.GL.Texturing.Filter+Graphics.Rendering.OpenGL.GL.PointParameter(Graphics.Rendering.OpenGL.GL.PixelFormat/Graphics.Rendering.OpenGL.GL.ComparisonFunction+Graphics.Rendering.OpenGL.GL.BlendingFactor:Graphics.Rendering.OpenGL.GL.Texturing.PixelInternalFormatAGraphics.Rendering.OpenGL.GL.FramebufferObjects.FramebufferTarget'Graphics.Rendering.OpenGL.GL.BufferMode$Graphics.Rendering.OpenGL.GL.IOState(Graphics.Rendering.OpenGL.GL.PolygonMode%Graphics.Rendering.OpenGL.GL.DataType&Graphics.Rendering.OpenGL.GL.PixelData2Graphics.Rendering.OpenGL.GL.Texturing.TextureUnit!Graphics.Rendering.OpenGL.GL.Face,Graphics.Rendering.OpenGL.GLU.ErrorsInternal%Graphics.Rendering.OpenGL.GL.PeekPokeKGraphics.Rendering.OpenGL.GL.FramebufferObjects.FramebufferObjectAttachmentBGraphics.Rendering.OpenGL.GL.FramebufferObjects.RenderbufferTarget-Graphics.Rendering.OpenGL.GL.QueryUtils.PName4Graphics.Rendering.OpenGL.GL.QueryUtils.VertexAttrib&Graphics.Rendering.OpenGL.GL.GLboolean2Graphics.Rendering.OpenGL.GL.PixelRectangles.Reset1Graphics.Rendering.OpenGL.GL.PixelRectangles.Sink&Graphics.Rendering.OpenGL.GL.Exception%Graphics.Rendering.OpenGL.GL.EdgeFlag'Graphics.Rendering.OpenGL.GL.QueryUtils#Graphics.Rendering.OpenGL.GL.Domain'Graphics.Rendering.OpenGL.GL.RenderMode'Graphics.Rendering.OpenGL.GL.ByteString'Graphics.Rendering.OpenGL.GL.Capability(Graphics.Rendering.OpenGL.GL.QueryObjectAGraphics.Rendering.OpenGL.GL.FramebufferObjects.FramebufferObjectBGraphics.Rendering.OpenGL.GL.FramebufferObjects.RenderbufferObject4Graphics.Rendering.OpenGL.GL.Texturing.TextureObject,Graphics.Rendering.OpenGL.GL.Shaders.Program.Graphics.Rendering.OpenGL.GL.Shaders.Variables+Graphics.Rendering.OpenGL.GL.Shaders.Shader InvalidValueInvalidOperationrenderPrimitive Data.BitstestBitsampleCoveragenormal normalize rescaleNormal activeTexture readBuffer4Graphics.Rendering.OpenGL.GL.Texturing.TextureTarget,Graphics.Rendering.OpenGL.GL.PixelRectangles/Graphics.Rendering.OpenGL.GL.FramebufferObjects$Graphics.Rendering.OpenGL.GL.Shaders3Graphics.Rendering.OpenGL.GL.Texturing.TexParametergenerateMipmap'generateMipmap&Graphics.Rendering.OpenGL.GL.TexturingPolygonvertex2Graphics.Rendering.OpenGL.GL.PrimitiveModeInternalvertexvcolorcolorvsecondaryColorsecondaryColorvindexindexvnormalvtexCoord texCoordv multiTexCoordmultiTexCoordvfogCoord fogCoordv evalPoint1 evalPoint2 evalCoord1 evalCoord1v evalCoord2 evalCoord2vmaterialAmbientmaterialDiffusematerialAmbientAndDiffusematerialSpecularmaterialEmissionmaterialShininesscallList callLists polygonModePointLine)Graphics.Rendering.OpenGL.GL.ControlPointGraphics.Rendering.OpenGL.GLUGraphics.Rendering.OpenGL.GLGraphics.Rendering.OpenGLIndex1Color4Color3 FogCoord1Normal3 TexCoord4 TexCoord3 TexCoord2 TexCoord1MagnificationFilterMinificationFilter TextureFilterNearestLinear' PixelFormat ColorIndex StencilIndexDepthComponent DepthStencilRedGreenBlueAlphaRGRGBRGBA LuminanceLuminanceAlpha RedInteger GreenInteger BlueInteger AlphaInteger RGInteger RGBInteger RGBAInteger BGRInteger BGRAIntegerABGRBGRBGRACMYKCMYKA FourTwoTwo FourTwoTwoRevFourTwoTwoAverageFourTwoTwoRevAverageYCBCR422ComparisonFunctionNeverLessEqualLequalGreaterNotequalGequalAlwaysBlendingFactorZeroOneSrcColorOneMinusSrcColorDstColorOneMinusDstColorSrcAlphaOneMinusSrcAlphaDstAlphaOneMinusDstAlpha ConstantColorOneMinusConstantColor ConstantAlphaOneMinusConstantAlphaSrcAlphaSaturatePixelInternalFormatAlpha'DepthComponent' Luminance'LuminanceAlpha' IntensityR8R16RG8RG16RGB'RGBA'SRGB SRGBAlpha SLuminanceSLuminanceAlphaAlpha4Alpha8Alpha12Alpha16DepthComponent16DepthComponent24DepthComponent32 Luminance4 Luminance8 Luminance12 Luminance16Luminance4Alpha4Luminance6Alpha2Luminance8Alpha8Luminance12Alpha4Luminance12Alpha12Luminance16Alpha16 Intensity4 Intensity8 Intensity12 Intensity16R3G3B2RGB4RGB5RGB8RGB10RGB12RGB16RGBA2RGBA4RGB5A1RGBA8RGB10A2RGBA12RGBA16SRGB8 SRGB8Alpha8R16FRG16FRGB16FRGBA16FR32FRG32FRGB32FRGBA32FR8IR8UIR16IR16UIR32IR32UIRG8IRG8UIRG16IRG16UIRG32IRG32UIRGB8IRGB8UIRGB16IRGB16UIRGB32IRGB32UIRGBA8IRGBA8UIRGBA16IRGBA16UIRGBA32IRGBA32UI SLuminance8SLuminance8Alpha8CompressedAlphaCompressedLuminanceCompressedLuminanceAlphaCompressedIntensity CompressedRed CompressedRG CompressedRGBCompressedRGBACompressedSRGBCompressedSRGBAlphaCompressedSLuminanceCompressedSLuminanceAlphaCompressedRedRGTC1CompressedSignedRedRGTC1CompressedRG_RGTC2CompressedSignedRG_RGTC2DepthComponent32fDepth32fStencil8RGB9E5 R11fG11fB10f StencilIndex1 StencilIndex4 StencilIndex8StencilIndex16FramebufferTargetDrawFramebufferReadFramebuffer Framebuffer BufferMode NoBuffersFrontLeftBufferFrontRightBufferBackLeftBufferBackRightBuffer FrontBuffers BackBuffers LeftBuffers RightBuffersFrontAndBackBuffers AuxBufferFBOColorAttachment PolygonModeFillDataType UnsignedByteByte UnsignedShortShort UnsignedIntInt HalfFloatFloatUnsignedByte332UnsignedByte233RevUnsignedShort565UnsignedShort565RevUnsignedShort4444UnsignedShort4444RevUnsignedShort5551UnsignedShort1555RevUnsignedInt8888UnsignedInt8888RevUnsignedInt1010102UnsignedInt2101010RevUnsignedInt248UnsignedInt10f11f11fRevUnsignedInt5999RevFloat32UnsignedInt248RevBitmapUnsignedShort88UnsignedShort88RevDoubleTwoBytes ThreeBytes FourBytes PixelData TextureUnitFaceFrontBack FrontAndBack ErrorCategory ContextLost InvalidEnumInvalidFramebufferOperation OutOfMemory StackOverflowStackUnderflow TableTooLargeTesselatorError NURBSErrorErrorerrorsFramebufferAttachmentmarshalAttachmentunmarshalAttachmentunmarshalAttachmentSafeFramebufferObjectAttachmentColorAttachmentDepthAttachmentStencilAttachmentDepthStencilAttachmentfboaToBufferModefboaFromBufferModeSamplesRenderbufferTarget RenderbufferAttribLocationResetNoResetSink PassThroughEdgeFlagBeginsInteriorEdgeBeginsBoundaryEdgemaxLabelLengthDomain RenderModeRenderFeedbackSelect renderModePixelStoreDirectionPackUnpack swapByteslsbFirst rowLengthskipRows skipPixels rowAlignment imageHeight skipImagesmaxVertexTextureImageUnitsmaxTextureImageUnitsmaxCombinedTextureImageUnitsmaxTextureCoordsmaxVertexUniformComponentsmaxFragmentUniformComponentsmaxVertexAttribsmaxVaryingFloatspackUtf8 unpackUtf8 gluVersion gluExtensions CapabilityDisabledEnabledminmax getMinmax resetMinmaxClientAttributeGroupPixelStoreAttributesVertexArrayAttributesAllClientAttributesServerAttributeGroupCurrentAttributesPointAttributesLineAttributesPolygonAttributesPolygonStippleAttributesPixelModeAttributesLightingAttributes FogAttributesDepthBufferAttributesAccumBufferAttributesStencilBufferAttributesViewportAttributesTransformAttributesEnableAttributesColorBufferAttributesHintAttributesEvalAttributesListAttributesTextureAttributesScissorAttributesMultisampleAttributesAllServerAttributespreservingAttribpreservingClientAttribContextProfile' CoreProfile'CompatibilityProfile'vendorrenderer glVersion glExtensionsextensionSupportedshadingLanguageVersioncontextProfile majorMinorVector4Vector3Vector2Vector1Vertex4Vertex3Vertex2Vertex1 CanBeLabeled objectLabel DebugGroup MessageGroupMessageGroupWithIDs DebugSeverityDebugSeverityHighDebugSeverityMediumDebugSeverityLowDebugSeverityNotificationDebugMessageID DebugTypeDebugTypeErrorDebugTypeDeprecatedBehaviorDebugTypeUndefinedBehaviorDebugTypePerformanceDebugTypePortabilityDebugTypeMarkerDebugTypePushGroupDebugTypePopGroupDebugTypeOther DebugSourceDebugSourceAPIDebugSourceShaderCompilerDebugSourceWindowSystemDebugSourceThirdPartyDebugSourceApplicationDebugSourceOther DebugMessage debugOutputmaxDebugMessageLengthdebugMessageCallbackmaxDebugLoggedMessagesdebugLoggedMessagesdebugMessageControldebugMessageInsertpushDebugGroup popDebugGroupwithDebugGroupmaxDebugGroupStackDepthdebugOutputSynchronous QueryObjectFramebufferObjectFramebufferStatusComplete UndefinedIncompleteMissingAttachmentIncompleteDrawBufferIncompleteReadBufferIncompleteMultiSample UnsupporteddefaultFramebufferObjectbindFramebufferframebufferStatusRenderbufferObjectRenderbufferSizenoRenderbufferObjectbindRenderbufferrenderbufferStorageMultiSamplerenderbufferStorage TextureObjectProgram ProgramBinaryProgramBinaryFormatprogramBinaryFormats programBinary VariableTypeFloat' FloatVec2 FloatVec3 FloatVec4Int'IntVec2IntVec3IntVec4 UnsignedInt'UnsignedIntVec2UnsignedIntVec3UnsignedIntVec4BoolBoolVec2BoolVec3BoolVec4 FloatMat2 FloatMat3 FloatMat4 FloatMat2x3 FloatMat2x4 FloatMat3x2 FloatMat3x4 FloatMat4x2 FloatMat4x3 Sampler1D Sampler2D Sampler3D SamplerCubeSampler1DShadowSampler2DShadowSampler1DArraySampler2DArraySampler1DArrayShadowSampler2DArrayShadowSamplerCubeShadow Sampler2DRectSampler2DRectShadow IntSampler1D IntSampler2D IntSampler3DIntSamplerCubeIntSampler1DArrayIntSampler2DArrayUnsignedIntSampler1DUnsignedIntSampler2DUnsignedIntSampler3DUnsignedIntSamplerCubeUnsignedIntSampler1DArrayUnsignedIntSampler2DArrayattribLocation activeAttribsShader PrecisionType ShaderType VertexShaderTessControlShaderTessEvaluationShaderGeometryShaderFragmentShader ComputeShadershaderCompiler createShadershaderSourceBS shaderSource compileShaderreleaseShaderCompiler shaderTypeshaderDeleteStatus compileStatus shaderInfoLogshaderPrecisionFormat ShaderBinaryShaderBinaryFormatshaderBinaryFormats shaderBinaryHintModeDontCareFastestNicest HintTargetPerspectiveCorrection PointSmooth LineSmooth PolygonSmoothFogGenerateMipmapTextureCompressionPackCMYK UnpackCMYKhintListModeCompileCompileAndExecute DisplayList defineList defineNewList listIndexlistModemaxListNestinglistBaseName HitRecord getHitRecordswithNameloadNamemaxNameStackDepthnameStackDepthcolorSum lineWidth lineStipple lineSmoothaliasedLineWidthRangesmoothLineWidthRangesmoothLineWidthGranularity pointSizevertexProgramPointSizepointSizeRangepointDistanceAttenuationpointFadeThresholdSize pointSmooth pointSpritealiasedPointSizeRangesmoothPointSizeRangesmoothPointSizeGranularity sampleBufferssamples multisample subpixelBitsTextureGenMode EyeLinear ObjectLinear SphereMap NormalMap ReflectionMapTextureCoordNameSTRQPlaneGLmatrixMatrix withNewMatrix withMatrix newMatrixgetMatrixComponentsMatrixComponentrotate translatescale MatrixOrder ColumnMajorRowMajor MatrixMode Modelview ProjectionTextureColor MatrixPaletteSizePosition depthRangeviewportmaxViewportDims matrixModematrix multMatrix loadIdentityorthofrustum depthClamppreservingMatrixunsafePreservingMatrix stackDepth maxStackDepthtextureGenMode ClipPlaneName clipPlane maxClipPlanesbitmap BlitBuffer ColorBuffer'StencilBuffer' DepthBuffer' PixelCopyType CopyColor CopyDepth CopyStencil readPixels copyPixelsblitFramebuffer drawPixels pixelZoomortho2D perspectivelookAt pickMatrixproject unProject unProject4VertexArrayObjectbindVertexArrayObject VertexAttrib vertexAttrib vertexAttribvVertexAttribComponent vertexAttrib1 vertexAttrib2 vertexAttrib3 vertexAttrib4vertexAttrib1NvertexAttrib2NvertexAttrib3NvertexAttrib4NvertexAttrib1IvertexAttrib2IvertexAttrib3IvertexAttrib4IvertexAttrib1vvertexAttrib2vvertexAttrib3vvertexAttrib4vvertexAttrib1NvvertexAttrib2NvvertexAttrib3NvvertexAttrib4NvvertexAttrib1IvvertexAttrib2IvvertexAttrib3IvvertexAttrib4IvIntegerHandlingToFloatToNormalizedFloat KeepIntegralIndexIndexComponentSecondaryColorColorComponentFogCoordFogCoordComponentNormalNormalComponentTexCoordTexCoordComponentVertexVertexComponentcurrentTextureCoords currentNormalcurrentFogCoordrgbaMode currentColorcurrentSecondaryColor currentIndexcurrentVertexAttribcurrentVertexAttribIcurrentVertexAttribIumaxTextureUnit WindowPos windowPos windowPosvWindowPosComponent RasterPos rasterPos rasterPosvRasterPosComponentcurrentRasterPositioncurrentRasterDistancecurrentRasterColorcurrentRasterSecondaryColorcurrentRasterIndexcurrentRasterTexCoordscurrentRasterPositionValidrasterPositionUnclipped ClampModeClampOn FixedOnlyClampOff ClampTargetClampVertexColorClampFragmentColorClampReadColor ShadingModelFlatSmoothColorMaterialParameterAmbientDiffuseSpecularEmissionAmbientAndDiffuseLightModelColorControl SingleColorSeparateSpecularColorFrontFaceDirectionCWCCWLightlightinglight maxLights frontFace maxShininessmaterialColorIndexesambientdiffusespecularposition spotDirection spotExponentmaxSpotExponent spotCutoff attenuationlightModelAmbientlightModelLocalViewerlightModelTwoSidevertexProgramTwoSidelightModelColorControl colorMaterial shadeModel clampColorQuadricPrimitiveSphereCylinderDisk PartialDiskLoopsStacksSlicesAngleHeightRadius QuadricStyleQuadricTextureNoTextureCoordinatesGenerateTextureCoordinatesQuadricOrientationOutsideInside QuadricNormalQuadricDrawStyle PointStyle LineStyle FillStyleSilhouetteStyle renderQuadricFogDistanceMode EyeRadialEyePlaneSignedEyePlaneAbsolute FogCoordSrc FragmentDepthFogModeLinearExpExp2fogfogModefogColorfogIndex fogCoordSrcfogDistanceModeAccumOpAccumLoadReturnMultAddClearBufferCommandClearColorBufferIntClearColorBufferFloatClearColorBufferUintClearDepthBufferClearStencilBufferClearDepthAndStencilBuffers ClearBuffer ColorBuffer AccumBuffer StencilBuffer DepthBufferDrawBufferIndex drawBuffernamedFramebufferDrawBuffer drawBuffersnamedFramebufferDrawBuffers drawBufferimaxDrawBuffers indexMask colorMask colorMaski depthMask stencilMaskstencilMaskSeparateclear clearColor clearIndex clearDepth clearDepthf clearStencil clearAccum clearBufferclearNamedFramebufferinvalidateSubFramebuffer!invalidateNamedFramebufferSubDatainvalidateFramebufferinvalidateNamedFramebufferData auxBuffers doubleBuffer stereoBufferrgbaBits stencilBits depthBits accumBitsrgbaSignedComponentsaccumLogicOpClearAnd AndReverseCopy AndInvertedNoopXorOrNorEquivInvert OrReverse CopyInverted OrInvertedNandSet BlendEquationFuncAdd FuncSubtractFuncReverseSubtractMinMax StencilOpOpZeroOpKeep OpReplaceOpIncr OpIncrWrapOpDecr OpDecrWrapOpInvertrasterizerDiscarddiscardingRasterizerscissorsampleAlphaToCoveragesampleAlphaToOne depthBounds alphaFunc stencilTest stencilFuncstencilFuncSeparate stencilOpstencilOpSeparateactiveStencilFace depthFuncblend blendBuffer blendEquationblendEquationSeparateblendFuncSeparate blendFunc blendColorditherlogicOp createProgram attachShader detachShaderattachedShaders linkProgramcurrentProgramvalidateProgramprogramInfoLogprogramSeparableprogramBinaryRetrievableHintprogramDeleteStatus linkStatusvalidateStatusbindFragDataLocationgetFragDataLocationPassThroughValue FeedbackTypeTwoDThreeD ThreeDColorThreeDColorTextureFourDColorTexture ColorInfo VertexInfoVertex2DVertex3D Vertex3DColorVertex3DColorTextureVertex4DColorTexture FeedbackToken PointToken LineTokenLineResetToken PolygonToken BitmapTokenDrawPixelTokenCopyPixelTokenPassThroughTokengetFeedbackTokens passThroughPixelTransferStagePreConvolutionPostConvolutionPostColorMatrixmapColor mapStencil indexShift indexOffset depthScale depthBias rgbaScalergbaBias GLpixelmapPixelMapwithNewPixelMap withPixelMap newPixelMapgetPixelMapComponentsPixelMapComponentPixelMapTargetIToISToSIToRIToGIToBIToARToRGToGBToBAToAmaxPixelMapTablepixelMappixelMapIToRGBApixelMapRGBAToRGBAProxyNoProxy ColorTablePostConvolutionColorTablePostColorMatrixColorTableTexture1DColorTableTexture2DColorTableTexture3DColorTableTextureCubeMapColorTableTextureColorTableSharedTexturePaletteColorTableStagePostConvolutionColorTableStagePostColorMatrixColorTableStageTextureColorTableStagecolorTableStage colorTable getColorTablecopyColorTable colorSubTablecopyColorSubTablecolorTableScalecolorTableBiascolorTableFormatcolorTableWidthcolorTableRGBASizescolorTableLuminanceSizecolorTableIntesitySizeTextureTargetBufferTextureBuffer'TextureTarget2DMultisampleArrayTexture2DMultisampleArrayTextureTarget3D Texture3DTexture2DArrayTextureCubeMapArrayTextureTargetCubeMapFaceTextureCubeMapPositiveXTextureCubeMapNegativeXTextureCubeMapPositiveYTextureCubeMapNegativeYTextureCubeMapPositiveZTextureCubeMapNegativeZTextureTargetCubeMapTextureCubeMapTextureTarget2DMultisampleTexture2DMultisampleTextureTarget2D Texture2DTexture1DArrayTextureRectangleTextureTarget1D Texture1DGettableTextureTargetQueryableTextureTargetThreeDimensionalTextureTargetTwoDimensionalTextureTargetOneDimensionalTextureTargetParameterizedTextureTargetBindableTextureTargettexture scaleImagebuild1DMipmapsbuild2DMipmapsConvolutionBorderModeReduceConstantBorderReplicateBorderConvolutionTarget Convolution1D Convolution2D Separable2D convolutionconvolutionFilter1DgetConvolutionFilter1DconvolutionFilter2DgetConvolutionFilter2DseparableFilter2DgetSeparableFilter2DcopyConvolutionFilter1DcopyConvolutionFilter2DconvolutionWidthconvolutionHeightmaxConvolutionWidthmaxConvolutionHeightconvolutionBorderModeconvolutionFilterScaleconvolutionFilterBias histogram getHistogramresetHistogramhistogramRGBASizeshistogramLuminanceSizeGLpolygonstipplePolygonStipplewithNewPolygonStipplewithPolygonStipplenewPolygonStipplegetPolygonStippleComponents polygonSmoothcullFacepolygonStipple polygonOffsetpolygonOffsetPointpolygonOffsetLinepolygonOffsetFillSampleLocationsFlexibleSampleLocationsFixedSampleLocationsCompressedPixelDataCompressedTextureFormat TextureSize3D TextureSize2D TextureSize1DTexturePosition3DTexturePosition2DTexturePosition1DBorderLevel texImage1D texImage2D texImage3D getTexImagecopyTexImage1DcopyTexImage2D texSubImage1D texSubImage2D texSubImage3DcopyTexSubImage1DcopyTexSubImage2DcopyTexSubImage3DcompressedTextureFormatscompressedTexImage1DcompressedTexImage2DcompressedTexImage3DgetCompressedTexImagecompressedTexSubImage1DcompressedTexSubImage2DcompressedTexSubImage3DtexImage2DMultisampletexImage3DMultisamplemaxTextureSizemaxCubeMapTextureSizemaxRectangleTextureSizemax3DTextureSizemaxArrayTextureLayersmaxSampleMaskWordsmaxColorTextureSamplesmaxDepthTextureSamplesmaxIntegerSamplesPixellikeObjectTargetpixellikeObjTarParamPixellikeObjectGetPNameRedSizeBlueSize GreenSize AlphaSize DepthSize StencilSizeframebufferRenderbufferframebufferTexture1DframebufferTexture2DframebufferTexture3DframebufferTextureLayerAttachmentObjectTypeDefaultFramebufferAttachmentTextureAttachmentRenderbufferAttachmentattachmentObjectTypeattachmentObjectattachmentTextureLayerattachmentTextureLevel)attachmentTextureTextureTargetCubeMapFaceattachmentRedSizeattachmentGreenSizeattachmentBlueSizeattachmentAlphaSizeattachmentDepthSizeattachmentStencilSizerenderbufferWidthrenderbufferHeightrenderbufferInternalFormatrenderbufferSamplesrenderbufferRedSizerenderbufferGreenSizerenderbufferBlueSizerenderbufferAlphaSizerenderbufferDepthSizerenderbufferStencilSizeUniformuniformuniformvUniformComponentUniformLocationuniformLocationactiveUniforms TextureQuerytextureInternalFormat textureSize1D textureSize2D textureSize3D textureBordertextureRGBASizestextureSharedSizetextureIntensitySizetextureLuminanceSizetextureIndexSizetextureDepthBitstextureCompressedImageSizetextureProxyOKTextureCompareOperatorLequalRGequalRLODClampingClampRepeat ClampToEdge ClampToBorder RepetitionRepeatedMirrored textureFiltertextureWrapModetextureBorderColortextureObjectLODBiasmaxTextureLODBiastextureLODRangetextureMaxAnisotropymaxTextureMaxAnisotropytextureLevelRangedepthTextureModetextureCompareModetextureCompareFailValuetextureCompareOperatorSrc CurrentUnitPreviousCrossbarConstant PrimaryColorArgArgNumArg0Arg1Arg2Arg3TextureCombineFunctionReplace' Modulate' AddUnsigned' AddSigned InterpolateSubtractDot3RGBDot3RGBATextureFunctionModulateDecalBlendReplace AddUnsignedCombineCombine4textureFunction combineRGB combineAlphaargRGBargAlphargbScale alphaScale constantColortextureUnitLODBiasTexturePrioritytextureBindingtextureResidentareTexturesResidenttexturePriorityprioritizeTexturesConditionalRenderMode QueryWait QueryNoWaitQueryByRegionWaitQueryByRegionNoWaitbeginConditionalRenderendConditionalRenderwithConditionalRenderRectrectrectv PrimitiveModePointsLinesLineLoop LineStrip Triangles TriangleStrip TriangleFanQuads QuadStripPatches patchVerticesmaxPatchVerticespatchDefaultOuterLevelpatchDefaultInnerLevelmaxTessGenLevelunsafeRenderPrimitiveprimitiveRestartedgeFlag BaseVertex BaseInstance NumInstancesNumIndexBlocksNumArrayIndices ArrayIndexInterleavedArraysV2fV3fC4ubV2fC4ubV3fC3fV3fN3fV3f C4fN3fV3fT2fV3fT4fV4f T2fC4ubV3f T2fC3fV3f T2fN3fV3f T2fC4fN3fV3f T4fC4fN3fV4fClientArrayType VertexArray NormalArray ColorArray IndexArrayTextureCoordArray EdgeFlagArray FogCoordArraySecondaryColorArrayMatrixIndexArrayVertexArrayDescriptorStride NumComponents arrayPointerinterleavedArrays clientStateclientActiveTexture arrayElement drawArraysdrawArraysInstancedBaseInstancedrawArraysInstancedmultiDrawArrays drawElements!drawElementsInstancedBaseInstancedrawElementsInstancedmultiDrawElementsdrawRangeElementsdrawElementsBaseVertexdrawRangeElementsBaseVertexdrawElementsInstancedBaseVertex+drawElementsInstancedBaseVertexBaseInstancemultiDrawElementsBaseVertexmaxElementsVerticesmaxElementsIndices lockArraysprimitiveRestartIndexprimitiveRestartIndexNVvertexAttribPointervertexAttribArrayIndexedBufferTargetIndexedAtomicCounterBufferIndexedShaderStorageBufferIndexedTransformFeedbackBufferIndexedUniformBuffer BufferRange RangeSizeRangeStartIndex BufferIndexLengthOffsetMapBufferUsageReadWriteInvalidateRangeInvalidateBuffer FlushExplicit UnsychronizedMappingFailure MappingFailedUnmappingFailedTransferDirectionReadFromBuffer WriteToBuffer BufferAccessReadOnly WriteOnly ReadWrite BufferUsage StreamDraw StreamRead StreamCopy StaticDraw StaticRead StaticCopy DynamicDraw DynamicRead DynamicCopy BufferTarget ArrayBufferAtomicCounterBufferCopyReadBufferCopyWriteBufferDispatchIndirectBufferDrawIndirectBufferElementArrayBufferPixelPackBufferPixelUnpackBuffer QueryBufferShaderStorageBuffer TextureBufferTransformFeedbackBuffer UniformBuffer BufferObject bindBufferarrayBufferBindingvertexAttribArrayBufferBinding bufferData bufferSubDatawithMappedBuffer mapBuffer unmapBuffer bufferAccess bufferMappedmapBufferRangeflushMappedBufferRangebindBufferBasebindBufferRangeindexedBufferStartindexedBufferSize ControlPointGLmap2Map2 withNewMap2withMap2newMap2getMap2ComponentsGLmap1Map1 withNewMap1withMap1newMap1getMap1Components MapDescriptorOrdermaxOrdermap1map2mapGrid1mapGrid2 evalMesh1 evalMesh2 autoNormalTransformFeedbackBufferModeInterleavedAttribsSeparateAttribsSeperateAttribsbeginTransformFeedbackendTransformFeedback"marshalTransformFeedbackBufferMode$unmarshalTransformFeedbackBufferMode#maxTransformFeedbackSeparateAttribs)maxTransformFeedbackInterleavedComponents&maxTransformFeedbackSeparateComponentssetTransformFeedbackVaryingstransformFeedbackBufferModetransformFeedbackVaryings SimplePolygon Primitive TriangulationTriangleTriangleVertexPolygonContours SimpleContour Tessellator ToleranceCombinerWeightedPropertiesComplexPolygonComplexContourAnnotatedVertex TessWindingTessWindingOddTessWindingNonzeroTessWindingPositiveTessWindingNegativeTessWindingAbsGeqTwoextractContours triangulate tessellate DisplayMode'Fill'OutlinePolygon OutlinePatchSamplingMethod PathLengthParametricErrorDomainDistanceObjectPathLengthObjectParametricError NURBSModeNURBSTessellator NURBSRenderer TrimmingPointNURBSEndCallbackNURBSColorCallbackNURBSNormalCallbackNURBSVertexCallbackNURBSBeginCallbackNURBSObj withNURBSObjwithNURBSBeginCallbackwithNURBSVertexCallbackwithNURBSNormalCallbackwithNURBSColorCallbackwithNURBSEndCallbackcheckForNURBSErrornurbsBeginEndCurve nurbsCurvenurbsBeginEndSurface nurbsSurfacenurbsBeginEndTrimpwlCurve trimmingCurve setNURBSModesetNURBSCullingsetSamplingMethodloadSamplingMatricessetDisplayMode' QueryResult QueryTarget SamplesPassedAnySamplesPassedAnySamplesPassedConservative TimeElapsedPrimitivesGenerated"TransformFeedbackPrimitivesWritten QueryIndexmaxVertexStreams beginQueryendQuery withQuery currentQueryqueryCounterBitsqueryResultAvailable queryResulttimestampQuery timestamp SyncStatus UnsignaledSignaled WaitResultAlreadySignaledTimeoutExpiredConditionSatisfied WaitFailedWaitFlagSyncFlushCommands WaitTimeout SyncObjectsyncGpuCommandsCompleteclientWaitSyncwaitSyncmaxServerWaitTimeout syncStatusflushfinishpeekApplicativeTraversable addressesnextPtr pokeFoldablepokeAndAdvance$fStorableIndex1$fTraversableIndex1$fFoldableIndex1$fApplicativeIndex1$fFunctorIndex1$fStorableColor4$fTraversableColor4$fFoldableColor4$fApplicativeColor4$fFunctorColor4$fStorableColor3$fTraversableColor3$fFoldableColor3$fApplicativeColor3$fFunctorColor3$fStorableFogCoord1$fTraversableFogCoord1$fFoldableFogCoord1$fApplicativeFogCoord1$fFunctorFogCoord1$fStorableNormal3$fTraversableNormal3$fFoldableNormal3$fApplicativeNormal3$fFunctorNormal3$fStorableTexCoord4$fTraversableTexCoord4$fFoldableTexCoord4$fApplicativeTexCoord4$fFunctorTexCoord4$fStorableTexCoord3$fTraversableTexCoord3$fFoldableTexCoord3$fApplicativeTexCoord3$fFunctorTexCoord3$fStorableTexCoord2$fTraversableTexCoord2$fFoldableTexCoord2$fApplicativeTexCoord2$fFunctorTexCoord2$fStorableTexCoord1$fTraversableTexCoord1$fFoldableTexCoord1$fApplicativeTexCoord1$fFunctorTexCoord1magToMinminToMagmarshalMinificationFiltermarshalMagnificationFilterunmarshalMinificationFilterunmarshalMagnificationFilterPointParameter PointSizeMin PointSizeMaxPointFadeThresholdSizePointDistanceAttenuationmarshalPointParameterpointParameterfpointParameterfvmarshalPixelFormatunmarshalPixelFormatmarshalComparisonFunctionunmarshalComparisonFunctionmarshalBlendingFactorunmarshalBlendingFactormarshalPixelInternalFormatmarshalPixelInternalFormat'unmarshalPixelInternalFormatmarshalFramebufferTargetmarshalBufferModeunmarshalBufferModeunmarshalBufferModeSafe maxAuxBuffermaxColorAttachmentsIOState runIOState getIOState putIOState peekIOState liftIOState evalIOStatenTimes$fMonadIOState$fFunctorIOState$fApplicativeIOStatemarshalPolygonModeunmarshalPolygonMode DataTypeTypeTNoneTSignedNormalizedTUnsignedNormalizedTFloatTInt TUnsignedIntmarshalDataTypeunmarshalDataTypemarshalDataTypeTypeunmarshalDataTypeType withPixelDatamarshalTextureUnitunmarshalTextureUnit$fStorableTextureUnit marshalFace unmarshalFace makeErrortheRecordedErrorsgetRecordedErrorssetRecordedErrors getGLErrorsisError getErrorsrecordErrorCoderecordInvalidEnumrecordInvalidValuerecordOutOfMemorygetErrorCodesAuxpoke1poke2poke3poke4peek1peek2peek3peek4peek1Mpeek2Mpeek3Mpeek4M"marshalFramebufferObjectAttachment$unmarshalFramebufferObjectAttachment(unmarshalFramebufferObjectAttachmentSafegetFBAParameteriv!$fFramebufferAttachmentBufferMode2$fFramebufferAttachmentFramebufferObjectAttachmentmarshalRenderbufferTargetgetRBParameterivGetCurrentColorGetCurrentTextureCoordsGetCurrentSecondaryColorGetLightModelAmbientGetMap2GridDomain GetFogColorGetColorClearValueGetAccumClearValueGetCurrentRasterColorGetCurrentRasterSecondaryColorGetCurrentRasterTextureCoordsGetCurrentRasterPosition GetBlendColorGetPatchDefaultOuterLevelPName4ISemiIndexedGetColorWritemask GetViewportGetRGBASignedComponents GetScissorBoxGetCurrentNormalGetPointDistanceAttenuation GetDepthRangeGetMap1GridDomainGetAliasedPointSizeRangeGetSmoothPointSizeRangeGetAliasedLineWidthRangeGetSmoothLineWidthRangeGetDepthBoundsGetPatchDefaultInnerLevelGetMaxViewportDimsGetCurrentFogCoordGetZoomXGetZoomYGetMaxShininessGetMaxSpotExponent GetFogStart GetFogEnd GetFogDensityGetDepthClearValueGetIndexClearValueGetCurrentRasterDistanceGetPointSizeMinGetPointSizeMaxGetPointFadeThresholdSizeGetSmoothPointSizeGranularity GetPointSize GetLineWidthGetSmoothLineWidthGranularityGetSampleCoverageValueGetAlphaTestRef GetRedScale GetGreenScale GetBlueScale GetAlphaScaleGetPostConvolutionRedScaleGetPostConvolutionGreenScaleGetPostConvolutionBlueScaleGetPostConvolutionAlphaScaleGetPostColorMatrixRedScaleGetPostColorMatrixGreenScaleGetPostColorMatrixBlueScaleGetPostColorMatrixAlphaScale GetRedBias GetGreenBias GetBlueBias GetAlphaBiasGetPostConvolutionRedBiasGetPostConvolutionGreenBiasGetPostConvolutionBlueBiasGetPostConvolutionAlphaBiasGetPostColorMatrixRedBiasGetPostColorMatrixGreenBiasGetPostColorMatrixBlueBiasGetPostColorMatrixAlphaBias GetDepthScale GetDepthBiasGetPolygonOffsetFactorGetPolygonOffsetUnitsGetMaxTextureMaxAnisotropyGetMaxTextureLODBias GetEdgeFlag GetRGBAModeGetCurrentIndexGetMaxTextureUnits GetListIndex GetListModeGetMaxListNesting GetListBase GetRenderModeGetDrawFramebufferBindingGetReadFramebufferBindingGetFramebufferBindingGetRenderbufferBindingGetPerspectiveCorrectionHintGetPointSmoothHintGetLineSmoothHintGetPolygonSmoothHint GetFogHintGetGenerateMipmapHintGetTextureCompressionHintGetPackCMYKHintGetUnpackCMYKHintGetVertexArrayBindingGetMaxNameStackDepthGetNameStackDepthGetContextProfileMaskGetPackSwapBytesGetUnpackSwapBytesGetPackLSBFirstGetUnpackLSBFirstGetPackRowLengthGetUnpackRowLengthGetPackSkipRowsGetUnpackSkipRowsGetPackSkipPixelsGetUnpackSkipPixelsGetPackAlignmentGetUnpackAlignmentGetPackImageHeightGetUnpackImageHeightGetPackSkipImagesGetUnpackSkipImagesGetPixelMapIToISizeGetPixelMapSToSSizeGetPixelMapIToRSizeGetPixelMapIToGSizeGetPixelMapIToBSizeGetPixelMapIToASizeGetPixelMapRToRSizeGetPixelMapGToGSizeGetPixelMapBToBSizeGetPixelMapAToASizeGetMaxPixelMapTableGetMaxVertexTextureImageUnitsGetMaxTextureImageUnitsGetMaxCombinedTextureImageUnitsGetMaxTextureCoordsGetMaxVertexUniformComponentsGetMaxFragmentUniformComponentsGetMaxVertexAttribsGetMaxVaryingFloatsGetPatchVerticesGetMaxPatchVerticesGetMaxTessGenLevel GetMatrixModeGetModelviewStackDepthGetProjectionStackDepthGetTextureStackDepthGetColorMatrixStackDepthGetMaxModelviewStackDepthGetMaxProjectionStackDepthGetMaxTextureStackDepthGetMaxColorMatrixStackDepthGetMaxMatrixPaletteStackDepthGetCurrentMatrixStackDepthGetActiveTextureGetVertexArraySizeGetVertexArrayTypeGetVertexArrayStrideGetNormalArrayTypeGetNormalArrayStrideGetColorArraySizeGetColorArrayTypeGetColorArrayStrideGetIndexArrayTypeGetIndexArrayStrideGetTextureCoordArraySizeGetTextureCoordArrayTypeGetTextureCoordArrayStrideGetEdgeFlagArrayStrideGetFogCoordArrayTypeGetFogCoordArrayStrideGetSecondaryColorArraySizeGetSecondaryColorArrayTypeGetSecondaryColorArrayStrideGetArrayElementLockCountGetArrayElementLockFirstGetClientActiveTextureGetMaxElementsVerticesGetMaxElementsIndicesGetPrimitiveRestartIndexGetPrimitiveRestartNVGetPrimitiveRestartIndexNVGetArrayBufferBindingGetAtomicCounterBufferBindingGetCopyReadBufferBindingGetCopyWriteBufferBinding GetDispatchIndirectBufferBindingGetDrawIndirectBufferBindingGetElementArrayBufferBindingGetPixelPackBufferBindingGetPixelUnpackBufferBindingGetQueryBufferBindingGetShaderStorageBufferBinding!GetTransformFeedbackBufferBindingGetUniformBufferBindingGetVertexArrayBufferBindingGetNormalArrayBufferBindingGetColorArrayBufferBindingGetIndexArrayBufferBinding!GetTextureCoordArrayBufferBindingGetEdgeFlagArrayBufferBinding#GetSecondaryColorArrayBufferBindingGetFogCoordArrayBufferBindingGetMaxClipPlanes GetMaxLights GetFrontFaceGetLightModelLocalViewerGetLightModelTwoSideGetLightModelColorControlGetColorMaterialFaceGetColorMaterialParameter GetShadeModelGetFragmentColorClampGetVertexColorClampGetReadColorClampGetMaxEvalOrderGetMap1GridSegments GetFogMode GetFogIndexGetFogCoordSrcGetFogDistanceMode GetAuxBuffersGetDoublebuffer GetStereo GetRedBits GetGreenBits GetBlueBits GetAlphaBitsGetStencilBits GetDepthBitsGetAccumRedBitsGetAccumGreenBitsGetAccumBlueBitsGetAccumAlphaBits GetDrawBufferGetMaxDrawBuffersGetIndexWritemaskGetDepthWritemaskGetStencilWritemaskGetStencilBackWritemaskGetStencilClearValueGetCurrentProgram&GetMaxTransformFeedbackSeparateAttribs,GetMaxTransformFeedbackInterleavedComponents)GetMaxTransformFeedbackSeparateComponentsGetCurrentRasterIndexGetCurrentRasterPositionValidGetLineStippleRepeatGetLineStipplePatternGetSampleCoverageInvertGetAlphaTestFuncGetStencilFuncGetStencilBackFuncGetStencilValueMaskGetStencilBackValueMask GetStencilRefGetStencilBackRefGetStencilFailGetStencilBackFailGetStencilPassDepthFailGetStencilBackPassDepthFailGetStencilPassDepthPassGetStencilBackPassDepthPassGetActiveStencilFaceGetLogicOpMode GetBlendDst GetBlendSrcGetBlendSrcRGBGetBlendSrcAlphaGetBlendDstRGBGetBlendDstAlphaGetBlendEquationGetBlendEquationAlpha GetDepthFunc GetMapColor GetMapStencil GetIndexShiftGetIndexOffsetGetNumCompressedTextureFormatsGetMaxTextureSizeGetMax3DTextureSizeGetMaxCubeMapTextureSizeGetMaxRectangleTextureSizeGetMaxArrayTextureLayersGetMaxSampleMaskWordsGetMaxColorTextureSamplesGetMaxDepthTextureSamplesGetMaxIntegerSamples GetReadBufferGetTextureBinding1DGetTextureBinding2DGetTextureBinding3DGetTextureBinding1DArrayGetTextureBinding2DArrayGetTextureBindingCubeMapArrayGetTextureBindingRectangleGetTextureBindingBufferGetTextureBindingCubeMapGetTextureBinding2DMultisample#GetTextureBinding2DMultisampleArrayGetSubpixelBits GetSamplesGetSampleBuffersGetMaxServerWaitTimeoutGetMaxVertexStreams GetTimestampGetShaderCompilerGetNumShaderBinaryFormatsGetNumProgramBinaryFormatsGetMaxDebugMessageLengthGetMaxDebugLoggedMessagesGetDebugLoggedMessagesGetDebugNextLoggedMessageLengthGetMaxDebugGroupStackDepthGetMaxLabelLengthGetNumExtensionsget1get2get3get4get4iGetPointervPNameDebugCallbackFunctionDebugCallbackUserParamSelectionBufferPointerFeedbackBufferPointerVertexArrayPointerNormalArrayPointerColorArrayPointerSecondaryColorArrayPointerIndexArrayPointerTextureCoordArrayPointerFogCoordArrayPointerEdgeFlagArrayPointerWeightArrayPointerMatrixIndexArrayPointer PNameMatrixGetModelviewMatrixGetProjectionMatrixGetTextureMatrixGetColorMatrixGetMatrixPalettePNameNIGetCompressedTextureFormatsGetShaderBinaryFormatsGetProgramBinaryFormatsPName4FPName4IPName3FPName2FPName2IGetMap2GridSegmentsGetPolygonModeIPName1IGetAtomicCounterBufferGetAtomicCounterBufferStartGetAtomicCounterBufferSizeGetShaderStorageBufferGetShaderStorageBufferStartGetShaderStorageBufferSizeGetTransformFeedbackBufferGetTransformFeedbackBufferStartGetTransformFeedbackBufferSizeGetUniformBufferGetUniformBufferStartGetUniformBufferSizePName1FPName1IGetDrawBufferNGetCullFaceModeGetPNameMatrix getMatrixf getMatrixd GetPNameNIgetEnumN GetIPName4I getBoolean4i getInteger4i getEnum4i getSizei4i GetPName4F getFloat4 getClampf4 getDouble4 getClampd4 GetPName4I getBoolean4 getInteger4getEnum4 getSizei4 GetPName3F getFloat3 getClampf3 getDouble3 getClampd3 GetPName3I getBoolean3 getInteger3getEnum3 getSizei3 GetPName2F getFloat2 getClampf2 getDouble2 getClampd2 GetPName2I getBoolean2 getInteger2getEnum2 getSizei2 GetIPName1I getBoolean1i getInteger1i getEnum1i getSizei1igetInteger641i GetPName1F getFloat1 getClampf1 getDouble1 getClampd1 GetPName1I getBoolean1 getInteger1getEnum1 getSizei1 getInteger64GetPNamemarshalGetPName getBooleanv getIntegerv getInteger64v getFloatv getDoublev getBooleaniv getIntegerivgetInteger64iv makeGetterget1idrawBufferIndexToEnummaxDrawBufferIndexclipPlaneIndexToEnummaxClipPlaneIndexmarshalGetPointervPName getPointer$fGetPNamePNameMatrix$fGetPNameMatrixPNameMatrix$fGetPNamePNameNI$fGetPNameNIPNameNI$fGetPNamePName4F$fGetPName4FPName4F$fGetPNamePName4ISemiIndexed$fGetIPName4IPName4ISemiIndexed$fGetPName4IPName4ISemiIndexed$fGetPNamePName4I$fGetPName4IPName4I$fGetPNamePName3F$fGetPName3FPName3F$fGetPNamePName2F$fGetPName2FPName2F$fGetPNamePName2I$fGetPName2IPName2I$fGetPNameIPName1I$fGetIPName1IIPName1I$fGetPNamePName1F$fGetPName1FPName1F$fGetPNamePName1I$fGetPName1IPName1IGetVertexAttribPointerPNameVertexAttribArrayPointerGetVertexAttribPNameGetVertexAttribArrayEnabledGetVertexAttribArraySizeGetVertexAttribArrayStrideGetVertexAttribArrayTypeGetVertexAttribArrayNormalizedGetCurrentVertexAttrib!GetVertexAttribArrayBufferBindingGetVertexAttribArrayIntegermarshalGetVertexAttribPNamegetVertexAttribInteger1getVertexAttribEnum1getVertexAttribBoolean1getVertexAttribFloat4getVertexAttribIInteger4getVertexAttribIuInteger4"marshalGetVertexAttribPointerPNamegetVertexAttribPointermarshalGLbooleanunmarshalGLboolean marshalReset marshalSink unmarshalSinkunsafeBracket_ finallyRetbaseControl.Exception.Basebracket_bracketmarshalEdgeFlagunmarshalEdgeFlaglightIndexToEnum maxLightIndexmodelviewIndexToEnummodelviewEnumToIndex maybeNullPtrobjectNameLabelobjectPtrLabelgetObjectLabelWithsetObjectLabelWithglMap1glMap2 glGetMapv glMapGrid1 glMapGrid2$fDomainCDouble$fDomainCFloatmarshalRenderModeunmarshalRenderModewithRenderMode setRenderMode PixelStoreUnpackSwapBytesUnpackLSBFirstUnpackRowLengthUnpackSkipRowsUnpackSkipPixelsUnpackAlignment PackSwapBytes PackLSBFirst PackRowLength PackSkipRowsPackSkipPixels PackAlignmentPackSkipImagesPackImageHeightUnpackSkipImagesUnpackImageHeightmarshalPixelStore pixelStoreb pixelStoreigetLimit stringQuerycreateByteStringcreateAndTrimByteStringwithByteString withGLstring getStringWith peekGLstringbytes_6elQVSg5cWdFrvRnfxTUrHData.ByteString.Internal ByteString getStringIndexedEnableCapBlendI EnableCapCapFog CapLighting CapTexture1D CapTexture2DCapTexture2DMultisampleCapTexture1DArrayCapTextureRectangleCapTextureCubeMap CapTexture3DCapTexture2DArrayCapTexture2DMultisampleArrayCapTextureCubeMapArrayCapLineStippleCapPolygonStipple CapCullFace CapAlphaTestCapBlendCapIndexLogicOpCapColorLogicOp CapDitherCapStencilTest CapDepthTest CapClipPlaneCapLightCapTextureGenSCapTextureGenTCapTextureGenRCapTextureGenQCapMap1Vertex3CapMap1Vertex4 CapMap1Color4 CapMap1Index CapMap1NormalCapMap1TextureCoord1CapMap1TextureCoord2CapMap1TextureCoord3CapMap1TextureCoord4CapMap2Vertex3CapMap2Vertex4 CapMap2Color4 CapMap2Index CapMap2NormalCapMap2TextureCoord1CapMap2TextureCoord2CapMap2TextureCoord3CapMap2TextureCoord4CapPointSmooth CapLineSmoothCapPolygonSmoothCapScissorTestCapColorMaterial CapNormalize CapAutoNormalCapPolygonOffsetPointCapPolygonOffsetLineCapPolygonOffsetFillCapVertexArrayCapNormalArray CapColorArray CapIndexArrayCapTextureCoordArrayCapEdgeFlagArrayCapFogCoordArrayCapSecondaryColorArrayCapMatrixIndexArrayCapConvolution1DCapConvolution2DCapSeparable2D CapHistogram CapMinmaxCapRescaleNormalCapSharedTexturePaletteCapMultisampleCapSampleAlphaToCoverageCapSampleAlphaToOneCapSampleCoverage CapColorTableCapPostConvolutionColorTableCapPostColorMatrixColorTable CapColorSumCapWeightSumUnityCapVertexBlendCapWeightArrayCapMatrixPalette CapDepthClampCapDepthBoundsTestCapPrimitiveRestartCapPointSpriteCapStencilTestTwoSideCapRasterPositionUnclippedCapRasterizerDiscardCapTextureColorTableCapVertexProgramPointSizeCapVertexProgramTwoSideCapDebugOutputCapDebugOutputSynchronousmarshalCapabilityunmarshalCapabilitymarshalEnableCapmakeCapability isEnabledenablemakeStateVarMaybegetStateVarMaybesetStateVarMaybemarshalIndexedEnableCapmakeIndexedCapabilityisIndexedEnabled enableIndexedGetMinmaxParameterPName MinmaxFormat MinmaxSink MinmaxTargetMinmaxmarshalMinmaxTarget getMinmax' setMinmaxmarshalGetMinmaxParameterPNamegetMinmaxParameterimarshalServerAttributeGroup pushAttribmarshalClientAttributeGrouppushClientAttribmarshalContextProfile'i2cps makeStringVar runParser parseVersion$fStorableVector4$fTraversableVector4$fFoldableVector4$fApplicativeVector4$fFunctorVector4$fStorableVector3$fTraversableVector3$fFoldableVector3$fApplicativeVector3$fFunctorVector3$fStorableVector2$fTraversableVector2$fFoldableVector2$fApplicativeVector2$fFunctorVector2$fStorableVector1$fTraversableVector1$fFoldableVector1$fApplicativeVector1$fFunctorVector1$fStorableVertex4$fTraversableVertex4$fFoldableVertex4$fApplicativeVertex4$fFunctorVertex4$fStorableVertex3$fTraversableVertex3$fFoldableVertex3$fApplicativeVertex3$fFunctorVertex3$fStorableVertex2$fTraversableVertex2$fFoldableVertex2$fApplicativeVertex2$fFunctorVertex2$fStorableVertex1$fTraversableVertex1$fFoldableVertex1$fApplicativeVertex1$fFunctorVertex1debugMessageID dyn_debugProcmarshalDebugSourceunmarshalDebugSourcemarshalDebugTypeunmarshalDebugTypemarshalDebugSeverityunmarshalDebugSeveritygetDebugMessageCallback toDebugProcsetDebugMessageCallback fromDebugProcgetDebugCallbackFunctiondebugNextLoggedMessagedoDebugMessageControlqueryID noQueryObject$fCanBeLabeledQueryObject"$fGeneratableObjectNameQueryObject$fObjectNameQueryObject framebufferID$fCanBeLabeledFramebufferObject($fGeneratableObjectNameFramebufferObject$fObjectNameFramebufferObjectmarshalFramebufferTargetBindinggetBoundFramebuffersetFramebufferunmarshalFramebufferStatusrenderbufferID $fCanBeLabeledRenderbufferObject)$fGeneratableObjectNameRenderbufferObject$fObjectNameRenderbufferObject marshalRenderbufferTargetBindinggetBoundRenderbuffersetRenderbuffer textureID$fCanBeLabeledTextureObject$$fGeneratableObjectNameTextureObject$fObjectNameTextureObjectGetProgramPNameProgramDeleteStatus LinkStatusValidateStatusProgramInfoLogLengthAttachedShadersActiveAttributesActiveAttributeMaxLengthActiveUniformsActiveUniformMaxLengthTransformFeedbackVaryings!TransformFeedbackVaryingMaxLengthActiveUniformBlocksActiveUniformBlockMaxNameLengthGeometryVerticesOutGeometryInputTypeGeometryOutputTypeGeometryShaderInvocationsTessControlOutputVertices TessGenModeTessGenSpacingTessGenVertexOrderTessGenPointModeComputeWorkGroupSizeProgramSeparableProgramBinaryRetrievableHintActiveAtomicCounterBuffersProgramBinaryLength programIDmarshalGetProgramPName programVar1 programVar3 programVarN$fCanBeLabeledProgram$fObjectNameProgramgetProgramBinarybind4thsetProgramBinaryprogramBinaryLengthunmarshalVariableType activeVarsactiveAttributesactiveAttributeMaxLengthgetAttribLocationbindAttribLocationshaderID$fCanBeLabeledShader$fObjectNameShaderLowFloat MediumFloat HighFloatLowInt MediumIntHighIntGetShaderPNameShaderDeleteStatus CompileStatusShaderInfoLogLengthShaderSourceLengthmarshalShaderTypeunmarshalShaderTypegetShaderSourceshaderSourceLengthsetShaderSourceshaderInfoLogLengthmarshalGetShaderPName shaderVarmarshalPrecisionTypemarshalHintTargethintTargetToGetPNamemarshalHintModeunmarshalHintMode displayListIDcombineConsecutivemarshalListModeunmarshalListMode noDisplayList"$fGeneratableObjectNameDisplayList$fCanBeLabeledDisplayList$fObjectNameDisplayListParserparseSelectionBufferparseSelectionHit parseGLuint parseGLfloat parseNameghc-prim GHC.TypesFalseGHC.BaseNothingantialiasingInfoTextureGenMode' EyeLinear' ObjectLinear' SphereMap' NormalMap'ReflectionMap'TextureGenParameter ObjectPlaneEyePlane getMatrix loadMatrixloadTransposeMatrix multMatrix_multTransposeMatrixmarshalMatrixModeunmarshalMatrixModematrixModeToGetMatrixmatrixModeToGetStackDepthmatrixModeToGetMaxStackDepthwithMatrixMode getMatrix' setMatrixpreservingMatrixModemarshalTextureCoordNamemarshalTextureGenParametermarshalTextureGenMode'unmarshalTextureGenMode'marshalTextureGenModetextureCoordNameToEnableCapgetModesetModegetPlanesetPlane$fStorablePlane$fMatrixGLmatrix$fMatrixComponentCDouble$fMatrixComponentCFloat nameToCapclipPlaneActionmarshalPixelCopyTypemarshalBlitBuffer withViewportwithColumnMajor getVertex3 getVertex4 vertexArrayIDgetVAObindVAOnoVAO$fCanBeLabeledVertexArrayObject($fGeneratableObjectNameVertexArrayObject$fObjectNameVertexArrayObjectTrueindex1index1vcolor3color4color3vcolor4vsecondaryColor3secondaryColor3v fogCoord1 fogCoord1vnormal3normal3v texCoord1 texCoord2 texCoord3 texCoord4 texCoord1v texCoord2v texCoord3v texCoord4vmultiTexCoord1multiTexCoord2multiTexCoord3multiTexCoord4multiTexCoord1vmultiTexCoord2vmultiTexCoord3vmultiTexCoord4vvertex2vertex3vertex4vertex2vvertex3vvertex4vvertexAttrib4IvRealFractoGLint$fVertexAttribIndex1$fVertexAttribColor4$fVertexAttribColor3$fVertexAttribFogCoord1$fVertexAttribNormal3$fVertexAttribTexCoord4$fVertexAttribTexCoord3$fVertexAttribTexCoord2$fVertexAttribTexCoord1$fVertexAttribVector4$fVertexAttribVector3$fVertexAttribVector2$fVertexAttribVector1$fVertexAttribVertex4$fVertexAttribVertex3$fVertexAttribVertex2$fVertexAttribVertex1$fVertexAttribComponentCDouble$fVertexAttribComponentCFloat$fVertexAttribComponentCUInt$fVertexAttribComponentCInt$fVertexAttribComponentCUShort$fVertexAttribComponentCShort$fVertexAttribComponentCUChar$fVertexAttribComponentCSChar $fIndexIndex1$fIndexComponentCUChar$fIndexComponentCDouble$fIndexComponentCFloat$fIndexComponentCInt$fIndexComponentCShort$fSecondaryColorColor3 $fColorColor4 $fColorColor3$fColorComponentCUInt$fColorComponentCUShort$fColorComponentCUChar$fColorComponentCDouble$fColorComponentCFloat$fColorComponentCInt$fColorComponentCShort$fColorComponentCSChar$fFogCoordFogCoord1$fFogCoordComponentCDouble$fFogCoordComponentCFloat$fNormalNormal3$fNormalComponentCDouble$fNormalComponentCFloat$fNormalComponentCInt$fNormalComponentCShort$fNormalComponentCSChar$fTexCoordTexCoord4$fTexCoordTexCoord3$fTexCoordTexCoord2$fTexCoordTexCoord1$fTexCoordComponentCDouble$fTexCoordComponentCFloat$fTexCoordComponentCInt$fTexCoordComponentCShort$fVertexVertex4$fVertexVertex3$fVertexVertex2$fVertexComponentCDouble$fVertexComponentCFloat$fVertexComponentCInt$fVertexComponentCShort windowPos2 windowPos3 windowPos2v windowPos3v rasterPos2 rasterPos3 rasterPos4 rasterPos2v rasterPos3v rasterPos4v$fWindowPosVertex3$fWindowPosVertex2$fWindowPosComponentCDouble$fWindowPosComponentCFloat$fWindowPosComponentCInt$fWindowPosComponentCShort$fRasterPosVertex4$fRasterPosVertex3$fRasterPosVertex2$fRasterPosComponentCDouble$fRasterPosComponentCFloat$fRasterPosComponentCInt$fRasterPosComponentCShortLightModelParameterLightModelAmbientLightModelLocalViewerLightModelTwoSideLightParameterAmbient'Diffuse' Specular' SpotDirection SpotExponent SpotCutoffConstantAttenuationLinearAttenuationQuadraticAttenuationMaterialParameterMaterialEmissionMaterialShininessMaterialAmbientAndDiffuseMaterialColorIndexesMaterialAmbientMaterialDiffuseMaterialSpecular marshalLightmarshalFrontFaceDirectionunmarshalFrontFaceDirectionmarshalMaterialParametermakeMaterialVarglGetMaterialfvc glMaterialfvcglGetMaterialfvf glMaterialffgetMaterialColorIndexessetMaterialColorIndexesmarshalLightParameterblack makeLightVar glGetLightfvc glLightfvc glLightfvv glGetLightfvv glLightfvn glGetLightfvnconstantAttenuationlinearAttenuationquadraticAttenuationmarshalLightModelParametermakeLightModelCapVarmarshalLightModelColorControlunmarshalLightModelColorControlmarshalColorMaterialParameterunmarshalColorMaterialParametermarshalShadingModelunmarshalShadingModelmarshalClampTargetmarshalClampTargetToPNamemarshalClampModeunmarshalClampMode QuadricObjmarshalQuadricDrawStylemarshalQuadricNormalmarshalQuadricOrientationmarshalQuadricTexturewithQuadricObjsafeDeleteQuadricwithErrorCallbacksetStyleisNullQuadricObjFogMode'Exp'Exp2' FogParameterFogIndex FogDensityFogStartFogEndFogColormarshalFogParametermarshalFogMode'unmarshalFogMode' getFogMode setFogModefogifogffogfvmarshalFogCoordSrcunmarshalFogCoordSrcmarshalFogDistanceModeunmarshalFogDistanceModeOpenG_HEgY9ZXzWHrDHzoi32fMz6#Graphics.Rendering.OpenGL.Raw.TypesGLfloat getDrawBuffer setDrawBuffergetDrawBufferssetDrawBufferswithBufferModesgetDrawBufferimarshalClearBufferwithAttachmentsmarshalAccumOpmarshalStencilOpunmarshalStencilOpmarshalBlendEquationunmarshalBlendEquationmarshalLogicOpunmarshalLogicOpgetAttachedShaderssetAttachedShaders noProgramprogramStateVarBoolprogramInfoLogLengthnumAttachedShaders FeedbackTagPointTagLineTag LineResetTag PolygonTag BitmapTag DrawPixelTag CopyPixelTagPassThroughTagunmarshalFeedbackTagmarshalFeedbackTypeparseFeedbackBuffer tokenParsercalcInfoParser parseVertex2 parseVertex3 parseVertex4calcColorParser parseIndex1 parseColor4parseTexCoord4parsePassThroughValue parseGLenum parseGLint PixelTransferMapColor MapStencil IndexShift IndexOffsetRedScaleRedBias GreenScale GreenBias BlueScaleBlueBias AlphaScale AlphaBias DepthScale DepthBiasPostConvolutionRedScalePostConvolutionGreenScalePostConvolutionBlueScalePostConvolutionAlphaScalePostConvolutionRedBiasPostConvolutionGreenBiasPostConvolutionBlueBiasPostConvolutionAlphaBiasPostColorMatrixRedScalePostColorMatrixGreenScalePostColorMatrixBlueScalePostColorMatrixAlphaScalePostColorMatrixRedBiasPostColorMatrixGreenBiasPostColorMatrixBlueBiasPostColorMatrixAlphaBiasmarshalPixelTransferstageToGetScalesstageToSetScalesstageToGetBiasesstageToSetBiasespixelTransferbpixelTransferipixelTransferfpixelTransfer4f getPixelMapv pixelMapvmarshalPixelMapTargetpixelMapTargetToGetPName pixelMapSize pixelMapXToYgetPixelMapXToYwithPixelMapForwithGLpixelmapsamplesetPixelMapXToY newGLpixelmap$fPixelMapGLpixelmap$fPixelMapComponentCFloat$fPixelMapComponentCUInt$fPixelMapComponentCUShortColorTablePNameColorTableScaleColorTableBiasColorTableFormatColorTableWidthColorTableRedSizeColorTableGreenSizeColorTableBlueSizeColorTableAlphaSizeColorTableLuminanceSizeColorTableIntensitySizecolorTableStageToColorTablecolorTableStageToEnableCapmarshalColorTablemarshalProxyColorTablemarshalColorTablePNamecolorTableScaleBiasgetColorTableParameterC4fcolorTableParameterC4fgetColorTableParameterimarshalGettableTextureTargetmarshalQueryableTextureTarget$marshalThreeDimensionalTextureTarget"marshalTwoDimensionalTextureTarget"marshalOneDimensionalTextureTarget!marshalParameterizedTextureTarget&marshalParameterizedTextureTargetProxy*marshalParameterizedTextureTargetEnableCapmarshalBindableTextureTarget#marshalBindableTextureTargetPName1I!unmarshalTextureTargetCubeMapFace*$fBindableTextureTargetTextureTargetBuffer7$fQueryableTextureTargetTextureTarget2DMultisampleArray;$fParameterizedTextureTargetTextureTarget2DMultisampleArray6$fBindableTextureTargetTextureTarget2DMultisampleArray&$fGettableTextureTargetTextureTarget3D'$fQueryableTextureTargetTextureTarget3D.$fThreeDimensionalTextureTargetTextureTarget3D+$fParameterizedTextureTargetTextureTarget3D&$fBindableTextureTargetTextureTarget3D/$fGettableTextureTargetTextureTargetCubeMapFace0$fQueryableTextureTargetTextureTargetCubeMapFace5$fTwoDimensionalTextureTargetTextureTargetCubeMapFace1$fTwoDimensionalTextureTargetTextureTargetCubeMap0$fParameterizedTextureTargetTextureTargetCubeMap+$fBindableTextureTargetTextureTargetCubeMap2$fQueryableTextureTargetTextureTarget2DMultisample6$fParameterizedTextureTargetTextureTarget2DMultisample1$fBindableTextureTargetTextureTarget2DMultisample&$fGettableTextureTargetTextureTarget2D'$fQueryableTextureTargetTextureTarget2D,$fTwoDimensionalTextureTargetTextureTarget2D+$fParameterizedTextureTargetTextureTarget2D&$fBindableTextureTargetTextureTarget2D&$fGettableTextureTargetTextureTarget1D'$fQueryableTextureTargetTextureTarget1D,$fOneDimensionalTextureTargetTextureTarget1D+$fParameterizedTextureTargetTextureTarget1D&$fBindableTextureTargetTextureTarget1DConvolutionBorderMode'Reduce'ConstantBorder'ReplicateBorder'ConvolutionParameterConvolutionBorderColorConvolutionFilterScaleConvolutionFilterBiasConvolutionFormatConvolutionWidthConvolutionHeightMaxConvolutionWidthMaxConvolutionHeightmarshalConvolutionTargetconvolutionTargetToEnableCapgetConvolutionFiltermarshalConvolutionParameterconvolutionParameterigetConvolutionParameterimarshalConvolutionBorderMode'unmarshalConvolutionBorderMode'getConvolutionBorderModesetConvolutionBorderModesetConvolutionParametericonvolutionC4fgetConvolutionParameterC4fconvolutionParameterC4fGetHistogramParameterPNameHistogramWidthHistogramFormatHistogramRedSizeHistogramGreenSizeHistogramBlueSizeHistogramAlphaSizeHistogramLuminanceSize HistogramSinkHistogramTarget HistogramProxyHistogrammarshalHistogramTargetproxyToHistogramTarget getHistogram'getHistogramParameteri setHistogram!marshalGetHistogramParameterPNamenumPolygonStippleBytes withoutGapsgetPolygonModesetPolygonMode $fPolygonStippleGLpolygonstipplewithCompressedPixelDatamarshalSampleLocationsmarshalMultisamplemaxTextureSizeWithTextureTargetFullFramebufferTargetAttachmentmarshalPixellikeOTpixObjTarQueryFunc($fPixellikeObjectTargetTextureTargetFull2$fPixellikeObjectTargetFramebufferTargetAttachment)$fPixellikeObjectTargetRenderbufferTargetGetRenderbufferPNameRenderbufferWidthRenderbufferHeightRenderbufferInternalFormatRenderbufferSamplesRenderbufferRedSizeRenderbufferBlueSizeRenderbufferGreenSizeRenderbufferAlphaSizeRenderbufferDepthSizeRenderbufferStencilSizeGetFramebufferAttachmentPNameAttachmentObjectNameAttachmentTextureLevelAttachmentTextureCubeMapFaceAttachmentTextureLayerAttachmentComponentTypeAttachmentColorEncodingAttachmentRedSizeAttachmentBlueSizeAttachmentGreenSizeAttachmentAlphaSizeAttachmentDepthSizeAttachmentStencilSizemarshalGetFBAPName getFBAPNameunmarshalAttachmentObjectTypemarshalGetRBPname getRBPNameuniform1uniform2uniform3uniform4 getUniform uniform1v uniform2v uniform3v uniform4vnumActiveUniformsactiveUniformMaxLengthmaxComponentSizemaxNumComponentsmaxUniformBufferSizemakeUniformVar$fUniformTextureUnit$fUniformIndex1$fUniformColor4$fUniformColor3$fUniformFogCoord1$fUniformNormal3$fUniformTexCoord4$fUniformTexCoord3$fUniformTexCoord2$fUniformTexCoord1$fUniformVertex4$fUniformVertex3$fUniformVertex2$fUniformComponentCFloat$fUniformComponentCUInt$fUniformComponentCIntTexLevelParameterTextureInternalFormat TextureWidth TextureHeight TextureDepth TextureBorderTextureRedSizeTextureGreenSizeTextureBlueSizeTextureAlphaSizeTextureIntensitySizeTextureLuminanceSizeTextureIndexSize DepthBitsTextureCompressedImageSizeTextureCompressedTextureSharedSizemarshalTexLevelParametergetTexLevelParameteriNoProxygetTexLevelParameteri TexParameterTextureMinFilterTextureMagFilter TextureWrapS TextureWrapT TextureWrapRTextureBorderColor TextureMinLOD TextureMaxLODTextureBaseLevelTextureMaxLevelTextureMaxAnisotropyTextureCompareTextureCompareFailValueTextureCompareModeTextureCompareFuncDepthTextureModeTextureLODBiasTextureResidentmarshalTexParameter texParametergetTexParameterm2a texParami texParamf texParamC4fglTexParameterC4fglGetTexParameterC4fgetTexParameterimarshalTextureWrapModeunmarshalTextureWrapModeinvalidTextureCoordmarshalTextureCompareModeunmarshalTextureCompareModemarshalTextureCompareOperatorunmarshalTextureCompareOperatorcombineTexParamscombineTexParamsMaybeTextureEnvParameterTexEnvParamTextureEnvModeTexEnvParamTextureEnvColorTexEnvParamCombineRGBTexEnvParamCombineAlphaTexEnvParamSrc0RGBTexEnvParamSrc1RGBTexEnvParamSrc2RGBTexEnvParamSrc3RGBTexEnvParamSrc0AlphaTexEnvParamSrc1AlphaTexEnvParamSrc2AlphaTexEnvParamSrc3AlphaTexEnvParamOperand0RGBTexEnvParamOperand1RGBTexEnvParamOperand2RGBTexEnvParamOperand3RGBTexEnvParamOperand0AlphaTexEnvParamOperand1AlphaTexEnvParamOperand2AlphaTexEnvParamOperand3AlphaTexEnvParamRGBScaleTexEnvParamAlphaScaleTexEnvParamLODBiasTextureEnvTarget TextureEnvTextureFilterControl PointSpritemarshalTextureEnvTargetmarshalTextureEnvParametertexEnv glTexEnvC4f getTexEnvglGetTexEnvC4ftexEnvitexEnvf texEnvC4fmarshalTextureFunctionunmarshalTextureFunctionmarshalTextureCombineFunctionunmarshalTextureCombineFunctioncombineargNumToOperandRGBargNumToOperandAlphaargNumToSrcRGBargNumToSrcAlpha marshalSrc unmarshalSrcargtextureEnvOperand textureEnvSrcdefaultTextureObjectmarshalConditionalRenderMode $fRectCDouble $fRectCFloat $fRectCInt $fRectCShortmarshalPrimitiveModeunmarshalPrimitiveMode renderPrimnoVertexArrayDescriptormarshalClientArrayTypeclientArrayTypeToEnableCapcheck vertexPointergetVertexPointersetVertexPointer normalPointergetNormalPointersetNormalPointer colorPointergetColorPointersetColorPointer indexPointergetIndexPointersetIndexPointertexCoordPointergetTexCoordPointersetTexCoordPointeredgeFlagPointergetEdgeFlagPointersetEdgeFlagPointerfogCoordPointergetFogCoordPointersetFogCoordPointersecondaryColorPointergetSecondaryColorPointersetSecondaryColorPointermarshalInterleavedArraysgetClientStatesetClientState getLockArrays setLockArraysgetPrimitiveRestartIndexNVsetPrimitiveRestartIndexNVgetVertexAttribPointer_setVertexAttribPointergetVertexAttribArraysetVertexAttribArrayGetBufferPName GetBufferSizeGetBufferUsageGetBufferAccessGetBufferMappedbufferIDmarshalBufferTargetbufferTargetToGetPNamemarshalBufferUsageunmarshalBufferUsagemarshalBufferAccessunmarshalBufferAccess getBindBuffer bufferQuerynoBufferObject setBindBufferclientArrayTypeToGetPName getBufferData setBufferDatamarshalGetBufferPNamegetBufferParametergetBufferPointer mapBuffer_marshalMapBufferUsagemapBufferRange_marshalIndexedBufferTargetgetIndexedBufferBindingsetIndexedBufferBasegetIndexedBufferRangesetIndexedBufferRange getIndexedmarshalIndexedBufferStartmarshalIndexedBufferSize$fCanBeLabeledBufferObject#$fGeneratableObjectNameBufferObject$fObjectNameBufferObject MapTarget Map1Color4 Map1Index Map1NormalMap1TextureCoord1Map1TextureCoord2Map1TextureCoord3Map1TextureCoord4 Map1Vertex3 Map1Vertex4 Map2Color4 Map2Index Map2NormalMap2TextureCoord1Map2TextureCoord2Map2TextureCoord3Map2TextureCoord4 Map2Vertex3 Map2Vertex4 map1Target map2Target enableCap1 enableCap2 numComponentspeekControlPointpokeControlPointmarshalMapTarget$fControlPointTexCoord4$fControlPointTexCoord3$fControlPointTexCoord2$fControlPointTexCoord1$fControlPointNormal3$fControlPointColor4$fControlPointIndex1$fControlPointVertex4$fControlPointVertex3 GetMapQueryCoefftotalComponents1totalComponents2peekControlPoints1peekControlPoints2pokeControlPoints1pokeControlPoints2controlPointPtrs1controlPointPtrs2 sizeOfPtrmakeMap1StateVargetMap1setMap1makeMap2StateVargetMap2setMap2marshalGetMapQuery $fMap2GLmap2 $fMap1GLmap1numTransformFeedbackVaryings!transformFeedbackVaryingMaxLengthCombineCallback ErrorCallback EndCallbackVertexCallbackEdgeFlagCallback BeginCallbackTessellatorObjmarshalTessWindingoffsetOfProperty alignOffsetsizeOfComplexContourpokeComplexContoursizeOfComplexPolygonpokeComplexPolygonwithComplexPolygoncollectTrianglesisNullTesselatorObjwithTessellatorObjsafeDeleteTessdefineComplexPolygontessBeginEndPolygondefineComplexContourtessBeginEndContour defineVertexwithBeginCallbackwithEdgeFlagCallbackwithVertexCallbackwithEndCallback checkForErrorwithCombineCallbackcombineProperties getProperty peekPropertysetTessellatorPropertiessetWindingRulesetBoundaryOnly setTolerance setNormal$fStorableAnnotatedVertexSamplingMethod' PathLength'ParametricError'DomainDistance'ObjectPathLength'ObjectParametricError'trimmingTargetisNullNURBSObjsafeDeleteNurbsRenderer pseudoPeekmarshalNURBSModemarshalSamplingMethod'setSamplingMethod'setAutoLoadMatrixwithMatrixColumnMajormarshalDisplayMode'$fTrimmingPointVertex3$fTrimmingPointVertex2getQueryObjectvGetQueryObjectPNameQueryResultAvailable GetQueryPNameQueryCounterBits CurrentQuerymarshalQueryTargetmarshalGetQueryPName getQueryi getQueryiv'marshalGetQueryObjectPNamegetQueryObject$fQueryResultWord64$fQueryResultInt64$fQueryResultCUInt$fQueryResultCIntsyncIDmarshalWaitFlagunmarshalWaitResultunmarshalSyncStatus$fCanBeLabeledSyncObject$fObjectNameSyncObjectObjec_Ej1Cgp8vUjN6m1ytQ9jTTTData.ObjectNamedeleteObjectNamesdeleteObjectName isObjectName ObjectNamegenObjectNames genObjectNameGeneratableObjectNamemakeGLDEBUGPROCKHRmakeGLDEBUGPROCARBmakeGLDEBUGPROCmakeGLDEBUGPROCAMD GLbooleanGLbyteGLubyteGLcharGLshortGLushortGLintGLuintGLfixedGLint64GLuint64GLsizeiGLenumGLintptr GLsizeiptrGLsync GLbitfieldGLhalfGLclampfGLdoubleGLclampd GLDEBUGPROCGLDEBUGPROCFuncGLvoid GLcharARB GLint64EXT GLuint64EXT GLintptrARB GLsizeiptrARB GLhalfARBGLhalfNVGLDEBUGPROCAMDGLDEBUGPROCAMDFuncGLDEBUGPROCARBGLDEBUGPROCARBFuncGLDEBUGPROCKHRGLDEBUGPROCKHRFuncGLclampx GLhandleARBGLvdpauSurfaceNV GLeglImageOESState_6K4a3UqSdqh6lGAm1wlr9s Data.StateVar$=!makeGettableStateVarmakeSettableStateVar mapStateVar makeStateVarStateVarSettableStateVarGettableStateVar$= HasSetter$~!$~ HasUpdateget HasGetter