github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/mobile/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  // Generated from gl.go using go generate. DO NOT EDIT.
     6  // See doc.go for details.
     7  
     8  // +build linux darwin windows
     9  // +build gldebug
    10  
    11  package gl
    12  
    13  import (
    14  	"fmt"
    15  	"log"
    16  	"math"
    17  	"sync/atomic"
    18  	"unsafe"
    19  )
    20  
    21  func (ctx *context) errDrain() string {
    22  	var errs []Enum
    23  	for {
    24  		e := ctx.GetError()
    25  		if e == 0 {
    26  			break
    27  		}
    28  		errs = append(errs, e)
    29  	}
    30  	if len(errs) > 0 {
    31  		return fmt.Sprintf(" error: %v", errs)
    32  	}
    33  	return ""
    34  }
    35  
    36  func (ctx *context) enqueueDebug(c call) uintptr {
    37  	numCalls := atomic.AddInt32(&ctx.debug, 1)
    38  	if numCalls > 1 {
    39  		panic("concurrent calls made to the same GL context")
    40  	}
    41  	defer func() {
    42  		if atomic.AddInt32(&ctx.debug, -1) > 0 {
    43  			select {} // block so you see us in the panic
    44  		}
    45  	}()
    46  
    47  	return ctx.enqueue(c)
    48  }
    49  
    50  func (v Enum) String() string {
    51  	switch v {
    52  	case 0x0:
    53  		return "0"
    54  	case 0x1:
    55  		return "1"
    56  	case 0x2:
    57  		return "LINE_LOOP"
    58  	case 0x3:
    59  		return "LINE_STRIP"
    60  	case 0x4:
    61  		return "TRIANGLES"
    62  	case 0x5:
    63  		return "TRIANGLE_STRIP"
    64  	case 0x6:
    65  		return "TRIANGLE_FAN"
    66  	case 0x300:
    67  		return "SRC_COLOR"
    68  	case 0x301:
    69  		return "ONE_MINUS_SRC_COLOR"
    70  	case 0x302:
    71  		return "SRC_ALPHA"
    72  	case 0x303:
    73  		return "ONE_MINUS_SRC_ALPHA"
    74  	case 0x304:
    75  		return "DST_ALPHA"
    76  	case 0x305:
    77  		return "ONE_MINUS_DST_ALPHA"
    78  	case 0x306:
    79  		return "DST_COLOR"
    80  	case 0x307:
    81  		return "ONE_MINUS_DST_COLOR"
    82  	case 0x308:
    83  		return "SRC_ALPHA_SATURATE"
    84  	case 0x8006:
    85  		return "FUNC_ADD"
    86  	case 0x8009:
    87  		return "32777"
    88  	case 0x883d:
    89  		return "BLEND_EQUATION_ALPHA"
    90  	case 0x800a:
    91  		return "FUNC_SUBTRACT"
    92  	case 0x800b:
    93  		return "FUNC_REVERSE_SUBTRACT"
    94  	case 0x80c8:
    95  		return "BLEND_DST_RGB"
    96  	case 0x80c9:
    97  		return "BLEND_SRC_RGB"
    98  	case 0x80ca:
    99  		return "BLEND_DST_ALPHA"
   100  	case 0x80cb:
   101  		return "BLEND_SRC_ALPHA"
   102  	case 0x8001:
   103  		return "CONSTANT_COLOR"
   104  	case 0x8002:
   105  		return "ONE_MINUS_CONSTANT_COLOR"
   106  	case 0x8003:
   107  		return "CONSTANT_ALPHA"
   108  	case 0x8004:
   109  		return "ONE_MINUS_CONSTANT_ALPHA"
   110  	case 0x8005:
   111  		return "BLEND_COLOR"
   112  	case 0x8892:
   113  		return "ARRAY_BUFFER"
   114  	case 0x8893:
   115  		return "ELEMENT_ARRAY_BUFFER"
   116  	case 0x8894:
   117  		return "ARRAY_BUFFER_BINDING"
   118  	case 0x8895:
   119  		return "ELEMENT_ARRAY_BUFFER_BINDING"
   120  	case 0x88e0:
   121  		return "STREAM_DRAW"
   122  	case 0x88e4:
   123  		return "STATIC_DRAW"
   124  	case 0x88e8:
   125  		return "DYNAMIC_DRAW"
   126  	case 0x8764:
   127  		return "BUFFER_SIZE"
   128  	case 0x8765:
   129  		return "BUFFER_USAGE"
   130  	case 0x8626:
   131  		return "CURRENT_VERTEX_ATTRIB"
   132  	case 0x404:
   133  		return "FRONT"
   134  	case 0x405:
   135  		return "BACK"
   136  	case 0x408:
   137  		return "FRONT_AND_BACK"
   138  	case 0xde1:
   139  		return "TEXTURE_2D"
   140  	case 0xb44:
   141  		return "CULL_FACE"
   142  	case 0xbe2:
   143  		return "BLEND"
   144  	case 0xbd0:
   145  		return "DITHER"
   146  	case 0xb90:
   147  		return "STENCIL_TEST"
   148  	case 0xb71:
   149  		return "DEPTH_TEST"
   150  	case 0xc11:
   151  		return "SCISSOR_TEST"
   152  	case 0x8037:
   153  		return "POLYGON_OFFSET_FILL"
   154  	case 0x809e:
   155  		return "SAMPLE_ALPHA_TO_COVERAGE"
   156  	case 0x80a0:
   157  		return "SAMPLE_COVERAGE"
   158  	case 0x500:
   159  		return "INVALID_ENUM"
   160  	case 0x501:
   161  		return "INVALID_VALUE"
   162  	case 0x502:
   163  		return "INVALID_OPERATION"
   164  	case 0x505:
   165  		return "OUT_OF_MEMORY"
   166  	case 0x900:
   167  		return "CW"
   168  	case 0x901:
   169  		return "CCW"
   170  	case 0xb21:
   171  		return "LINE_WIDTH"
   172  	case 0x846d:
   173  		return "ALIASED_POINT_SIZE_RANGE"
   174  	case 0x846e:
   175  		return "ALIASED_LINE_WIDTH_RANGE"
   176  	case 0xb45:
   177  		return "CULL_FACE_MODE"
   178  	case 0xb46:
   179  		return "FRONT_FACE"
   180  	case 0xb70:
   181  		return "DEPTH_RANGE"
   182  	case 0xb72:
   183  		return "DEPTH_WRITEMASK"
   184  	case 0xb73:
   185  		return "DEPTH_CLEAR_VALUE"
   186  	case 0xb74:
   187  		return "DEPTH_FUNC"
   188  	case 0xb91:
   189  		return "STENCIL_CLEAR_VALUE"
   190  	case 0xb92:
   191  		return "STENCIL_FUNC"
   192  	case 0xb94:
   193  		return "STENCIL_FAIL"
   194  	case 0xb95:
   195  		return "STENCIL_PASS_DEPTH_FAIL"
   196  	case 0xb96:
   197  		return "STENCIL_PASS_DEPTH_PASS"
   198  	case 0xb97:
   199  		return "STENCIL_REF"
   200  	case 0xb93:
   201  		return "STENCIL_VALUE_MASK"
   202  	case 0xb98:
   203  		return "STENCIL_WRITEMASK"
   204  	case 0x8800:
   205  		return "STENCIL_BACK_FUNC"
   206  	case 0x8801:
   207  		return "STENCIL_BACK_FAIL"
   208  	case 0x8802:
   209  		return "STENCIL_BACK_PASS_DEPTH_FAIL"
   210  	case 0x8803:
   211  		return "STENCIL_BACK_PASS_DEPTH_PASS"
   212  	case 0x8ca3:
   213  		return "STENCIL_BACK_REF"
   214  	case 0x8ca4:
   215  		return "STENCIL_BACK_VALUE_MASK"
   216  	case 0x8ca5:
   217  		return "STENCIL_BACK_WRITEMASK"
   218  	case 0xba2:
   219  		return "VIEWPORT"
   220  	case 0xc10:
   221  		return "SCISSOR_BOX"
   222  	case 0xc22:
   223  		return "COLOR_CLEAR_VALUE"
   224  	case 0xc23:
   225  		return "COLOR_WRITEMASK"
   226  	case 0xcf5:
   227  		return "UNPACK_ALIGNMENT"
   228  	case 0xd05:
   229  		return "PACK_ALIGNMENT"
   230  	case 0xd33:
   231  		return "MAX_TEXTURE_SIZE"
   232  	case 0xd3a:
   233  		return "MAX_VIEWPORT_DIMS"
   234  	case 0xd50:
   235  		return "SUBPIXEL_BITS"
   236  	case 0xd52:
   237  		return "RED_BITS"
   238  	case 0xd53:
   239  		return "GREEN_BITS"
   240  	case 0xd54:
   241  		return "BLUE_BITS"
   242  	case 0xd55:
   243  		return "ALPHA_BITS"
   244  	case 0xd56:
   245  		return "DEPTH_BITS"
   246  	case 0xd57:
   247  		return "STENCIL_BITS"
   248  	case 0x2a00:
   249  		return "POLYGON_OFFSET_UNITS"
   250  	case 0x8038:
   251  		return "POLYGON_OFFSET_FACTOR"
   252  	case 0x8069:
   253  		return "TEXTURE_BINDING_2D"
   254  	case 0x80a8:
   255  		return "SAMPLE_BUFFERS"
   256  	case 0x80a9:
   257  		return "SAMPLES"
   258  	case 0x80aa:
   259  		return "SAMPLE_COVERAGE_VALUE"
   260  	case 0x80ab:
   261  		return "SAMPLE_COVERAGE_INVERT"
   262  	case 0x86a2:
   263  		return "NUM_COMPRESSED_TEXTURE_FORMATS"
   264  	case 0x86a3:
   265  		return "COMPRESSED_TEXTURE_FORMATS"
   266  	case 0x1100:
   267  		return "DONT_CARE"
   268  	case 0x1101:
   269  		return "FASTEST"
   270  	case 0x1102:
   271  		return "NICEST"
   272  	case 0x8192:
   273  		return "GENERATE_MIPMAP_HINT"
   274  	case 0x1400:
   275  		return "BYTE"
   276  	case 0x1401:
   277  		return "UNSIGNED_BYTE"
   278  	case 0x1402:
   279  		return "SHORT"
   280  	case 0x1403:
   281  		return "UNSIGNED_SHORT"
   282  	case 0x1404:
   283  		return "INT"
   284  	case 0x1405:
   285  		return "UNSIGNED_INT"
   286  	case 0x1406:
   287  		return "FLOAT"
   288  	case 0x140c:
   289  		return "FIXED"
   290  	case 0x1902:
   291  		return "DEPTH_COMPONENT"
   292  	case 0x1906:
   293  		return "ALPHA"
   294  	case 0x1907:
   295  		return "RGB"
   296  	case 0x1908:
   297  		return "RGBA"
   298  	case 0x1909:
   299  		return "LUMINANCE"
   300  	case 0x190a:
   301  		return "LUMINANCE_ALPHA"
   302  	case 0x8033:
   303  		return "UNSIGNED_SHORT_4_4_4_4"
   304  	case 0x8034:
   305  		return "UNSIGNED_SHORT_5_5_5_1"
   306  	case 0x8363:
   307  		return "UNSIGNED_SHORT_5_6_5"
   308  	case 0x8869:
   309  		return "MAX_VERTEX_ATTRIBS"
   310  	case 0x8dfb:
   311  		return "MAX_VERTEX_UNIFORM_VECTORS"
   312  	case 0x8dfc:
   313  		return "MAX_VARYING_VECTORS"
   314  	case 0x8b4d:
   315  		return "MAX_COMBINED_TEXTURE_IMAGE_UNITS"
   316  	case 0x8b4c:
   317  		return "MAX_VERTEX_TEXTURE_IMAGE_UNITS"
   318  	case 0x8872:
   319  		return "MAX_TEXTURE_IMAGE_UNITS"
   320  	case 0x8dfd:
   321  		return "MAX_FRAGMENT_UNIFORM_VECTORS"
   322  	case 0x8b4f:
   323  		return "SHADER_TYPE"
   324  	case 0x8b80:
   325  		return "DELETE_STATUS"
   326  	case 0x8b82:
   327  		return "LINK_STATUS"
   328  	case 0x8b83:
   329  		return "VALIDATE_STATUS"
   330  	case 0x8b85:
   331  		return "ATTACHED_SHADERS"
   332  	case 0x8b86:
   333  		return "ACTIVE_UNIFORMS"
   334  	case 0x8b87:
   335  		return "ACTIVE_UNIFORM_MAX_LENGTH"
   336  	case 0x8b89:
   337  		return "ACTIVE_ATTRIBUTES"
   338  	case 0x8b8a:
   339  		return "ACTIVE_ATTRIBUTE_MAX_LENGTH"
   340  	case 0x8b8c:
   341  		return "SHADING_LANGUAGE_VERSION"
   342  	case 0x8b8d:
   343  		return "CURRENT_PROGRAM"
   344  	case 0x200:
   345  		return "NEVER"
   346  	case 0x201:
   347  		return "LESS"
   348  	case 0x202:
   349  		return "EQUAL"
   350  	case 0x203:
   351  		return "LEQUAL"
   352  	case 0x204:
   353  		return "GREATER"
   354  	case 0x205:
   355  		return "NOTEQUAL"
   356  	case 0x206:
   357  		return "GEQUAL"
   358  	case 0x207:
   359  		return "ALWAYS"
   360  	case 0x1e00:
   361  		return "KEEP"
   362  	case 0x1e01:
   363  		return "REPLACE"
   364  	case 0x1e02:
   365  		return "INCR"
   366  	case 0x1e03:
   367  		return "DECR"
   368  	case 0x150a:
   369  		return "INVERT"
   370  	case 0x8507:
   371  		return "INCR_WRAP"
   372  	case 0x8508:
   373  		return "DECR_WRAP"
   374  	case 0x1f00:
   375  		return "VENDOR"
   376  	case 0x1f01:
   377  		return "RENDERER"
   378  	case 0x1f02:
   379  		return "VERSION"
   380  	case 0x1f03:
   381  		return "EXTENSIONS"
   382  	case 0x2600:
   383  		return "NEAREST"
   384  	case 0x2601:
   385  		return "LINEAR"
   386  	case 0x2700:
   387  		return "NEAREST_MIPMAP_NEAREST"
   388  	case 0x2701:
   389  		return "LINEAR_MIPMAP_NEAREST"
   390  	case 0x2702:
   391  		return "NEAREST_MIPMAP_LINEAR"
   392  	case 0x2703:
   393  		return "LINEAR_MIPMAP_LINEAR"
   394  	case 0x2800:
   395  		return "TEXTURE_MAG_FILTER"
   396  	case 0x2801:
   397  		return "TEXTURE_MIN_FILTER"
   398  	case 0x2802:
   399  		return "TEXTURE_WRAP_S"
   400  	case 0x2803:
   401  		return "TEXTURE_WRAP_T"
   402  	case 0x1702:
   403  		return "TEXTURE"
   404  	case 0x8513:
   405  		return "TEXTURE_CUBE_MAP"
   406  	case 0x8514:
   407  		return "TEXTURE_BINDING_CUBE_MAP"
   408  	case 0x8515:
   409  		return "TEXTURE_CUBE_MAP_POSITIVE_X"
   410  	case 0x8516:
   411  		return "TEXTURE_CUBE_MAP_NEGATIVE_X"
   412  	case 0x8517:
   413  		return "TEXTURE_CUBE_MAP_POSITIVE_Y"
   414  	case 0x8518:
   415  		return "TEXTURE_CUBE_MAP_NEGATIVE_Y"
   416  	case 0x8519:
   417  		return "TEXTURE_CUBE_MAP_POSITIVE_Z"
   418  	case 0x851a:
   419  		return "TEXTURE_CUBE_MAP_NEGATIVE_Z"
   420  	case 0x851c:
   421  		return "MAX_CUBE_MAP_TEXTURE_SIZE"
   422  	case 0x84c0:
   423  		return "TEXTURE0"
   424  	case 0x84c1:
   425  		return "TEXTURE1"
   426  	case 0x84c2:
   427  		return "TEXTURE2"
   428  	case 0x84c3:
   429  		return "TEXTURE3"
   430  	case 0x84c4:
   431  		return "TEXTURE4"
   432  	case 0x84c5:
   433  		return "TEXTURE5"
   434  	case 0x84c6:
   435  		return "TEXTURE6"
   436  	case 0x84c7:
   437  		return "TEXTURE7"
   438  	case 0x84c8:
   439  		return "TEXTURE8"
   440  	case 0x84c9:
   441  		return "TEXTURE9"
   442  	case 0x84ca:
   443  		return "TEXTURE10"
   444  	case 0x84cb:
   445  		return "TEXTURE11"
   446  	case 0x84cc:
   447  		return "TEXTURE12"
   448  	case 0x84cd:
   449  		return "TEXTURE13"
   450  	case 0x84ce:
   451  		return "TEXTURE14"
   452  	case 0x84cf:
   453  		return "TEXTURE15"
   454  	case 0x84d0:
   455  		return "TEXTURE16"
   456  	case 0x84d1:
   457  		return "TEXTURE17"
   458  	case 0x84d2:
   459  		return "TEXTURE18"
   460  	case 0x84d3:
   461  		return "TEXTURE19"
   462  	case 0x84d4:
   463  		return "TEXTURE20"
   464  	case 0x84d5:
   465  		return "TEXTURE21"
   466  	case 0x84d6:
   467  		return "TEXTURE22"
   468  	case 0x84d7:
   469  		return "TEXTURE23"
   470  	case 0x84d8:
   471  		return "TEXTURE24"
   472  	case 0x84d9:
   473  		return "TEXTURE25"
   474  	case 0x84da:
   475  		return "TEXTURE26"
   476  	case 0x84db:
   477  		return "TEXTURE27"
   478  	case 0x84dc:
   479  		return "TEXTURE28"
   480  	case 0x84dd:
   481  		return "TEXTURE29"
   482  	case 0x84de:
   483  		return "TEXTURE30"
   484  	case 0x84df:
   485  		return "TEXTURE31"
   486  	case 0x84e0:
   487  		return "ACTIVE_TEXTURE"
   488  	case 0x2901:
   489  		return "REPEAT"
   490  	case 0x812f:
   491  		return "CLAMP_TO_EDGE"
   492  	case 0x8370:
   493  		return "MIRRORED_REPEAT"
   494  	case 0x8622:
   495  		return "VERTEX_ATTRIB_ARRAY_ENABLED"
   496  	case 0x8623:
   497  		return "VERTEX_ATTRIB_ARRAY_SIZE"
   498  	case 0x8624:
   499  		return "VERTEX_ATTRIB_ARRAY_STRIDE"
   500  	case 0x8625:
   501  		return "VERTEX_ATTRIB_ARRAY_TYPE"
   502  	case 0x886a:
   503  		return "VERTEX_ATTRIB_ARRAY_NORMALIZED"
   504  	case 0x8645:
   505  		return "VERTEX_ATTRIB_ARRAY_POINTER"
   506  	case 0x889f:
   507  		return "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"
   508  	case 0x8b9a:
   509  		return "IMPLEMENTATION_COLOR_READ_TYPE"
   510  	case 0x8b9b:
   511  		return "IMPLEMENTATION_COLOR_READ_FORMAT"
   512  	case 0x8b81:
   513  		return "COMPILE_STATUS"
   514  	case 0x8b84:
   515  		return "INFO_LOG_LENGTH"
   516  	case 0x8b88:
   517  		return "SHADER_SOURCE_LENGTH"
   518  	case 0x8dfa:
   519  		return "SHADER_COMPILER"
   520  	case 0x8df8:
   521  		return "SHADER_BINARY_FORMATS"
   522  	case 0x8df9:
   523  		return "NUM_SHADER_BINARY_FORMATS"
   524  	case 0x8df0:
   525  		return "LOW_FLOAT"
   526  	case 0x8df1:
   527  		return "MEDIUM_FLOAT"
   528  	case 0x8df2:
   529  		return "HIGH_FLOAT"
   530  	case 0x8df3:
   531  		return "LOW_INT"
   532  	case 0x8df4:
   533  		return "MEDIUM_INT"
   534  	case 0x8df5:
   535  		return "HIGH_INT"
   536  	case 0x8d40:
   537  		return "FRAMEBUFFER"
   538  	case 0x8d41:
   539  		return "RENDERBUFFER"
   540  	case 0x8056:
   541  		return "RGBA4"
   542  	case 0x8057:
   543  		return "RGB5_A1"
   544  	case 0x8d62:
   545  		return "RGB565"
   546  	case 0x81a5:
   547  		return "DEPTH_COMPONENT16"
   548  	case 0x8d48:
   549  		return "STENCIL_INDEX8"
   550  	case 0x8d42:
   551  		return "RENDERBUFFER_WIDTH"
   552  	case 0x8d43:
   553  		return "RENDERBUFFER_HEIGHT"
   554  	case 0x8d44:
   555  		return "RENDERBUFFER_INTERNAL_FORMAT"
   556  	case 0x8d50:
   557  		return "RENDERBUFFER_RED_SIZE"
   558  	case 0x8d51:
   559  		return "RENDERBUFFER_GREEN_SIZE"
   560  	case 0x8d52:
   561  		return "RENDERBUFFER_BLUE_SIZE"
   562  	case 0x8d53:
   563  		return "RENDERBUFFER_ALPHA_SIZE"
   564  	case 0x8d54:
   565  		return "RENDERBUFFER_DEPTH_SIZE"
   566  	case 0x8d55:
   567  		return "RENDERBUFFER_STENCIL_SIZE"
   568  	case 0x8cd0:
   569  		return "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"
   570  	case 0x8cd1:
   571  		return "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"
   572  	case 0x8cd2:
   573  		return "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"
   574  	case 0x8cd3:
   575  		return "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"
   576  	case 0x8ce0:
   577  		return "COLOR_ATTACHMENT0"
   578  	case 0x8d00:
   579  		return "DEPTH_ATTACHMENT"
   580  	case 0x8d20:
   581  		return "STENCIL_ATTACHMENT"
   582  	case 0x8cd5:
   583  		return "FRAMEBUFFER_COMPLETE"
   584  	case 0x8cd6:
   585  		return "FRAMEBUFFER_INCOMPLETE_ATTACHMENT"
   586  	case 0x8cd7:
   587  		return "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"
   588  	case 0x8cd9:
   589  		return "FRAMEBUFFER_INCOMPLETE_DIMENSIONS"
   590  	case 0x8cdd:
   591  		return "FRAMEBUFFER_UNSUPPORTED"
   592  	case 0x8ca6:
   593  		return "FRAMEBUFFER_BINDING"
   594  	case 0x8ca7:
   595  		return "RENDERBUFFER_BINDING"
   596  	case 0x84e8:
   597  		return "MAX_RENDERBUFFER_SIZE"
   598  	case 0x506:
   599  		return "INVALID_FRAMEBUFFER_OPERATION"
   600  	case 0x100:
   601  		return "DEPTH_BUFFER_BIT"
   602  	case 0x400:
   603  		return "STENCIL_BUFFER_BIT"
   604  	case 0x4000:
   605  		return "COLOR_BUFFER_BIT"
   606  	case 0x8b50:
   607  		return "FLOAT_VEC2"
   608  	case 0x8b51:
   609  		return "FLOAT_VEC3"
   610  	case 0x8b52:
   611  		return "FLOAT_VEC4"
   612  	case 0x8b53:
   613  		return "INT_VEC2"
   614  	case 0x8b54:
   615  		return "INT_VEC3"
   616  	case 0x8b55:
   617  		return "INT_VEC4"
   618  	case 0x8b56:
   619  		return "BOOL"
   620  	case 0x8b57:
   621  		return "BOOL_VEC2"
   622  	case 0x8b58:
   623  		return "BOOL_VEC3"
   624  	case 0x8b59:
   625  		return "BOOL_VEC4"
   626  	case 0x8b5a:
   627  		return "FLOAT_MAT2"
   628  	case 0x8b5b:
   629  		return "FLOAT_MAT3"
   630  	case 0x8b5c:
   631  		return "FLOAT_MAT4"
   632  	case 0x8b5e:
   633  		return "SAMPLER_2D"
   634  	case 0x8b60:
   635  		return "SAMPLER_CUBE"
   636  	case 0x8b30:
   637  		return "FRAGMENT_SHADER"
   638  	case 0x8b31:
   639  		return "VERTEX_SHADER"
   640  	default:
   641  		return fmt.Sprintf("gl.Enum(0x%x)", uint32(v))
   642  	}
   643  }
   644  
   645  func (ctx *context) ActiveTexture(texture Enum) {
   646  	defer func() {
   647  		errstr := ctx.errDrain()
   648  		log.Printf("gl.ActiveTexture(%v) %v", texture, errstr)
   649  	}()
   650  	ctx.enqueueDebug(call{
   651  		args: fnargs{
   652  			fn: glfnActiveTexture,
   653  			a0: texture.c(),
   654  		},
   655  		blocking: true})
   656  }
   657  
   658  func (ctx *context) AttachShader(p Program, s Shader) {
   659  	defer func() {
   660  		errstr := ctx.errDrain()
   661  		log.Printf("gl.AttachShader(%v, %v) %v", p, s, errstr)
   662  	}()
   663  	ctx.enqueueDebug(call{
   664  		args: fnargs{
   665  			fn: glfnAttachShader,
   666  			a0: p.c(),
   667  			a1: s.c(),
   668  		},
   669  		blocking: true})
   670  }
   671  
   672  func (ctx *context) BindAttribLocation(p Program, a Attrib, name string) {
   673  	defer func() {
   674  		errstr := ctx.errDrain()
   675  		log.Printf("gl.BindAttribLocation(%v, %v, %v) %v", p, a, name, errstr)
   676  	}()
   677  	s, free := ctx.cString(name)
   678  	defer free()
   679  	ctx.enqueueDebug(call{
   680  		args: fnargs{
   681  			fn: glfnBindAttribLocation,
   682  			a0: p.c(),
   683  			a1: a.c(),
   684  			a2: s,
   685  		},
   686  		blocking: true,
   687  	})
   688  }
   689  
   690  func (ctx *context) BindBuffer(target Enum, b Buffer) {
   691  	defer func() {
   692  		errstr := ctx.errDrain()
   693  		log.Printf("gl.BindBuffer(%v, %v) %v", target, b, errstr)
   694  	}()
   695  	ctx.enqueueDebug(call{
   696  		args: fnargs{
   697  			fn: glfnBindBuffer,
   698  			a0: target.c(),
   699  			a1: b.c(),
   700  		},
   701  		blocking: true})
   702  }
   703  
   704  func (ctx *context) BindFramebuffer(target Enum, fb Framebuffer) {
   705  	defer func() {
   706  		errstr := ctx.errDrain()
   707  		log.Printf("gl.BindFramebuffer(%v, %v) %v", target, fb, errstr)
   708  	}()
   709  	ctx.enqueueDebug(call{
   710  		args: fnargs{
   711  			fn: glfnBindFramebuffer,
   712  			a0: target.c(),
   713  			a1: fb.c(),
   714  		},
   715  		blocking: true})
   716  }
   717  
   718  func (ctx *context) BindRenderbuffer(target Enum, rb Renderbuffer) {
   719  	defer func() {
   720  		errstr := ctx.errDrain()
   721  		log.Printf("gl.BindRenderbuffer(%v, %v) %v", target, rb, errstr)
   722  	}()
   723  	ctx.enqueueDebug(call{
   724  		args: fnargs{
   725  			fn: glfnBindRenderbuffer,
   726  			a0: target.c(),
   727  			a1: rb.c(),
   728  		},
   729  		blocking: true})
   730  }
   731  
   732  func (ctx *context) BindTexture(target Enum, t Texture) {
   733  	defer func() {
   734  		errstr := ctx.errDrain()
   735  		log.Printf("gl.BindTexture(%v, %v) %v", target, t, errstr)
   736  	}()
   737  	ctx.enqueueDebug(call{
   738  		args: fnargs{
   739  			fn: glfnBindTexture,
   740  			a0: target.c(),
   741  			a1: t.c(),
   742  		},
   743  		blocking: true})
   744  }
   745  
   746  func (ctx *context) BlendColor(red, green, blue, alpha float32) {
   747  	defer func() {
   748  		errstr := ctx.errDrain()
   749  		log.Printf("gl.BlendColor(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
   750  	}()
   751  	ctx.enqueueDebug(call{
   752  		args: fnargs{
   753  			fn: glfnBlendColor,
   754  			a0: uintptr(math.Float32bits(red)),
   755  			a1: uintptr(math.Float32bits(green)),
   756  			a2: uintptr(math.Float32bits(blue)),
   757  			a3: uintptr(math.Float32bits(alpha)),
   758  		},
   759  		blocking: true})
   760  }
   761  
   762  func (ctx *context) BlendEquation(mode Enum) {
   763  	defer func() {
   764  		errstr := ctx.errDrain()
   765  		log.Printf("gl.BlendEquation(%v) %v", mode, errstr)
   766  	}()
   767  	ctx.enqueueDebug(call{
   768  		args: fnargs{
   769  			fn: glfnBlendEquation,
   770  			a0: mode.c(),
   771  		},
   772  		blocking: true})
   773  }
   774  
   775  func (ctx *context) BlendEquationSeparate(modeRGB, modeAlpha Enum) {
   776  	defer func() {
   777  		errstr := ctx.errDrain()
   778  		log.Printf("gl.BlendEquationSeparate(%v, %v) %v", modeRGB, modeAlpha, errstr)
   779  	}()
   780  	ctx.enqueueDebug(call{
   781  		args: fnargs{
   782  			fn: glfnBlendEquationSeparate,
   783  			a0: modeRGB.c(),
   784  			a1: modeAlpha.c(),
   785  		},
   786  		blocking: true})
   787  }
   788  
   789  func (ctx *context) BlendFunc(sfactor, dfactor Enum) {
   790  	defer func() {
   791  		errstr := ctx.errDrain()
   792  		log.Printf("gl.BlendFunc(%v, %v) %v", sfactor, dfactor, errstr)
   793  	}()
   794  	ctx.enqueueDebug(call{
   795  		args: fnargs{
   796  			fn: glfnBlendFunc,
   797  			a0: sfactor.c(),
   798  			a1: dfactor.c(),
   799  		},
   800  		blocking: true})
   801  }
   802  
   803  func (ctx *context) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha Enum) {
   804  	defer func() {
   805  		errstr := ctx.errDrain()
   806  		log.Printf("gl.BlendFuncSeparate(%v, %v, %v, %v) %v", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha, errstr)
   807  	}()
   808  	ctx.enqueueDebug(call{
   809  		args: fnargs{
   810  			fn: glfnBlendFuncSeparate,
   811  			a0: sfactorRGB.c(),
   812  			a1: dfactorRGB.c(),
   813  			a2: sfactorAlpha.c(),
   814  			a3: dfactorAlpha.c(),
   815  		},
   816  		blocking: true})
   817  }
   818  
   819  func (ctx *context) BufferData(target Enum, src []byte, usage Enum) {
   820  	defer func() {
   821  		errstr := ctx.errDrain()
   822  		log.Printf("gl.BufferData(%v, len(%d), %v) %v", target, len(src), usage, errstr)
   823  	}()
   824  	parg := unsafe.Pointer(nil)
   825  	if len(src) > 0 {
   826  		parg = unsafe.Pointer(&src[0])
   827  	}
   828  	ctx.enqueueDebug(call{
   829  		args: fnargs{
   830  			fn: glfnBufferData,
   831  			a0: target.c(),
   832  			a1: uintptr(len(src)),
   833  			a2: usage.c(),
   834  		},
   835  		parg:     parg,
   836  		blocking: true,
   837  	})
   838  }
   839  
   840  func (ctx *context) BufferInit(target Enum, size int, usage Enum) {
   841  	defer func() {
   842  		errstr := ctx.errDrain()
   843  		log.Printf("gl.BufferInit(%v, %v, %v) %v", target, size, usage, errstr)
   844  	}()
   845  	ctx.enqueueDebug(call{
   846  		args: fnargs{
   847  			fn: glfnBufferData,
   848  			a0: target.c(),
   849  			a1: uintptr(size),
   850  			a2: 0,
   851  			a3: usage.c(),
   852  		},
   853  		blocking: true})
   854  }
   855  
   856  func (ctx *context) BufferSubData(target Enum, offset int, data []byte) {
   857  	defer func() {
   858  		errstr := ctx.errDrain()
   859  		log.Printf("gl.BufferSubData(%v, %v, len(%d)) %v", target, offset, len(data), errstr)
   860  	}()
   861  	ctx.enqueueDebug(call{
   862  		args: fnargs{
   863  			fn: glfnBufferSubData,
   864  			a0: target.c(),
   865  			a1: uintptr(offset),
   866  			a2: uintptr(len(data)),
   867  		},
   868  		parg:     unsafe.Pointer(&data[0]),
   869  		blocking: true,
   870  	})
   871  }
   872  
   873  func (ctx *context) CheckFramebufferStatus(target Enum) (r0 Enum) {
   874  	defer func() {
   875  		errstr := ctx.errDrain()
   876  		log.Printf("gl.CheckFramebufferStatus(%v) %v%v", target, r0, errstr)
   877  	}()
   878  	return Enum(ctx.enqueue(call{
   879  		args: fnargs{
   880  			fn: glfnCheckFramebufferStatus,
   881  			a0: target.c(),
   882  		},
   883  		blocking: true,
   884  	}))
   885  }
   886  
   887  func (ctx *context) Clear(mask Enum) {
   888  	defer func() {
   889  		errstr := ctx.errDrain()
   890  		log.Printf("gl.Clear(%v) %v", mask, errstr)
   891  	}()
   892  	ctx.enqueueDebug(call{
   893  		args: fnargs{
   894  			fn: glfnClear,
   895  			a0: uintptr(mask),
   896  		},
   897  		blocking: true})
   898  }
   899  
   900  func (ctx *context) ClearColor(red, green, blue, alpha float32) {
   901  	defer func() {
   902  		errstr := ctx.errDrain()
   903  		log.Printf("gl.ClearColor(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
   904  	}()
   905  	ctx.enqueueDebug(call{
   906  		args: fnargs{
   907  			fn: glfnClearColor,
   908  			a0: uintptr(math.Float32bits(red)),
   909  			a1: uintptr(math.Float32bits(green)),
   910  			a2: uintptr(math.Float32bits(blue)),
   911  			a3: uintptr(math.Float32bits(alpha)),
   912  		},
   913  		blocking: true})
   914  }
   915  
   916  func (ctx *context) ClearDepthf(d float32) {
   917  	defer func() {
   918  		errstr := ctx.errDrain()
   919  		log.Printf("gl.ClearDepthf(%v) %v", d, errstr)
   920  	}()
   921  	ctx.enqueueDebug(call{
   922  		args: fnargs{
   923  			fn: glfnClearDepthf,
   924  			a0: uintptr(math.Float32bits(d)),
   925  		},
   926  		blocking: true})
   927  }
   928  
   929  func (ctx *context) ClearStencil(s int) {
   930  	defer func() {
   931  		errstr := ctx.errDrain()
   932  		log.Printf("gl.ClearStencil(%v) %v", s, errstr)
   933  	}()
   934  	ctx.enqueueDebug(call{
   935  		args: fnargs{
   936  			fn: glfnClearStencil,
   937  			a0: uintptr(s),
   938  		},
   939  		blocking: true})
   940  }
   941  
   942  func (ctx *context) ColorMask(red, green, blue, alpha bool) {
   943  	defer func() {
   944  		errstr := ctx.errDrain()
   945  		log.Printf("gl.ColorMask(%v, %v, %v, %v) %v", red, green, blue, alpha, errstr)
   946  	}()
   947  	ctx.enqueueDebug(call{
   948  		args: fnargs{
   949  			fn: glfnColorMask,
   950  			a0: glBoolean(red),
   951  			a1: glBoolean(green),
   952  			a2: glBoolean(blue),
   953  			a3: glBoolean(alpha),
   954  		},
   955  		blocking: true})
   956  }
   957  
   958  func (ctx *context) CompileShader(s Shader) {
   959  	defer func() {
   960  		errstr := ctx.errDrain()
   961  		log.Printf("gl.CompileShader(%v) %v", s, errstr)
   962  	}()
   963  	ctx.enqueueDebug(call{
   964  		args: fnargs{
   965  			fn: glfnCompileShader,
   966  			a0: s.c(),
   967  		},
   968  		blocking: true})
   969  }
   970  
   971  func (ctx *context) CompressedTexImage2D(target Enum, level int, internalformat Enum, width, height, border int, data []byte) {
   972  	defer func() {
   973  		errstr := ctx.errDrain()
   974  		log.Printf("gl.CompressedTexImage2D(%v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, internalformat, width, height, border, len(data), errstr)
   975  	}()
   976  	ctx.enqueueDebug(call{
   977  		args: fnargs{
   978  			fn: glfnCompressedTexImage2D,
   979  			a0: target.c(),
   980  			a1: uintptr(level),
   981  			a2: internalformat.c(),
   982  			a3: uintptr(width),
   983  			a4: uintptr(height),
   984  			a5: uintptr(border),
   985  			a6: uintptr(len(data)),
   986  		},
   987  		parg:     unsafe.Pointer(&data[0]),
   988  		blocking: true,
   989  	})
   990  }
   991  
   992  func (ctx *context) CompressedTexSubImage2D(target Enum, level, xoffset, yoffset, width, height int, format Enum, data []byte) {
   993  	defer func() {
   994  		errstr := ctx.errDrain()
   995  		log.Printf("gl.CompressedTexSubImage2D(%v, %v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, xoffset, yoffset, width, height, format, len(data), errstr)
   996  	}()
   997  	ctx.enqueueDebug(call{
   998  		args: fnargs{
   999  			fn: glfnCompressedTexSubImage2D,
  1000  			a0: target.c(),
  1001  			a1: uintptr(level),
  1002  			a2: uintptr(xoffset),
  1003  			a3: uintptr(yoffset),
  1004  			a4: uintptr(width),
  1005  			a5: uintptr(height),
  1006  			a6: format.c(),
  1007  			a7: uintptr(len(data)),
  1008  		},
  1009  		parg:     unsafe.Pointer(&data[0]),
  1010  		blocking: true,
  1011  	})
  1012  }
  1013  
  1014  func (ctx *context) CopyTexImage2D(target Enum, level int, internalformat Enum, x, y, width, height, border int) {
  1015  	defer func() {
  1016  		errstr := ctx.errDrain()
  1017  		log.Printf("gl.CopyTexImage2D(%v, %v, %v, %v, %v, %v, %v, %v) %v", target, level, internalformat, x, y, width, height, border, errstr)
  1018  	}()
  1019  	ctx.enqueueDebug(call{
  1020  		args: fnargs{
  1021  			fn: glfnCopyTexImage2D,
  1022  			a0: target.c(),
  1023  			a1: uintptr(level),
  1024  			a2: internalformat.c(),
  1025  			a3: uintptr(x),
  1026  			a4: uintptr(y),
  1027  			a5: uintptr(width),
  1028  			a6: uintptr(height),
  1029  			a7: uintptr(border),
  1030  		},
  1031  		blocking: true})
  1032  }
  1033  
  1034  func (ctx *context) CopyTexSubImage2D(target Enum, level, xoffset, yoffset, x, y, width, height int) {
  1035  	defer func() {
  1036  		errstr := ctx.errDrain()
  1037  		log.Printf("gl.CopyTexSubImage2D(%v, %v, %v, %v, %v, %v, %v, %v) %v", target, level, xoffset, yoffset, x, y, width, height, errstr)
  1038  	}()
  1039  	ctx.enqueueDebug(call{
  1040  		args: fnargs{
  1041  			fn: glfnCopyTexSubImage2D,
  1042  			a0: target.c(),
  1043  			a1: uintptr(level),
  1044  			a2: uintptr(xoffset),
  1045  			a3: uintptr(yoffset),
  1046  			a4: uintptr(x),
  1047  			a5: uintptr(y),
  1048  			a6: uintptr(width),
  1049  			a7: uintptr(height),
  1050  		},
  1051  		blocking: true})
  1052  }
  1053  
  1054  func (ctx *context) CreateBuffer() (r0 Buffer) {
  1055  	defer func() {
  1056  		errstr := ctx.errDrain()
  1057  		log.Printf("gl.CreateBuffer() %v%v", r0, errstr)
  1058  	}()
  1059  	return Buffer{Value: uint32(ctx.enqueue(call{
  1060  		args: fnargs{
  1061  			fn: glfnGenBuffer,
  1062  		},
  1063  		blocking: true,
  1064  	}))}
  1065  }
  1066  
  1067  func (ctx *context) CreateFramebuffer() (r0 Framebuffer) {
  1068  	defer func() {
  1069  		errstr := ctx.errDrain()
  1070  		log.Printf("gl.CreateFramebuffer() %v%v", r0, errstr)
  1071  	}()
  1072  	return Framebuffer{Value: uint32(ctx.enqueue(call{
  1073  		args: fnargs{
  1074  			fn: glfnGenFramebuffer,
  1075  		},
  1076  		blocking: true,
  1077  	}))}
  1078  }
  1079  
  1080  func (ctx *context) CreateProgram() (r0 Program) {
  1081  	defer func() {
  1082  		errstr := ctx.errDrain()
  1083  		log.Printf("gl.CreateProgram() %v%v", r0, errstr)
  1084  	}()
  1085  	return Program{
  1086  		Init: true,
  1087  		Value: uint32(ctx.enqueue(call{
  1088  			args: fnargs{
  1089  				fn: glfnCreateProgram,
  1090  			},
  1091  			blocking: true,
  1092  		},
  1093  		))}
  1094  }
  1095  
  1096  func (ctx *context) CreateRenderbuffer() (r0 Renderbuffer) {
  1097  	defer func() {
  1098  		errstr := ctx.errDrain()
  1099  		log.Printf("gl.CreateRenderbuffer() %v%v", r0, errstr)
  1100  	}()
  1101  	return Renderbuffer{Value: uint32(ctx.enqueue(call{
  1102  		args: fnargs{
  1103  			fn: glfnGenRenderbuffer,
  1104  		},
  1105  		blocking: true,
  1106  	}))}
  1107  }
  1108  
  1109  func (ctx *context) CreateShader(ty Enum) (r0 Shader) {
  1110  	defer func() {
  1111  		errstr := ctx.errDrain()
  1112  		log.Printf("gl.CreateShader(%v) %v%v", ty, r0, errstr)
  1113  	}()
  1114  	return Shader{Value: uint32(ctx.enqueue(call{
  1115  		args: fnargs{
  1116  			fn: glfnCreateShader,
  1117  			a0: uintptr(ty),
  1118  		},
  1119  		blocking: true,
  1120  	}))}
  1121  }
  1122  
  1123  func (ctx *context) CreateTexture() (r0 Texture) {
  1124  	defer func() {
  1125  		errstr := ctx.errDrain()
  1126  		log.Printf("gl.CreateTexture() %v%v", r0, errstr)
  1127  	}()
  1128  	return Texture{Value: uint32(ctx.enqueue(call{
  1129  		args: fnargs{
  1130  			fn: glfnGenTexture,
  1131  		},
  1132  		blocking: true,
  1133  	}))}
  1134  }
  1135  
  1136  func (ctx *context) CullFace(mode Enum) {
  1137  	defer func() {
  1138  		errstr := ctx.errDrain()
  1139  		log.Printf("gl.CullFace(%v) %v", mode, errstr)
  1140  	}()
  1141  	ctx.enqueueDebug(call{
  1142  		args: fnargs{
  1143  			fn: glfnCullFace,
  1144  			a0: mode.c(),
  1145  		},
  1146  		blocking: true})
  1147  }
  1148  
  1149  func (ctx *context) DeleteBuffer(v Buffer) {
  1150  	defer func() {
  1151  		errstr := ctx.errDrain()
  1152  		log.Printf("gl.DeleteBuffer(%v) %v", v, errstr)
  1153  	}()
  1154  	ctx.enqueueDebug(call{
  1155  		args: fnargs{
  1156  			fn: glfnDeleteBuffer,
  1157  			a0: uintptr(v.Value),
  1158  		},
  1159  		blocking: true})
  1160  }
  1161  
  1162  func (ctx *context) DeleteFramebuffer(v Framebuffer) {
  1163  	defer func() {
  1164  		errstr := ctx.errDrain()
  1165  		log.Printf("gl.DeleteFramebuffer(%v) %v", v, errstr)
  1166  	}()
  1167  	ctx.enqueueDebug(call{
  1168  		args: fnargs{
  1169  			fn: glfnDeleteFramebuffer,
  1170  			a0: uintptr(v.Value),
  1171  		},
  1172  		blocking: true})
  1173  }
  1174  
  1175  func (ctx *context) DeleteProgram(p Program) {
  1176  	defer func() {
  1177  		errstr := ctx.errDrain()
  1178  		log.Printf("gl.DeleteProgram(%v) %v", p, errstr)
  1179  	}()
  1180  	ctx.enqueueDebug(call{
  1181  		args: fnargs{
  1182  			fn: glfnDeleteProgram,
  1183  			a0: p.c(),
  1184  		},
  1185  		blocking: true})
  1186  }
  1187  
  1188  func (ctx *context) DeleteRenderbuffer(v Renderbuffer) {
  1189  	defer func() {
  1190  		errstr := ctx.errDrain()
  1191  		log.Printf("gl.DeleteRenderbuffer(%v) %v", v, errstr)
  1192  	}()
  1193  	ctx.enqueueDebug(call{
  1194  		args: fnargs{
  1195  			fn: glfnDeleteRenderbuffer,
  1196  			a0: v.c(),
  1197  		},
  1198  		blocking: true})
  1199  }
  1200  
  1201  func (ctx *context) DeleteShader(s Shader) {
  1202  	defer func() {
  1203  		errstr := ctx.errDrain()
  1204  		log.Printf("gl.DeleteShader(%v) %v", s, errstr)
  1205  	}()
  1206  	ctx.enqueueDebug(call{
  1207  		args: fnargs{
  1208  			fn: glfnDeleteShader,
  1209  			a0: s.c(),
  1210  		},
  1211  		blocking: true})
  1212  }
  1213  
  1214  func (ctx *context) DeleteTexture(v Texture) {
  1215  	defer func() {
  1216  		errstr := ctx.errDrain()
  1217  		log.Printf("gl.DeleteTexture(%v) %v", v, errstr)
  1218  	}()
  1219  	ctx.enqueueDebug(call{
  1220  		args: fnargs{
  1221  			fn: glfnDeleteTexture,
  1222  			a0: v.c(),
  1223  		},
  1224  		blocking: true})
  1225  }
  1226  
  1227  func (ctx *context) DepthFunc(fn Enum) {
  1228  	defer func() {
  1229  		errstr := ctx.errDrain()
  1230  		log.Printf("gl.DepthFunc(%v) %v", fn, errstr)
  1231  	}()
  1232  	ctx.enqueueDebug(call{
  1233  		args: fnargs{
  1234  			fn: glfnDepthFunc,
  1235  			a0: fn.c(),
  1236  		},
  1237  		blocking: true})
  1238  }
  1239  
  1240  func (ctx *context) DepthMask(flag bool) {
  1241  	defer func() {
  1242  		errstr := ctx.errDrain()
  1243  		log.Printf("gl.DepthMask(%v) %v", flag, errstr)
  1244  	}()
  1245  	ctx.enqueueDebug(call{
  1246  		args: fnargs{
  1247  			fn: glfnDepthMask,
  1248  			a0: glBoolean(flag),
  1249  		},
  1250  		blocking: true})
  1251  }
  1252  
  1253  func (ctx *context) DepthRangef(n, f float32) {
  1254  	defer func() {
  1255  		errstr := ctx.errDrain()
  1256  		log.Printf("gl.DepthRangef(%v, %v) %v", n, f, errstr)
  1257  	}()
  1258  	ctx.enqueueDebug(call{
  1259  		args: fnargs{
  1260  			fn: glfnDepthRangef,
  1261  			a0: uintptr(math.Float32bits(n)),
  1262  			a1: uintptr(math.Float32bits(f)),
  1263  		},
  1264  		blocking: true})
  1265  }
  1266  
  1267  func (ctx *context) DetachShader(p Program, s Shader) {
  1268  	defer func() {
  1269  		errstr := ctx.errDrain()
  1270  		log.Printf("gl.DetachShader(%v, %v) %v", p, s, errstr)
  1271  	}()
  1272  	ctx.enqueueDebug(call{
  1273  		args: fnargs{
  1274  			fn: glfnDetachShader,
  1275  			a0: p.c(),
  1276  			a1: s.c(),
  1277  		},
  1278  		blocking: true})
  1279  }
  1280  
  1281  func (ctx *context) Disable(cap Enum) {
  1282  	defer func() {
  1283  		errstr := ctx.errDrain()
  1284  		log.Printf("gl.Disable(%v) %v", cap, errstr)
  1285  	}()
  1286  	ctx.enqueueDebug(call{
  1287  		args: fnargs{
  1288  			fn: glfnDisable,
  1289  			a0: cap.c(),
  1290  		},
  1291  		blocking: true})
  1292  }
  1293  
  1294  func (ctx *context) DisableVertexAttribArray(a Attrib) {
  1295  	defer func() {
  1296  		errstr := ctx.errDrain()
  1297  		log.Printf("gl.DisableVertexAttribArray(%v) %v", a, errstr)
  1298  	}()
  1299  	ctx.enqueueDebug(call{
  1300  		args: fnargs{
  1301  			fn: glfnDisableVertexAttribArray,
  1302  			a0: a.c(),
  1303  		},
  1304  		blocking: true})
  1305  }
  1306  
  1307  func (ctx *context) DrawArrays(mode Enum, first, count int) {
  1308  	defer func() {
  1309  		errstr := ctx.errDrain()
  1310  		log.Printf("gl.DrawArrays(%v, %v, %v) %v", mode, first, count, errstr)
  1311  	}()
  1312  	ctx.enqueueDebug(call{
  1313  		args: fnargs{
  1314  			fn: glfnDrawArrays,
  1315  			a0: mode.c(),
  1316  			a1: uintptr(first),
  1317  			a2: uintptr(count),
  1318  		},
  1319  		blocking: true})
  1320  }
  1321  
  1322  func (ctx *context) DrawElements(mode Enum, count int, ty Enum, offset int) {
  1323  	defer func() {
  1324  		errstr := ctx.errDrain()
  1325  		log.Printf("gl.DrawElements(%v, %v, %v, %v) %v", mode, count, ty, offset, errstr)
  1326  	}()
  1327  	ctx.enqueueDebug(call{
  1328  		args: fnargs{
  1329  			fn: glfnDrawElements,
  1330  			a0: mode.c(),
  1331  			a1: uintptr(count),
  1332  			a2: ty.c(),
  1333  			a3: uintptr(offset),
  1334  		},
  1335  		blocking: true})
  1336  }
  1337  
  1338  func (ctx *context) Enable(cap Enum) {
  1339  	defer func() {
  1340  		errstr := ctx.errDrain()
  1341  		log.Printf("gl.Enable(%v) %v", cap, errstr)
  1342  	}()
  1343  	ctx.enqueueDebug(call{
  1344  		args: fnargs{
  1345  			fn: glfnEnable,
  1346  			a0: cap.c(),
  1347  		},
  1348  		blocking: true})
  1349  }
  1350  
  1351  func (ctx *context) EnableVertexAttribArray(a Attrib) {
  1352  	defer func() {
  1353  		errstr := ctx.errDrain()
  1354  		log.Printf("gl.EnableVertexAttribArray(%v) %v", a, errstr)
  1355  	}()
  1356  	ctx.enqueueDebug(call{
  1357  		args: fnargs{
  1358  			fn: glfnEnableVertexAttribArray,
  1359  			a0: a.c(),
  1360  		},
  1361  		blocking: true})
  1362  }
  1363  
  1364  func (ctx *context) Finish() {
  1365  	defer func() {
  1366  		errstr := ctx.errDrain()
  1367  		log.Printf("gl.Finish() %v", errstr)
  1368  	}()
  1369  	ctx.enqueueDebug(call{
  1370  		args: fnargs{
  1371  			fn: glfnFinish,
  1372  		},
  1373  		blocking: true,
  1374  	})
  1375  }
  1376  
  1377  func (ctx *context) Flush() {
  1378  	defer func() {
  1379  		errstr := ctx.errDrain()
  1380  		log.Printf("gl.Flush() %v", errstr)
  1381  	}()
  1382  	ctx.enqueueDebug(call{
  1383  		args: fnargs{
  1384  			fn: glfnFlush,
  1385  		},
  1386  		blocking: true,
  1387  	})
  1388  }
  1389  
  1390  func (ctx *context) FramebufferRenderbuffer(target, attachment, rbTarget Enum, rb Renderbuffer) {
  1391  	defer func() {
  1392  		errstr := ctx.errDrain()
  1393  		log.Printf("gl.FramebufferRenderbuffer(%v, %v, %v, %v) %v", target, attachment, rbTarget, rb, errstr)
  1394  	}()
  1395  	ctx.enqueueDebug(call{
  1396  		args: fnargs{
  1397  			fn: glfnFramebufferRenderbuffer,
  1398  			a0: target.c(),
  1399  			a1: attachment.c(),
  1400  			a2: rbTarget.c(),
  1401  			a3: rb.c(),
  1402  		},
  1403  		blocking: true})
  1404  }
  1405  
  1406  func (ctx *context) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) {
  1407  	defer func() {
  1408  		errstr := ctx.errDrain()
  1409  		log.Printf("gl.FramebufferTexture2D(%v, %v, %v, %v, %v) %v", target, attachment, texTarget, t, level, errstr)
  1410  	}()
  1411  	ctx.enqueueDebug(call{
  1412  		args: fnargs{
  1413  			fn: glfnFramebufferTexture2D,
  1414  			a0: target.c(),
  1415  			a1: attachment.c(),
  1416  			a2: texTarget.c(),
  1417  			a3: t.c(),
  1418  			a4: uintptr(level),
  1419  		},
  1420  		blocking: true})
  1421  }
  1422  
  1423  func (ctx *context) FrontFace(mode Enum) {
  1424  	defer func() {
  1425  		errstr := ctx.errDrain()
  1426  		log.Printf("gl.FrontFace(%v) %v", mode, errstr)
  1427  	}()
  1428  	ctx.enqueueDebug(call{
  1429  		args: fnargs{
  1430  			fn: glfnFrontFace,
  1431  			a0: mode.c(),
  1432  		},
  1433  		blocking: true})
  1434  }
  1435  
  1436  func (ctx *context) GenerateMipmap(target Enum) {
  1437  	defer func() {
  1438  		errstr := ctx.errDrain()
  1439  		log.Printf("gl.GenerateMipmap(%v) %v", target, errstr)
  1440  	}()
  1441  	ctx.enqueueDebug(call{
  1442  		args: fnargs{
  1443  			fn: glfnGenerateMipmap,
  1444  			a0: target.c(),
  1445  		},
  1446  		blocking: true})
  1447  }
  1448  
  1449  func (ctx *context) GetActiveAttrib(p Program, index uint32) (name string, size int, ty Enum) {
  1450  	defer func() {
  1451  		errstr := ctx.errDrain()
  1452  		log.Printf("gl.GetActiveAttrib(%v, %v) (%v, %v, %v) %v", p, index, name, size, ty, errstr)
  1453  	}()
  1454  	bufSize := ctx.GetProgrami(p, ACTIVE_ATTRIBUTE_MAX_LENGTH)
  1455  	buf := make([]byte, bufSize)
  1456  	var cType int
  1457  	cSize := ctx.enqueue(call{
  1458  		args: fnargs{
  1459  			fn: glfnGetActiveAttrib,
  1460  			a0: p.c(),
  1461  			a1: uintptr(index),
  1462  			a2: uintptr(bufSize),
  1463  			a3: uintptr(unsafe.Pointer(&cType)),
  1464  		},
  1465  		parg:     unsafe.Pointer(&buf[0]),
  1466  		blocking: true,
  1467  	})
  1468  	return goString(buf), int(cSize), Enum(cType)
  1469  }
  1470  
  1471  func (ctx *context) GetActiveUniform(p Program, index uint32) (name string, size int, ty Enum) {
  1472  	defer func() {
  1473  		errstr := ctx.errDrain()
  1474  		log.Printf("gl.GetActiveUniform(%v, %v) (%v, %v, %v) %v", p, index, name, size, ty, errstr)
  1475  	}()
  1476  	bufSize := ctx.GetProgrami(p, ACTIVE_UNIFORM_MAX_LENGTH)
  1477  	buf := make([]byte, bufSize+8)
  1478  	var cType int
  1479  	cSize := ctx.enqueue(call{
  1480  		args: fnargs{
  1481  			fn: glfnGetActiveUniform,
  1482  			a0: p.c(),
  1483  			a1: uintptr(index),
  1484  			a2: uintptr(bufSize),
  1485  			a3: uintptr(unsafe.Pointer(&cType)),
  1486  		},
  1487  		parg:     unsafe.Pointer(&buf[0]),
  1488  		blocking: true,
  1489  	})
  1490  	return goString(buf), int(cSize), Enum(cType)
  1491  }
  1492  
  1493  func (ctx *context) GetAttachedShaders(p Program) (r0 []Shader) {
  1494  	defer func() {
  1495  		errstr := ctx.errDrain()
  1496  		log.Printf("gl.GetAttachedShaders(%v) %v%v", p, r0, errstr)
  1497  	}()
  1498  	shadersLen := ctx.GetProgrami(p, ATTACHED_SHADERS)
  1499  	if shadersLen == 0 {
  1500  		return nil
  1501  	}
  1502  	buf := make([]uint32, shadersLen)
  1503  	n := int(ctx.enqueue(call{
  1504  		args: fnargs{
  1505  			fn: glfnGetAttachedShaders,
  1506  			a0: p.c(),
  1507  			a1: uintptr(shadersLen),
  1508  		},
  1509  		parg:     unsafe.Pointer(&buf[0]),
  1510  		blocking: true,
  1511  	}))
  1512  	buf = buf[:int(n)]
  1513  	shaders := make([]Shader, len(buf))
  1514  	for i, s := range buf {
  1515  		shaders[i] = Shader{Value: uint32(s)}
  1516  	}
  1517  	return shaders
  1518  }
  1519  
  1520  func (ctx *context) GetAttribLocation(p Program, name string) (r0 Attrib) {
  1521  	defer func() {
  1522  		errstr := ctx.errDrain()
  1523  		r0.name = name
  1524  		log.Printf("gl.GetAttribLocation(%v, %v) %v%v", p, name, r0, errstr)
  1525  	}()
  1526  	s, free := ctx.cString(name)
  1527  	defer free()
  1528  	return Attrib{Value: uint(ctx.enqueue(call{
  1529  		args: fnargs{
  1530  			fn: glfnGetAttribLocation,
  1531  			a0: p.c(),
  1532  			a1: s,
  1533  		},
  1534  		blocking: true,
  1535  	}))}
  1536  }
  1537  
  1538  func (ctx *context) GetBooleanv(dst []bool, pname Enum) {
  1539  	defer func() {
  1540  		errstr := ctx.errDrain()
  1541  		log.Printf("gl.GetBooleanv(%v, %v) %v", dst, pname, errstr)
  1542  	}()
  1543  	buf := make([]int32, len(dst))
  1544  	ctx.enqueueDebug(call{
  1545  		args: fnargs{
  1546  			fn: glfnGetBooleanv,
  1547  			a0: pname.c(),
  1548  		},
  1549  		parg:     unsafe.Pointer(&buf[0]),
  1550  		blocking: true,
  1551  	})
  1552  	for i, v := range buf {
  1553  		dst[i] = v != 0
  1554  	}
  1555  }
  1556  
  1557  func (ctx *context) GetFloatv(dst []float32, pname Enum) {
  1558  	defer func() {
  1559  		errstr := ctx.errDrain()
  1560  		log.Printf("gl.GetFloatv(len(%d), %v) %v", len(dst), pname, errstr)
  1561  	}()
  1562  	ctx.enqueueDebug(call{
  1563  		args: fnargs{
  1564  			fn: glfnGetFloatv,
  1565  			a0: pname.c(),
  1566  		},
  1567  		parg:     unsafe.Pointer(&dst[0]),
  1568  		blocking: true,
  1569  	})
  1570  }
  1571  
  1572  func (ctx *context) GetIntegerv(dst []int32, pname Enum) {
  1573  	defer func() {
  1574  		errstr := ctx.errDrain()
  1575  		log.Printf("gl.GetIntegerv(%v, %v) %v", dst, pname, errstr)
  1576  	}()
  1577  	ctx.enqueueDebug(call{
  1578  		args: fnargs{
  1579  			fn: glfnGetIntegerv,
  1580  			a0: pname.c(),
  1581  		},
  1582  		parg:     unsafe.Pointer(&dst[0]),
  1583  		blocking: true,
  1584  	})
  1585  }
  1586  
  1587  func (ctx *context) GetInteger(pname Enum) (r0 int) {
  1588  	defer func() {
  1589  		errstr := ctx.errDrain()
  1590  		log.Printf("gl.GetInteger(%v) %v%v", pname, r0, errstr)
  1591  	}()
  1592  	var v [1]int32
  1593  	ctx.GetIntegerv(v[:], pname)
  1594  	return int(v[0])
  1595  }
  1596  
  1597  func (ctx *context) GetBufferParameteri(target, value Enum) (r0 int) {
  1598  	defer func() {
  1599  		errstr := ctx.errDrain()
  1600  		log.Printf("gl.GetBufferParameteri(%v, %v) %v%v", target, value, r0, errstr)
  1601  	}()
  1602  	return int(ctx.enqueue(call{
  1603  		args: fnargs{
  1604  			fn: glfnGetBufferParameteri,
  1605  			a0: target.c(),
  1606  			a1: value.c(),
  1607  		},
  1608  		blocking: true,
  1609  	}))
  1610  }
  1611  
  1612  func (ctx *context) GetError() (r0 Enum) {
  1613  	return Enum(ctx.enqueue(call{
  1614  		args: fnargs{
  1615  			fn: glfnGetError,
  1616  		},
  1617  		blocking: true,
  1618  	}))
  1619  }
  1620  
  1621  func (ctx *context) GetFramebufferAttachmentParameteri(target, attachment, pname Enum) (r0 int) {
  1622  	defer func() {
  1623  		errstr := ctx.errDrain()
  1624  		log.Printf("gl.GetFramebufferAttachmentParameteri(%v, %v, %v) %v%v", target, attachment, pname, r0, errstr)
  1625  	}()
  1626  	return int(ctx.enqueue(call{
  1627  		args: fnargs{
  1628  			fn: glfnGetFramebufferAttachmentParameteriv,
  1629  			a0: target.c(),
  1630  			a1: attachment.c(),
  1631  			a2: pname.c(),
  1632  		},
  1633  		blocking: true,
  1634  	}))
  1635  }
  1636  
  1637  func (ctx *context) GetProgrami(p Program, pname Enum) (r0 int) {
  1638  	defer func() {
  1639  		errstr := ctx.errDrain()
  1640  		log.Printf("gl.GetProgrami(%v, %v) %v%v", p, pname, r0, errstr)
  1641  	}()
  1642  	return int(ctx.enqueue(call{
  1643  		args: fnargs{
  1644  			fn: glfnGetProgramiv,
  1645  			a0: p.c(),
  1646  			a1: pname.c(),
  1647  		},
  1648  		blocking: true,
  1649  	}))
  1650  }
  1651  
  1652  func (ctx *context) GetProgramInfoLog(p Program) (r0 string) {
  1653  	defer func() {
  1654  		errstr := ctx.errDrain()
  1655  		log.Printf("gl.GetProgramInfoLog(%v) %v%v", p, r0, errstr)
  1656  	}()
  1657  	infoLen := ctx.GetProgrami(p, INFO_LOG_LENGTH)
  1658  	if infoLen == 0 {
  1659  		return ""
  1660  	}
  1661  	buf := make([]byte, infoLen)
  1662  	ctx.enqueueDebug(call{
  1663  		args: fnargs{
  1664  			fn: glfnGetProgramInfoLog,
  1665  			a0: p.c(),
  1666  			a1: uintptr(infoLen),
  1667  		},
  1668  		parg:     unsafe.Pointer(&buf[0]),
  1669  		blocking: true,
  1670  	})
  1671  	return goString(buf)
  1672  }
  1673  
  1674  func (ctx *context) GetRenderbufferParameteri(target, pname Enum) (r0 int) {
  1675  	defer func() {
  1676  		errstr := ctx.errDrain()
  1677  		log.Printf("gl.GetRenderbufferParameteri(%v, %v) %v%v", target, pname, r0, errstr)
  1678  	}()
  1679  	return int(ctx.enqueue(call{
  1680  		args: fnargs{
  1681  			fn: glfnGetRenderbufferParameteriv,
  1682  			a0: target.c(),
  1683  			a1: pname.c(),
  1684  		},
  1685  		blocking: true,
  1686  	}))
  1687  }
  1688  
  1689  func (ctx *context) GetShaderi(s Shader, pname Enum) (r0 int) {
  1690  	defer func() {
  1691  		errstr := ctx.errDrain()
  1692  		log.Printf("gl.GetShaderi(%v, %v) %v%v", s, pname, r0, errstr)
  1693  	}()
  1694  	return int(ctx.enqueue(call{
  1695  		args: fnargs{
  1696  			fn: glfnGetShaderiv,
  1697  			a0: s.c(),
  1698  			a1: pname.c(),
  1699  		},
  1700  		blocking: true,
  1701  	}))
  1702  }
  1703  
  1704  func (ctx *context) GetShaderInfoLog(s Shader) (r0 string) {
  1705  	defer func() {
  1706  		errstr := ctx.errDrain()
  1707  		log.Printf("gl.GetShaderInfoLog(%v) %v%v", s, r0, errstr)
  1708  	}()
  1709  	infoLen := ctx.GetShaderi(s, INFO_LOG_LENGTH)
  1710  	if infoLen == 0 {
  1711  		return ""
  1712  	}
  1713  	buf := make([]byte, infoLen)
  1714  	ctx.enqueueDebug(call{
  1715  		args: fnargs{
  1716  			fn: glfnGetShaderInfoLog,
  1717  			a0: s.c(),
  1718  			a1: uintptr(infoLen),
  1719  		},
  1720  		parg:     unsafe.Pointer(&buf[0]),
  1721  		blocking: true,
  1722  	})
  1723  	return goString(buf)
  1724  }
  1725  
  1726  func (ctx *context) GetShaderPrecisionFormat(shadertype, precisiontype Enum) (rangeLow, rangeHigh, precision int) {
  1727  	defer func() {
  1728  		errstr := ctx.errDrain()
  1729  		log.Printf("gl.GetShaderPrecisionFormat(%v, %v) (%v, %v, %v) %v", shadertype, precisiontype, rangeLow, rangeHigh, precision, errstr)
  1730  	}()
  1731  	var rangeAndPrec [3]int32
  1732  	ctx.enqueueDebug(call{
  1733  		args: fnargs{
  1734  			fn: glfnGetShaderPrecisionFormat,
  1735  			a0: shadertype.c(),
  1736  			a1: precisiontype.c(),
  1737  		},
  1738  		parg:     unsafe.Pointer(&rangeAndPrec[0]),
  1739  		blocking: true,
  1740  	})
  1741  	return int(rangeAndPrec[0]), int(rangeAndPrec[1]), int(rangeAndPrec[2])
  1742  }
  1743  
  1744  func (ctx *context) GetShaderSource(s Shader) (r0 string) {
  1745  	defer func() {
  1746  		errstr := ctx.errDrain()
  1747  		log.Printf("gl.GetShaderSource(%v) %v%v", s, r0, errstr)
  1748  	}()
  1749  	sourceLen := ctx.GetShaderi(s, SHADER_SOURCE_LENGTH)
  1750  	if sourceLen == 0 {
  1751  		return ""
  1752  	}
  1753  	buf := make([]byte, sourceLen)
  1754  	ctx.enqueueDebug(call{
  1755  		args: fnargs{
  1756  			fn: glfnGetShaderSource,
  1757  			a0: s.c(),
  1758  			a1: uintptr(sourceLen),
  1759  		},
  1760  		parg:     unsafe.Pointer(&buf[0]),
  1761  		blocking: true,
  1762  	})
  1763  	return goString(buf)
  1764  }
  1765  
  1766  func (ctx *context) GetString(pname Enum) (r0 string) {
  1767  	defer func() {
  1768  		errstr := ctx.errDrain()
  1769  		log.Printf("gl.GetString(%v) %v%v", pname, r0, errstr)
  1770  	}()
  1771  	ret := ctx.enqueue(call{
  1772  		args: fnargs{
  1773  			fn: glfnGetString,
  1774  			a0: pname.c(),
  1775  		},
  1776  		blocking: true,
  1777  	})
  1778  	retp := unsafe.Pointer(ret)
  1779  	buf := (*[1 << 24]byte)(retp)[:]
  1780  	return goString(buf)
  1781  }
  1782  
  1783  func (ctx *context) GetTexParameterfv(dst []float32, target, pname Enum) {
  1784  	defer func() {
  1785  		errstr := ctx.errDrain()
  1786  		log.Printf("gl.GetTexParameterfv(len(%d), %v, %v) %v", len(dst), target, pname, errstr)
  1787  	}()
  1788  	ctx.enqueueDebug(call{
  1789  		args: fnargs{
  1790  			fn: glfnGetTexParameterfv,
  1791  			a0: target.c(),
  1792  			a1: pname.c(),
  1793  		},
  1794  		parg:     unsafe.Pointer(&dst[0]),
  1795  		blocking: true,
  1796  	})
  1797  }
  1798  
  1799  func (ctx *context) GetTexParameteriv(dst []int32, target, pname Enum) {
  1800  	defer func() {
  1801  		errstr := ctx.errDrain()
  1802  		log.Printf("gl.GetTexParameteriv(%v, %v, %v) %v", dst, target, pname, errstr)
  1803  	}()
  1804  	ctx.enqueueDebug(call{
  1805  		args: fnargs{
  1806  			fn: glfnGetTexParameteriv,
  1807  			a0: target.c(),
  1808  			a1: pname.c(),
  1809  		},
  1810  		blocking: true,
  1811  	})
  1812  }
  1813  
  1814  func (ctx *context) GetUniformfv(dst []float32, src Uniform, p Program) {
  1815  	defer func() {
  1816  		errstr := ctx.errDrain()
  1817  		log.Printf("gl.GetUniformfv(len(%d), %v, %v) %v", len(dst), src, p, errstr)
  1818  	}()
  1819  	ctx.enqueueDebug(call{
  1820  		args: fnargs{
  1821  			fn: glfnGetUniformfv,
  1822  			a0: p.c(),
  1823  			a1: src.c(),
  1824  		},
  1825  		parg:     unsafe.Pointer(&dst[0]),
  1826  		blocking: true,
  1827  	})
  1828  }
  1829  
  1830  func (ctx *context) GetUniformiv(dst []int32, src Uniform, p Program) {
  1831  	defer func() {
  1832  		errstr := ctx.errDrain()
  1833  		log.Printf("gl.GetUniformiv(%v, %v, %v) %v", dst, src, p, errstr)
  1834  	}()
  1835  	ctx.enqueueDebug(call{
  1836  		args: fnargs{
  1837  			fn: glfnGetUniformiv,
  1838  			a0: p.c(),
  1839  			a1: src.c(),
  1840  		},
  1841  		parg:     unsafe.Pointer(&dst[0]),
  1842  		blocking: true,
  1843  	})
  1844  }
  1845  
  1846  func (ctx *context) GetUniformLocation(p Program, name string) (r0 Uniform) {
  1847  	defer func() {
  1848  		errstr := ctx.errDrain()
  1849  		r0.name = name
  1850  		log.Printf("gl.GetUniformLocation(%v, %v) %v%v", p, name, r0, errstr)
  1851  	}()
  1852  	s, free := ctx.cString(name)
  1853  	defer free()
  1854  	return Uniform{Value: int32(ctx.enqueue(call{
  1855  		args: fnargs{
  1856  			fn: glfnGetUniformLocation,
  1857  			a0: p.c(),
  1858  			a1: s,
  1859  		},
  1860  		blocking: true,
  1861  	}))}
  1862  }
  1863  
  1864  func (ctx *context) GetVertexAttribf(src Attrib, pname Enum) (r0 float32) {
  1865  	defer func() {
  1866  		errstr := ctx.errDrain()
  1867  		log.Printf("gl.GetVertexAttribf(%v, %v) %v%v", src, pname, r0, errstr)
  1868  	}()
  1869  	var params [1]float32
  1870  	ctx.GetVertexAttribfv(params[:], src, pname)
  1871  	return params[0]
  1872  }
  1873  
  1874  func (ctx *context) GetVertexAttribfv(dst []float32, src Attrib, pname Enum) {
  1875  	defer func() {
  1876  		errstr := ctx.errDrain()
  1877  		log.Printf("gl.GetVertexAttribfv(len(%d), %v, %v) %v", len(dst), src, pname, errstr)
  1878  	}()
  1879  	ctx.enqueueDebug(call{
  1880  		args: fnargs{
  1881  			fn: glfnGetVertexAttribfv,
  1882  			a0: src.c(),
  1883  			a1: pname.c(),
  1884  		},
  1885  		parg:     unsafe.Pointer(&dst[0]),
  1886  		blocking: true,
  1887  	})
  1888  }
  1889  
  1890  func (ctx *context) GetVertexAttribi(src Attrib, pname Enum) (r0 int32) {
  1891  	defer func() {
  1892  		errstr := ctx.errDrain()
  1893  		log.Printf("gl.GetVertexAttribi(%v, %v) %v%v", src, pname, r0, errstr)
  1894  	}()
  1895  	var params [1]int32
  1896  	ctx.GetVertexAttribiv(params[:], src, pname)
  1897  	return params[0]
  1898  }
  1899  
  1900  func (ctx *context) GetVertexAttribiv(dst []int32, src Attrib, pname Enum) {
  1901  	defer func() {
  1902  		errstr := ctx.errDrain()
  1903  		log.Printf("gl.GetVertexAttribiv(%v, %v, %v) %v", dst, src, pname, errstr)
  1904  	}()
  1905  	ctx.enqueueDebug(call{
  1906  		args: fnargs{
  1907  			fn: glfnGetVertexAttribiv,
  1908  			a0: src.c(),
  1909  			a1: pname.c(),
  1910  		},
  1911  		parg:     unsafe.Pointer(&dst[0]),
  1912  		blocking: true,
  1913  	})
  1914  }
  1915  
  1916  func (ctx *context) Hint(target, mode Enum) {
  1917  	defer func() {
  1918  		errstr := ctx.errDrain()
  1919  		log.Printf("gl.Hint(%v, %v) %v", target, mode, errstr)
  1920  	}()
  1921  	ctx.enqueueDebug(call{
  1922  		args: fnargs{
  1923  			fn: glfnHint,
  1924  			a0: target.c(),
  1925  			a1: mode.c(),
  1926  		},
  1927  		blocking: true})
  1928  }
  1929  
  1930  func (ctx *context) IsBuffer(b Buffer) (r0 bool) {
  1931  	defer func() {
  1932  		errstr := ctx.errDrain()
  1933  		log.Printf("gl.IsBuffer(%v) %v%v", b, r0, errstr)
  1934  	}()
  1935  	return 0 != ctx.enqueue(call{
  1936  		args: fnargs{
  1937  			fn: glfnIsBuffer,
  1938  			a0: b.c(),
  1939  		},
  1940  		blocking: true,
  1941  	})
  1942  }
  1943  
  1944  func (ctx *context) IsEnabled(cap Enum) (r0 bool) {
  1945  	defer func() {
  1946  		errstr := ctx.errDrain()
  1947  		log.Printf("gl.IsEnabled(%v) %v%v", cap, r0, errstr)
  1948  	}()
  1949  	return 0 != ctx.enqueue(call{
  1950  		args: fnargs{
  1951  			fn: glfnIsEnabled,
  1952  			a0: cap.c(),
  1953  		},
  1954  		blocking: true,
  1955  	})
  1956  }
  1957  
  1958  func (ctx *context) IsFramebuffer(fb Framebuffer) (r0 bool) {
  1959  	defer func() {
  1960  		errstr := ctx.errDrain()
  1961  		log.Printf("gl.IsFramebuffer(%v) %v%v", fb, r0, errstr)
  1962  	}()
  1963  	return 0 != ctx.enqueue(call{
  1964  		args: fnargs{
  1965  			fn: glfnIsFramebuffer,
  1966  			a0: fb.c(),
  1967  		},
  1968  		blocking: true,
  1969  	})
  1970  }
  1971  
  1972  func (ctx *context) IsProgram(p Program) (r0 bool) {
  1973  	defer func() {
  1974  		errstr := ctx.errDrain()
  1975  		log.Printf("gl.IsProgram(%v) %v%v", p, r0, errstr)
  1976  	}()
  1977  	return 0 != ctx.enqueue(call{
  1978  		args: fnargs{
  1979  			fn: glfnIsProgram,
  1980  			a0: p.c(),
  1981  		},
  1982  		blocking: true,
  1983  	})
  1984  }
  1985  
  1986  func (ctx *context) IsRenderbuffer(rb Renderbuffer) (r0 bool) {
  1987  	defer func() {
  1988  		errstr := ctx.errDrain()
  1989  		log.Printf("gl.IsRenderbuffer(%v) %v%v", rb, r0, errstr)
  1990  	}()
  1991  	return 0 != ctx.enqueue(call{
  1992  		args: fnargs{
  1993  			fn: glfnIsRenderbuffer,
  1994  			a0: rb.c(),
  1995  		},
  1996  		blocking: true,
  1997  	})
  1998  }
  1999  
  2000  func (ctx *context) IsShader(s Shader) (r0 bool) {
  2001  	defer func() {
  2002  		errstr := ctx.errDrain()
  2003  		log.Printf("gl.IsShader(%v) %v%v", s, r0, errstr)
  2004  	}()
  2005  	return 0 != ctx.enqueue(call{
  2006  		args: fnargs{
  2007  			fn: glfnIsShader,
  2008  			a0: s.c(),
  2009  		},
  2010  		blocking: true,
  2011  	})
  2012  }
  2013  
  2014  func (ctx *context) IsTexture(t Texture) (r0 bool) {
  2015  	defer func() {
  2016  		errstr := ctx.errDrain()
  2017  		log.Printf("gl.IsTexture(%v) %v%v", t, r0, errstr)
  2018  	}()
  2019  	return 0 != ctx.enqueue(call{
  2020  		args: fnargs{
  2021  			fn: glfnIsTexture,
  2022  			a0: t.c(),
  2023  		},
  2024  		blocking: true,
  2025  	})
  2026  }
  2027  
  2028  func (ctx *context) LineWidth(width float32) {
  2029  	defer func() {
  2030  		errstr := ctx.errDrain()
  2031  		log.Printf("gl.LineWidth(%v) %v", width, errstr)
  2032  	}()
  2033  	ctx.enqueueDebug(call{
  2034  		args: fnargs{
  2035  			fn: glfnLineWidth,
  2036  			a0: uintptr(math.Float32bits(width)),
  2037  		},
  2038  		blocking: true})
  2039  }
  2040  
  2041  func (ctx *context) LinkProgram(p Program) {
  2042  	defer func() {
  2043  		errstr := ctx.errDrain()
  2044  		log.Printf("gl.LinkProgram(%v) %v", p, errstr)
  2045  	}()
  2046  	ctx.enqueueDebug(call{
  2047  		args: fnargs{
  2048  			fn: glfnLinkProgram,
  2049  			a0: p.c(),
  2050  		},
  2051  		blocking: true})
  2052  }
  2053  
  2054  func (ctx *context) PixelStorei(pname Enum, param int32) {
  2055  	defer func() {
  2056  		errstr := ctx.errDrain()
  2057  		log.Printf("gl.PixelStorei(%v, %v) %v", pname, param, errstr)
  2058  	}()
  2059  	ctx.enqueueDebug(call{
  2060  		args: fnargs{
  2061  			fn: glfnPixelStorei,
  2062  			a0: pname.c(),
  2063  			a1: uintptr(param),
  2064  		},
  2065  		blocking: true})
  2066  }
  2067  
  2068  func (ctx *context) PolygonOffset(factor, units float32) {
  2069  	defer func() {
  2070  		errstr := ctx.errDrain()
  2071  		log.Printf("gl.PolygonOffset(%v, %v) %v", factor, units, errstr)
  2072  	}()
  2073  	ctx.enqueueDebug(call{
  2074  		args: fnargs{
  2075  			fn: glfnPolygonOffset,
  2076  			a0: uintptr(math.Float32bits(factor)),
  2077  			a1: uintptr(math.Float32bits(units)),
  2078  		},
  2079  		blocking: true})
  2080  }
  2081  
  2082  func (ctx *context) ReadPixels(dst []byte, x, y, width, height int, format, ty Enum) {
  2083  	defer func() {
  2084  		errstr := ctx.errDrain()
  2085  		log.Printf("gl.ReadPixels(len(%d), %v, %v, %v, %v, %v, %v) %v", len(dst), x, y, width, height, format, ty, errstr)
  2086  	}()
  2087  	ctx.enqueueDebug(call{
  2088  		args: fnargs{
  2089  			fn: glfnReadPixels,
  2090  
  2091  			a0: uintptr(x),
  2092  			a1: uintptr(y),
  2093  			a2: uintptr(width),
  2094  			a3: uintptr(height),
  2095  			a4: format.c(),
  2096  			a5: ty.c(),
  2097  		},
  2098  		parg:     unsafe.Pointer(&dst[0]),
  2099  		blocking: true,
  2100  	})
  2101  }
  2102  
  2103  func (ctx *context) ReleaseShaderCompiler() {
  2104  	defer func() {
  2105  		errstr := ctx.errDrain()
  2106  		log.Printf("gl.ReleaseShaderCompiler() %v", errstr)
  2107  	}()
  2108  	ctx.enqueueDebug(call{
  2109  		args: fnargs{
  2110  			fn: glfnReleaseShaderCompiler,
  2111  		},
  2112  		blocking: true})
  2113  }
  2114  
  2115  func (ctx *context) RenderbufferStorage(target, internalFormat Enum, width, height int) {
  2116  	defer func() {
  2117  		errstr := ctx.errDrain()
  2118  		log.Printf("gl.RenderbufferStorage(%v, %v, %v, %v) %v", target, internalFormat, width, height, errstr)
  2119  	}()
  2120  	ctx.enqueueDebug(call{
  2121  		args: fnargs{
  2122  			fn: glfnRenderbufferStorage,
  2123  			a0: target.c(),
  2124  			a1: internalFormat.c(),
  2125  			a2: uintptr(width),
  2126  			a3: uintptr(height),
  2127  		},
  2128  		blocking: true})
  2129  }
  2130  
  2131  func (ctx *context) SampleCoverage(value float32, invert bool) {
  2132  	defer func() {
  2133  		errstr := ctx.errDrain()
  2134  		log.Printf("gl.SampleCoverage(%v, %v) %v", value, invert, errstr)
  2135  	}()
  2136  	ctx.enqueueDebug(call{
  2137  		args: fnargs{
  2138  			fn: glfnSampleCoverage,
  2139  			a0: uintptr(math.Float32bits(value)),
  2140  			a1: glBoolean(invert),
  2141  		},
  2142  		blocking: true})
  2143  }
  2144  
  2145  func (ctx *context) Scissor(x, y, width, height int32) {
  2146  	defer func() {
  2147  		errstr := ctx.errDrain()
  2148  		log.Printf("gl.Scissor(%v, %v, %v, %v) %v", x, y, width, height, errstr)
  2149  	}()
  2150  	ctx.enqueueDebug(call{
  2151  		args: fnargs{
  2152  			fn: glfnScissor,
  2153  			a0: uintptr(x),
  2154  			a1: uintptr(y),
  2155  			a2: uintptr(width),
  2156  			a3: uintptr(height),
  2157  		},
  2158  		blocking: true})
  2159  }
  2160  
  2161  func (ctx *context) ShaderSource(s Shader, src string) {
  2162  	defer func() {
  2163  		errstr := ctx.errDrain()
  2164  		log.Printf("gl.ShaderSource(%v, %v) %v", s, src, errstr)
  2165  	}()
  2166  	strp, free := ctx.cStringPtr(src)
  2167  	defer free()
  2168  	ctx.enqueueDebug(call{
  2169  		args: fnargs{
  2170  			fn: glfnShaderSource,
  2171  			a0: s.c(),
  2172  			a1: 1,
  2173  			a2: strp,
  2174  		},
  2175  		blocking: true,
  2176  	})
  2177  }
  2178  
  2179  func (ctx *context) StencilFunc(fn Enum, ref int, mask uint32) {
  2180  	defer func() {
  2181  		errstr := ctx.errDrain()
  2182  		log.Printf("gl.StencilFunc(%v, %v, %v) %v", fn, ref, mask, errstr)
  2183  	}()
  2184  	ctx.enqueueDebug(call{
  2185  		args: fnargs{
  2186  			fn: glfnStencilFunc,
  2187  			a0: fn.c(),
  2188  			a1: uintptr(ref),
  2189  			a2: uintptr(mask),
  2190  		},
  2191  		blocking: true})
  2192  }
  2193  
  2194  func (ctx *context) StencilFuncSeparate(face, fn Enum, ref int, mask uint32) {
  2195  	defer func() {
  2196  		errstr := ctx.errDrain()
  2197  		log.Printf("gl.StencilFuncSeparate(%v, %v, %v, %v) %v", face, fn, ref, mask, errstr)
  2198  	}()
  2199  	ctx.enqueueDebug(call{
  2200  		args: fnargs{
  2201  			fn: glfnStencilFuncSeparate,
  2202  			a0: face.c(),
  2203  			a1: fn.c(),
  2204  			a2: uintptr(ref),
  2205  			a3: uintptr(mask),
  2206  		},
  2207  		blocking: true})
  2208  }
  2209  
  2210  func (ctx *context) StencilMask(mask uint32) {
  2211  	defer func() {
  2212  		errstr := ctx.errDrain()
  2213  		log.Printf("gl.StencilMask(%v) %v", mask, errstr)
  2214  	}()
  2215  	ctx.enqueueDebug(call{
  2216  		args: fnargs{
  2217  			fn: glfnStencilMask,
  2218  			a0: uintptr(mask),
  2219  		},
  2220  		blocking: true})
  2221  }
  2222  
  2223  func (ctx *context) StencilMaskSeparate(face Enum, mask uint32) {
  2224  	defer func() {
  2225  		errstr := ctx.errDrain()
  2226  		log.Printf("gl.StencilMaskSeparate(%v, %v) %v", face, mask, errstr)
  2227  	}()
  2228  	ctx.enqueueDebug(call{
  2229  		args: fnargs{
  2230  			fn: glfnStencilMaskSeparate,
  2231  			a0: face.c(),
  2232  			a1: uintptr(mask),
  2233  		},
  2234  		blocking: true})
  2235  }
  2236  
  2237  func (ctx *context) StencilOp(fail, zfail, zpass Enum) {
  2238  	defer func() {
  2239  		errstr := ctx.errDrain()
  2240  		log.Printf("gl.StencilOp(%v, %v, %v) %v", fail, zfail, zpass, errstr)
  2241  	}()
  2242  	ctx.enqueueDebug(call{
  2243  		args: fnargs{
  2244  			fn: glfnStencilOp,
  2245  			a0: fail.c(),
  2246  			a1: zfail.c(),
  2247  			a2: zpass.c(),
  2248  		},
  2249  		blocking: true})
  2250  }
  2251  
  2252  func (ctx *context) StencilOpSeparate(face, sfail, dpfail, dppass Enum) {
  2253  	defer func() {
  2254  		errstr := ctx.errDrain()
  2255  		log.Printf("gl.StencilOpSeparate(%v, %v, %v, %v) %v", face, sfail, dpfail, dppass, errstr)
  2256  	}()
  2257  	ctx.enqueueDebug(call{
  2258  		args: fnargs{
  2259  			fn: glfnStencilOpSeparate,
  2260  			a0: face.c(),
  2261  			a1: sfail.c(),
  2262  			a2: dpfail.c(),
  2263  			a3: dppass.c(),
  2264  		},
  2265  		blocking: true})
  2266  }
  2267  
  2268  func (ctx *context) TexImage2D(target Enum, level int, width, height int, format Enum, ty Enum, data []byte) {
  2269  	defer func() {
  2270  		errstr := ctx.errDrain()
  2271  		log.Printf("gl.TexImage2D(%v, %v, %v, %v, %v, %v, len(%d)) %v", target, level, width, height, format, ty, len(data), errstr)
  2272  	}()
  2273  	parg := unsafe.Pointer(nil)
  2274  	if len(data) > 0 {
  2275  		parg = unsafe.Pointer(&data[0])
  2276  	}
  2277  	ctx.enqueueDebug(call{
  2278  		args: fnargs{
  2279  			fn: glfnTexImage2D,
  2280  
  2281  			a0: target.c(),
  2282  			a1: uintptr(level),
  2283  			a2: uintptr(format),
  2284  			a3: uintptr(width),
  2285  			a4: uintptr(height),
  2286  			a5: format.c(),
  2287  			a6: ty.c(),
  2288  		},
  2289  		parg:     parg,
  2290  		blocking: true,
  2291  	})
  2292  }
  2293  
  2294  func (ctx *context) TexSubImage2D(target Enum, level int, x, y, width, height int, format, ty Enum, data []byte) {
  2295  	defer func() {
  2296  		errstr := ctx.errDrain()
  2297  		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)
  2298  	}()
  2299  	ctx.enqueueDebug(call{
  2300  		args: fnargs{
  2301  			fn: glfnTexSubImage2D,
  2302  
  2303  			a0: target.c(),
  2304  			a1: uintptr(level),
  2305  			a2: uintptr(x),
  2306  			a3: uintptr(y),
  2307  			a4: uintptr(width),
  2308  			a5: uintptr(height),
  2309  			a6: format.c(),
  2310  			a7: ty.c(),
  2311  		},
  2312  		parg:     unsafe.Pointer(&data[0]),
  2313  		blocking: true,
  2314  	})
  2315  }
  2316  
  2317  func (ctx *context) TexParameterf(target, pname Enum, param float32) {
  2318  	defer func() {
  2319  		errstr := ctx.errDrain()
  2320  		log.Printf("gl.TexParameterf(%v, %v, %v) %v", target, pname, param, errstr)
  2321  	}()
  2322  	ctx.enqueueDebug(call{
  2323  		args: fnargs{
  2324  			fn: glfnTexParameterf,
  2325  			a0: target.c(),
  2326  			a1: pname.c(),
  2327  			a2: uintptr(math.Float32bits(param)),
  2328  		},
  2329  		blocking: true})
  2330  }
  2331  
  2332  func (ctx *context) TexParameterfv(target, pname Enum, params []float32) {
  2333  	defer func() {
  2334  		errstr := ctx.errDrain()
  2335  		log.Printf("gl.TexParameterfv(%v, %v, len(%d)) %v", target, pname, len(params), errstr)
  2336  	}()
  2337  	ctx.enqueueDebug(call{
  2338  		args: fnargs{
  2339  			fn: glfnTexParameterfv,
  2340  			a0: target.c(),
  2341  			a1: pname.c(),
  2342  		},
  2343  		parg:     unsafe.Pointer(&params[0]),
  2344  		blocking: true,
  2345  	})
  2346  }
  2347  
  2348  func (ctx *context) TexParameteri(target, pname Enum, param int) {
  2349  	defer func() {
  2350  		errstr := ctx.errDrain()
  2351  		log.Printf("gl.TexParameteri(%v, %v, %v) %v", target, pname, param, errstr)
  2352  	}()
  2353  	ctx.enqueueDebug(call{
  2354  		args: fnargs{
  2355  			fn: glfnTexParameteri,
  2356  			a0: target.c(),
  2357  			a1: pname.c(),
  2358  			a2: uintptr(param),
  2359  		},
  2360  		blocking: true})
  2361  }
  2362  
  2363  func (ctx *context) TexParameteriv(target, pname Enum, params []int32) {
  2364  	defer func() {
  2365  		errstr := ctx.errDrain()
  2366  		log.Printf("gl.TexParameteriv(%v, %v, %v) %v", target, pname, params, errstr)
  2367  	}()
  2368  	ctx.enqueueDebug(call{
  2369  		args: fnargs{
  2370  			fn: glfnTexParameteriv,
  2371  			a0: target.c(),
  2372  			a1: pname.c(),
  2373  		},
  2374  		parg:     unsafe.Pointer(&params[0]),
  2375  		blocking: true,
  2376  	})
  2377  }
  2378  
  2379  func (ctx *context) Uniform1f(dst Uniform, v float32) {
  2380  	defer func() {
  2381  		errstr := ctx.errDrain()
  2382  		log.Printf("gl.Uniform1f(%v, %v) %v", dst, v, errstr)
  2383  	}()
  2384  	ctx.enqueueDebug(call{
  2385  		args: fnargs{
  2386  			fn: glfnUniform1f,
  2387  			a0: dst.c(),
  2388  			a1: uintptr(math.Float32bits(v)),
  2389  		},
  2390  		blocking: true})
  2391  }
  2392  
  2393  func (ctx *context) Uniform1fv(dst Uniform, src []float32) {
  2394  	defer func() {
  2395  		errstr := ctx.errDrain()
  2396  		log.Printf("gl.Uniform1fv(%v, len(%d)) %v", dst, len(src), errstr)
  2397  	}()
  2398  	ctx.enqueueDebug(call{
  2399  		args: fnargs{
  2400  			fn: glfnUniform1fv,
  2401  			a0: dst.c(),
  2402  			a1: uintptr(len(src)),
  2403  		},
  2404  		parg:     unsafe.Pointer(&src[0]),
  2405  		blocking: true,
  2406  	})
  2407  }
  2408  
  2409  func (ctx *context) Uniform1i(dst Uniform, v int) {
  2410  	defer func() {
  2411  		errstr := ctx.errDrain()
  2412  		log.Printf("gl.Uniform1i(%v, %v) %v", dst, v, errstr)
  2413  	}()
  2414  	ctx.enqueueDebug(call{
  2415  		args: fnargs{
  2416  			fn: glfnUniform1i,
  2417  			a0: dst.c(),
  2418  			a1: uintptr(v),
  2419  		},
  2420  		blocking: true})
  2421  }
  2422  
  2423  func (ctx *context) Uniform1iv(dst Uniform, src []int32) {
  2424  	defer func() {
  2425  		errstr := ctx.errDrain()
  2426  		log.Printf("gl.Uniform1iv(%v, %v) %v", dst, src, errstr)
  2427  	}()
  2428  	ctx.enqueueDebug(call{
  2429  		args: fnargs{
  2430  			fn: glfnUniform1iv,
  2431  			a0: dst.c(),
  2432  			a1: uintptr(len(src)),
  2433  		},
  2434  		parg:     unsafe.Pointer(&src[0]),
  2435  		blocking: true,
  2436  	})
  2437  }
  2438  
  2439  func (ctx *context) Uniform2f(dst Uniform, v0, v1 float32) {
  2440  	defer func() {
  2441  		errstr := ctx.errDrain()
  2442  		log.Printf("gl.Uniform2f(%v, %v, %v) %v", dst, v0, v1, errstr)
  2443  	}()
  2444  	ctx.enqueueDebug(call{
  2445  		args: fnargs{
  2446  			fn: glfnUniform2f,
  2447  			a0: dst.c(),
  2448  			a1: uintptr(math.Float32bits(v0)),
  2449  			a2: uintptr(math.Float32bits(v1)),
  2450  		},
  2451  		blocking: true})
  2452  }
  2453  
  2454  func (ctx *context) Uniform2fv(dst Uniform, src []float32) {
  2455  	defer func() {
  2456  		errstr := ctx.errDrain()
  2457  		log.Printf("gl.Uniform2fv(%v, len(%d)) %v", dst, len(src), errstr)
  2458  	}()
  2459  	ctx.enqueueDebug(call{
  2460  		args: fnargs{
  2461  			fn: glfnUniform2fv,
  2462  			a0: dst.c(),
  2463  			a1: uintptr(len(src) / 2),
  2464  		},
  2465  		parg:     unsafe.Pointer(&src[0]),
  2466  		blocking: true,
  2467  	})
  2468  }
  2469  
  2470  func (ctx *context) Uniform2i(dst Uniform, v0, v1 int) {
  2471  	defer func() {
  2472  		errstr := ctx.errDrain()
  2473  		log.Printf("gl.Uniform2i(%v, %v, %v) %v", dst, v0, v1, errstr)
  2474  	}()
  2475  	ctx.enqueueDebug(call{
  2476  		args: fnargs{
  2477  			fn: glfnUniform2i,
  2478  			a0: dst.c(),
  2479  			a1: uintptr(v0),
  2480  			a2: uintptr(v1),
  2481  		},
  2482  		blocking: true})
  2483  }
  2484  
  2485  func (ctx *context) Uniform2iv(dst Uniform, src []int32) {
  2486  	defer func() {
  2487  		errstr := ctx.errDrain()
  2488  		log.Printf("gl.Uniform2iv(%v, %v) %v", dst, src, errstr)
  2489  	}()
  2490  	ctx.enqueueDebug(call{
  2491  		args: fnargs{
  2492  			fn: glfnUniform2iv,
  2493  			a0: dst.c(),
  2494  			a1: uintptr(len(src) / 2),
  2495  		},
  2496  		parg:     unsafe.Pointer(&src[0]),
  2497  		blocking: true,
  2498  	})
  2499  }
  2500  
  2501  func (ctx *context) Uniform3f(dst Uniform, v0, v1, v2 float32) {
  2502  	defer func() {
  2503  		errstr := ctx.errDrain()
  2504  		log.Printf("gl.Uniform3f(%v, %v, %v, %v) %v", dst, v0, v1, v2, errstr)
  2505  	}()
  2506  	ctx.enqueueDebug(call{
  2507  		args: fnargs{
  2508  			fn: glfnUniform3f,
  2509  			a0: dst.c(),
  2510  			a1: uintptr(math.Float32bits(v0)),
  2511  			a2: uintptr(math.Float32bits(v1)),
  2512  			a3: uintptr(math.Float32bits(v2)),
  2513  		},
  2514  		blocking: true})
  2515  }
  2516  
  2517  func (ctx *context) Uniform3fv(dst Uniform, src []float32) {
  2518  	defer func() {
  2519  		errstr := ctx.errDrain()
  2520  		log.Printf("gl.Uniform3fv(%v, len(%d)) %v", dst, len(src), errstr)
  2521  	}()
  2522  	ctx.enqueueDebug(call{
  2523  		args: fnargs{
  2524  			fn: glfnUniform3fv,
  2525  			a0: dst.c(),
  2526  			a1: uintptr(len(src) / 3),
  2527  		},
  2528  		parg:     unsafe.Pointer(&src[0]),
  2529  		blocking: true,
  2530  	})
  2531  }
  2532  
  2533  func (ctx *context) Uniform3i(dst Uniform, v0, v1, v2 int32) {
  2534  	defer func() {
  2535  		errstr := ctx.errDrain()
  2536  		log.Printf("gl.Uniform3i(%v, %v, %v, %v) %v", dst, v0, v1, v2, errstr)
  2537  	}()
  2538  	ctx.enqueueDebug(call{
  2539  		args: fnargs{
  2540  			fn: glfnUniform3i,
  2541  			a0: dst.c(),
  2542  			a1: uintptr(v0),
  2543  			a2: uintptr(v1),
  2544  			a3: uintptr(v2),
  2545  		},
  2546  		blocking: true})
  2547  }
  2548  
  2549  func (ctx *context) Uniform3iv(dst Uniform, src []int32) {
  2550  	defer func() {
  2551  		errstr := ctx.errDrain()
  2552  		log.Printf("gl.Uniform3iv(%v, %v) %v", dst, src, errstr)
  2553  	}()
  2554  	ctx.enqueueDebug(call{
  2555  		args: fnargs{
  2556  			fn: glfnUniform3iv,
  2557  			a0: dst.c(),
  2558  			a1: uintptr(len(src) / 3),
  2559  		},
  2560  		parg:     unsafe.Pointer(&src[0]),
  2561  		blocking: true,
  2562  	})
  2563  }
  2564  
  2565  func (ctx *context) Uniform4f(dst Uniform, v0, v1, v2, v3 float32) {
  2566  	defer func() {
  2567  		errstr := ctx.errDrain()
  2568  		log.Printf("gl.Uniform4f(%v, %v, %v, %v, %v) %v", dst, v0, v1, v2, v3, errstr)
  2569  	}()
  2570  	ctx.enqueueDebug(call{
  2571  		args: fnargs{
  2572  			fn: glfnUniform4f,
  2573  			a0: dst.c(),
  2574  			a1: uintptr(math.Float32bits(v0)),
  2575  			a2: uintptr(math.Float32bits(v1)),
  2576  			a3: uintptr(math.Float32bits(v2)),
  2577  			a4: uintptr(math.Float32bits(v3)),
  2578  		},
  2579  		blocking: true})
  2580  }
  2581  
  2582  func (ctx *context) Uniform4fv(dst Uniform, src []float32) {
  2583  	defer func() {
  2584  		errstr := ctx.errDrain()
  2585  		log.Printf("gl.Uniform4fv(%v, len(%d)) %v", dst, len(src), errstr)
  2586  	}()
  2587  	ctx.enqueueDebug(call{
  2588  		args: fnargs{
  2589  			fn: glfnUniform4fv,
  2590  			a0: dst.c(),
  2591  			a1: uintptr(len(src) / 4),
  2592  		},
  2593  		parg:     unsafe.Pointer(&src[0]),
  2594  		blocking: true,
  2595  	})
  2596  }
  2597  
  2598  func (ctx *context) Uniform4i(dst Uniform, v0, v1, v2, v3 int32) {
  2599  	defer func() {
  2600  		errstr := ctx.errDrain()
  2601  		log.Printf("gl.Uniform4i(%v, %v, %v, %v, %v) %v", dst, v0, v1, v2, v3, errstr)
  2602  	}()
  2603  	ctx.enqueueDebug(call{
  2604  		args: fnargs{
  2605  			fn: glfnUniform4i,
  2606  			a0: dst.c(),
  2607  			a1: uintptr(v0),
  2608  			a2: uintptr(v1),
  2609  			a3: uintptr(v2),
  2610  			a4: uintptr(v3),
  2611  		},
  2612  		blocking: true})
  2613  }
  2614  
  2615  func (ctx *context) Uniform4iv(dst Uniform, src []int32) {
  2616  	defer func() {
  2617  		errstr := ctx.errDrain()
  2618  		log.Printf("gl.Uniform4iv(%v, %v) %v", dst, src, errstr)
  2619  	}()
  2620  	ctx.enqueueDebug(call{
  2621  		args: fnargs{
  2622  			fn: glfnUniform4iv,
  2623  			a0: dst.c(),
  2624  			a1: uintptr(len(src) / 4),
  2625  		},
  2626  		parg:     unsafe.Pointer(&src[0]),
  2627  		blocking: true,
  2628  	})
  2629  }
  2630  
  2631  func (ctx *context) UniformMatrix2fv(dst Uniform, src []float32) {
  2632  	defer func() {
  2633  		errstr := ctx.errDrain()
  2634  		log.Printf("gl.UniformMatrix2fv(%v, len(%d)) %v", dst, len(src), errstr)
  2635  	}()
  2636  	ctx.enqueueDebug(call{
  2637  		args: fnargs{
  2638  			fn: glfnUniformMatrix2fv,
  2639  
  2640  			a0: dst.c(),
  2641  			a1: uintptr(len(src) / 4),
  2642  		},
  2643  		parg:     unsafe.Pointer(&src[0]),
  2644  		blocking: true,
  2645  	})
  2646  }
  2647  
  2648  func (ctx *context) UniformMatrix3fv(dst Uniform, src []float32) {
  2649  	defer func() {
  2650  		errstr := ctx.errDrain()
  2651  		log.Printf("gl.UniformMatrix3fv(%v, len(%d)) %v", dst, len(src), errstr)
  2652  	}()
  2653  	ctx.enqueueDebug(call{
  2654  		args: fnargs{
  2655  			fn: glfnUniformMatrix3fv,
  2656  			a0: dst.c(),
  2657  			a1: uintptr(len(src) / 9),
  2658  		},
  2659  		parg:     unsafe.Pointer(&src[0]),
  2660  		blocking: true,
  2661  	})
  2662  }
  2663  
  2664  func (ctx *context) UniformMatrix4fv(dst Uniform, src []float32) {
  2665  	defer func() {
  2666  		errstr := ctx.errDrain()
  2667  		log.Printf("gl.UniformMatrix4fv(%v, len(%d)) %v", dst, len(src), errstr)
  2668  	}()
  2669  	ctx.enqueueDebug(call{
  2670  		args: fnargs{
  2671  			fn: glfnUniformMatrix4fv,
  2672  			a0: dst.c(),
  2673  			a1: uintptr(len(src) / 16),
  2674  		},
  2675  		parg:     unsafe.Pointer(&src[0]),
  2676  		blocking: true,
  2677  	})
  2678  }
  2679  
  2680  func (ctx *context) UseProgram(p Program) {
  2681  	defer func() {
  2682  		errstr := ctx.errDrain()
  2683  		log.Printf("gl.UseProgram(%v) %v", p, errstr)
  2684  	}()
  2685  	ctx.enqueueDebug(call{
  2686  		args: fnargs{
  2687  			fn: glfnUseProgram,
  2688  			a0: p.c(),
  2689  		},
  2690  		blocking: true})
  2691  }
  2692  
  2693  func (ctx *context) ValidateProgram(p Program) {
  2694  	defer func() {
  2695  		errstr := ctx.errDrain()
  2696  		log.Printf("gl.ValidateProgram(%v) %v", p, errstr)
  2697  	}()
  2698  	ctx.enqueueDebug(call{
  2699  		args: fnargs{
  2700  			fn: glfnValidateProgram,
  2701  			a0: p.c(),
  2702  		},
  2703  		blocking: true})
  2704  }
  2705  
  2706  func (ctx *context) VertexAttrib1f(dst Attrib, x float32) {
  2707  	defer func() {
  2708  		errstr := ctx.errDrain()
  2709  		log.Printf("gl.VertexAttrib1f(%v, %v) %v", dst, x, errstr)
  2710  	}()
  2711  	ctx.enqueueDebug(call{
  2712  		args: fnargs{
  2713  			fn: glfnVertexAttrib1f,
  2714  			a0: dst.c(),
  2715  			a1: uintptr(math.Float32bits(x)),
  2716  		},
  2717  		blocking: true})
  2718  }
  2719  
  2720  func (ctx *context) VertexAttrib1fv(dst Attrib, src []float32) {
  2721  	defer func() {
  2722  		errstr := ctx.errDrain()
  2723  		log.Printf("gl.VertexAttrib1fv(%v, len(%d)) %v", dst, len(src), errstr)
  2724  	}()
  2725  	ctx.enqueueDebug(call{
  2726  		args: fnargs{
  2727  			fn: glfnVertexAttrib1fv,
  2728  			a0: dst.c(),
  2729  		},
  2730  		parg:     unsafe.Pointer(&src[0]),
  2731  		blocking: true,
  2732  	})
  2733  }
  2734  
  2735  func (ctx *context) VertexAttrib2f(dst Attrib, x, y float32) {
  2736  	defer func() {
  2737  		errstr := ctx.errDrain()
  2738  		log.Printf("gl.VertexAttrib2f(%v, %v, %v) %v", dst, x, y, errstr)
  2739  	}()
  2740  	ctx.enqueueDebug(call{
  2741  		args: fnargs{
  2742  			fn: glfnVertexAttrib2f,
  2743  			a0: dst.c(),
  2744  			a1: uintptr(math.Float32bits(x)),
  2745  			a2: uintptr(math.Float32bits(y)),
  2746  		},
  2747  		blocking: true})
  2748  }
  2749  
  2750  func (ctx *context) VertexAttrib2fv(dst Attrib, src []float32) {
  2751  	defer func() {
  2752  		errstr := ctx.errDrain()
  2753  		log.Printf("gl.VertexAttrib2fv(%v, len(%d)) %v", dst, len(src), errstr)
  2754  	}()
  2755  	ctx.enqueueDebug(call{
  2756  		args: fnargs{
  2757  			fn: glfnVertexAttrib2fv,
  2758  			a0: dst.c(),
  2759  		},
  2760  		parg:     unsafe.Pointer(&src[0]),
  2761  		blocking: true,
  2762  	})
  2763  }
  2764  
  2765  func (ctx *context) VertexAttrib3f(dst Attrib, x, y, z float32) {
  2766  	defer func() {
  2767  		errstr := ctx.errDrain()
  2768  		log.Printf("gl.VertexAttrib3f(%v, %v, %v, %v) %v", dst, x, y, z, errstr)
  2769  	}()
  2770  	ctx.enqueueDebug(call{
  2771  		args: fnargs{
  2772  			fn: glfnVertexAttrib3f,
  2773  			a0: dst.c(),
  2774  			a1: uintptr(math.Float32bits(x)),
  2775  			a2: uintptr(math.Float32bits(y)),
  2776  			a3: uintptr(math.Float32bits(z)),
  2777  		},
  2778  		blocking: true})
  2779  }
  2780  
  2781  func (ctx *context) VertexAttrib3fv(dst Attrib, src []float32) {
  2782  	defer func() {
  2783  		errstr := ctx.errDrain()
  2784  		log.Printf("gl.VertexAttrib3fv(%v, len(%d)) %v", dst, len(src), errstr)
  2785  	}()
  2786  	ctx.enqueueDebug(call{
  2787  		args: fnargs{
  2788  			fn: glfnVertexAttrib3fv,
  2789  			a0: dst.c(),
  2790  		},
  2791  		parg:     unsafe.Pointer(&src[0]),
  2792  		blocking: true,
  2793  	})
  2794  }
  2795  
  2796  func (ctx *context) VertexAttrib4f(dst Attrib, x, y, z, w float32) {
  2797  	defer func() {
  2798  		errstr := ctx.errDrain()
  2799  		log.Printf("gl.VertexAttrib4f(%v, %v, %v, %v, %v) %v", dst, x, y, z, w, errstr)
  2800  	}()
  2801  	ctx.enqueueDebug(call{
  2802  		args: fnargs{
  2803  			fn: glfnVertexAttrib4f,
  2804  			a0: dst.c(),
  2805  			a1: uintptr(math.Float32bits(x)),
  2806  			a2: uintptr(math.Float32bits(y)),
  2807  			a3: uintptr(math.Float32bits(z)),
  2808  			a4: uintptr(math.Float32bits(w)),
  2809  		},
  2810  		blocking: true})
  2811  }
  2812  
  2813  func (ctx *context) VertexAttrib4fv(dst Attrib, src []float32) {
  2814  	defer func() {
  2815  		errstr := ctx.errDrain()
  2816  		log.Printf("gl.VertexAttrib4fv(%v, len(%d)) %v", dst, len(src), errstr)
  2817  	}()
  2818  	ctx.enqueueDebug(call{
  2819  		args: fnargs{
  2820  			fn: glfnVertexAttrib4fv,
  2821  			a0: dst.c(),
  2822  		},
  2823  		parg:     unsafe.Pointer(&src[0]),
  2824  		blocking: true,
  2825  	})
  2826  }
  2827  
  2828  func (ctx *context) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int) {
  2829  	defer func() {
  2830  		errstr := ctx.errDrain()
  2831  		log.Printf("gl.VertexAttribPointer(%v, %v, %v, %v, %v, %v) %v", dst, size, ty, normalized, stride, offset, errstr)
  2832  	}()
  2833  	ctx.enqueueDebug(call{
  2834  		args: fnargs{
  2835  			fn: glfnVertexAttribPointer,
  2836  			a0: dst.c(),
  2837  			a1: uintptr(size),
  2838  			a2: ty.c(),
  2839  			a3: glBoolean(normalized),
  2840  			a4: uintptr(stride),
  2841  			a5: uintptr(offset),
  2842  		},
  2843  		blocking: true})
  2844  }
  2845  
  2846  func (ctx *context) Viewport(x, y, width, height int) {
  2847  	defer func() {
  2848  		errstr := ctx.errDrain()
  2849  		log.Printf("gl.Viewport(%v, %v, %v, %v) %v", x, y, width, height, errstr)
  2850  	}()
  2851  	ctx.enqueueDebug(call{
  2852  		args: fnargs{
  2853  			fn: glfnViewport,
  2854  			a0: uintptr(x),
  2855  			a1: uintptr(y),
  2856  			a2: uintptr(width),
  2857  			a3: uintptr(height),
  2858  		},
  2859  		blocking: true})
  2860  }