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(¶ms[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(¶ms[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 }