github.com/TimaSlipko/gomobile@v1.0.8/gl/gldebug.go (about)

     1  // Copyright 2014 The Go Authors.  All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Code generated from gl.go using go generate. DO NOT EDIT.
     6  // See doc.go for details.
     7  
     8  //go:build (darwin || linux || openbsd || windows) && gldebug
     9  
    10  package gl
    11  
    12  import (
    13  	"fmt"
    14  	"log"
    15  	"math"
    16  	"sync/atomic"
    17  	"unsafe"
    18  )
    19  
    20  func (ctx *context) errDrain() string {
    21  	var errs []Enum
    22  	for {
    23  		e := ctx.GetError()
    24  		if e == 0 {
    25  			break
    26  		}
    27  		errs = append(errs, e)
    28  	}
    29  	if len(errs) > 0 {
    30  		return fmt.Sprintf(" error: %v", errs)
    31  	}
    32  	return ""
    33  }
    34  
    35  func (ctx *context) enqueueDebug(c call) uintptr {
    36  	numCalls := atomic.AddInt32(&ctx.debug, 1)
    37  	if numCalls > 1 {
    38  		panic("concurrent calls made to the same GL context")
    39  	}
    40  	defer func() {
    41  		if atomic.AddInt32(&ctx.debug, -1) > 0 {
    42  			select {} // block so you see us in the panic
    43  		}
    44  	}()
    45  
    46  	return ctx.enqueue(c)
    47  }
    48  
    49  func (v Enum) String() string {
    50  	switch v {
    51  	case 0x0:
    52  		return "0"
    53  	case 0x1:
    54  		return "1"
    55  	case 0x2:
    56  		return "2"
    57  	case 0x3:
    58  		return "LINE_STRIP"
    59  	case 0x4:
    60  		return "4"
    61  	case 0x5:
    62  		return "TRIANGLE_STRIP"
    63  	case 0x6:
    64  		return "TRIANGLE_FAN"
    65  	case 0x300:
    66  		return "SRC_COLOR"
    67  	case 0x301:
    68  		return "ONE_MINUS_SRC_COLOR"
    69  	case 0x302:
    70  		return "SRC_ALPHA"
    71  	case 0x303:
    72  		return "ONE_MINUS_SRC_ALPHA"
    73  	case 0x304:
    74  		return "DST_ALPHA"
    75  	case 0x305:
    76  		return "ONE_MINUS_DST_ALPHA"
    77  	case 0x306:
    78  		return "DST_COLOR"
    79  	case 0x307:
    80  		return "ONE_MINUS_DST_COLOR"
    81  	case 0x308:
    82  		return "SRC_ALPHA_SATURATE"
    83  	case 0x8006:
    84  		return "FUNC_ADD"
    85  	case 0x8009:
    86  		return "32777"
    87  	case 0x883d:
    88  		return "BLEND_EQUATION_ALPHA"
    89  	case 0x800a:
    90  		return "FUNC_SUBTRACT"
    91  	case 0x800b:
    92  		return "FUNC_REVERSE_SUBTRACT"
    93  	case 0x80c8:
    94  		return "BLEND_DST_RGB"
    95  	case 0x80c9:
    96  		return "BLEND_SRC_RGB"
    97  	case 0x80ca:
    98  		return "BLEND_DST_ALPHA"
    99  	case 0x80cb:
   100  		return "BLEND_SRC_ALPHA"
   101  	case 0x8001:
   102  		return "CONSTANT_COLOR"
   103  	case 0x8002:
   104  		return "ONE_MINUS_CONSTANT_COLOR"
   105  	case 0x8003:
   106  		return "CONSTANT_ALPHA"
   107  	case 0x8004:
   108  		return "ONE_MINUS_CONSTANT_ALPHA"
   109  	case 0x8005:
   110  		return "BLEND_COLOR"
   111  	case 0x8892:
   112  		return "ARRAY_BUFFER"
   113  	case 0x8893:
   114  		return "ELEMENT_ARRAY_BUFFER"
   115  	case 0x8894:
   116  		return "ARRAY_BUFFER_BINDING"
   117  	case 0x8895:
   118  		return "ELEMENT_ARRAY_BUFFER_BINDING"
   119  	case 0x88e0:
   120  		return "STREAM_DRAW"
   121  	case 0x88e4:
   122  		return "STATIC_DRAW"
   123  	case 0x88e8:
   124  		return "DYNAMIC_DRAW"
   125  	case 0x8764:
   126  		return "BUFFER_SIZE"
   127  	case 0x8765:
   128  		return "BUFFER_USAGE"
   129  	case 0x8626:
   130  		return "CURRENT_VERTEX_ATTRIB"
   131  	case 0x404:
   132  		return "FRONT"
   133  	case 0x405:
   134  		return "BACK"
   135  	case 0x408:
   136  		return "FRONT_AND_BACK"
   137  	case 0xde1:
   138  		return "TEXTURE_2D"
   139  	case 0xb44:
   140  		return "CULL_FACE"
   141  	case 0xbe2:
   142  		return "BLEND"
   143  	case 0xbd0:
   144  		return "DITHER"
   145  	case 0xb90:
   146  		return "STENCIL_TEST"
   147  	case 0xb71:
   148  		return "DEPTH_TEST"
   149  	case 0xc11:
   150  		return "SCISSOR_TEST"
   151  	case 0x8037:
   152  		return "POLYGON_OFFSET_FILL"
   153  	case 0x809e:
   154  		return "SAMPLE_ALPHA_TO_COVERAGE"
   155  	case 0x80a0:
   156  		return "SAMPLE_COVERAGE"
   157  	case 0x500:
   158  		return "INVALID_ENUM"
   159  	case 0x501:
   160  		return "INVALID_VALUE"
   161  	case 0x502:
   162  		return "INVALID_OPERATION"
   163  	case 0x505:
   164  		return "OUT_OF_MEMORY"
   165  	case 0x900:
   166  		return "CW"
   167  	case 0x901:
   168  		return "CCW"
   169  	case 0xb21:
   170  		return "LINE_WIDTH"
   171  	case 0x846d:
   172  		return "ALIASED_POINT_SIZE_RANGE"
   173  	case 0x846e:
   174  		return "ALIASED_LINE_WIDTH_RANGE"
   175  	case 0xb45:
   176  		return "CULL_FACE_MODE"
   177  	case 0xb46:
   178  		return "FRONT_FACE"
   179  	case 0xb70:
   180  		return "DEPTH_RANGE"
   181  	case 0xb72:
   182  		return "DEPTH_WRITEMASK"
   183  	case 0xb73:
   184  		return "DEPTH_CLEAR_VALUE"
   185  	case 0xb74:
   186  		return "DEPTH_FUNC"
   187  	case 0xb91:
   188  		return "STENCIL_CLEAR_VALUE"
   189  	case 0xb92:
   190  		return "STENCIL_FUNC"
   191  	case 0xb94:
   192  		return "STENCIL_FAIL"
   193  	case 0xb95:
   194  		return "STENCIL_PASS_DEPTH_FAIL"
   195  	case 0xb96:
   196  		return "STENCIL_PASS_DEPTH_PASS"
   197  	case 0xb97:
   198  		return "STENCIL_REF"
   199  	case 0xb93:
   200  		return "STENCIL_VALUE_MASK"
   201  	case 0xb98:
   202  		return "STENCIL_WRITEMASK"
   203  	case 0x8800:
   204  		return "STENCIL_BACK_FUNC"
   205  	case 0x8801:
   206  		return "STENCIL_BACK_FAIL"
   207  	case 0x8802:
   208  		return "STENCIL_BACK_PASS_DEPTH_FAIL"
   209  	case 0x8803:
   210  		return "STENCIL_BACK_PASS_DEPTH_PASS"
   211  	case 0x8ca3:
   212  		return "STENCIL_BACK_REF"
   213  	case 0x8ca4:
   214  		return "STENCIL_BACK_VALUE_MASK"
   215  	case 0x8ca5:
   216  		return "STENCIL_BACK_WRITEMASK"
   217  	case 0xba2:
   218  		return "VIEWPORT"
   219  	case 0xc10:
   220  		return "SCISSOR_BOX"
   221  	case 0xc22:
   222  		return "COLOR_CLEAR_VALUE"
   223  	case 0xc23:
   224  		return "COLOR_WRITEMASK"
   225  	case 0xcf5:
   226  		return "UNPACK_ALIGNMENT"
   227  	case 0xd05:
   228  		return "PACK_ALIGNMENT"
   229  	case 0xd33:
   230  		return "MAX_TEXTURE_SIZE"
   231  	case 0xd3a:
   232  		return "MAX_VIEWPORT_DIMS"
   233  	case 0xd50:
   234  		return "SUBPIXEL_BITS"
   235  	case 0xd52:
   236  		return "RED_BITS"
   237  	case 0xd53:
   238  		return "GREEN_BITS"
   239  	case 0xd54:
   240  		return "BLUE_BITS"
   241  	case 0xd55:
   242  		return "ALPHA_BITS"
   243  	case 0xd56:
   244  		return "DEPTH_BITS"
   245  	case 0xd57:
   246  		return "STENCIL_BITS"
   247  	case 0x2a00:
   248  		return "POLYGON_OFFSET_UNITS"
   249  	case 0x8038:
   250  		return "POLYGON_OFFSET_FACTOR"
   251  	case 0x8069:
   252  		return "TEXTURE_BINDING_2D"
   253  	case 0x80a8:
   254  		return "SAMPLE_BUFFERS"
   255  	case 0x80a9:
   256  		return "SAMPLES"
   257  	case 0x80aa:
   258  		return "SAMPLE_COVERAGE_VALUE"
   259  	case 0x80ab:
   260  		return "SAMPLE_COVERAGE_INVERT"
   261  	case 0x86a2:
   262  		return "NUM_COMPRESSED_TEXTURE_FORMATS"
   263  	case 0x86a3:
   264  		return "COMPRESSED_TEXTURE_FORMATS"
   265  	case 0x1100:
   266  		return "DONT_CARE"
   267  	case 0x1101:
   268  		return "FASTEST"
   269  	case 0x1102:
   270  		return "NICEST"
   271  	case 0x8192:
   272  		return "GENERATE_MIPMAP_HINT"
   273  	case 0x1400:
   274  		return "BYTE"
   275  	case 0x1401:
   276  		return "UNSIGNED_BYTE"
   277  	case 0x1402:
   278  		return "SHORT"
   279  	case 0x1403:
   280  		return "UNSIGNED_SHORT"
   281  	case 0x1404:
   282  		return "INT"
   283  	case 0x1405:
   284  		return "UNSIGNED_INT"
   285  	case 0x1406:
   286  		return "FLOAT"
   287  	case 0x140c:
   288  		return "FIXED"
   289  	case 0x1902:
   290  		return "DEPTH_COMPONENT"
   291  	case 0x1906:
   292  		return "ALPHA"
   293  	case 0x1907:
   294  		return "RGB"
   295  	case 0x1908:
   296  		return "RGBA"
   297  	case 0x1909:
   298  		return "LUMINANCE"
   299  	case 0x190a:
   300  		return "LUMINANCE_ALPHA"
   301  	case 0x8033:
   302  		return "UNSIGNED_SHORT_4_4_4_4"
   303  	case 0x8034:
   304  		return "UNSIGNED_SHORT_5_5_5_1"
   305  	case 0x8363:
   306  		return "UNSIGNED_SHORT_5_6_5"
   307  	case 0x8869:
   308  		return "MAX_VERTEX_ATTRIBS"
   309  	case 0x8dfb:
   310  		return "MAX_VERTEX_UNIFORM_VECTORS"
   311  	case 0x8dfc:
   312  		return "MAX_VARYING_VECTORS"
   313  	case 0x8b4d:
   314  		return "MAX_COMBINED_TEXTURE_IMAGE_UNITS"
   315  	case 0x8b4c:
   316  		return "MAX_VERTEX_TEXTURE_IMAGE_UNITS"
   317  	case 0x8872:
   318  		return "MAX_TEXTURE_IMAGE_UNITS"
   319  	case 0x8dfd:
   320  		return "MAX_FRAGMENT_UNIFORM_VECTORS"
   321  	case 0x8b4f:
   322  		return "SHADER_TYPE"
   323  	case 0x8b80:
   324  		return "DELETE_STATUS"
   325  	case 0x8b82:
   326  		return "LINK_STATUS"
   327  	case 0x8b83:
   328  		return "VALIDATE_STATUS"
   329  	case 0x8b85:
   330  		return "ATTACHED_SHADERS"
   331  	case 0x8b86:
   332  		return "ACTIVE_UNIFORMS"
   333  	case 0x8b87:
   334  		return "ACTIVE_UNIFORM_MAX_LENGTH"
   335  	case 0x8b89:
   336  		return "ACTIVE_ATTRIBUTES"
   337  	case 0x8b8a:
   338  		return "ACTIVE_ATTRIBUTE_MAX_LENGTH"
   339  	case 0x8b8c:
   340  		return "SHADING_LANGUAGE_VERSION"
   341  	case 0x8b8d:
   342  		return "CURRENT_PROGRAM"
   343  	case 0x200:
   344  		return "NEVER"
   345  	case 0x201:
   346  		return "LESS"
   347  	case 0x202:
   348  		return "EQUAL"
   349  	case 0x203:
   350  		return "LEQUAL"
   351  	case 0x204:
   352  		return "GREATER"
   353  	case 0x205:
   354  		return "NOTEQUAL"
   355  	case 0x206:
   356  		return "GEQUAL"
   357  	case 0x207:
   358  		return "ALWAYS"
   359  	case 0x1e00:
   360  		return "KEEP"
   361  	case 0x1e01:
   362  		return "REPLACE"
   363  	case 0x1e02:
   364  		return "INCR"
   365  	case 0x1e03:
   366  		return "DECR"
   367  	case 0x150a:
   368  		return "INVERT"
   369  	case 0x8507:
   370  		return "INCR_WRAP"
   371  	case 0x8508:
   372  		return "DECR_WRAP"
   373  	case 0x1f00:
   374  		return "VENDOR"
   375  	case 0x1f01:
   376  		return "RENDERER"
   377  	case 0x1f02:
   378  		return "VERSION"
   379  	case 0x1f03:
   380  		return "EXTENSIONS"
   381  	case 0x2600:
   382  		return "NEAREST"
   383  	case 0x2601:
   384  		return "LINEAR"
   385  	case 0x2700:
   386  		return "NEAREST_MIPMAP_NEAREST"
   387  	case 0x2701:
   388  		return "LINEAR_MIPMAP_NEAREST"
   389  	case 0x2702:
   390  		return "NEAREST_MIPMAP_LINEAR"
   391  	case 0x2703:
   392  		return "LINEAR_MIPMAP_LINEAR"
   393  	case 0x2800:
   394  		return "TEXTURE_MAG_FILTER"
   395  	case 0x2801:
   396  		return "TEXTURE_MIN_FILTER"
   397  	case 0x2802:
   398  		return "TEXTURE_WRAP_S"
   399  	case 0x2803:
   400  		return "TEXTURE_WRAP_T"
   401  	case 0x1702:
   402  		return "TEXTURE"
   403  	case 0x8513:
   404  		return "TEXTURE_CUBE_MAP"
   405  	case 0x8514:
   406  		return "TEXTURE_BINDING_CUBE_MAP"
   407  	case 0x8515:
   408  		return "TEXTURE_CUBE_MAP_POSITIVE_X"
   409  	case 0x8516:
   410  		return "TEXTURE_CUBE_MAP_NEGATIVE_X"
   411  	case 0x8517:
   412  		return "TEXTURE_CUBE_MAP_POSITIVE_Y"
   413  	case 0x8518:
   414  		return "TEXTURE_CUBE_MAP_NEGATIVE_Y"
   415  	case 0x8519:
   416  		return "TEXTURE_CUBE_MAP_POSITIVE_Z"
   417  	case 0x851a:
   418  		return "TEXTURE_CUBE_MAP_NEGATIVE_Z"
   419  	case 0x851c:
   420  		return "MAX_CUBE_MAP_TEXTURE_SIZE"
   421  	case 0x84c0:
   422  		return "TEXTURE0"
   423  	case 0x84c1:
   424  		return "TEXTURE1"
   425  	case 0x84c2:
   426  		return "TEXTURE2"
   427  	case 0x84c3:
   428  		return "TEXTURE3"
   429  	case 0x84c4:
   430  		return "TEXTURE4"
   431  	case 0x84c5:
   432  		return "TEXTURE5"
   433  	case 0x84c6:
   434  		return "TEXTURE6"
   435  	case 0x84c7:
   436  		return "TEXTURE7"
   437  	case 0x84c8:
   438  		return "TEXTURE8"
   439  	case 0x84c9:
   440  		return "TEXTURE9"
   441  	case 0x84ca:
   442  		return "TEXTURE10"
   443  	case 0x84cb:
   444  		return "TEXTURE11"
   445  	case 0x84cc:
   446  		return "TEXTURE12"
   447  	case 0x84cd:
   448  		return "TEXTURE13"
   449  	case 0x84ce:
   450  		return "TEXTURE14"
   451  	case 0x84cf:
   452  		return "TEXTURE15"
   453  	case 0x84d0:
   454  		return "TEXTURE16"
   455  	case 0x84d1:
   456  		return "TEXTURE17"
   457  	case 0x84d2:
   458  		return "TEXTURE18"
   459  	case 0x84d3:
   460  		return "TEXTURE19"
   461  	case 0x84d4:
   462  		return "TEXTURE20"
   463  	case 0x84d5:
   464  		return "TEXTURE21"
   465  	case 0x84d6:
   466  		return "TEXTURE22"
   467  	case 0x84d7:
   468  		return "TEXTURE23"
   469  	case 0x84d8:
   470  		return "TEXTURE24"
   471  	case 0x84d9:
   472  		return "TEXTURE25"
   473  	case 0x84da:
   474  		return "TEXTURE26"
   475  	case 0x84db:
   476  		return "TEXTURE27"
   477  	case 0x84dc:
   478  		return "TEXTURE28"
   479  	case 0x84dd:
   480  		return "TEXTURE29"
   481  	case 0x84de:
   482  		return "TEXTURE30"
   483  	case 0x84df:
   484  		return "TEXTURE31"
   485  	case 0x84e0:
   486  		return "ACTIVE_TEXTURE"
   487  	case 0x2901:
   488  		return "REPEAT"
   489  	case 0x812f:
   490  		return "CLAMP_TO_EDGE"
   491  	case 0x8370:
   492  		return "MIRRORED_REPEAT"
   493  	case 0x8622:
   494  		return "VERTEX_ATTRIB_ARRAY_ENABLED"
   495  	case 0x8623:
   496  		return "VERTEX_ATTRIB_ARRAY_SIZE"
   497  	case 0x8624:
   498  		return "VERTEX_ATTRIB_ARRAY_STRIDE"
   499  	case 0x8625:
   500  		return "VERTEX_ATTRIB_ARRAY_TYPE"
   501  	case 0x886a:
   502  		return "VERTEX_ATTRIB_ARRAY_NORMALIZED"
   503  	case 0x8645:
   504  		return "VERTEX_ATTRIB_ARRAY_POINTER"
   505  	case 0x889f:
   506  		return "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"
   507  	case 0x8b9a:
   508  		return "IMPLEMENTATION_COLOR_READ_TYPE"
   509  	case 0x8b9b:
   510  		return "IMPLEMENTATION_COLOR_READ_FORMAT"
   511  	case 0x8b81:
   512  		return "COMPILE_STATUS"
   513  	case 0x8b84:
   514  		return "INFO_LOG_LENGTH"
   515  	case 0x8b88:
   516  		return "SHADER_SOURCE_LENGTH"
   517  	case 0x8dfa:
   518  		return "SHADER_COMPILER"
   519  	case 0x8df8:
   520  		return "SHADER_BINARY_FORMATS"
   521  	case 0x8df9:
   522  		return "NUM_SHADER_BINARY_FORMATS"
   523  	case 0x8df0:
   524  		return "LOW_FLOAT"
   525  	case 0x8df1:
   526  		return "MEDIUM_FLOAT"
   527  	case 0x8df2:
   528  		return "HIGH_FLOAT"
   529  	case 0x8df3:
   530  		return "LOW_INT"
   531  	case 0x8df4:
   532  		return "MEDIUM_INT"
   533  	case 0x8df5:
   534  		return "HIGH_INT"
   535  	case 0x8d40:
   536  		return "FRAMEBUFFER"
   537  	case 0x8d41:
   538  		return "RENDERBUFFER"
   539  	case 0x8056:
   540  		return "RGBA4"
   541  	case 0x8057:
   542  		return "RGB5_A1"
   543  	case 0x8d62:
   544  		return "RGB565"
   545  	case 0x81a5:
   546  		return "DEPTH_COMPONENT16"
   547  	case 0x8d48:
   548  		return "STENCIL_INDEX8"
   549  	case 0x8d42:
   550  		return "RENDERBUFFER_WIDTH"
   551  	case 0x8d43:
   552  		return "RENDERBUFFER_HEIGHT"
   553  	case 0x8d44:
   554  		return "RENDERBUFFER_INTERNAL_FORMAT"
   555  	case 0x8d50:
   556  		return "RENDERBUFFER_RED_SIZE"
   557  	case 0x8d51:
   558  		return "RENDERBUFFER_GREEN_SIZE"
   559  	case 0x8d52:
   560  		return "RENDERBUFFER_BLUE_SIZE"
   561  	case 0x8d53:
   562  		return "RENDERBUFFER_ALPHA_SIZE"
   563  	case 0x8d54:
   564  		return "RENDERBUFFER_DEPTH_SIZE"
   565  	case 0x8d55:
   566  		return "RENDERBUFFER_STENCIL_SIZE"
   567  	case 0x8cd0:
   568  		return "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"
   569  	case 0x8cd1:
   570  		return "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"
   571  	case 0x8cd2:
   572  		return "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"
   573  	case 0x8cd3:
   574  		return "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"
   575  	case 0x8ce0:
   576  		return "COLOR_ATTACHMENT0"
   577  	case 0x8d00:
   578  		return "DEPTH_ATTACHMENT"
   579  	case 0x8d20:
   580  		return "STENCIL_ATTACHMENT"
   581  	case 0x8cd5:
   582  		return "FRAMEBUFFER_COMPLETE"
   583  	case 0x8cd6:
   584  		return "FRAMEBUFFER_INCOMPLETE_ATTACHMENT"
   585  	case 0x8cd7:
   586  		return "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"
   587  	case 0x8cd9:
   588  		return "FRAMEBUFFER_INCOMPLETE_DIMENSIONS"
   589  	case 0x8cdd:
   590  		return "FRAMEBUFFER_UNSUPPORTED"
   591  	case 0x8ca6:
   592  		return "36006"
   593  	case 0x8ca7:
   594  		return "RENDERBUFFER_BINDING"
   595  	case 0x84e8:
   596  		return "MAX_RENDERBUFFER_SIZE"
   597  	case 0x506:
   598  		return "INVALID_FRAMEBUFFER_OPERATION"
   599  	case 0x100:
   600  		return "DEPTH_BUFFER_BIT"
   601  	case 0x400:
   602  		return "STENCIL_BUFFER_BIT"
   603  	case 0x4000:
   604  		return "COLOR_BUFFER_BIT"
   605  	case 0x8b50:
   606  		return "FLOAT_VEC2"
   607  	case 0x8b51:
   608  		return "FLOAT_VEC3"
   609  	case 0x8b52:
   610  		return "FLOAT_VEC4"
   611  	case 0x8b53:
   612  		return "INT_VEC2"
   613  	case 0x8b54:
   614  		return "INT_VEC3"
   615  	case 0x8b55:
   616  		return "INT_VEC4"
   617  	case 0x8b56:
   618  		return "BOOL"
   619  	case 0x8b57:
   620  		return "BOOL_VEC2"
   621  	case 0x8b58:
   622  		return "BOOL_VEC3"
   623  	case 0x8b59:
   624  		return "BOOL_VEC4"
   625  	case 0x8b5a:
   626  		return "FLOAT_MAT2"
   627  	case 0x8b5b:
   628  		return "FLOAT_MAT3"
   629  	case 0x8b5c:
   630  		return "FLOAT_MAT4"
   631  	case 0x8b5e:
   632  		return "SAMPLER_2D"
   633  	case 0x8b60:
   634  		return "SAMPLER_CUBE"
   635  	case 0x8b30:
   636  		return "FRAGMENT_SHADER"
   637  	case 0x8b31:
   638  		return "VERTEX_SHADER"
   639  	case 0x8a35:
   640  		return "ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH"
   641  	case 0x8a36:
   642  		return "ACTIVE_UNIFORM_BLOCKS"
   643  	case 0x911a:
   644  		return "ALREADY_SIGNALED"
   645  	case 0x8c2f:
   646  		return "ANY_SAMPLES_PASSED"
   647  	case 0x8d6a:
   648  		return "ANY_SAMPLES_PASSED_CONSERVATIVE"
   649  	case 0x1905:
   650  		return "BLUE"
   651  	case 0x911f:
   652  		return "BUFFER_ACCESS_FLAGS"
   653  	case 0x9120:
   654  		return "BUFFER_MAP_LENGTH"
   655  	case 0x9121:
   656  		return "BUFFER_MAP_OFFSET"
   657  	case 0x88bc:
   658  		return "BUFFER_MAPPED"
   659  	case 0x88bd:
   660  		return "BUFFER_MAP_POINTER"
   661  	case 0x1800:
   662  		return "COLOR"
   663  	case 0x8cea:
   664  		return "COLOR_ATTACHMENT10"
   665  	case 0x8ce1:
   666  		return "COLOR_ATTACHMENT1"
   667  	case 0x8ceb:
   668  		return "COLOR_ATTACHMENT11"
   669  	case 0x8cec:
   670  		return "COLOR_ATTACHMENT12"
   671  	case 0x8ced:
   672  		return "COLOR_ATTACHMENT13"
   673  	case 0x8cee:
   674  		return "COLOR_ATTACHMENT14"
   675  	case 0x8cef:
   676  		return "COLOR_ATTACHMENT15"
   677  	case 0x8ce2:
   678  		return "COLOR_ATTACHMENT2"
   679  	case 0x8ce3:
   680  		return "COLOR_ATTACHMENT3"
   681  	case 0x8ce4:
   682  		return "COLOR_ATTACHMENT4"
   683  	case 0x8ce5:
   684  		return "COLOR_ATTACHMENT5"
   685  	case 0x8ce6:
   686  		return "COLOR_ATTACHMENT6"
   687  	case 0x8ce7:
   688  		return "COLOR_ATTACHMENT7"
   689  	case 0x8ce8:
   690  		return "COLOR_ATTACHMENT8"
   691  	case 0x8ce9:
   692  		return "COLOR_ATTACHMENT9"
   693  	case 0x884e:
   694  		return "COMPARE_REF_TO_TEXTURE"
   695  	case 0x9270:
   696  		return "COMPRESSED_R11_EAC"
   697  	case 0x9272:
   698  		return "COMPRESSED_RG11_EAC"
   699  	case 0x9274:
   700  		return "COMPRESSED_RGB8_ETC2"
   701  	case 0x9276:
   702  		return "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"
   703  	case 0x9278:
   704  		return "COMPRESSED_RGBA8_ETC2_EAC"
   705  	case 0x9271:
   706  		return "COMPRESSED_SIGNED_R11_EAC"
   707  	case 0x9273:
   708  		return "COMPRESSED_SIGNED_RG11_EAC"
   709  	case 0x9279:
   710  		return "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"
   711  	case 0x9275:
   712  		return "COMPRESSED_SRGB8_ETC2"
   713  	case 0x9277:
   714  		return "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"
   715  	case 0x911c:
   716  		return "CONDITION_SATISFIED"
   717  	case 0x8f36:
   718  		return "36662"
   719  	case 0x8f37:
   720  		return "36663"
   721  	case 0x8865:
   722  		return "CURRENT_QUERY"
   723  	case 0x1801:
   724  		return "DEPTH"
   725  	case 0x88f0:
   726  		return "DEPTH24_STENCIL8"
   727  	case 0x8cad:
   728  		return "DEPTH32F_STENCIL8"
   729  	case 0x81a6:
   730  		return "DEPTH_COMPONENT24"
   731  	case 0x8cac:
   732  		return "DEPTH_COMPONENT32F"
   733  	case 0x84f9:
   734  		return "DEPTH_STENCIL"
   735  	case 0x821a:
   736  		return "DEPTH_STENCIL_ATTACHMENT"
   737  	case 0x8825:
   738  		return "DRAW_BUFFER0"
   739  	case 0x882f:
   740  		return "DRAW_BUFFER10"
   741  	case 0x8826:
   742  		return "DRAW_BUFFER1"
   743  	case 0x8830:
   744  		return "DRAW_BUFFER11"
   745  	case 0x8831:
   746  		return "DRAW_BUFFER12"
   747  	case 0x8832:
   748  		return "DRAW_BUFFER13"
   749  	case 0x8833:
   750  		return "DRAW_BUFFER14"
   751  	case 0x8834:
   752  		return "DRAW_BUFFER15"
   753  	case 0x8827:
   754  		return "DRAW_BUFFER2"
   755  	case 0x8828:
   756  		return "DRAW_BUFFER3"
   757  	case 0x8829:
   758  		return "DRAW_BUFFER4"
   759  	case 0x882a:
   760  		return "DRAW_BUFFER5"
   761  	case 0x882b:
   762  		return "DRAW_BUFFER6"
   763  	case 0x882c:
   764  		return "DRAW_BUFFER7"
   765  	case 0x882d:
   766  		return "DRAW_BUFFER8"
   767  	case 0x882e:
   768  		return "DRAW_BUFFER9"
   769  	case 0x8ca9:
   770  		return "DRAW_FRAMEBUFFER"
   771  	case 0x88ea:
   772  		return "DYNAMIC_COPY"
   773  	case 0x88e9:
   774  		return "DYNAMIC_READ"
   775  	case 0x8dad:
   776  		return "FLOAT_32_UNSIGNED_INT_24_8_REV"
   777  	case 0x8b65:
   778  		return "FLOAT_MAT2x3"
   779  	case 0x8b66:
   780  		return "FLOAT_MAT2x4"
   781  	case 0x8b67:
   782  		return "FLOAT_MAT3x2"
   783  	case 0x8b68:
   784  		return "FLOAT_MAT3x4"
   785  	case 0x8b69:
   786  		return "FLOAT_MAT4x2"
   787  	case 0x8b6a:
   788  		return "FLOAT_MAT4x3"
   789  	case 0x8b8b:
   790  		return "FRAGMENT_SHADER_DERIVATIVE_HINT"
   791  	case 0x8215:
   792  		return "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"
   793  	case 0x8214:
   794  		return "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"
   795  	case 0x8210:
   796  		return "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"
   797  	case 0x8211:
   798  		return "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"
   799  	case 0x8216:
   800  		return "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"
   801  	case 0x8213:
   802  		return "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"
   803  	case 0x8212:
   804  		return "FRAMEBUFFER_ATTACHMENT_RED_SIZE"
   805  	case 0x8217:
   806  		return "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"
   807  	case 0x8cd4:
   808  		return "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"
   809  	case 0x8218:
   810  		return "FRAMEBUFFER_DEFAULT"
   811  	case 0x8d56:
   812  		return "FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"
   813  	case 0x8219:
   814  		return "FRAMEBUFFER_UNDEFINED"
   815  	case 0x1904:
   816  		return "GREEN"
   817  	case 0x140b:
   818  		return "HALF_FLOAT"
   819  	case 0x8d9f:
   820  		return "INT_2_10_10_10_REV"
   821  	case 0x8c8c:
   822  		return "INTERLEAVED_ATTRIBS"
   823  	case 0x8dca:
   824  		return "INT_SAMPLER_2D"
   825  	case 0x8dcf:
   826  		return "INT_SAMPLER_2D_ARRAY"
   827  	case 0x8dcb:
   828  		return "INT_SAMPLER_3D"
   829  	case 0x8dcc:
   830  		return "INT_SAMPLER_CUBE"
   831  	case 0xffffffff:
   832  		return "INVALID_INDEX"
   833  	case 0x821b:
   834  		return "MAJOR_VERSION"
   835  	case 0x10:
   836  		return "MAP_FLUSH_EXPLICIT_BIT"
   837  	case 0x8:
   838  		return "MAP_INVALIDATE_BUFFER_BIT"
   839  	case 0x20:
   840  		return "MAP_UNSYNCHRONIZED_BIT"
   841  	case 0x8008:
   842  		return "MAX"
   843  	case 0x8073:
   844  		return "MAX_3D_TEXTURE_SIZE"
   845  	case 0x88ff:
   846  		return "MAX_ARRAY_TEXTURE_LAYERS"
   847  	case 0x8cdf:
   848  		return "MAX_COLOR_ATTACHMENTS"
   849  	case 0x8a33:
   850  		return "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"
   851  	case 0x8a2e:
   852  		return "MAX_COMBINED_UNIFORM_BLOCKS"
   853  	case 0x8a31:
   854  		return "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"
   855  	case 0x8824:
   856  		return "MAX_DRAW_BUFFERS"
   857  	case 0x8d6b:
   858  		return "MAX_ELEMENT_INDEX"
   859  	case 0x80e9:
   860  		return "MAX_ELEMENTS_INDICES"
   861  	case 0x80e8:
   862  		return "MAX_ELEMENTS_VERTICES"
   863  	case 0x9125:
   864  		return "MAX_FRAGMENT_INPUT_COMPONENTS"
   865  	case 0x8a2d:
   866  		return "MAX_FRAGMENT_UNIFORM_BLOCKS"
   867  	case 0x8b49:
   868  		return "MAX_FRAGMENT_UNIFORM_COMPONENTS"
   869  	case 0x8905:
   870  		return "MAX_PROGRAM_TEXEL_OFFSET"
   871  	case 0x8d57:
   872  		return "MAX_SAMPLES"
   873  	case 0x9111:
   874  		return "MAX_SERVER_WAIT_TIMEOUT"
   875  	case 0x84fd:
   876  		return "MAX_TEXTURE_LOD_BIAS"
   877  	case 0x8c8a:
   878  		return "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS"
   879  	case 0x8c8b:
   880  		return "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS"
   881  	case 0x8c80:
   882  		return "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"
   883  	case 0x8a30:
   884  		return "MAX_UNIFORM_BLOCK_SIZE"
   885  	case 0x8a2f:
   886  		return "MAX_UNIFORM_BUFFER_BINDINGS"
   887  	case 0x8b4b:
   888  		return "MAX_VARYING_COMPONENTS"
   889  	case 0x9122:
   890  		return "MAX_VERTEX_OUTPUT_COMPONENTS"
   891  	case 0x8a2b:
   892  		return "MAX_VERTEX_UNIFORM_BLOCKS"
   893  	case 0x8b4a:
   894  		return "MAX_VERTEX_UNIFORM_COMPONENTS"
   895  	case 0x8007:
   896  		return "MIN"
   897  	case 0x821c:
   898  		return "MINOR_VERSION"
   899  	case 0x8904:
   900  		return "MIN_PROGRAM_TEXEL_OFFSET"
   901  	case 0x821d:
   902  		return "NUM_EXTENSIONS"
   903  	case 0x87fe:
   904  		return "NUM_PROGRAM_BINARY_FORMATS"
   905  	case 0x9380:
   906  		return "NUM_SAMPLE_COUNTS"
   907  	case 0x9112:
   908  		return "OBJECT_TYPE"
   909  	case 0xd02:
   910  		return "PACK_ROW_LENGTH"
   911  	case 0xd04:
   912  		return "PACK_SKIP_PIXELS"
   913  	case 0xd03:
   914  		return "PACK_SKIP_ROWS"
   915  	case 0x88eb:
   916  		return "PIXEL_PACK_BUFFER"
   917  	case 0x88ed:
   918  		return "PIXEL_PACK_BUFFER_BINDING"
   919  	case 0x88ec:
   920  		return "PIXEL_UNPACK_BUFFER"
   921  	case 0x88ef:
   922  		return "PIXEL_UNPACK_BUFFER_BINDING"
   923  	case 0x8d69:
   924  		return "PRIMITIVE_RESTART_FIXED_INDEX"
   925  	case 0x87ff:
   926  		return "PROGRAM_BINARY_FORMATS"
   927  	case 0x8741:
   928  		return "PROGRAM_BINARY_LENGTH"
   929  	case 0x8257:
   930  		return "PROGRAM_BINARY_RETRIEVABLE_HINT"
   931  	case 0x8866:
   932  		return "QUERY_RESULT"
   933  	case 0x8867:
   934  		return "QUERY_RESULT_AVAILABLE"
   935  	case 0x8c3a:
   936  		return "R11F_G11F_B10F"
   937  	case 0x822d:
   938  		return "R16F"
   939  	case 0x8233:
   940  		return "R16I"
   941  	case 0x8234:
   942  		return "R16UI"
   943  	case 0x822e:
   944  		return "R32F"
   945  	case 0x8235:
   946  		return "R32I"
   947  	case 0x8236:
   948  		return "R32UI"
   949  	case 0x8229:
   950  		return "R8"
   951  	case 0x8231:
   952  		return "R8I"
   953  	case 0x8f94:
   954  		return "R8_SNORM"
   955  	case 0x8232:
   956  		return "R8UI"
   957  	case 0x8c89:
   958  		return "RASTERIZER_DISCARD"
   959  	case 0xc02:
   960  		return "READ_BUFFER"
   961  	case 0x8ca8:
   962  		return "READ_FRAMEBUFFER"
   963  	case 0x8caa:
   964  		return "READ_FRAMEBUFFER_BINDING"
   965  	case 0x1903:
   966  		return "RED"
   967  	case 0x8d94:
   968  		return "RED_INTEGER"
   969  	case 0x8cab:
   970  		return "RENDERBUFFER_SAMPLES"
   971  	case 0x8227:
   972  		return "RG"
   973  	case 0x822f:
   974  		return "RG16F"
   975  	case 0x8239:
   976  		return "RG16I"
   977  	case 0x823a:
   978  		return "RG16UI"
   979  	case 0x8230:
   980  		return "RG32F"
   981  	case 0x823b:
   982  		return "RG32I"
   983  	case 0x823c:
   984  		return "RG32UI"
   985  	case 0x822b:
   986  		return "RG8"
   987  	case 0x8237:
   988  		return "RG8I"
   989  	case 0x8f95:
   990  		return "RG8_SNORM"
   991  	case 0x8238:
   992  		return "RG8UI"
   993  	case 0x8059:
   994  		return "RGB10_A2"
   995  	case 0x906f:
   996  		return "RGB10_A2UI"
   997  	case 0x881b:
   998  		return "RGB16F"
   999  	case 0x8d89:
  1000  		return "RGB16I"
  1001  	case 0x8d77:
  1002  		return "RGB16UI"
  1003  	case 0x8815:
  1004  		return "RGB32F"
  1005  	case 0x8d83:
  1006  		return "RGB32I"
  1007  	case 0x8d71:
  1008  		return "RGB32UI"
  1009  	case 0x8051:
  1010  		return "RGB8"
  1011  	case 0x8d8f:
  1012  		return "RGB8I"
  1013  	case 0x8f96:
  1014  		return "RGB8_SNORM"
  1015  	case 0x8d7d:
  1016  		return "RGB8UI"
  1017  	case 0x8c3d:
  1018  		return "RGB9_E5"
  1019  	case 0x881a:
  1020  		return "RGBA16F"
  1021  	case 0x8d88:
  1022  		return "RGBA16I"
  1023  	case 0x8d76:
  1024  		return "RGBA16UI"
  1025  	case 0x8814:
  1026  		return "RGBA32F"
  1027  	case 0x8d82:
  1028  		return "RGBA32I"
  1029  	case 0x8d70:
  1030  		return "RGBA32UI"
  1031  	case 0x8058:
  1032  		return "RGBA8"
  1033  	case 0x8d8e:
  1034  		return "RGBA8I"
  1035  	case 0x8f97:
  1036  		return "RGBA8_SNORM"
  1037  	case 0x8d7c:
  1038  		return "RGBA8UI"
  1039  	case 0x8d99:
  1040  		return "RGBA_INTEGER"
  1041  	case 0x8d98:
  1042  		return "RGB_INTEGER"
  1043  	case 0x8228:
  1044  		return "RG_INTEGER"
  1045  	case 0x8dc1:
  1046  		return "SAMPLER_2D_ARRAY"
  1047  	case 0x8dc4:
  1048  		return "SAMPLER_2D_ARRAY_SHADOW"
  1049  	case 0x8b62:
  1050  		return "SAMPLER_2D_SHADOW"
  1051  	case 0x8b5f:
  1052  		return "SAMPLER_3D"
  1053  	case 0x8919:
  1054  		return "SAMPLER_BINDING"
  1055  	case 0x8dc5:
  1056  		return "SAMPLER_CUBE_SHADOW"
  1057  	case 0x8c8d:
  1058  		return "SEPARATE_ATTRIBS"
  1059  	case 0x9119:
  1060  		return "SIGNALED"
  1061  	case 0x8f9c:
  1062  		return "SIGNED_NORMALIZED"
  1063  	case 0x8c40:
  1064  		return "SRGB"
  1065  	case 0x8c41:
  1066  		return "SRGB8"
  1067  	case 0x8c43:
  1068  		return "SRGB8_ALPHA8"
  1069  	case 0x88e6:
  1070  		return "STATIC_COPY"
  1071  	case 0x88e5:
  1072  		return "STATIC_READ"
  1073  	case 0x1802:
  1074  		return "STENCIL"
  1075  	case 0x88e2:
  1076  		return "STREAM_COPY"
  1077  	case 0x88e1:
  1078  		return "STREAM_READ"
  1079  	case 0x9113:
  1080  		return "SYNC_CONDITION"
  1081  	case 0x9116:
  1082  		return "SYNC_FENCE"
  1083  	case 0x9115:
  1084  		return "SYNC_FLAGS"
  1085  	case 0x9117:
  1086  		return "SYNC_GPU_COMMANDS_COMPLETE"
  1087  	case 0x9114:
  1088  		return "SYNC_STATUS"
  1089  	case 0x8c1a:
  1090  		return "TEXTURE_2D_ARRAY"
  1091  	case 0x806f:
  1092  		return "TEXTURE_3D"
  1093  	case 0x813c:
  1094  		return "TEXTURE_BASE_LEVEL"
  1095  	case 0x8c1d:
  1096  		return "TEXTURE_BINDING_2D_ARRAY"
  1097  	case 0x806a:
  1098  		return "TEXTURE_BINDING_3D"
  1099  	case 0x884d:
  1100  		return "TEXTURE_COMPARE_FUNC"
  1101  	case 0x884c:
  1102  		return "TEXTURE_COMPARE_MODE"
  1103  	case 0x912f:
  1104  		return "TEXTURE_IMMUTABLE_FORMAT"
  1105  	case 0x82df:
  1106  		return "TEXTURE_IMMUTABLE_LEVELS"
  1107  	case 0x813d:
  1108  		return "TEXTURE_MAX_LEVEL"
  1109  	case 0x813b:
  1110  		return "TEXTURE_MAX_LOD"
  1111  	case 0x813a:
  1112  		return "TEXTURE_MIN_LOD"
  1113  	case 0x8e45:
  1114  		return "TEXTURE_SWIZZLE_A"
  1115  	case 0x8e44:
  1116  		return "TEXTURE_SWIZZLE_B"
  1117  	case 0x8e43:
  1118  		return "TEXTURE_SWIZZLE_G"
  1119  	case 0x8e42:
  1120  		return "TEXTURE_SWIZZLE_R"
  1121  	case 0x8072:
  1122  		return "TEXTURE_WRAP_R"
  1123  	case 0x911b:
  1124  		return "TIMEOUT_EXPIRED"
  1125  	case 0x8e22:
  1126  		return "TRANSFORM_FEEDBACK"
  1127  	case 0x8e24:
  1128  		return "TRANSFORM_FEEDBACK_ACTIVE"
  1129  	case 0x8e25:
  1130  		return "TRANSFORM_FEEDBACK_BINDING"
  1131  	case 0x8c8e:
  1132  		return "TRANSFORM_FEEDBACK_BUFFER"
  1133  	case 0x8c8f:
  1134  		return "TRANSFORM_FEEDBACK_BUFFER_BINDING"
  1135  	case 0x8c7f:
  1136  		return "TRANSFORM_FEEDBACK_BUFFER_MODE"
  1137  	case 0x8c85:
  1138  		return "TRANSFORM_FEEDBACK_BUFFER_SIZE"
  1139  	case 0x8c84:
  1140  		return "TRANSFORM_FEEDBACK_BUFFER_START"
  1141  	case 0x8e23:
  1142  		return "TRANSFORM_FEEDBACK_PAUSED"
  1143  	case 0x8c88:
  1144  		return "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"
  1145  	case 0x8c76:
  1146  		return "TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH"
  1147  	case 0x8c83:
  1148  		return "TRANSFORM_FEEDBACK_VARYINGS"
  1149  	case 0x8a3c:
  1150  		return "UNIFORM_ARRAY_STRIDE"
  1151  	case 0x8a43:
  1152  		return "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"
  1153  	case 0x8a42:
  1154  		return "UNIFORM_BLOCK_ACTIVE_UNIFORMS"
  1155  	case 0x8a3f:
  1156  		return "UNIFORM_BLOCK_BINDING"
  1157  	case 0x8a40:
  1158  		return "UNIFORM_BLOCK_DATA_SIZE"
  1159  	case 0x8a3a:
  1160  		return "UNIFORM_BLOCK_INDEX"
  1161  	case 0x8a41:
  1162  		return "UNIFORM_BLOCK_NAME_LENGTH"
  1163  	case 0x8a46:
  1164  		return "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"
  1165  	case 0x8a44:
  1166  		return "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"
  1167  	case 0x8a11:
  1168  		return "UNIFORM_BUFFER"
  1169  	case 0x8a28:
  1170  		return "UNIFORM_BUFFER_BINDING"
  1171  	case 0x8a34:
  1172  		return "UNIFORM_BUFFER_OFFSET_ALIGNMENT"
  1173  	case 0x8a2a:
  1174  		return "UNIFORM_BUFFER_SIZE"
  1175  	case 0x8a29:
  1176  		return "UNIFORM_BUFFER_START"
  1177  	case 0x8a3e:
  1178  		return "UNIFORM_IS_ROW_MAJOR"
  1179  	case 0x8a3d:
  1180  		return "UNIFORM_MATRIX_STRIDE"
  1181  	case 0x8a39:
  1182  		return "UNIFORM_NAME_LENGTH"
  1183  	case 0x8a3b:
  1184  		return "UNIFORM_OFFSET"
  1185  	case 0x8a38:
  1186  		return "UNIFORM_SIZE"
  1187  	case 0x8a37:
  1188  		return "UNIFORM_TYPE"
  1189  	case 0x806e:
  1190  		return "UNPACK_IMAGE_HEIGHT"
  1191  	case 0xcf2:
  1192  		return "UNPACK_ROW_LENGTH"
  1193  	case 0x806d:
  1194  		return "UNPACK_SKIP_IMAGES"
  1195  	case 0xcf4:
  1196  		return "UNPACK_SKIP_PIXELS"
  1197  	case 0xcf3:
  1198  		return "UNPACK_SKIP_ROWS"
  1199  	case 0x9118:
  1200  		return "UNSIGNALED"
  1201  	case 0x8c3b:
  1202  		return "UNSIGNED_INT_10F_11F_11F_REV"
  1203  	case 0x8368:
  1204  		return "UNSIGNED_INT_2_10_10_10_REV"
  1205  	case 0x84fa:
  1206  		return "UNSIGNED_INT_24_8"
  1207  	case 0x8c3e:
  1208  		return "UNSIGNED_INT_5_9_9_9_REV"
  1209  	case 0x8dd2:
  1210  		return "UNSIGNED_INT_SAMPLER_2D"
  1211  	case 0x8dd7:
  1212  		return "UNSIGNED_INT_SAMPLER_2D_ARRAY"
  1213  	case 0x8dd3:
  1214  		return "UNSIGNED_INT_SAMPLER_3D"
  1215  	case 0x8dd4:
  1216  		return "UNSIGNED_INT_SAMPLER_CUBE"
  1217  	case 0x8dc6:
  1218  		return "UNSIGNED_INT_VEC2"
  1219  	case 0x8dc7:
  1220  		return "UNSIGNED_INT_VEC3"
  1221  	case 0x8dc8:
  1222  		return "UNSIGNED_INT_VEC4"
  1223  	case 0x8c17:
  1224  		return "UNSIGNED_NORMALIZED"
  1225  	case 0x85b5:
  1226  		return "VERTEX_ARRAY_BINDING"
  1227  	case 0x88fe:
  1228  		return "VERTEX_ATTRIB_ARRAY_DIVISOR"
  1229  	case 0x88fd:
  1230  		return "VERTEX_ATTRIB_ARRAY_INTEGER"
  1231  	case 0x911d:
  1232  		return "WAIT_FAILED"
  1233  	default:
  1234  		return fmt.Sprintf("gl.Enum(0x%x)", uint32(v))
  1235  	}
  1236  }
  1237  
  1238  func (ctx *context) ActiveTexture(texture Enum) {
  1239  	defer func() {
  1240  		errstr := ctx.errDrain()
  1241  		log.Printf("gl.ActiveTexture(%v) %v", texture, errstr)
  1242  	}()
  1243  	ctx.enqueueDebug(call{
  1244  		args: fnargs{
  1245  			fn: glfnActiveTexture,
  1246  			a0: texture.c(),
  1247  		},
  1248  		blocking: true})
  1249  }
  1250  
  1251  func (ctx *context) AttachShader(p Program, s Shader) {
  1252  	defer func() {
  1253  		errstr := ctx.errDrain()
  1254  		log.Printf("gl.AttachShader(%v, %v) %v", p, s, errstr)
  1255  	}()
  1256  	ctx.enqueueDebug(call{
  1257  		args: fnargs{
  1258  			fn: glfnAttachShader,
  1259  			a0: p.c(),
  1260  			a1: s.c(),
  1261  		},
  1262  		blocking: true})
  1263  }
  1264  
  1265  func (ctx *context) BindAttribLocation(p Program, a Attrib, name string) {
  1266  	defer func() {
  1267  		errstr := ctx.errDrain()
  1268  		log.Printf("gl.BindAttribLocation(%v, %v, %v) %v", p, a, name, errstr)
  1269  	}()
  1270  	s, free := ctx.cString(name)
  1271  	defer free()
  1272  	ctx.enqueueDebug(call{
  1273  		args: fnargs{
  1274  			fn: glfnBindAttribLocation,
  1275  			a0: p.c(),
  1276  			a1: a.c(),
  1277  			a2: s,
  1278  		},
  1279  		blocking: true,
  1280  	})
  1281  }
  1282  
  1283  func (ctx *context) BindBuffer(target Enum, b Buffer) {
  1284  	defer func() {
  1285  		errstr := ctx.errDrain()
  1286  		log.Printf("gl.BindBuffer(%v, %v) %v", target, b, errstr)
  1287  	}()
  1288  	ctx.enqueueDebug(call{
  1289  		args: fnargs{
  1290  			fn: glfnBindBuffer,
  1291  			a0: target.c(),
  1292  			a1: b.c(),
  1293  		},
  1294  		blocking: true})
  1295  }
  1296  
  1297  func (ctx *context) BindFramebuffer(target Enum, fb Framebuffer) {
  1298  	defer func() {
  1299  		errstr := ctx.errDrain()
  1300  		log.Printf("gl.BindFramebuffer(%v, %v) %v", target, fb, errstr)
  1301  	}()
  1302  	ctx.enqueueDebug(call{
  1303  		args: fnargs{
  1304  			fn: glfnBindFramebuffer,
  1305  			a0: target.c(),
  1306  			a1: fb.c(),
  1307  		},
  1308  		blocking: true})
  1309  }
  1310  
  1311  func (ctx *context) BindRenderbuffer(target Enum, rb Renderbuffer) {
  1312  	defer func() {
  1313  		errstr := ctx.errDrain()
  1314  		log.Printf("gl.BindRenderbuffer(%v, %v) %v", target, rb, errstr)
  1315  	}()
  1316  	ctx.enqueueDebug(call{
  1317  		args: fnargs{
  1318  			fn: glfnBindRenderbuffer,
  1319  			a0: target.c(),
  1320  			a1: rb.c(),
  1321  		},
  1322  		blocking: true})
  1323  }
  1324  
  1325  func (ctx *context) BindTexture(target Enum, t Texture) {
  1326  	defer func() {
  1327  		errstr := ctx.errDrain()
  1328  		log.Printf("gl.BindTexture(%v, %v) %v", target, t, errstr)
  1329  	}()
  1330  	ctx.enqueueDebug(call{
  1331  		args: fnargs{
  1332  			fn: glfnBindTexture,
  1333  			a0: target.c(),
  1334  			a1: t.c(),
  1335  		},
  1336  		blocking: true})
  1337  }
  1338  
  1339  func (ctx *context) BindVertexArray(va VertexArray) {
  1340  	defer func() {
  1341  		errstr := ctx.errDrain()
  1342  		log.Printf("gl.BindVertexArray(%v) %v", va, errstr)
  1343  	}()
  1344  	ctx.enqueueDebug(call{
  1345  		args: fnargs{
  1346  			fn: glfnBindVertexArray,
  1347  			a0: va.c(),
  1348  		},
  1349  		blocking: true})
  1350  }
  1351  
  1352  func (ctx *context) BlendColor(red, green, blue, alpha float32) {
  1353  	defer func() {
  1354  		errstr := ctx.errDrain()
  1355  		log.Printf("gl.BlendColor(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
  1356  	}()
  1357  	ctx.enqueueDebug(call{
  1358  		args: fnargs{
  1359  			fn: glfnBlendColor,
  1360  			a0: uintptr(math.Float32bits(red)),
  1361  			a1: uintptr(math.Float32bits(green)),
  1362  			a2: uintptr(math.Float32bits(blue)),
  1363  			a3: uintptr(math.Float32bits(alpha)),
  1364  		},
  1365  		blocking: true})
  1366  }
  1367  
  1368  func (ctx *context) BlendEquation(mode Enum) {
  1369  	defer func() {
  1370  		errstr := ctx.errDrain()
  1371  		log.Printf("gl.BlendEquation(%v) %v", mode, errstr)
  1372  	}()
  1373  	ctx.enqueueDebug(call{
  1374  		args: fnargs{
  1375  			fn: glfnBlendEquation,
  1376  			a0: mode.c(),
  1377  		},
  1378  		blocking: true})
  1379  }
  1380  
  1381  func (ctx *context) BlendEquationSeparate(modeRGB, modeAlpha Enum) {
  1382  	defer func() {
  1383  		errstr := ctx.errDrain()
  1384  		log.Printf("gl.BlendEquationSeparate(%v, %v) %v", modeRGB, modeAlpha, errstr)
  1385  	}()
  1386  	ctx.enqueueDebug(call{
  1387  		args: fnargs{
  1388  			fn: glfnBlendEquationSeparate,
  1389  			a0: modeRGB.c(),
  1390  			a1: modeAlpha.c(),
  1391  		},
  1392  		blocking: true})
  1393  }
  1394  
  1395  func (ctx *context) BlendFunc(sfactor, dfactor Enum) {
  1396  	defer func() {
  1397  		errstr := ctx.errDrain()
  1398  		log.Printf("gl.BlendFunc(%v, %v) %v", sfactor, dfactor, errstr)
  1399  	}()
  1400  	ctx.enqueueDebug(call{
  1401  		args: fnargs{
  1402  			fn: glfnBlendFunc,
  1403  			a0: sfactor.c(),
  1404  			a1: dfactor.c(),
  1405  		},
  1406  		blocking: true})
  1407  }
  1408  
  1409  func (ctx *context) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha Enum) {
  1410  	defer func() {
  1411  		errstr := ctx.errDrain()
  1412  		log.Printf("gl.BlendFuncSeparate(%v, %v, %v, %v) %v", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha, errstr)
  1413  	}()
  1414  	ctx.enqueueDebug(call{
  1415  		args: fnargs{
  1416  			fn: glfnBlendFuncSeparate,
  1417  			a0: sfactorRGB.c(),
  1418  			a1: dfactorRGB.c(),
  1419  			a2: sfactorAlpha.c(),
  1420  			a3: dfactorAlpha.c(),
  1421  		},
  1422  		blocking: true})
  1423  }
  1424  
  1425  func (ctx *context) BufferData(target Enum, src []byte, usage Enum) {
  1426  	defer func() {
  1427  		errstr := ctx.errDrain()
  1428  		log.Printf("gl.BufferData(%v, len(%d), %v) %v", target, len(src), usage, errstr)
  1429  	}()
  1430  	parg := unsafe.Pointer(nil)
  1431  	if len(src) > 0 {
  1432  		parg = unsafe.Pointer(&src[0])
  1433  	}
  1434  	ctx.enqueueDebug(call{
  1435  		args: fnargs{
  1436  			fn: glfnBufferData,
  1437  			a0: target.c(),
  1438  			a1: uintptr(len(src)),
  1439  			a2: usage.c(),
  1440  		},
  1441  		parg:     parg,
  1442  		blocking: true,
  1443  	})
  1444  }
  1445  
  1446  func (ctx *context) BufferInit(target Enum, size int, usage Enum) {
  1447  	defer func() {
  1448  		errstr := ctx.errDrain()
  1449  		log.Printf("gl.BufferInit(%v, %v, %v) %v", target, size, usage, errstr)
  1450  	}()
  1451  	ctx.enqueueDebug(call{
  1452  		args: fnargs{
  1453  			fn: glfnBufferData,
  1454  			a0: target.c(),
  1455  			a1: uintptr(size),
  1456  			a2: usage.c(),
  1457  		},
  1458  		parg:     unsafe.Pointer(nil),
  1459  		blocking: true})
  1460  }
  1461  
  1462  func (ctx *context) BufferSubData(target Enum, offset int, data []byte) {
  1463  	defer func() {
  1464  		errstr := ctx.errDrain()
  1465  		log.Printf("gl.BufferSubData(%v, %v, len(%d)) %v", target, offset, len(data), errstr)
  1466  	}()
  1467  	ctx.enqueueDebug(call{
  1468  		args: fnargs{
  1469  			fn: glfnBufferSubData,
  1470  			a0: target.c(),
  1471  			a1: uintptr(offset),
  1472  			a2: uintptr(len(data)),
  1473  		},
  1474  		parg:     unsafe.Pointer(&data[0]),
  1475  		blocking: true,
  1476  	})
  1477  }
  1478  
  1479  func (ctx *context) CheckFramebufferStatus(target Enum) (r0 Enum) {
  1480  	defer func() {
  1481  		errstr := ctx.errDrain()
  1482  		log.Printf("gl.CheckFramebufferStatus(%v) %v%v", target, r0, errstr)
  1483  	}()
  1484  	return Enum(ctx.enqueue(call{
  1485  		args: fnargs{
  1486  			fn: glfnCheckFramebufferStatus,
  1487  			a0: target.c(),
  1488  		},
  1489  		blocking: true,
  1490  	}))
  1491  }
  1492  
  1493  func (ctx *context) Clear(mask Enum) {
  1494  	defer func() {
  1495  		errstr := ctx.errDrain()
  1496  		log.Printf("gl.Clear(%v) %v", mask, errstr)
  1497  	}()
  1498  	ctx.enqueueDebug(call{
  1499  		args: fnargs{
  1500  			fn: glfnClear,
  1501  			a0: uintptr(mask),
  1502  		},
  1503  		blocking: true})
  1504  }
  1505  
  1506  func (ctx *context) ClearColor(red, green, blue, alpha float32) {
  1507  	defer func() {
  1508  		errstr := ctx.errDrain()
  1509  		log.Printf("gl.ClearColor(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
  1510  	}()
  1511  	ctx.enqueueDebug(call{
  1512  		args: fnargs{
  1513  			fn: glfnClearColor,
  1514  			a0: uintptr(math.Float32bits(red)),
  1515  			a1: uintptr(math.Float32bits(green)),
  1516  			a2: uintptr(math.Float32bits(blue)),
  1517  			a3: uintptr(math.Float32bits(alpha)),
  1518  		},
  1519  		blocking: true})
  1520  }
  1521  
  1522  func (ctx *context) ClearDepthf(d float32) {
  1523  	defer func() {
  1524  		errstr := ctx.errDrain()
  1525  		log.Printf("gl.ClearDepthf(%v) %v", d, errstr)
  1526  	}()
  1527  	ctx.enqueueDebug(call{
  1528  		args: fnargs{
  1529  			fn: glfnClearDepthf,
  1530  			a0: uintptr(math.Float32bits(d)),
  1531  		},
  1532  		blocking: true})
  1533  }
  1534  
  1535  func (ctx *context) ClearStencil(s int) {
  1536  	defer func() {
  1537  		errstr := ctx.errDrain()
  1538  		log.Printf("gl.ClearStencil(%v) %v", s, errstr)
  1539  	}()
  1540  	ctx.enqueueDebug(call{
  1541  		args: fnargs{
  1542  			fn: glfnClearStencil,
  1543  			a0: uintptr(s),
  1544  		},
  1545  		blocking: true})
  1546  }
  1547  
  1548  func (ctx *context) ColorMask(red, green, blue, alpha bool) {
  1549  	defer func() {
  1550  		errstr := ctx.errDrain()
  1551  		log.Printf("gl.ColorMask(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
  1552  	}()
  1553  	ctx.enqueueDebug(call{
  1554  		args: fnargs{
  1555  			fn: glfnColorMask,
  1556  			a0: glBoolean(red),
  1557  			a1: glBoolean(green),
  1558  			a2: glBoolean(blue),
  1559  			a3: glBoolean(alpha),
  1560  		},
  1561  		blocking: true})
  1562  }
  1563  
  1564  func (ctx *context) CompileShader(s Shader) {
  1565  	defer func() {
  1566  		errstr := ctx.errDrain()
  1567  		log.Printf("gl.CompileShader(%v) %v", s, errstr)
  1568  	}()
  1569  	ctx.enqueueDebug(call{
  1570  		args: fnargs{
  1571  			fn: glfnCompileShader,
  1572  			a0: s.c(),
  1573  		},
  1574  		blocking: true})
  1575  }
  1576  
  1577  func (ctx *context) CompressedTexImage2D(target Enum, level int, internalformat Enum, width, height, border int, data []byte) {
  1578  	defer func() {
  1579  		errstr := ctx.errDrain()
  1580  		log.Printf("gl.CompressedTexImage2D(%v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, internalformat, width, height, border, len(data), errstr)
  1581  	}()
  1582  	ctx.enqueueDebug(call{
  1583  		args: fnargs{
  1584  			fn: glfnCompressedTexImage2D,
  1585  			a0: target.c(),
  1586  			a1: uintptr(level),
  1587  			a2: internalformat.c(),
  1588  			a3: uintptr(width),
  1589  			a4: uintptr(height),
  1590  			a5: uintptr(border),
  1591  			a6: uintptr(len(data)),
  1592  		},
  1593  		parg:     unsafe.Pointer(&data[0]),
  1594  		blocking: true,
  1595  	})
  1596  }
  1597  
  1598  func (ctx *context) CompressedTexSubImage2D(target Enum, level, xoffset, yoffset, width, height int, format Enum, data []byte) {
  1599  	defer func() {
  1600  		errstr := ctx.errDrain()
  1601  		log.Printf("gl.CompressedTexSubImage2D(%v, %v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, xoffset, yoffset, width, height, format, len(data), errstr)
  1602  	}()
  1603  	ctx.enqueueDebug(call{
  1604  		args: fnargs{
  1605  			fn: glfnCompressedTexSubImage2D,
  1606  			a0: target.c(),
  1607  			a1: uintptr(level),
  1608  			a2: uintptr(xoffset),
  1609  			a3: uintptr(yoffset),
  1610  			a4: uintptr(width),
  1611  			a5: uintptr(height),
  1612  			a6: format.c(),
  1613  			a7: uintptr(len(data)),
  1614  		},
  1615  		parg:     unsafe.Pointer(&data[0]),
  1616  		blocking: true,
  1617  	})
  1618  }
  1619  
  1620  func (ctx *context) CopyTexImage2D(target Enum, level int, internalformat Enum, x, y, width, height, border int) {
  1621  	defer func() {
  1622  		errstr := ctx.errDrain()
  1623  		log.Printf("gl.CopyTexImage2D(%v, %v, %v, %v, %v, %v, %v, %v) %v", target, level, internalformat, x, y, width, height, border, errstr)
  1624  	}()
  1625  	ctx.enqueueDebug(call{
  1626  		args: fnargs{
  1627  			fn: glfnCopyTexImage2D,
  1628  			a0: target.c(),
  1629  			a1: uintptr(level),
  1630  			a2: internalformat.c(),
  1631  			a3: uintptr(x),
  1632  			a4: uintptr(y),
  1633  			a5: uintptr(width),
  1634  			a6: uintptr(height),
  1635  			a7: uintptr(border),
  1636  		},
  1637  		blocking: true})
  1638  }
  1639  
  1640  func (ctx *context) CopyTexSubImage2D(target Enum, level, xoffset, yoffset, x, y, width, height int) {
  1641  	defer func() {
  1642  		errstr := ctx.errDrain()
  1643  		log.Printf("gl.CopyTexSubImage2D(%v, %v, %v, %v, %v, %v, %v, %v) %v", target, level, xoffset, yoffset, x, y, width, height, errstr)
  1644  	}()
  1645  	ctx.enqueueDebug(call{
  1646  		args: fnargs{
  1647  			fn: glfnCopyTexSubImage2D,
  1648  			a0: target.c(),
  1649  			a1: uintptr(level),
  1650  			a2: uintptr(xoffset),
  1651  			a3: uintptr(yoffset),
  1652  			a4: uintptr(x),
  1653  			a5: uintptr(y),
  1654  			a6: uintptr(width),
  1655  			a7: uintptr(height),
  1656  		},
  1657  		blocking: true})
  1658  }
  1659  
  1660  func (ctx *context) CreateBuffer() (r0 Buffer) {
  1661  	defer func() {
  1662  		errstr := ctx.errDrain()
  1663  		log.Printf("gl.CreateBuffer() %v%v", r0, errstr)
  1664  	}()
  1665  	return Buffer{Value: uint32(ctx.enqueue(call{
  1666  		args: fnargs{
  1667  			fn: glfnGenBuffer,
  1668  		},
  1669  		blocking: true,
  1670  	}))}
  1671  }
  1672  
  1673  func (ctx *context) CreateFramebuffer() (r0 Framebuffer) {
  1674  	defer func() {
  1675  		errstr := ctx.errDrain()
  1676  		log.Printf("gl.CreateFramebuffer() %v%v", r0, errstr)
  1677  	}()
  1678  	return Framebuffer{Value: uint32(ctx.enqueue(call{
  1679  		args: fnargs{
  1680  			fn: glfnGenFramebuffer,
  1681  		},
  1682  		blocking: true,
  1683  	}))}
  1684  }
  1685  
  1686  func (ctx *context) CreateProgram() (r0 Program) {
  1687  	defer func() {
  1688  		errstr := ctx.errDrain()
  1689  		log.Printf("gl.CreateProgram() %v%v", r0, errstr)
  1690  	}()
  1691  	return Program{
  1692  		Init: true,
  1693  		Value: uint32(ctx.enqueue(call{
  1694  			args: fnargs{
  1695  				fn: glfnCreateProgram,
  1696  			},
  1697  			blocking: true,
  1698  		},
  1699  		))}
  1700  }
  1701  
  1702  func (ctx *context) CreateRenderbuffer() (r0 Renderbuffer) {
  1703  	defer func() {
  1704  		errstr := ctx.errDrain()
  1705  		log.Printf("gl.CreateRenderbuffer() %v%v", r0, errstr)
  1706  	}()
  1707  	return Renderbuffer{Value: uint32(ctx.enqueue(call{
  1708  		args: fnargs{
  1709  			fn: glfnGenRenderbuffer,
  1710  		},
  1711  		blocking: true,
  1712  	}))}
  1713  }
  1714  
  1715  func (ctx *context) CreateShader(ty Enum) (r0 Shader) {
  1716  	defer func() {
  1717  		errstr := ctx.errDrain()
  1718  		log.Printf("gl.CreateShader(%v) %v%v", ty, r0, errstr)
  1719  	}()
  1720  	return Shader{Value: uint32(ctx.enqueue(call{
  1721  		args: fnargs{
  1722  			fn: glfnCreateShader,
  1723  			a0: uintptr(ty),
  1724  		},
  1725  		blocking: true,
  1726  	}))}
  1727  }
  1728  
  1729  func (ctx *context) CreateTexture() (r0 Texture) {
  1730  	defer func() {
  1731  		errstr := ctx.errDrain()
  1732  		log.Printf("gl.CreateTexture() %v%v", r0, errstr)
  1733  	}()
  1734  	return Texture{Value: uint32(ctx.enqueue(call{
  1735  		args: fnargs{
  1736  			fn: glfnGenTexture,
  1737  		},
  1738  		blocking: true,
  1739  	}))}
  1740  }
  1741  
  1742  func (ctx *context) CreateVertexArray() (r0 VertexArray) {
  1743  	defer func() {
  1744  		errstr := ctx.errDrain()
  1745  		log.Printf("gl.CreateVertexArray() %v%v", r0, errstr)
  1746  	}()
  1747  	return VertexArray{Value: uint32(ctx.enqueue(call{
  1748  		args: fnargs{
  1749  			fn: glfnGenVertexArray,
  1750  		},
  1751  		blocking: true,
  1752  	}))}
  1753  }
  1754  
  1755  func (ctx *context) CullFace(mode Enum) {
  1756  	defer func() {
  1757  		errstr := ctx.errDrain()
  1758  		log.Printf("gl.CullFace(%v) %v", mode, errstr)
  1759  	}()
  1760  	ctx.enqueueDebug(call{
  1761  		args: fnargs{
  1762  			fn: glfnCullFace,
  1763  			a0: mode.c(),
  1764  		},
  1765  		blocking: true})
  1766  }
  1767  
  1768  func (ctx *context) DeleteBuffer(v Buffer) {
  1769  	defer func() {
  1770  		errstr := ctx.errDrain()
  1771  		log.Printf("gl.DeleteBuffer(%v) %v", v, errstr)
  1772  	}()
  1773  	ctx.enqueueDebug(call{
  1774  		args: fnargs{
  1775  			fn: glfnDeleteBuffer,
  1776  			a0: v.c(),
  1777  		},
  1778  		blocking: true})
  1779  }
  1780  
  1781  func (ctx *context) DeleteFramebuffer(v Framebuffer) {
  1782  	defer func() {
  1783  		errstr := ctx.errDrain()
  1784  		log.Printf("gl.DeleteFramebuffer(%v) %v", v, errstr)
  1785  	}()
  1786  	ctx.enqueueDebug(call{
  1787  		args: fnargs{
  1788  			fn: glfnDeleteFramebuffer,
  1789  			a0: v.c(),
  1790  		},
  1791  		blocking: true})
  1792  }
  1793  
  1794  func (ctx *context) DeleteProgram(p Program) {
  1795  	defer func() {
  1796  		errstr := ctx.errDrain()
  1797  		log.Printf("gl.DeleteProgram(%v) %v", p, errstr)
  1798  	}()
  1799  	ctx.enqueueDebug(call{
  1800  		args: fnargs{
  1801  			fn: glfnDeleteProgram,
  1802  			a0: p.c(),
  1803  		},
  1804  		blocking: true})
  1805  }
  1806  
  1807  func (ctx *context) DeleteRenderbuffer(v Renderbuffer) {
  1808  	defer func() {
  1809  		errstr := ctx.errDrain()
  1810  		log.Printf("gl.DeleteRenderbuffer(%v) %v", v, errstr)
  1811  	}()
  1812  	ctx.enqueueDebug(call{
  1813  		args: fnargs{
  1814  			fn: glfnDeleteRenderbuffer,
  1815  			a0: v.c(),
  1816  		},
  1817  		blocking: true})
  1818  }
  1819  
  1820  func (ctx *context) DeleteShader(s Shader) {
  1821  	defer func() {
  1822  		errstr := ctx.errDrain()
  1823  		log.Printf("gl.DeleteShader(%v) %v", s, errstr)
  1824  	}()
  1825  	ctx.enqueueDebug(call{
  1826  		args: fnargs{
  1827  			fn: glfnDeleteShader,
  1828  			a0: s.c(),
  1829  		},
  1830  		blocking: true})
  1831  }
  1832  
  1833  func (ctx *context) DeleteTexture(v Texture) {
  1834  	defer func() {
  1835  		errstr := ctx.errDrain()
  1836  		log.Printf("gl.DeleteTexture(%v) %v", v, errstr)
  1837  	}()
  1838  	ctx.enqueueDebug(call{
  1839  		args: fnargs{
  1840  			fn: glfnDeleteTexture,
  1841  			a0: v.c(),
  1842  		},
  1843  		blocking: true})
  1844  }
  1845  
  1846  func (ctx *context) DeleteVertexArray(v VertexArray) {
  1847  	defer func() {
  1848  		errstr := ctx.errDrain()
  1849  		log.Printf("gl.DeleteVertexArray(%v) %v", v, errstr)
  1850  	}()
  1851  	ctx.enqueueDebug(call{
  1852  		args: fnargs{
  1853  			fn: glfnDeleteVertexArray,
  1854  			a0: v.c(),
  1855  		},
  1856  		blocking: true})
  1857  }
  1858  
  1859  func (ctx *context) DepthFunc(fn Enum) {
  1860  	defer func() {
  1861  		errstr := ctx.errDrain()
  1862  		log.Printf("gl.DepthFunc(%v) %v", fn, errstr)
  1863  	}()
  1864  	ctx.enqueueDebug(call{
  1865  		args: fnargs{
  1866  			fn: glfnDepthFunc,
  1867  			a0: fn.c(),
  1868  		},
  1869  		blocking: true})
  1870  }
  1871  
  1872  func (ctx *context) DepthMask(flag bool) {
  1873  	defer func() {
  1874  		errstr := ctx.errDrain()
  1875  		log.Printf("gl.DepthMask(%v) %v", flag, errstr)
  1876  	}()
  1877  	ctx.enqueueDebug(call{
  1878  		args: fnargs{
  1879  			fn: glfnDepthMask,
  1880  			a0: glBoolean(flag),
  1881  		},
  1882  		blocking: true})
  1883  }
  1884  
  1885  func (ctx *context) DepthRangef(n, f float32) {
  1886  	defer func() {
  1887  		errstr := ctx.errDrain()
  1888  		log.Printf("gl.DepthRangef(%v, %v) %v", n, f, errstr)
  1889  	}()
  1890  	ctx.enqueueDebug(call{
  1891  		args: fnargs{
  1892  			fn: glfnDepthRangef,
  1893  			a0: uintptr(math.Float32bits(n)),
  1894  			a1: uintptr(math.Float32bits(f)),
  1895  		},
  1896  		blocking: true})
  1897  }
  1898  
  1899  func (ctx *context) DetachShader(p Program, s Shader) {
  1900  	defer func() {
  1901  		errstr := ctx.errDrain()
  1902  		log.Printf("gl.DetachShader(%v, %v) %v", p, s, errstr)
  1903  	}()
  1904  	ctx.enqueueDebug(call{
  1905  		args: fnargs{
  1906  			fn: glfnDetachShader,
  1907  			a0: p.c(),
  1908  			a1: s.c(),
  1909  		},
  1910  		blocking: true})
  1911  }
  1912  
  1913  func (ctx *context) Disable(cap Enum) {
  1914  	defer func() {
  1915  		errstr := ctx.errDrain()
  1916  		log.Printf("gl.Disable(%v) %v", cap, errstr)
  1917  	}()
  1918  	ctx.enqueueDebug(call{
  1919  		args: fnargs{
  1920  			fn: glfnDisable,
  1921  			a0: cap.c(),
  1922  		},
  1923  		blocking: true})
  1924  }
  1925  
  1926  func (ctx *context) DisableVertexAttribArray(a Attrib) {
  1927  	defer func() {
  1928  		errstr := ctx.errDrain()
  1929  		log.Printf("gl.DisableVertexAttribArray(%v) %v", a, errstr)
  1930  	}()
  1931  	ctx.enqueueDebug(call{
  1932  		args: fnargs{
  1933  			fn: glfnDisableVertexAttribArray,
  1934  			a0: a.c(),
  1935  		},
  1936  		blocking: true})
  1937  }
  1938  
  1939  func (ctx *context) DrawArrays(mode Enum, first, count int) {
  1940  	defer func() {
  1941  		errstr := ctx.errDrain()
  1942  		log.Printf("gl.DrawArrays(%v, %v, %v) %v", mode, first, count, errstr)
  1943  	}()
  1944  	ctx.enqueueDebug(call{
  1945  		args: fnargs{
  1946  			fn: glfnDrawArrays,
  1947  			a0: mode.c(),
  1948  			a1: uintptr(first),
  1949  			a2: uintptr(count),
  1950  		},
  1951  		blocking: true})
  1952  }
  1953  
  1954  func (ctx *context) DrawElements(mode Enum, count int, ty Enum, offset int) {
  1955  	defer func() {
  1956  		errstr := ctx.errDrain()
  1957  		log.Printf("gl.DrawElements(%v, %v, %v, %v) %v", mode, count, ty, offset, errstr)
  1958  	}()
  1959  	ctx.enqueueDebug(call{
  1960  		args: fnargs{
  1961  			fn: glfnDrawElements,
  1962  			a0: mode.c(),
  1963  			a1: uintptr(count),
  1964  			a2: ty.c(),
  1965  			a3: uintptr(offset),
  1966  		},
  1967  		blocking: true})
  1968  }
  1969  
  1970  func (ctx *context) Enable(cap Enum) {
  1971  	defer func() {
  1972  		errstr := ctx.errDrain()
  1973  		log.Printf("gl.Enable(%v) %v", cap, errstr)
  1974  	}()
  1975  	ctx.enqueueDebug(call{
  1976  		args: fnargs{
  1977  			fn: glfnEnable,
  1978  			a0: cap.c(),
  1979  		},
  1980  		blocking: true})
  1981  }
  1982  
  1983  func (ctx *context) EnableVertexAttribArray(a Attrib) {
  1984  	defer func() {
  1985  		errstr := ctx.errDrain()
  1986  		log.Printf("gl.EnableVertexAttribArray(%v) %v", a, errstr)
  1987  	}()
  1988  	ctx.enqueueDebug(call{
  1989  		args: fnargs{
  1990  			fn: glfnEnableVertexAttribArray,
  1991  			a0: a.c(),
  1992  		},
  1993  		blocking: true})
  1994  }
  1995  
  1996  func (ctx *context) Finish() {
  1997  	defer func() {
  1998  		errstr := ctx.errDrain()
  1999  		log.Printf("gl.Finish() %v", errstr)
  2000  	}()
  2001  	ctx.enqueueDebug(call{
  2002  		args: fnargs{
  2003  			fn: glfnFinish,
  2004  		},
  2005  		blocking: true,
  2006  	})
  2007  }
  2008  
  2009  func (ctx *context) Flush() {
  2010  	defer func() {
  2011  		errstr := ctx.errDrain()
  2012  		log.Printf("gl.Flush() %v", errstr)
  2013  	}()
  2014  	ctx.enqueueDebug(call{
  2015  		args: fnargs{
  2016  			fn: glfnFlush,
  2017  		},
  2018  		blocking: true,
  2019  	})
  2020  }
  2021  
  2022  func (ctx *context) FramebufferRenderbuffer(target, attachment, rbTarget Enum, rb Renderbuffer) {
  2023  	defer func() {
  2024  		errstr := ctx.errDrain()
  2025  		log.Printf("gl.FramebufferRenderbuffer(%v, %v, %v, %v) %v", target, attachment, rbTarget, rb, errstr)
  2026  	}()
  2027  	ctx.enqueueDebug(call{
  2028  		args: fnargs{
  2029  			fn: glfnFramebufferRenderbuffer,
  2030  			a0: target.c(),
  2031  			a1: attachment.c(),
  2032  			a2: rbTarget.c(),
  2033  			a3: rb.c(),
  2034  		},
  2035  		blocking: true})
  2036  }
  2037  
  2038  func (ctx *context) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) {
  2039  	defer func() {
  2040  		errstr := ctx.errDrain()
  2041  		log.Printf("gl.FramebufferTexture2D(%v, %v, %v, %v, %v) %v", target, attachment, texTarget, t, level, errstr)
  2042  	}()
  2043  	ctx.enqueueDebug(call{
  2044  		args: fnargs{
  2045  			fn: glfnFramebufferTexture2D,
  2046  			a0: target.c(),
  2047  			a1: attachment.c(),
  2048  			a2: texTarget.c(),
  2049  			a3: t.c(),
  2050  			a4: uintptr(level),
  2051  		},
  2052  		blocking: true})
  2053  }
  2054  
  2055  func (ctx *context) FrontFace(mode Enum) {
  2056  	defer func() {
  2057  		errstr := ctx.errDrain()
  2058  		log.Printf("gl.FrontFace(%v) %v", mode, errstr)
  2059  	}()
  2060  	ctx.enqueueDebug(call{
  2061  		args: fnargs{
  2062  			fn: glfnFrontFace,
  2063  			a0: mode.c(),
  2064  		},
  2065  		blocking: true})
  2066  }
  2067  
  2068  func (ctx *context) GenerateMipmap(target Enum) {
  2069  	defer func() {
  2070  		errstr := ctx.errDrain()
  2071  		log.Printf("gl.GenerateMipmap(%v) %v", target, errstr)
  2072  	}()
  2073  	ctx.enqueueDebug(call{
  2074  		args: fnargs{
  2075  			fn: glfnGenerateMipmap,
  2076  			a0: target.c(),
  2077  		},
  2078  		blocking: true})
  2079  }
  2080  
  2081  func (ctx *context) GetActiveAttrib(p Program, index uint32) (name string, size int, ty Enum) {
  2082  	defer func() {
  2083  		errstr := ctx.errDrain()
  2084  		log.Printf("gl.GetActiveAttrib(%v, %v) (%v, %v, %v) %v", p, index, name, size, ty, errstr)
  2085  	}()
  2086  	bufSize := ctx.GetProgrami(p, ACTIVE_ATTRIBUTE_MAX_LENGTH)
  2087  	buf := make([]byte, bufSize)
  2088  	var cType int
  2089  	cSize := ctx.enqueue(call{
  2090  		args: fnargs{
  2091  			fn: glfnGetActiveAttrib,
  2092  			a0: p.c(),
  2093  			a1: uintptr(index),
  2094  			a2: uintptr(bufSize),
  2095  			a3: uintptr(unsafe.Pointer(&cType)),
  2096  		},
  2097  		parg:     unsafe.Pointer(&buf[0]),
  2098  		blocking: true,
  2099  	})
  2100  	return goString(buf), int(cSize), Enum(cType)
  2101  }
  2102  
  2103  func (ctx *context) GetActiveUniform(p Program, index uint32) (name string, size int, ty Enum) {
  2104  	defer func() {
  2105  		errstr := ctx.errDrain()
  2106  		log.Printf("gl.GetActiveUniform(%v, %v) (%v, %v, %v) %v", p, index, name, size, ty, errstr)
  2107  	}()
  2108  	bufSize := ctx.GetProgrami(p, ACTIVE_UNIFORM_MAX_LENGTH)
  2109  	buf := make([]byte, bufSize+8)
  2110  	var cType int
  2111  	cSize := ctx.enqueue(call{
  2112  		args: fnargs{
  2113  			fn: glfnGetActiveUniform,
  2114  			a0: p.c(),
  2115  			a1: uintptr(index),
  2116  			a2: uintptr(bufSize),
  2117  			a3: uintptr(unsafe.Pointer(&cType)),
  2118  		},
  2119  		parg:     unsafe.Pointer(&buf[0]),
  2120  		blocking: true,
  2121  	})
  2122  	return goString(buf), int(cSize), Enum(cType)
  2123  }
  2124  
  2125  func (ctx *context) GetAttachedShaders(p Program) (r0 []Shader) {
  2126  	defer func() {
  2127  		errstr := ctx.errDrain()
  2128  		log.Printf("gl.GetAttachedShaders(%v) %v%v", p, r0, errstr)
  2129  	}()
  2130  	shadersLen := ctx.GetProgrami(p, ATTACHED_SHADERS)
  2131  	if shadersLen == 0 {
  2132  		return nil
  2133  	}
  2134  	buf := make([]uint32, shadersLen)
  2135  	n := int(ctx.enqueue(call{
  2136  		args: fnargs{
  2137  			fn: glfnGetAttachedShaders,
  2138  			a0: p.c(),
  2139  			a1: uintptr(shadersLen),
  2140  		},
  2141  		parg:     unsafe.Pointer(&buf[0]),
  2142  		blocking: true,
  2143  	}))
  2144  	buf = buf[:int(n)]
  2145  	shaders := make([]Shader, len(buf))
  2146  	for i, s := range buf {
  2147  		shaders[i] = Shader{Value: uint32(s)}
  2148  	}
  2149  	return shaders
  2150  }
  2151  
  2152  func (ctx *context) GetAttribLocation(p Program, name string) (r0 Attrib) {
  2153  	defer func() {
  2154  		errstr := ctx.errDrain()
  2155  		r0.name = name
  2156  		log.Printf("gl.GetAttribLocation(%v, %v) %v%v", p, name, r0, errstr)
  2157  	}()
  2158  	s, free := ctx.cString(name)
  2159  	defer free()
  2160  	return Attrib{Value: uint(ctx.enqueue(call{
  2161  		args: fnargs{
  2162  			fn: glfnGetAttribLocation,
  2163  			a0: p.c(),
  2164  			a1: s,
  2165  		},
  2166  		blocking: true,
  2167  	}))}
  2168  }
  2169  
  2170  func (ctx *context) GetBooleanv(dst []bool, pname Enum) {
  2171  	defer func() {
  2172  		errstr := ctx.errDrain()
  2173  		log.Printf("gl.GetBooleanv(%v, %v) %v", dst, pname, errstr)
  2174  	}()
  2175  	buf := make([]int32, len(dst))
  2176  	ctx.enqueueDebug(call{
  2177  		args: fnargs{
  2178  			fn: glfnGetBooleanv,
  2179  			a0: pname.c(),
  2180  		},
  2181  		parg:     unsafe.Pointer(&buf[0]),
  2182  		blocking: true,
  2183  	})
  2184  	for i, v := range buf {
  2185  		dst[i] = v != 0
  2186  	}
  2187  }
  2188  
  2189  func (ctx *context) GetFloatv(dst []float32, pname Enum) {
  2190  	defer func() {
  2191  		errstr := ctx.errDrain()
  2192  		log.Printf("gl.GetFloatv(len(%d), %v) %v", len(dst), pname, errstr)
  2193  	}()
  2194  	ctx.enqueueDebug(call{
  2195  		args: fnargs{
  2196  			fn: glfnGetFloatv,
  2197  			a0: pname.c(),
  2198  		},
  2199  		parg:     unsafe.Pointer(&dst[0]),
  2200  		blocking: true,
  2201  	})
  2202  }
  2203  
  2204  func (ctx *context) GetIntegerv(dst []int32, pname Enum) {
  2205  	defer func() {
  2206  		errstr := ctx.errDrain()
  2207  		log.Printf("gl.GetIntegerv(%v, %v) %v", dst, pname, errstr)
  2208  	}()
  2209  	ctx.enqueueDebug(call{
  2210  		args: fnargs{
  2211  			fn: glfnGetIntegerv,
  2212  			a0: pname.c(),
  2213  		},
  2214  		parg:     unsafe.Pointer(&dst[0]),
  2215  		blocking: true,
  2216  	})
  2217  }
  2218  
  2219  func (ctx *context) GetInteger(pname Enum) (r0 int) {
  2220  	defer func() {
  2221  		errstr := ctx.errDrain()
  2222  		log.Printf("gl.GetInteger(%v) %v%v", pname, r0, errstr)
  2223  	}()
  2224  	var v [1]int32
  2225  	ctx.GetIntegerv(v[:], pname)
  2226  	return int(v[0])
  2227  }
  2228  
  2229  func (ctx *context) GetBufferParameteri(target, value Enum) (r0 int) {
  2230  	defer func() {
  2231  		errstr := ctx.errDrain()
  2232  		log.Printf("gl.GetBufferParameteri(%v, %v) %v%v", target, value, r0, errstr)
  2233  	}()
  2234  	return int(ctx.enqueue(call{
  2235  		args: fnargs{
  2236  			fn: glfnGetBufferParameteri,
  2237  			a0: target.c(),
  2238  			a1: value.c(),
  2239  		},
  2240  		blocking: true,
  2241  	}))
  2242  }
  2243  
  2244  func (ctx *context) GetError() (r0 Enum) {
  2245  	return Enum(ctx.enqueue(call{
  2246  		args: fnargs{
  2247  			fn: glfnGetError,
  2248  		},
  2249  		blocking: true,
  2250  	}))
  2251  }
  2252  
  2253  func (ctx *context) GetFramebufferAttachmentParameteri(target, attachment, pname Enum) (r0 int) {
  2254  	defer func() {
  2255  		errstr := ctx.errDrain()
  2256  		log.Printf("gl.GetFramebufferAttachmentParameteri(%v, %v, %v) %v%v", target, attachment, pname, r0, errstr)
  2257  	}()
  2258  	return int(ctx.enqueue(call{
  2259  		args: fnargs{
  2260  			fn: glfnGetFramebufferAttachmentParameteriv,
  2261  			a0: target.c(),
  2262  			a1: attachment.c(),
  2263  			a2: pname.c(),
  2264  		},
  2265  		blocking: true,
  2266  	}))
  2267  }
  2268  
  2269  func (ctx *context) GetProgrami(p Program, pname Enum) (r0 int) {
  2270  	defer func() {
  2271  		errstr := ctx.errDrain()
  2272  		log.Printf("gl.GetProgrami(%v, %v) %v%v", p, pname, r0, errstr)
  2273  	}()
  2274  	return int(ctx.enqueue(call{
  2275  		args: fnargs{
  2276  			fn: glfnGetProgramiv,
  2277  			a0: p.c(),
  2278  			a1: pname.c(),
  2279  		},
  2280  		blocking: true,
  2281  	}))
  2282  }
  2283  
  2284  func (ctx *context) GetProgramInfoLog(p Program) (r0 string) {
  2285  	defer func() {
  2286  		errstr := ctx.errDrain()
  2287  		log.Printf("gl.GetProgramInfoLog(%v) %v%v", p, r0, errstr)
  2288  	}()
  2289  	infoLen := ctx.GetProgrami(p, INFO_LOG_LENGTH)
  2290  	if infoLen == 0 {
  2291  		return ""
  2292  	}
  2293  	buf := make([]byte, infoLen)
  2294  	ctx.enqueueDebug(call{
  2295  		args: fnargs{
  2296  			fn: glfnGetProgramInfoLog,
  2297  			a0: p.c(),
  2298  			a1: uintptr(infoLen),
  2299  		},
  2300  		parg:     unsafe.Pointer(&buf[0]),
  2301  		blocking: true,
  2302  	})
  2303  	return goString(buf)
  2304  }
  2305  
  2306  func (ctx *context) GetRenderbufferParameteri(target, pname Enum) (r0 int) {
  2307  	defer func() {
  2308  		errstr := ctx.errDrain()
  2309  		log.Printf("gl.GetRenderbufferParameteri(%v, %v) %v%v", target, pname, r0, errstr)
  2310  	}()
  2311  	return int(ctx.enqueue(call{
  2312  		args: fnargs{
  2313  			fn: glfnGetRenderbufferParameteriv,
  2314  			a0: target.c(),
  2315  			a1: pname.c(),
  2316  		},
  2317  		blocking: true,
  2318  	}))
  2319  }
  2320  
  2321  func (ctx *context) GetShaderi(s Shader, pname Enum) (r0 int) {
  2322  	defer func() {
  2323  		errstr := ctx.errDrain()
  2324  		log.Printf("gl.GetShaderi(%v, %v) %v%v", s, pname, r0, errstr)
  2325  	}()
  2326  	return int(ctx.enqueue(call{
  2327  		args: fnargs{
  2328  			fn: glfnGetShaderiv,
  2329  			a0: s.c(),
  2330  			a1: pname.c(),
  2331  		},
  2332  		blocking: true,
  2333  	}))
  2334  }
  2335  
  2336  func (ctx *context) GetShaderInfoLog(s Shader) (r0 string) {
  2337  	defer func() {
  2338  		errstr := ctx.errDrain()
  2339  		log.Printf("gl.GetShaderInfoLog(%v) %v%v", s, r0, errstr)
  2340  	}()
  2341  	infoLen := ctx.GetShaderi(s, INFO_LOG_LENGTH)
  2342  	if infoLen == 0 {
  2343  		return ""
  2344  	}
  2345  	buf := make([]byte, infoLen)
  2346  	ctx.enqueueDebug(call{
  2347  		args: fnargs{
  2348  			fn: glfnGetShaderInfoLog,
  2349  			a0: s.c(),
  2350  			a1: uintptr(infoLen),
  2351  		},
  2352  		parg:     unsafe.Pointer(&buf[0]),
  2353  		blocking: true,
  2354  	})
  2355  	return goString(buf)
  2356  }
  2357  
  2358  func (ctx *context) GetShaderPrecisionFormat(shadertype, precisiontype Enum) (rangeLow, rangeHigh, precision int) {
  2359  	defer func() {
  2360  		errstr := ctx.errDrain()
  2361  		log.Printf("gl.GetShaderPrecisionFormat(%v, %v) (%v, %v, %v) %v", shadertype, precisiontype, rangeLow, rangeHigh, precision, errstr)
  2362  	}()
  2363  	var rangeAndPrec [3]int32
  2364  	ctx.enqueueDebug(call{
  2365  		args: fnargs{
  2366  			fn: glfnGetShaderPrecisionFormat,
  2367  			a0: shadertype.c(),
  2368  			a1: precisiontype.c(),
  2369  		},
  2370  		parg:     unsafe.Pointer(&rangeAndPrec[0]),
  2371  		blocking: true,
  2372  	})
  2373  	return int(rangeAndPrec[0]), int(rangeAndPrec[1]), int(rangeAndPrec[2])
  2374  }
  2375  
  2376  func (ctx *context) GetShaderSource(s Shader) (r0 string) {
  2377  	defer func() {
  2378  		errstr := ctx.errDrain()
  2379  		log.Printf("gl.GetShaderSource(%v) %v%v", s, r0, errstr)
  2380  	}()
  2381  	sourceLen := ctx.GetShaderi(s, SHADER_SOURCE_LENGTH)
  2382  	if sourceLen == 0 {
  2383  		return ""
  2384  	}
  2385  	buf := make([]byte, sourceLen)
  2386  	ctx.enqueueDebug(call{
  2387  		args: fnargs{
  2388  			fn: glfnGetShaderSource,
  2389  			a0: s.c(),
  2390  			a1: uintptr(sourceLen),
  2391  		},
  2392  		parg:     unsafe.Pointer(&buf[0]),
  2393  		blocking: true,
  2394  	})
  2395  	return goString(buf)
  2396  }
  2397  
  2398  func (ctx *context) GetString(pname Enum) (r0 string) {
  2399  	defer func() {
  2400  		errstr := ctx.errDrain()
  2401  		log.Printf("gl.GetString(%v) %v%v", pname, r0, errstr)
  2402  	}()
  2403  	ret := ctx.enqueue(call{
  2404  		args: fnargs{
  2405  			fn: glfnGetString,
  2406  			a0: pname.c(),
  2407  		},
  2408  		blocking: true,
  2409  	})
  2410  	retp := unsafe.Pointer(ret)
  2411  	buf := (*[1 << 24]byte)(retp)[:]
  2412  	return goString(buf)
  2413  }
  2414  
  2415  func (ctx *context) GetTexParameterfv(dst []float32, target, pname Enum) {
  2416  	defer func() {
  2417  		errstr := ctx.errDrain()
  2418  		log.Printf("gl.GetTexParameterfv(len(%d), %v, %v) %v", len(dst), target, pname, errstr)
  2419  	}()
  2420  	ctx.enqueueDebug(call{
  2421  		args: fnargs{
  2422  			fn: glfnGetTexParameterfv,
  2423  			a0: target.c(),
  2424  			a1: pname.c(),
  2425  		},
  2426  		parg:     unsafe.Pointer(&dst[0]),
  2427  		blocking: true,
  2428  	})
  2429  }
  2430  
  2431  func (ctx *context) GetTexParameteriv(dst []int32, target, pname Enum) {
  2432  	defer func() {
  2433  		errstr := ctx.errDrain()
  2434  		log.Printf("gl.GetTexParameteriv(%v, %v, %v) %v", dst, target, pname, errstr)
  2435  	}()
  2436  	ctx.enqueueDebug(call{
  2437  		args: fnargs{
  2438  			fn: glfnGetTexParameteriv,
  2439  			a0: target.c(),
  2440  			a1: pname.c(),
  2441  		},
  2442  		blocking: true,
  2443  	})
  2444  }
  2445  
  2446  func (ctx *context) GetUniformfv(dst []float32, src Uniform, p Program) {
  2447  	defer func() {
  2448  		errstr := ctx.errDrain()
  2449  		log.Printf("gl.GetUniformfv(len(%d), %v, %v) %v", len(dst), src, p, errstr)
  2450  	}()
  2451  	ctx.enqueueDebug(call{
  2452  		args: fnargs{
  2453  			fn: glfnGetUniformfv,
  2454  			a0: p.c(),
  2455  			a1: src.c(),
  2456  		},
  2457  		parg:     unsafe.Pointer(&dst[0]),
  2458  		blocking: true,
  2459  	})
  2460  }
  2461  
  2462  func (ctx *context) GetUniformiv(dst []int32, src Uniform, p Program) {
  2463  	defer func() {
  2464  		errstr := ctx.errDrain()
  2465  		log.Printf("gl.GetUniformiv(%v, %v, %v) %v", dst, src, p, errstr)
  2466  	}()
  2467  	ctx.enqueueDebug(call{
  2468  		args: fnargs{
  2469  			fn: glfnGetUniformiv,
  2470  			a0: p.c(),
  2471  			a1: src.c(),
  2472  		},
  2473  		parg:     unsafe.Pointer(&dst[0]),
  2474  		blocking: true,
  2475  	})
  2476  }
  2477  
  2478  func (ctx *context) GetUniformLocation(p Program, name string) (r0 Uniform) {
  2479  	defer func() {
  2480  		errstr := ctx.errDrain()
  2481  		r0.name = name
  2482  		log.Printf("gl.GetUniformLocation(%v, %v) %v%v", p, name, r0, errstr)
  2483  	}()
  2484  	s, free := ctx.cString(name)
  2485  	defer free()
  2486  	return Uniform{Value: int32(ctx.enqueue(call{
  2487  		args: fnargs{
  2488  			fn: glfnGetUniformLocation,
  2489  			a0: p.c(),
  2490  			a1: s,
  2491  		},
  2492  		blocking: true,
  2493  	}))}
  2494  }
  2495  
  2496  func (ctx *context) GetVertexAttribf(src Attrib, pname Enum) (r0 float32) {
  2497  	defer func() {
  2498  		errstr := ctx.errDrain()
  2499  		log.Printf("gl.GetVertexAttribf(%v, %v) %v%v", src, pname, r0, errstr)
  2500  	}()
  2501  	var params [1]float32
  2502  	ctx.GetVertexAttribfv(params[:], src, pname)
  2503  	return params[0]
  2504  }
  2505  
  2506  func (ctx *context) GetVertexAttribfv(dst []float32, src Attrib, pname Enum) {
  2507  	defer func() {
  2508  		errstr := ctx.errDrain()
  2509  		log.Printf("gl.GetVertexAttribfv(len(%d), %v, %v) %v", len(dst), src, pname, errstr)
  2510  	}()
  2511  	ctx.enqueueDebug(call{
  2512  		args: fnargs{
  2513  			fn: glfnGetVertexAttribfv,
  2514  			a0: src.c(),
  2515  			a1: pname.c(),
  2516  		},
  2517  		parg:     unsafe.Pointer(&dst[0]),
  2518  		blocking: true,
  2519  	})
  2520  }
  2521  
  2522  func (ctx *context) GetVertexAttribi(src Attrib, pname Enum) (r0 int32) {
  2523  	defer func() {
  2524  		errstr := ctx.errDrain()
  2525  		log.Printf("gl.GetVertexAttribi(%v, %v) %v%v", src, pname, r0, errstr)
  2526  	}()
  2527  	var params [1]int32
  2528  	ctx.GetVertexAttribiv(params[:], src, pname)
  2529  	return params[0]
  2530  }
  2531  
  2532  func (ctx *context) GetVertexAttribiv(dst []int32, src Attrib, pname Enum) {
  2533  	defer func() {
  2534  		errstr := ctx.errDrain()
  2535  		log.Printf("gl.GetVertexAttribiv(%v, %v, %v) %v", dst, src, pname, errstr)
  2536  	}()
  2537  	ctx.enqueueDebug(call{
  2538  		args: fnargs{
  2539  			fn: glfnGetVertexAttribiv,
  2540  			a0: src.c(),
  2541  			a1: pname.c(),
  2542  		},
  2543  		parg:     unsafe.Pointer(&dst[0]),
  2544  		blocking: true,
  2545  	})
  2546  }
  2547  
  2548  func (ctx *context) Hint(target, mode Enum) {
  2549  	defer func() {
  2550  		errstr := ctx.errDrain()
  2551  		log.Printf("gl.Hint(%v, %v) %v", target, mode, errstr)
  2552  	}()
  2553  	ctx.enqueueDebug(call{
  2554  		args: fnargs{
  2555  			fn: glfnHint,
  2556  			a0: target.c(),
  2557  			a1: mode.c(),
  2558  		},
  2559  		blocking: true})
  2560  }
  2561  
  2562  func (ctx *context) IsBuffer(b Buffer) (r0 bool) {
  2563  	defer func() {
  2564  		errstr := ctx.errDrain()
  2565  		log.Printf("gl.IsBuffer(%v) %v%v", b, r0, errstr)
  2566  	}()
  2567  	return 0 != ctx.enqueue(call{
  2568  		args: fnargs{
  2569  			fn: glfnIsBuffer,
  2570  			a0: b.c(),
  2571  		},
  2572  		blocking: true,
  2573  	})
  2574  }
  2575  
  2576  func (ctx *context) IsEnabled(cap Enum) (r0 bool) {
  2577  	defer func() {
  2578  		errstr := ctx.errDrain()
  2579  		log.Printf("gl.IsEnabled(%v) %v%v", cap, r0, errstr)
  2580  	}()
  2581  	return 0 != ctx.enqueue(call{
  2582  		args: fnargs{
  2583  			fn: glfnIsEnabled,
  2584  			a0: cap.c(),
  2585  		},
  2586  		blocking: true,
  2587  	})
  2588  }
  2589  
  2590  func (ctx *context) IsFramebuffer(fb Framebuffer) (r0 bool) {
  2591  	defer func() {
  2592  		errstr := ctx.errDrain()
  2593  		log.Printf("gl.IsFramebuffer(%v) %v%v", fb, r0, errstr)
  2594  	}()
  2595  	return 0 != ctx.enqueue(call{
  2596  		args: fnargs{
  2597  			fn: glfnIsFramebuffer,
  2598  			a0: fb.c(),
  2599  		},
  2600  		blocking: true,
  2601  	})
  2602  }
  2603  
  2604  func (ctx *context) IsProgram(p Program) (r0 bool) {
  2605  	defer func() {
  2606  		errstr := ctx.errDrain()
  2607  		log.Printf("gl.IsProgram(%v) %v%v", p, r0, errstr)
  2608  	}()
  2609  	return 0 != ctx.enqueue(call{
  2610  		args: fnargs{
  2611  			fn: glfnIsProgram,
  2612  			a0: p.c(),
  2613  		},
  2614  		blocking: true,
  2615  	})
  2616  }
  2617  
  2618  func (ctx *context) IsRenderbuffer(rb Renderbuffer) (r0 bool) {
  2619  	defer func() {
  2620  		errstr := ctx.errDrain()
  2621  		log.Printf("gl.IsRenderbuffer(%v) %v%v", rb, r0, errstr)
  2622  	}()
  2623  	return 0 != ctx.enqueue(call{
  2624  		args: fnargs{
  2625  			fn: glfnIsRenderbuffer,
  2626  			a0: rb.c(),
  2627  		},
  2628  		blocking: true,
  2629  	})
  2630  }
  2631  
  2632  func (ctx *context) IsShader(s Shader) (r0 bool) {
  2633  	defer func() {
  2634  		errstr := ctx.errDrain()
  2635  		log.Printf("gl.IsShader(%v) %v%v", s, r0, errstr)
  2636  	}()
  2637  	return 0 != ctx.enqueue(call{
  2638  		args: fnargs{
  2639  			fn: glfnIsShader,
  2640  			a0: s.c(),
  2641  		},
  2642  		blocking: true,
  2643  	})
  2644  }
  2645  
  2646  func (ctx *context) IsTexture(t Texture) (r0 bool) {
  2647  	defer func() {
  2648  		errstr := ctx.errDrain()
  2649  		log.Printf("gl.IsTexture(%v) %v%v", t, r0, errstr)
  2650  	}()
  2651  	return 0 != ctx.enqueue(call{
  2652  		args: fnargs{
  2653  			fn: glfnIsTexture,
  2654  			a0: t.c(),
  2655  		},
  2656  		blocking: true,
  2657  	})
  2658  }
  2659  
  2660  func (ctx *context) LineWidth(width float32) {
  2661  	defer func() {
  2662  		errstr := ctx.errDrain()
  2663  		log.Printf("gl.LineWidth(%v) %v", width, errstr)
  2664  	}()
  2665  	ctx.enqueueDebug(call{
  2666  		args: fnargs{
  2667  			fn: glfnLineWidth,
  2668  			a0: uintptr(math.Float32bits(width)),
  2669  		},
  2670  		blocking: true})
  2671  }
  2672  
  2673  func (ctx *context) LinkProgram(p Program) {
  2674  	defer func() {
  2675  		errstr := ctx.errDrain()
  2676  		log.Printf("gl.LinkProgram(%v) %v", p, errstr)
  2677  	}()
  2678  	ctx.enqueueDebug(call{
  2679  		args: fnargs{
  2680  			fn: glfnLinkProgram,
  2681  			a0: p.c(),
  2682  		},
  2683  		blocking: true})
  2684  }
  2685  
  2686  func (ctx *context) PixelStorei(pname Enum, param int32) {
  2687  	defer func() {
  2688  		errstr := ctx.errDrain()
  2689  		log.Printf("gl.PixelStorei(%v, %v) %v", pname, param, errstr)
  2690  	}()
  2691  	ctx.enqueueDebug(call{
  2692  		args: fnargs{
  2693  			fn: glfnPixelStorei,
  2694  			a0: pname.c(),
  2695  			a1: uintptr(param),
  2696  		},
  2697  		blocking: true})
  2698  }
  2699  
  2700  func (ctx *context) PolygonOffset(factor, units float32) {
  2701  	defer func() {
  2702  		errstr := ctx.errDrain()
  2703  		log.Printf("gl.PolygonOffset(%v, %v) %v", factor, units, errstr)
  2704  	}()
  2705  	ctx.enqueueDebug(call{
  2706  		args: fnargs{
  2707  			fn: glfnPolygonOffset,
  2708  			a0: uintptr(math.Float32bits(factor)),
  2709  			a1: uintptr(math.Float32bits(units)),
  2710  		},
  2711  		blocking: true})
  2712  }
  2713  
  2714  func (ctx *context) ReadPixels(dst []byte, x, y, width, height int, format, ty Enum) {
  2715  	defer func() {
  2716  		errstr := ctx.errDrain()
  2717  		log.Printf("gl.ReadPixels(len(%d), %v, %v, %v, %v, %v, %v) %v", len(dst), x, y, width, height, format, ty, errstr)
  2718  	}()
  2719  	ctx.enqueueDebug(call{
  2720  		args: fnargs{
  2721  			fn: glfnReadPixels,
  2722  
  2723  			a0: uintptr(x),
  2724  			a1: uintptr(y),
  2725  			a2: uintptr(width),
  2726  			a3: uintptr(height),
  2727  			a4: format.c(),
  2728  			a5: ty.c(),
  2729  		},
  2730  		parg:     unsafe.Pointer(&dst[0]),
  2731  		blocking: true,
  2732  	})
  2733  }
  2734  
  2735  func (ctx *context) ReleaseShaderCompiler() {
  2736  	defer func() {
  2737  		errstr := ctx.errDrain()
  2738  		log.Printf("gl.ReleaseShaderCompiler() %v", errstr)
  2739  	}()
  2740  	ctx.enqueueDebug(call{
  2741  		args: fnargs{
  2742  			fn: glfnReleaseShaderCompiler,
  2743  		},
  2744  		blocking: true})
  2745  }
  2746  
  2747  func (ctx *context) RenderbufferStorage(target, internalFormat Enum, width, height int) {
  2748  	defer func() {
  2749  		errstr := ctx.errDrain()
  2750  		log.Printf("gl.RenderbufferStorage(%v, %v, %v, %v) %v", target, internalFormat, width, height, errstr)
  2751  	}()
  2752  	ctx.enqueueDebug(call{
  2753  		args: fnargs{
  2754  			fn: glfnRenderbufferStorage,
  2755  			a0: target.c(),
  2756  			a1: internalFormat.c(),
  2757  			a2: uintptr(width),
  2758  			a3: uintptr(height),
  2759  		},
  2760  		blocking: true})
  2761  }
  2762  
  2763  func (ctx *context) SampleCoverage(value float32, invert bool) {
  2764  	defer func() {
  2765  		errstr := ctx.errDrain()
  2766  		log.Printf("gl.SampleCoverage(%v, %v) %v", value, invert, errstr)
  2767  	}()
  2768  	ctx.enqueueDebug(call{
  2769  		args: fnargs{
  2770  			fn: glfnSampleCoverage,
  2771  			a0: uintptr(math.Float32bits(value)),
  2772  			a1: glBoolean(invert),
  2773  		},
  2774  		blocking: true})
  2775  }
  2776  
  2777  func (ctx *context) Scissor(x, y, width, height int32) {
  2778  	defer func() {
  2779  		errstr := ctx.errDrain()
  2780  		log.Printf("gl.Scissor(%v, %v, %v, %v) %v", x, y, width, height, errstr)
  2781  	}()
  2782  	ctx.enqueueDebug(call{
  2783  		args: fnargs{
  2784  			fn: glfnScissor,
  2785  			a0: uintptr(x),
  2786  			a1: uintptr(y),
  2787  			a2: uintptr(width),
  2788  			a3: uintptr(height),
  2789  		},
  2790  		blocking: true})
  2791  }
  2792  
  2793  func (ctx *context) ShaderSource(s Shader, src string) {
  2794  	defer func() {
  2795  		errstr := ctx.errDrain()
  2796  		log.Printf("gl.ShaderSource(%v, %v) %v", s, src, errstr)
  2797  	}()
  2798  	strp, free := ctx.cStringPtr(src)
  2799  	defer free()
  2800  	ctx.enqueueDebug(call{
  2801  		args: fnargs{
  2802  			fn: glfnShaderSource,
  2803  			a0: s.c(),
  2804  			a1: 1,
  2805  			a2: strp,
  2806  		},
  2807  		blocking: true,
  2808  	})
  2809  }
  2810  
  2811  func (ctx *context) StencilFunc(fn Enum, ref int, mask uint32) {
  2812  	defer func() {
  2813  		errstr := ctx.errDrain()
  2814  		log.Printf("gl.StencilFunc(%v, %v, %v) %v", fn, ref, mask, errstr)
  2815  	}()
  2816  	ctx.enqueueDebug(call{
  2817  		args: fnargs{
  2818  			fn: glfnStencilFunc,
  2819  			a0: fn.c(),
  2820  			a1: uintptr(ref),
  2821  			a2: uintptr(mask),
  2822  		},
  2823  		blocking: true})
  2824  }
  2825  
  2826  func (ctx *context) StencilFuncSeparate(face, fn Enum, ref int, mask uint32) {
  2827  	defer func() {
  2828  		errstr := ctx.errDrain()
  2829  		log.Printf("gl.StencilFuncSeparate(%v, %v, %v, %v) %v", face, fn, ref, mask, errstr)
  2830  	}()
  2831  	ctx.enqueueDebug(call{
  2832  		args: fnargs{
  2833  			fn: glfnStencilFuncSeparate,
  2834  			a0: face.c(),
  2835  			a1: fn.c(),
  2836  			a2: uintptr(ref),
  2837  			a3: uintptr(mask),
  2838  		},
  2839  		blocking: true})
  2840  }
  2841  
  2842  func (ctx *context) StencilMask(mask uint32) {
  2843  	defer func() {
  2844  		errstr := ctx.errDrain()
  2845  		log.Printf("gl.StencilMask(%v) %v", mask, errstr)
  2846  	}()
  2847  	ctx.enqueueDebug(call{
  2848  		args: fnargs{
  2849  			fn: glfnStencilMask,
  2850  			a0: uintptr(mask),
  2851  		},
  2852  		blocking: true})
  2853  }
  2854  
  2855  func (ctx *context) StencilMaskSeparate(face Enum, mask uint32) {
  2856  	defer func() {
  2857  		errstr := ctx.errDrain()
  2858  		log.Printf("gl.StencilMaskSeparate(%v, %v) %v", face, mask, errstr)
  2859  	}()
  2860  	ctx.enqueueDebug(call{
  2861  		args: fnargs{
  2862  			fn: glfnStencilMaskSeparate,
  2863  			a0: face.c(),
  2864  			a1: uintptr(mask),
  2865  		},
  2866  		blocking: true})
  2867  }
  2868  
  2869  func (ctx *context) StencilOp(fail, zfail, zpass Enum) {
  2870  	defer func() {
  2871  		errstr := ctx.errDrain()
  2872  		log.Printf("gl.StencilOp(%v, %v, %v) %v", fail, zfail, zpass, errstr)
  2873  	}()
  2874  	ctx.enqueueDebug(call{
  2875  		args: fnargs{
  2876  			fn: glfnStencilOp,
  2877  			a0: fail.c(),
  2878  			a1: zfail.c(),
  2879  			a2: zpass.c(),
  2880  		},
  2881  		blocking: true})
  2882  }
  2883  
  2884  func (ctx *context) StencilOpSeparate(face, sfail, dpfail, dppass Enum) {
  2885  	defer func() {
  2886  		errstr := ctx.errDrain()
  2887  		log.Printf("gl.StencilOpSeparate(%v, %v, %v, %v) %v", face, sfail, dpfail, dppass, errstr)
  2888  	}()
  2889  	ctx.enqueueDebug(call{
  2890  		args: fnargs{
  2891  			fn: glfnStencilOpSeparate,
  2892  			a0: face.c(),
  2893  			a1: sfail.c(),
  2894  			a2: dpfail.c(),
  2895  			a3: dppass.c(),
  2896  		},
  2897  		blocking: true})
  2898  }
  2899  
  2900  func (ctx *context) TexImage2D(target Enum, level int, internalFormat int, width, height int, format Enum, ty Enum, data []byte) {
  2901  	defer func() {
  2902  		errstr := ctx.errDrain()
  2903  		log.Printf("gl.TexImage2D(%v, %v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, internalFormat, width, height, format, ty, len(data), errstr)
  2904  	}()
  2905  	parg := unsafe.Pointer(nil)
  2906  	if len(data) > 0 {
  2907  		parg = unsafe.Pointer(&data[0])
  2908  	}
  2909  	ctx.enqueueDebug(call{
  2910  		args: fnargs{
  2911  			fn: glfnTexImage2D,
  2912  
  2913  			a0: target.c(),
  2914  			a1: uintptr(level),
  2915  			a2: uintptr(internalFormat),
  2916  			a3: uintptr(width),
  2917  			a4: uintptr(height),
  2918  			a5: format.c(),
  2919  			a6: ty.c(),
  2920  		},
  2921  		parg:     parg,
  2922  		blocking: true,
  2923  	})
  2924  }
  2925  
  2926  func (ctx *context) TexSubImage2D(target Enum, level int, x, y, width, height int, format, ty Enum, data []byte) {
  2927  	defer func() {
  2928  		errstr := ctx.errDrain()
  2929  		log.Printf("gl.TexSubImage2D(%v, %v, %v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, x, y, width, height, format, ty, len(data), errstr)
  2930  	}()
  2931  	ctx.enqueueDebug(call{
  2932  		args: fnargs{
  2933  			fn: glfnTexSubImage2D,
  2934  
  2935  			a0: target.c(),
  2936  			a1: uintptr(level),
  2937  			a2: uintptr(x),
  2938  			a3: uintptr(y),
  2939  			a4: uintptr(width),
  2940  			a5: uintptr(height),
  2941  			a6: format.c(),
  2942  			a7: ty.c(),
  2943  		},
  2944  		parg:     unsafe.Pointer(&data[0]),
  2945  		blocking: true,
  2946  	})
  2947  }
  2948  
  2949  func (ctx *context) TexParameterf(target, pname Enum, param float32) {
  2950  	defer func() {
  2951  		errstr := ctx.errDrain()
  2952  		log.Printf("gl.TexParameterf(%v, %v, %v) %v", target, pname, param, errstr)
  2953  	}()
  2954  	ctx.enqueueDebug(call{
  2955  		args: fnargs{
  2956  			fn: glfnTexParameterf,
  2957  			a0: target.c(),
  2958  			a1: pname.c(),
  2959  			a2: uintptr(math.Float32bits(param)),
  2960  		},
  2961  		blocking: true})
  2962  }
  2963  
  2964  func (ctx *context) TexParameterfv(target, pname Enum, params []float32) {
  2965  	defer func() {
  2966  		errstr := ctx.errDrain()
  2967  		log.Printf("gl.TexParameterfv(%v, %v, len(%d)) %v", target, pname, len(params), errstr)
  2968  	}()
  2969  	ctx.enqueueDebug(call{
  2970  		args: fnargs{
  2971  			fn: glfnTexParameterfv,
  2972  			a0: target.c(),
  2973  			a1: pname.c(),
  2974  		},
  2975  		parg:     unsafe.Pointer(&params[0]),
  2976  		blocking: true,
  2977  	})
  2978  }
  2979  
  2980  func (ctx *context) TexParameteri(target, pname Enum, param int) {
  2981  	defer func() {
  2982  		errstr := ctx.errDrain()
  2983  		log.Printf("gl.TexParameteri(%v, %v, %v) %v", target, pname, param, errstr)
  2984  	}()
  2985  	ctx.enqueueDebug(call{
  2986  		args: fnargs{
  2987  			fn: glfnTexParameteri,
  2988  			a0: target.c(),
  2989  			a1: pname.c(),
  2990  			a2: uintptr(param),
  2991  		},
  2992  		blocking: true})
  2993  }
  2994  
  2995  func (ctx *context) TexParameteriv(target, pname Enum, params []int32) {
  2996  	defer func() {
  2997  		errstr := ctx.errDrain()
  2998  		log.Printf("gl.TexParameteriv(%v, %v, %v) %v", target, pname, params, errstr)
  2999  	}()
  3000  	ctx.enqueueDebug(call{
  3001  		args: fnargs{
  3002  			fn: glfnTexParameteriv,
  3003  			a0: target.c(),
  3004  			a1: pname.c(),
  3005  		},
  3006  		parg:     unsafe.Pointer(&params[0]),
  3007  		blocking: true,
  3008  	})
  3009  }
  3010  
  3011  func (ctx *context) Uniform1f(dst Uniform, v float32) {
  3012  	defer func() {
  3013  		errstr := ctx.errDrain()
  3014  		log.Printf("gl.Uniform1f(%v, %v) %v", dst, v, errstr)
  3015  	}()
  3016  	ctx.enqueueDebug(call{
  3017  		args: fnargs{
  3018  			fn: glfnUniform1f,
  3019  			a0: dst.c(),
  3020  			a1: uintptr(math.Float32bits(v)),
  3021  		},
  3022  		blocking: true})
  3023  }
  3024  
  3025  func (ctx *context) Uniform1fv(dst Uniform, src []float32) {
  3026  	defer func() {
  3027  		errstr := ctx.errDrain()
  3028  		log.Printf("gl.Uniform1fv(%v, len(%d)) %v", dst, len(src), errstr)
  3029  	}()
  3030  	ctx.enqueueDebug(call{
  3031  		args: fnargs{
  3032  			fn: glfnUniform1fv,
  3033  			a0: dst.c(),
  3034  			a1: uintptr(len(src)),
  3035  		},
  3036  		parg:     unsafe.Pointer(&src[0]),
  3037  		blocking: true,
  3038  	})
  3039  }
  3040  
  3041  func (ctx *context) Uniform1i(dst Uniform, v int) {
  3042  	defer func() {
  3043  		errstr := ctx.errDrain()
  3044  		log.Printf("gl.Uniform1i(%v, %v) %v", dst, v, errstr)
  3045  	}()
  3046  	ctx.enqueueDebug(call{
  3047  		args: fnargs{
  3048  			fn: glfnUniform1i,
  3049  			a0: dst.c(),
  3050  			a1: uintptr(v),
  3051  		},
  3052  		blocking: true})
  3053  }
  3054  
  3055  func (ctx *context) Uniform1iv(dst Uniform, src []int32) {
  3056  	defer func() {
  3057  		errstr := ctx.errDrain()
  3058  		log.Printf("gl.Uniform1iv(%v, %v) %v", dst, src, errstr)
  3059  	}()
  3060  	ctx.enqueueDebug(call{
  3061  		args: fnargs{
  3062  			fn: glfnUniform1iv,
  3063  			a0: dst.c(),
  3064  			a1: uintptr(len(src)),
  3065  		},
  3066  		parg:     unsafe.Pointer(&src[0]),
  3067  		blocking: true,
  3068  	})
  3069  }
  3070  
  3071  func (ctx *context) Uniform2f(dst Uniform, v0, v1 float32) {
  3072  	defer func() {
  3073  		errstr := ctx.errDrain()
  3074  		log.Printf("gl.Uniform2f(%v, %v, %v) %v", dst, v0, v1, errstr)
  3075  	}()
  3076  	ctx.enqueueDebug(call{
  3077  		args: fnargs{
  3078  			fn: glfnUniform2f,
  3079  			a0: dst.c(),
  3080  			a1: uintptr(math.Float32bits(v0)),
  3081  			a2: uintptr(math.Float32bits(v1)),
  3082  		},
  3083  		blocking: true})
  3084  }
  3085  
  3086  func (ctx *context) Uniform2fv(dst Uniform, src []float32) {
  3087  	defer func() {
  3088  		errstr := ctx.errDrain()
  3089  		log.Printf("gl.Uniform2fv(%v, len(%d)) %v", dst, len(src), errstr)
  3090  	}()
  3091  	ctx.enqueueDebug(call{
  3092  		args: fnargs{
  3093  			fn: glfnUniform2fv,
  3094  			a0: dst.c(),
  3095  			a1: uintptr(len(src) / 2),
  3096  		},
  3097  		parg:     unsafe.Pointer(&src[0]),
  3098  		blocking: true,
  3099  	})
  3100  }
  3101  
  3102  func (ctx *context) Uniform2i(dst Uniform, v0, v1 int) {
  3103  	defer func() {
  3104  		errstr := ctx.errDrain()
  3105  		log.Printf("gl.Uniform2i(%v, %v, %v) %v", dst, v0, v1, errstr)
  3106  	}()
  3107  	ctx.enqueueDebug(call{
  3108  		args: fnargs{
  3109  			fn: glfnUniform2i,
  3110  			a0: dst.c(),
  3111  			a1: uintptr(v0),
  3112  			a2: uintptr(v1),
  3113  		},
  3114  		blocking: true})
  3115  }
  3116  
  3117  func (ctx *context) Uniform2iv(dst Uniform, src []int32) {
  3118  	defer func() {
  3119  		errstr := ctx.errDrain()
  3120  		log.Printf("gl.Uniform2iv(%v, %v) %v", dst, src, errstr)
  3121  	}()
  3122  	ctx.enqueueDebug(call{
  3123  		args: fnargs{
  3124  			fn: glfnUniform2iv,
  3125  			a0: dst.c(),
  3126  			a1: uintptr(len(src) / 2),
  3127  		},
  3128  		parg:     unsafe.Pointer(&src[0]),
  3129  		blocking: true,
  3130  	})
  3131  }
  3132  
  3133  func (ctx *context) Uniform3f(dst Uniform, v0, v1, v2 float32) {
  3134  	defer func() {
  3135  		errstr := ctx.errDrain()
  3136  		log.Printf("gl.Uniform3f(%v, %v, %v, %v) %v", dst, v0, v1, v2, errstr)
  3137  	}()
  3138  	ctx.enqueueDebug(call{
  3139  		args: fnargs{
  3140  			fn: glfnUniform3f,
  3141  			a0: dst.c(),
  3142  			a1: uintptr(math.Float32bits(v0)),
  3143  			a2: uintptr(math.Float32bits(v1)),
  3144  			a3: uintptr(math.Float32bits(v2)),
  3145  		},
  3146  		blocking: true})
  3147  }
  3148  
  3149  func (ctx *context) Uniform3fv(dst Uniform, src []float32) {
  3150  	defer func() {
  3151  		errstr := ctx.errDrain()
  3152  		log.Printf("gl.Uniform3fv(%v, len(%d)) %v", dst, len(src), errstr)
  3153  	}()
  3154  	ctx.enqueueDebug(call{
  3155  		args: fnargs{
  3156  			fn: glfnUniform3fv,
  3157  			a0: dst.c(),
  3158  			a1: uintptr(len(src) / 3),
  3159  		},
  3160  		parg:     unsafe.Pointer(&src[0]),
  3161  		blocking: true,
  3162  	})
  3163  }
  3164  
  3165  func (ctx *context) Uniform3i(dst Uniform, v0, v1, v2 int32) {
  3166  	defer func() {
  3167  		errstr := ctx.errDrain()
  3168  		log.Printf("gl.Uniform3i(%v, %v, %v, %v) %v", dst, v0, v1, v2, errstr)
  3169  	}()
  3170  	ctx.enqueueDebug(call{
  3171  		args: fnargs{
  3172  			fn: glfnUniform3i,
  3173  			a0: dst.c(),
  3174  			a1: uintptr(v0),
  3175  			a2: uintptr(v1),
  3176  			a3: uintptr(v2),
  3177  		},
  3178  		blocking: true})
  3179  }
  3180  
  3181  func (ctx *context) Uniform3iv(dst Uniform, src []int32) {
  3182  	defer func() {
  3183  		errstr := ctx.errDrain()
  3184  		log.Printf("gl.Uniform3iv(%v, %v) %v", dst, src, errstr)
  3185  	}()
  3186  	ctx.enqueueDebug(call{
  3187  		args: fnargs{
  3188  			fn: glfnUniform3iv,
  3189  			a0: dst.c(),
  3190  			a1: uintptr(len(src) / 3),
  3191  		},
  3192  		parg:     unsafe.Pointer(&src[0]),
  3193  		blocking: true,
  3194  	})
  3195  }
  3196  
  3197  func (ctx *context) Uniform4f(dst Uniform, v0, v1, v2, v3 float32) {
  3198  	defer func() {
  3199  		errstr := ctx.errDrain()
  3200  		log.Printf("gl.Uniform4f(%v, %v, %v, %v, %v) %v", dst, v0, v1, v2, v3, errstr)
  3201  	}()
  3202  	ctx.enqueueDebug(call{
  3203  		args: fnargs{
  3204  			fn: glfnUniform4f,
  3205  			a0: dst.c(),
  3206  			a1: uintptr(math.Float32bits(v0)),
  3207  			a2: uintptr(math.Float32bits(v1)),
  3208  			a3: uintptr(math.Float32bits(v2)),
  3209  			a4: uintptr(math.Float32bits(v3)),
  3210  		},
  3211  		blocking: true})
  3212  }
  3213  
  3214  func (ctx *context) Uniform4fv(dst Uniform, src []float32) {
  3215  	defer func() {
  3216  		errstr := ctx.errDrain()
  3217  		log.Printf("gl.Uniform4fv(%v, len(%d)) %v", dst, len(src), errstr)
  3218  	}()
  3219  	ctx.enqueueDebug(call{
  3220  		args: fnargs{
  3221  			fn: glfnUniform4fv,
  3222  			a0: dst.c(),
  3223  			a1: uintptr(len(src) / 4),
  3224  		},
  3225  		parg:     unsafe.Pointer(&src[0]),
  3226  		blocking: true,
  3227  	})
  3228  }
  3229  
  3230  func (ctx *context) Uniform4i(dst Uniform, v0, v1, v2, v3 int32) {
  3231  	defer func() {
  3232  		errstr := ctx.errDrain()
  3233  		log.Printf("gl.Uniform4i(%v, %v, %v, %v, %v) %v", dst, v0, v1, v2, v3, errstr)
  3234  	}()
  3235  	ctx.enqueueDebug(call{
  3236  		args: fnargs{
  3237  			fn: glfnUniform4i,
  3238  			a0: dst.c(),
  3239  			a1: uintptr(v0),
  3240  			a2: uintptr(v1),
  3241  			a3: uintptr(v2),
  3242  			a4: uintptr(v3),
  3243  		},
  3244  		blocking: true})
  3245  }
  3246  
  3247  func (ctx *context) Uniform4iv(dst Uniform, src []int32) {
  3248  	defer func() {
  3249  		errstr := ctx.errDrain()
  3250  		log.Printf("gl.Uniform4iv(%v, %v) %v", dst, src, errstr)
  3251  	}()
  3252  	ctx.enqueueDebug(call{
  3253  		args: fnargs{
  3254  			fn: glfnUniform4iv,
  3255  			a0: dst.c(),
  3256  			a1: uintptr(len(src) / 4),
  3257  		},
  3258  		parg:     unsafe.Pointer(&src[0]),
  3259  		blocking: true,
  3260  	})
  3261  }
  3262  
  3263  func (ctx *context) UniformMatrix2fv(dst Uniform, src []float32) {
  3264  	defer func() {
  3265  		errstr := ctx.errDrain()
  3266  		log.Printf("gl.UniformMatrix2fv(%v, len(%d)) %v", dst, len(src), errstr)
  3267  	}()
  3268  	ctx.enqueueDebug(call{
  3269  		args: fnargs{
  3270  			fn: glfnUniformMatrix2fv,
  3271  
  3272  			a0: dst.c(),
  3273  			a1: uintptr(len(src) / 4),
  3274  		},
  3275  		parg:     unsafe.Pointer(&src[0]),
  3276  		blocking: true,
  3277  	})
  3278  }
  3279  
  3280  func (ctx *context) UniformMatrix3fv(dst Uniform, src []float32) {
  3281  	defer func() {
  3282  		errstr := ctx.errDrain()
  3283  		log.Printf("gl.UniformMatrix3fv(%v, len(%d)) %v", dst, len(src), errstr)
  3284  	}()
  3285  	ctx.enqueueDebug(call{
  3286  		args: fnargs{
  3287  			fn: glfnUniformMatrix3fv,
  3288  			a0: dst.c(),
  3289  			a1: uintptr(len(src) / 9),
  3290  		},
  3291  		parg:     unsafe.Pointer(&src[0]),
  3292  		blocking: true,
  3293  	})
  3294  }
  3295  
  3296  func (ctx *context) UniformMatrix4fv(dst Uniform, src []float32) {
  3297  	defer func() {
  3298  		errstr := ctx.errDrain()
  3299  		log.Printf("gl.UniformMatrix4fv(%v, len(%d)) %v", dst, len(src), errstr)
  3300  	}()
  3301  	ctx.enqueueDebug(call{
  3302  		args: fnargs{
  3303  			fn: glfnUniformMatrix4fv,
  3304  			a0: dst.c(),
  3305  			a1: uintptr(len(src) / 16),
  3306  		},
  3307  		parg:     unsafe.Pointer(&src[0]),
  3308  		blocking: true,
  3309  	})
  3310  }
  3311  
  3312  func (ctx *context) UseProgram(p Program) {
  3313  	defer func() {
  3314  		errstr := ctx.errDrain()
  3315  		log.Printf("gl.UseProgram(%v) %v", p, errstr)
  3316  	}()
  3317  	ctx.enqueueDebug(call{
  3318  		args: fnargs{
  3319  			fn: glfnUseProgram,
  3320  			a0: p.c(),
  3321  		},
  3322  		blocking: true})
  3323  }
  3324  
  3325  func (ctx *context) ValidateProgram(p Program) {
  3326  	defer func() {
  3327  		errstr := ctx.errDrain()
  3328  		log.Printf("gl.ValidateProgram(%v) %v", p, errstr)
  3329  	}()
  3330  	ctx.enqueueDebug(call{
  3331  		args: fnargs{
  3332  			fn: glfnValidateProgram,
  3333  			a0: p.c(),
  3334  		},
  3335  		blocking: true})
  3336  }
  3337  
  3338  func (ctx *context) VertexAttrib1f(dst Attrib, x float32) {
  3339  	defer func() {
  3340  		errstr := ctx.errDrain()
  3341  		log.Printf("gl.VertexAttrib1f(%v, %v) %v", dst, x, errstr)
  3342  	}()
  3343  	ctx.enqueueDebug(call{
  3344  		args: fnargs{
  3345  			fn: glfnVertexAttrib1f,
  3346  			a0: dst.c(),
  3347  			a1: uintptr(math.Float32bits(x)),
  3348  		},
  3349  		blocking: true})
  3350  }
  3351  
  3352  func (ctx *context) VertexAttrib1fv(dst Attrib, src []float32) {
  3353  	defer func() {
  3354  		errstr := ctx.errDrain()
  3355  		log.Printf("gl.VertexAttrib1fv(%v, len(%d)) %v", dst, len(src), errstr)
  3356  	}()
  3357  	ctx.enqueueDebug(call{
  3358  		args: fnargs{
  3359  			fn: glfnVertexAttrib1fv,
  3360  			a0: dst.c(),
  3361  		},
  3362  		parg:     unsafe.Pointer(&src[0]),
  3363  		blocking: true,
  3364  	})
  3365  }
  3366  
  3367  func (ctx *context) VertexAttrib2f(dst Attrib, x, y float32) {
  3368  	defer func() {
  3369  		errstr := ctx.errDrain()
  3370  		log.Printf("gl.VertexAttrib2f(%v, %v, %v) %v", dst, x, y, errstr)
  3371  	}()
  3372  	ctx.enqueueDebug(call{
  3373  		args: fnargs{
  3374  			fn: glfnVertexAttrib2f,
  3375  			a0: dst.c(),
  3376  			a1: uintptr(math.Float32bits(x)),
  3377  			a2: uintptr(math.Float32bits(y)),
  3378  		},
  3379  		blocking: true})
  3380  }
  3381  
  3382  func (ctx *context) VertexAttrib2fv(dst Attrib, src []float32) {
  3383  	defer func() {
  3384  		errstr := ctx.errDrain()
  3385  		log.Printf("gl.VertexAttrib2fv(%v, len(%d)) %v", dst, len(src), errstr)
  3386  	}()
  3387  	ctx.enqueueDebug(call{
  3388  		args: fnargs{
  3389  			fn: glfnVertexAttrib2fv,
  3390  			a0: dst.c(),
  3391  		},
  3392  		parg:     unsafe.Pointer(&src[0]),
  3393  		blocking: true,
  3394  	})
  3395  }
  3396  
  3397  func (ctx *context) VertexAttrib3f(dst Attrib, x, y, z float32) {
  3398  	defer func() {
  3399  		errstr := ctx.errDrain()
  3400  		log.Printf("gl.VertexAttrib3f(%v, %v, %v, %v) %v", dst, x, y, z, errstr)
  3401  	}()
  3402  	ctx.enqueueDebug(call{
  3403  		args: fnargs{
  3404  			fn: glfnVertexAttrib3f,
  3405  			a0: dst.c(),
  3406  			a1: uintptr(math.Float32bits(x)),
  3407  			a2: uintptr(math.Float32bits(y)),
  3408  			a3: uintptr(math.Float32bits(z)),
  3409  		},
  3410  		blocking: true})
  3411  }
  3412  
  3413  func (ctx *context) VertexAttrib3fv(dst Attrib, src []float32) {
  3414  	defer func() {
  3415  		errstr := ctx.errDrain()
  3416  		log.Printf("gl.VertexAttrib3fv(%v, len(%d)) %v", dst, len(src), errstr)
  3417  	}()
  3418  	ctx.enqueueDebug(call{
  3419  		args: fnargs{
  3420  			fn: glfnVertexAttrib3fv,
  3421  			a0: dst.c(),
  3422  		},
  3423  		parg:     unsafe.Pointer(&src[0]),
  3424  		blocking: true,
  3425  	})
  3426  }
  3427  
  3428  func (ctx *context) VertexAttrib4f(dst Attrib, x, y, z, w float32) {
  3429  	defer func() {
  3430  		errstr := ctx.errDrain()
  3431  		log.Printf("gl.VertexAttrib4f(%v, %v, %v, %v, %v) %v", dst, x, y, z, w, errstr)
  3432  	}()
  3433  	ctx.enqueueDebug(call{
  3434  		args: fnargs{
  3435  			fn: glfnVertexAttrib4f,
  3436  			a0: dst.c(),
  3437  			a1: uintptr(math.Float32bits(x)),
  3438  			a2: uintptr(math.Float32bits(y)),
  3439  			a3: uintptr(math.Float32bits(z)),
  3440  			a4: uintptr(math.Float32bits(w)),
  3441  		},
  3442  		blocking: true})
  3443  }
  3444  
  3445  func (ctx *context) VertexAttrib4fv(dst Attrib, src []float32) {
  3446  	defer func() {
  3447  		errstr := ctx.errDrain()
  3448  		log.Printf("gl.VertexAttrib4fv(%v, len(%d)) %v", dst, len(src), errstr)
  3449  	}()
  3450  	ctx.enqueueDebug(call{
  3451  		args: fnargs{
  3452  			fn: glfnVertexAttrib4fv,
  3453  			a0: dst.c(),
  3454  		},
  3455  		parg:     unsafe.Pointer(&src[0]),
  3456  		blocking: true,
  3457  	})
  3458  }
  3459  
  3460  func (ctx *context) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int) {
  3461  	defer func() {
  3462  		errstr := ctx.errDrain()
  3463  		log.Printf("gl.VertexAttribPointer(%v, %v, %v, %v, %v, %v) %v", dst, size, ty, normalized, stride, offset, errstr)
  3464  	}()
  3465  	ctx.enqueueDebug(call{
  3466  		args: fnargs{
  3467  			fn: glfnVertexAttribPointer,
  3468  			a0: dst.c(),
  3469  			a1: uintptr(size),
  3470  			a2: ty.c(),
  3471  			a3: glBoolean(normalized),
  3472  			a4: uintptr(stride),
  3473  			a5: uintptr(offset),
  3474  		},
  3475  		blocking: true})
  3476  }
  3477  
  3478  func (ctx *context) Viewport(x, y, width, height int) {
  3479  	defer func() {
  3480  		errstr := ctx.errDrain()
  3481  		log.Printf("gl.Viewport(%v, %v, %v, %v) %v", x, y, width, height, errstr)
  3482  	}()
  3483  	ctx.enqueueDebug(call{
  3484  		args: fnargs{
  3485  			fn: glfnViewport,
  3486  			a0: uintptr(x),
  3487  			a1: uintptr(y),
  3488  			a2: uintptr(width),
  3489  			a3: uintptr(height),
  3490  		},
  3491  		blocking: true})
  3492  }
  3493  
  3494  func (ctx context3) UniformMatrix2x3fv(dst Uniform, src []float32) {
  3495  	defer func() {
  3496  		errstr := ctx.errDrain()
  3497  		log.Printf("gl.UniformMatrix2x3fv(%v, len(%d)) %v", dst, len(src), errstr)
  3498  	}()
  3499  	ctx.enqueueDebug(call{
  3500  		args: fnargs{
  3501  			fn: glfnUniformMatrix2x3fv,
  3502  			a0: dst.c(),
  3503  			a1: uintptr(len(src) / 6),
  3504  		},
  3505  		parg:     unsafe.Pointer(&src[0]),
  3506  		blocking: true,
  3507  	})
  3508  }
  3509  
  3510  func (ctx context3) UniformMatrix3x2fv(dst Uniform, src []float32) {
  3511  	defer func() {
  3512  		errstr := ctx.errDrain()
  3513  		log.Printf("gl.UniformMatrix3x2fv(%v, len(%d)) %v", dst, len(src), errstr)
  3514  	}()
  3515  	ctx.enqueueDebug(call{
  3516  		args: fnargs{
  3517  			fn: glfnUniformMatrix3x2fv,
  3518  			a0: dst.c(),
  3519  			a1: uintptr(len(src) / 6),
  3520  		},
  3521  		parg:     unsafe.Pointer(&src[0]),
  3522  		blocking: true,
  3523  	})
  3524  }
  3525  
  3526  func (ctx context3) UniformMatrix2x4fv(dst Uniform, src []float32) {
  3527  	defer func() {
  3528  		errstr := ctx.errDrain()
  3529  		log.Printf("gl.UniformMatrix2x4fv(%v, len(%d)) %v", dst, len(src), errstr)
  3530  	}()
  3531  	ctx.enqueueDebug(call{
  3532  		args: fnargs{
  3533  			fn: glfnUniformMatrix2x4fv,
  3534  			a0: dst.c(),
  3535  			a1: uintptr(len(src) / 8),
  3536  		},
  3537  		parg:     unsafe.Pointer(&src[0]),
  3538  		blocking: true,
  3539  	})
  3540  }
  3541  
  3542  func (ctx context3) UniformMatrix4x2fv(dst Uniform, src []float32) {
  3543  	defer func() {
  3544  		errstr := ctx.errDrain()
  3545  		log.Printf("gl.UniformMatrix4x2fv(%v, len(%d)) %v", dst, len(src), errstr)
  3546  	}()
  3547  	ctx.enqueueDebug(call{
  3548  		args: fnargs{
  3549  			fn: glfnUniformMatrix4x2fv,
  3550  			a0: dst.c(),
  3551  			a1: uintptr(len(src) / 8),
  3552  		},
  3553  		parg:     unsafe.Pointer(&src[0]),
  3554  		blocking: true,
  3555  	})
  3556  }
  3557  
  3558  func (ctx context3) UniformMatrix3x4fv(dst Uniform, src []float32) {
  3559  	defer func() {
  3560  		errstr := ctx.errDrain()
  3561  		log.Printf("gl.UniformMatrix3x4fv(%v, len(%d)) %v", dst, len(src), errstr)
  3562  	}()
  3563  	ctx.enqueueDebug(call{
  3564  		args: fnargs{
  3565  			fn: glfnUniformMatrix3x4fv,
  3566  			a0: dst.c(),
  3567  			a1: uintptr(len(src) / 12),
  3568  		},
  3569  		parg:     unsafe.Pointer(&src[0]),
  3570  		blocking: true,
  3571  	})
  3572  }
  3573  
  3574  func (ctx context3) UniformMatrix4x3fv(dst Uniform, src []float32) {
  3575  	defer func() {
  3576  		errstr := ctx.errDrain()
  3577  		log.Printf("gl.UniformMatrix4x3fv(%v, len(%d)) %v", dst, len(src), errstr)
  3578  	}()
  3579  	ctx.enqueueDebug(call{
  3580  		args: fnargs{
  3581  			fn: glfnUniformMatrix4x3fv,
  3582  			a0: dst.c(),
  3583  			a1: uintptr(len(src) / 12),
  3584  		},
  3585  		parg:     unsafe.Pointer(&src[0]),
  3586  		blocking: true,
  3587  	})
  3588  }
  3589  
  3590  func (ctx context3) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int, mask uint, filter Enum) {
  3591  	defer func() {
  3592  		errstr := ctx.errDrain()
  3593  		log.Printf("gl.BlitFramebuffer(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v) %v", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter, errstr)
  3594  	}()
  3595  	ctx.enqueueDebug(call{
  3596  		args: fnargs{
  3597  			fn: glfnBlitFramebuffer,
  3598  			a0: uintptr(srcX0),
  3599  			a1: uintptr(srcY0),
  3600  			a2: uintptr(srcX1),
  3601  			a3: uintptr(srcY1),
  3602  			a4: uintptr(dstX0),
  3603  			a5: uintptr(dstY0),
  3604  			a6: uintptr(dstX1),
  3605  			a7: uintptr(dstY1),
  3606  			a8: uintptr(mask),
  3607  			a9: filter.c(),
  3608  		},
  3609  		blocking: true})
  3610  }
  3611  
  3612  func (ctx context3) Uniform1ui(dst Uniform, v uint32) {
  3613  	defer func() {
  3614  		errstr := ctx.errDrain()
  3615  		log.Printf("gl.Uniform1ui(%v, %v) %v", dst, v, errstr)
  3616  	}()
  3617  	ctx.enqueueDebug(call{
  3618  		args: fnargs{
  3619  			fn: glfnUniform1ui,
  3620  			a0: dst.c(),
  3621  			a1: uintptr(v),
  3622  		},
  3623  		blocking: true})
  3624  }
  3625  
  3626  func (ctx context3) Uniform2ui(dst Uniform, v0, v1 uint32) {
  3627  	defer func() {
  3628  		errstr := ctx.errDrain()
  3629  		log.Printf("gl.Uniform2ui(%v, %v, %v) %v", dst, v0, v1, errstr)
  3630  	}()
  3631  	ctx.enqueueDebug(call{
  3632  		args: fnargs{
  3633  			fn: glfnUniform2ui,
  3634  			a0: dst.c(),
  3635  			a1: uintptr(v0),
  3636  			a2: uintptr(v1),
  3637  		},
  3638  		blocking: true})
  3639  }
  3640  
  3641  func (ctx context3) Uniform3ui(dst Uniform, v0, v1, v2 uint) {
  3642  	defer func() {
  3643  		errstr := ctx.errDrain()
  3644  		log.Printf("gl.Uniform3ui(%v, %v, %v, %v) %v", dst, v0, v1, v2, errstr)
  3645  	}()
  3646  	ctx.enqueueDebug(call{
  3647  		args: fnargs{
  3648  			fn: glfnUniform3ui,
  3649  			a0: dst.c(),
  3650  			a1: uintptr(v0),
  3651  			a2: uintptr(v1),
  3652  			a3: uintptr(v2),
  3653  		},
  3654  		blocking: true})
  3655  }
  3656  
  3657  func (ctx context3) Uniform4ui(dst Uniform, v0, v1, v2, v3 uint32) {
  3658  	defer func() {
  3659  		errstr := ctx.errDrain()
  3660  		log.Printf("gl.Uniform4ui(%v, %v, %v, %v, %v) %v", dst, v0, v1, v2, v3, errstr)
  3661  	}()
  3662  	ctx.enqueueDebug(call{
  3663  		args: fnargs{
  3664  			fn: glfnUniform4ui,
  3665  			a0: dst.c(),
  3666  			a1: uintptr(v0),
  3667  			a2: uintptr(v1),
  3668  			a3: uintptr(v2),
  3669  			a4: uintptr(v3),
  3670  		},
  3671  		blocking: true})
  3672  }