github.com/corfe83/mobile@v0.0.0-20220928034243-9edc37f43fac/gl/gl.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 //go:build (darwin || linux || openbsd || windows) && !gldebug 6 // +build darwin linux openbsd windows 7 // +build !gldebug 8 9 package gl 10 11 // TODO(crawshaw): should functions on specific types become methods? E.g. 12 // func (t Texture) Bind(target Enum) 13 // this seems natural in Go, but moves us slightly 14 // further away from the underlying OpenGL spec. 15 16 import ( 17 "math" 18 "unsafe" 19 ) 20 21 func (ctx *context) ActiveTexture(texture Enum) { 22 ctx.enqueue(call{ 23 args: fnargs{ 24 fn: glfnActiveTexture, 25 a0: texture.c(), 26 }, 27 }) 28 } 29 30 func (ctx *context) AttachShader(p Program, s Shader) { 31 ctx.enqueue(call{ 32 args: fnargs{ 33 fn: glfnAttachShader, 34 a0: p.c(), 35 a1: s.c(), 36 }, 37 }) 38 } 39 40 func (ctx *context) BindAttribLocation(p Program, a Attrib, name string) { 41 s, free := ctx.cString(name) 42 defer free() 43 ctx.enqueue(call{ 44 args: fnargs{ 45 fn: glfnBindAttribLocation, 46 a0: p.c(), 47 a1: a.c(), 48 a2: s, 49 }, 50 blocking: true, 51 }) 52 } 53 54 func (ctx *context) BindBuffer(target Enum, b Buffer) { 55 ctx.enqueue(call{ 56 args: fnargs{ 57 fn: glfnBindBuffer, 58 a0: target.c(), 59 a1: b.c(), 60 }, 61 }) 62 } 63 64 func (ctx *context) BindFramebuffer(target Enum, fb Framebuffer) { 65 ctx.enqueue(call{ 66 args: fnargs{ 67 fn: glfnBindFramebuffer, 68 a0: target.c(), 69 a1: fb.c(), 70 }, 71 }) 72 } 73 74 func (ctx *context) BindRenderbuffer(target Enum, rb Renderbuffer) { 75 ctx.enqueue(call{ 76 args: fnargs{ 77 fn: glfnBindRenderbuffer, 78 a0: target.c(), 79 a1: rb.c(), 80 }, 81 }) 82 } 83 84 func (ctx *context) BindTexture(target Enum, t Texture) { 85 ctx.enqueue(call{ 86 args: fnargs{ 87 fn: glfnBindTexture, 88 a0: target.c(), 89 a1: t.c(), 90 }, 91 }) 92 } 93 94 func (ctx *context) BindVertexArray(va VertexArray) { 95 ctx.enqueue(call{ 96 args: fnargs{ 97 fn: glfnBindVertexArray, 98 a0: va.c(), 99 }, 100 }) 101 } 102 103 func (ctx *context) BlendColor(red, green, blue, alpha float32) { 104 ctx.enqueue(call{ 105 args: fnargs{ 106 fn: glfnBlendColor, 107 a0: uintptr(math.Float32bits(red)), 108 a1: uintptr(math.Float32bits(green)), 109 a2: uintptr(math.Float32bits(blue)), 110 a3: uintptr(math.Float32bits(alpha)), 111 }, 112 }) 113 } 114 115 func (ctx *context) BlendEquation(mode Enum) { 116 ctx.enqueue(call{ 117 args: fnargs{ 118 fn: glfnBlendEquation, 119 a0: mode.c(), 120 }, 121 }) 122 } 123 124 func (ctx *context) BlendEquationSeparate(modeRGB, modeAlpha Enum) { 125 ctx.enqueue(call{ 126 args: fnargs{ 127 fn: glfnBlendEquationSeparate, 128 a0: modeRGB.c(), 129 a1: modeAlpha.c(), 130 }, 131 }) 132 } 133 134 func (ctx *context) BlendFunc(sfactor, dfactor Enum) { 135 ctx.enqueue(call{ 136 args: fnargs{ 137 fn: glfnBlendFunc, 138 a0: sfactor.c(), 139 a1: dfactor.c(), 140 }, 141 }) 142 } 143 144 func (ctx *context) BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha Enum) { 145 ctx.enqueue(call{ 146 args: fnargs{ 147 fn: glfnBlendFuncSeparate, 148 a0: sfactorRGB.c(), 149 a1: dfactorRGB.c(), 150 a2: sfactorAlpha.c(), 151 a3: dfactorAlpha.c(), 152 }, 153 }) 154 } 155 156 func (ctx *context) BufferData(target Enum, src []byte, usage Enum) { 157 parg := unsafe.Pointer(nil) 158 if len(src) > 0 { 159 parg = unsafe.Pointer(&src[0]) 160 } 161 ctx.enqueue(call{ 162 args: fnargs{ 163 fn: glfnBufferData, 164 a0: target.c(), 165 a1: uintptr(len(src)), 166 a2: usage.c(), 167 }, 168 parg: parg, 169 blocking: true, 170 }) 171 } 172 173 func (ctx *context) BufferInit(target Enum, size int, usage Enum) { 174 ctx.enqueue(call{ 175 args: fnargs{ 176 fn: glfnBufferData, 177 a0: target.c(), 178 a1: uintptr(size), 179 a2: usage.c(), 180 }, 181 parg: unsafe.Pointer(nil), 182 }) 183 } 184 185 func (ctx *context) BufferSubData(target Enum, offset int, data []byte) { 186 ctx.enqueue(call{ 187 args: fnargs{ 188 fn: glfnBufferSubData, 189 a0: target.c(), 190 a1: uintptr(offset), 191 a2: uintptr(len(data)), 192 }, 193 parg: unsafe.Pointer(&data[0]), 194 blocking: true, 195 }) 196 } 197 198 func (ctx *context) CheckFramebufferStatus(target Enum) Enum { 199 return Enum(ctx.enqueue(call{ 200 args: fnargs{ 201 fn: glfnCheckFramebufferStatus, 202 a0: target.c(), 203 }, 204 blocking: true, 205 })) 206 } 207 208 func (ctx *context) Clear(mask Enum) { 209 ctx.enqueue(call{ 210 args: fnargs{ 211 fn: glfnClear, 212 a0: uintptr(mask), 213 }, 214 }) 215 } 216 217 func (ctx *context) ClearColor(red, green, blue, alpha float32) { 218 ctx.enqueue(call{ 219 args: fnargs{ 220 fn: glfnClearColor, 221 a0: uintptr(math.Float32bits(red)), 222 a1: uintptr(math.Float32bits(green)), 223 a2: uintptr(math.Float32bits(blue)), 224 a3: uintptr(math.Float32bits(alpha)), 225 }, 226 }) 227 } 228 229 func (ctx *context) ClearDepthf(d float32) { 230 ctx.enqueue(call{ 231 args: fnargs{ 232 fn: glfnClearDepthf, 233 a0: uintptr(math.Float32bits(d)), 234 }, 235 }) 236 } 237 238 func (ctx *context) ClearStencil(s int) { 239 ctx.enqueue(call{ 240 args: fnargs{ 241 fn: glfnClearStencil, 242 a0: uintptr(s), 243 }, 244 }) 245 } 246 247 func (ctx *context) ColorMask(red, green, blue, alpha bool) { 248 ctx.enqueue(call{ 249 args: fnargs{ 250 fn: glfnColorMask, 251 a0: glBoolean(red), 252 a1: glBoolean(green), 253 a2: glBoolean(blue), 254 a3: glBoolean(alpha), 255 }, 256 }) 257 } 258 259 func (ctx *context) CompileShader(s Shader) { 260 ctx.enqueue(call{ 261 args: fnargs{ 262 fn: glfnCompileShader, 263 a0: s.c(), 264 }, 265 }) 266 } 267 268 func (ctx *context) CompressedTexImage2D(target Enum, level int, internalformat Enum, width, height, border int, data []byte) { 269 ctx.enqueue(call{ 270 args: fnargs{ 271 fn: glfnCompressedTexImage2D, 272 a0: target.c(), 273 a1: uintptr(level), 274 a2: internalformat.c(), 275 a3: uintptr(width), 276 a4: uintptr(height), 277 a5: uintptr(border), 278 a6: uintptr(len(data)), 279 }, 280 parg: unsafe.Pointer(&data[0]), 281 blocking: true, 282 }) 283 } 284 285 func (ctx *context) CompressedTexSubImage2D(target Enum, level, xoffset, yoffset, width, height int, format Enum, data []byte) { 286 ctx.enqueue(call{ 287 args: fnargs{ 288 fn: glfnCompressedTexSubImage2D, 289 a0: target.c(), 290 a1: uintptr(level), 291 a2: uintptr(xoffset), 292 a3: uintptr(yoffset), 293 a4: uintptr(width), 294 a5: uintptr(height), 295 a6: format.c(), 296 a7: uintptr(len(data)), 297 }, 298 parg: unsafe.Pointer(&data[0]), 299 blocking: true, 300 }) 301 } 302 303 func (ctx *context) CopyTexImage2D(target Enum, level int, internalformat Enum, x, y, width, height, border int) { 304 ctx.enqueue(call{ 305 args: fnargs{ 306 fn: glfnCopyTexImage2D, 307 a0: target.c(), 308 a1: uintptr(level), 309 a2: internalformat.c(), 310 a3: uintptr(x), 311 a4: uintptr(y), 312 a5: uintptr(width), 313 a6: uintptr(height), 314 a7: uintptr(border), 315 }, 316 }) 317 } 318 319 func (ctx *context) CopyTexSubImage2D(target Enum, level, xoffset, yoffset, x, y, width, height int) { 320 ctx.enqueue(call{ 321 args: fnargs{ 322 fn: glfnCopyTexSubImage2D, 323 a0: target.c(), 324 a1: uintptr(level), 325 a2: uintptr(xoffset), 326 a3: uintptr(yoffset), 327 a4: uintptr(x), 328 a5: uintptr(y), 329 a6: uintptr(width), 330 a7: uintptr(height), 331 }, 332 }) 333 } 334 335 func (ctx *context) CreateBuffer() Buffer { 336 return Buffer{Value: uint32(ctx.enqueue(call{ 337 args: fnargs{ 338 fn: glfnGenBuffer, 339 }, 340 blocking: true, 341 }))} 342 } 343 344 func (ctx *context) CreateFramebuffer() Framebuffer { 345 return Framebuffer{Value: uint32(ctx.enqueue(call{ 346 args: fnargs{ 347 fn: glfnGenFramebuffer, 348 }, 349 blocking: true, 350 }))} 351 } 352 353 func (ctx *context) CreateProgram() Program { 354 return Program{ 355 Init: true, 356 Value: uint32(ctx.enqueue(call{ 357 args: fnargs{ 358 fn: glfnCreateProgram, 359 }, 360 blocking: true, 361 }, 362 ))} 363 } 364 365 func (ctx *context) CreateRenderbuffer() Renderbuffer { 366 return Renderbuffer{Value: uint32(ctx.enqueue(call{ 367 args: fnargs{ 368 fn: glfnGenRenderbuffer, 369 }, 370 blocking: true, 371 }))} 372 } 373 374 func (ctx *context) CreateShader(ty Enum) Shader { 375 return Shader{Value: uint32(ctx.enqueue(call{ 376 args: fnargs{ 377 fn: glfnCreateShader, 378 a0: uintptr(ty), 379 }, 380 blocking: true, 381 }))} 382 } 383 384 func (ctx *context) CreateTexture() Texture { 385 return Texture{Value: uint32(ctx.enqueue(call{ 386 args: fnargs{ 387 fn: glfnGenTexture, 388 }, 389 blocking: true, 390 }))} 391 } 392 393 func (ctx *context) CreateVertexArray() VertexArray { 394 return VertexArray{Value: uint32(ctx.enqueue(call{ 395 args: fnargs{ 396 fn: glfnGenVertexArray, 397 }, 398 blocking: true, 399 }))} 400 } 401 402 func (ctx *context) CullFace(mode Enum) { 403 ctx.enqueue(call{ 404 args: fnargs{ 405 fn: glfnCullFace, 406 a0: mode.c(), 407 }, 408 }) 409 } 410 411 func (ctx *context) DeleteBuffer(v Buffer) { 412 ctx.enqueue(call{ 413 args: fnargs{ 414 fn: glfnDeleteBuffer, 415 a0: v.c(), 416 }, 417 }) 418 } 419 420 func (ctx *context) DeleteFramebuffer(v Framebuffer) { 421 ctx.enqueue(call{ 422 args: fnargs{ 423 fn: glfnDeleteFramebuffer, 424 a0: v.c(), 425 }, 426 }) 427 } 428 429 func (ctx *context) DeleteProgram(p Program) { 430 ctx.enqueue(call{ 431 args: fnargs{ 432 fn: glfnDeleteProgram, 433 a0: p.c(), 434 }, 435 }) 436 } 437 438 func (ctx *context) DeleteRenderbuffer(v Renderbuffer) { 439 ctx.enqueue(call{ 440 args: fnargs{ 441 fn: glfnDeleteRenderbuffer, 442 a0: v.c(), 443 }, 444 }) 445 } 446 447 func (ctx *context) DeleteShader(s Shader) { 448 ctx.enqueue(call{ 449 args: fnargs{ 450 fn: glfnDeleteShader, 451 a0: s.c(), 452 }, 453 }) 454 } 455 456 func (ctx *context) DeleteTexture(v Texture) { 457 ctx.enqueue(call{ 458 args: fnargs{ 459 fn: glfnDeleteTexture, 460 a0: v.c(), 461 }, 462 }) 463 } 464 465 func (ctx *context) DeleteVertexArray(v VertexArray) { 466 ctx.enqueue(call{ 467 args: fnargs{ 468 fn: glfnDeleteVertexArray, 469 a0: v.c(), 470 }, 471 }) 472 } 473 474 func (ctx *context) DepthFunc(fn Enum) { 475 ctx.enqueue(call{ 476 args: fnargs{ 477 fn: glfnDepthFunc, 478 a0: fn.c(), 479 }, 480 }) 481 } 482 483 func (ctx *context) DepthMask(flag bool) { 484 ctx.enqueue(call{ 485 args: fnargs{ 486 fn: glfnDepthMask, 487 a0: glBoolean(flag), 488 }, 489 }) 490 } 491 492 func (ctx *context) DepthRangef(n, f float32) { 493 ctx.enqueue(call{ 494 args: fnargs{ 495 fn: glfnDepthRangef, 496 a0: uintptr(math.Float32bits(n)), 497 a1: uintptr(math.Float32bits(f)), 498 }, 499 }) 500 } 501 502 func (ctx *context) DetachShader(p Program, s Shader) { 503 ctx.enqueue(call{ 504 args: fnargs{ 505 fn: glfnDetachShader, 506 a0: p.c(), 507 a1: s.c(), 508 }, 509 }) 510 } 511 512 func (ctx *context) Disable(cap Enum) { 513 ctx.enqueue(call{ 514 args: fnargs{ 515 fn: glfnDisable, 516 a0: cap.c(), 517 }, 518 }) 519 } 520 521 func (ctx *context) DisableVertexAttribArray(a Attrib) { 522 ctx.enqueue(call{ 523 args: fnargs{ 524 fn: glfnDisableVertexAttribArray, 525 a0: a.c(), 526 }, 527 }) 528 } 529 530 func (ctx *context) DrawArrays(mode Enum, first, count int) { 531 ctx.enqueue(call{ 532 args: fnargs{ 533 fn: glfnDrawArrays, 534 a0: mode.c(), 535 a1: uintptr(first), 536 a2: uintptr(count), 537 }, 538 }) 539 } 540 541 func (ctx *context) DrawElements(mode Enum, count int, ty Enum, offset int) { 542 ctx.enqueue(call{ 543 args: fnargs{ 544 fn: glfnDrawElements, 545 a0: mode.c(), 546 a1: uintptr(count), 547 a2: ty.c(), 548 a3: uintptr(offset), 549 }, 550 }) 551 } 552 553 func (ctx *context) Enable(cap Enum) { 554 ctx.enqueue(call{ 555 args: fnargs{ 556 fn: glfnEnable, 557 a0: cap.c(), 558 }, 559 }) 560 } 561 562 func (ctx *context) EnableVertexAttribArray(a Attrib) { 563 ctx.enqueue(call{ 564 args: fnargs{ 565 fn: glfnEnableVertexAttribArray, 566 a0: a.c(), 567 }, 568 }) 569 } 570 571 func (ctx *context) Finish() { 572 ctx.enqueue(call{ 573 args: fnargs{ 574 fn: glfnFinish, 575 }, 576 blocking: true, 577 }) 578 } 579 580 func (ctx *context) Flush() { 581 ctx.enqueue(call{ 582 args: fnargs{ 583 fn: glfnFlush, 584 }, 585 blocking: true, 586 }) 587 } 588 589 func (ctx *context) FramebufferRenderbuffer(target, attachment, rbTarget Enum, rb Renderbuffer) { 590 ctx.enqueue(call{ 591 args: fnargs{ 592 fn: glfnFramebufferRenderbuffer, 593 a0: target.c(), 594 a1: attachment.c(), 595 a2: rbTarget.c(), 596 a3: rb.c(), 597 }, 598 }) 599 } 600 601 func (ctx *context) FramebufferTexture2D(target, attachment, texTarget Enum, t Texture, level int) { 602 ctx.enqueue(call{ 603 args: fnargs{ 604 fn: glfnFramebufferTexture2D, 605 a0: target.c(), 606 a1: attachment.c(), 607 a2: texTarget.c(), 608 a3: t.c(), 609 a4: uintptr(level), 610 }, 611 }) 612 } 613 614 func (ctx *context) FrontFace(mode Enum) { 615 ctx.enqueue(call{ 616 args: fnargs{ 617 fn: glfnFrontFace, 618 a0: mode.c(), 619 }, 620 }) 621 } 622 623 func (ctx *context) GenerateMipmap(target Enum) { 624 ctx.enqueue(call{ 625 args: fnargs{ 626 fn: glfnGenerateMipmap, 627 a0: target.c(), 628 }, 629 }) 630 } 631 632 func (ctx *context) GetActiveAttrib(p Program, index uint32) (name string, size int, ty Enum) { 633 bufSize := ctx.GetProgrami(p, ACTIVE_ATTRIBUTE_MAX_LENGTH) 634 buf := make([]byte, bufSize) 635 var cType int 636 637 cSize := ctx.enqueue(call{ 638 args: fnargs{ 639 fn: glfnGetActiveAttrib, 640 a0: p.c(), 641 a1: uintptr(index), 642 a2: uintptr(bufSize), 643 a3: uintptr(unsafe.Pointer(&cType)), // TODO(crawshaw): not safe for a moving collector 644 }, 645 parg: unsafe.Pointer(&buf[0]), 646 blocking: true, 647 }) 648 649 return goString(buf), int(cSize), Enum(cType) 650 } 651 652 func (ctx *context) GetActiveUniform(p Program, index uint32) (name string, size int, ty Enum) { 653 bufSize := ctx.GetProgrami(p, ACTIVE_UNIFORM_MAX_LENGTH) 654 buf := make([]byte, bufSize+8) // extra space for cType 655 var cType int 656 657 cSize := ctx.enqueue(call{ 658 args: fnargs{ 659 fn: glfnGetActiveUniform, 660 a0: p.c(), 661 a1: uintptr(index), 662 a2: uintptr(bufSize), 663 a3: uintptr(unsafe.Pointer(&cType)), // TODO(crawshaw): not safe for a moving collector 664 }, 665 parg: unsafe.Pointer(&buf[0]), 666 blocking: true, 667 }) 668 669 return goString(buf), int(cSize), Enum(cType) 670 } 671 672 func (ctx *context) GetAttachedShaders(p Program) []Shader { 673 shadersLen := ctx.GetProgrami(p, ATTACHED_SHADERS) 674 if shadersLen == 0 { 675 return nil 676 } 677 buf := make([]uint32, shadersLen) 678 679 n := int(ctx.enqueue(call{ 680 args: fnargs{ 681 fn: glfnGetAttachedShaders, 682 a0: p.c(), 683 a1: uintptr(shadersLen), 684 }, 685 parg: unsafe.Pointer(&buf[0]), 686 blocking: true, 687 })) 688 689 buf = buf[:int(n)] 690 shaders := make([]Shader, len(buf)) 691 for i, s := range buf { 692 shaders[i] = Shader{Value: uint32(s)} 693 } 694 return shaders 695 } 696 697 func (ctx *context) GetAttribLocation(p Program, name string) Attrib { 698 s, free := ctx.cString(name) 699 defer free() 700 return Attrib{Value: uint(ctx.enqueue(call{ 701 args: fnargs{ 702 fn: glfnGetAttribLocation, 703 a0: p.c(), 704 a1: s, 705 }, 706 blocking: true, 707 }))} 708 } 709 710 func (ctx *context) GetBooleanv(dst []bool, pname Enum) { 711 buf := make([]int32, len(dst)) 712 713 ctx.enqueue(call{ 714 args: fnargs{ 715 fn: glfnGetBooleanv, 716 a0: pname.c(), 717 }, 718 parg: unsafe.Pointer(&buf[0]), 719 blocking: true, 720 }) 721 722 for i, v := range buf { 723 dst[i] = v != 0 724 } 725 } 726 727 func (ctx *context) GetFloatv(dst []float32, pname Enum) { 728 ctx.enqueue(call{ 729 args: fnargs{ 730 fn: glfnGetFloatv, 731 a0: pname.c(), 732 }, 733 parg: unsafe.Pointer(&dst[0]), 734 blocking: true, 735 }) 736 } 737 738 func (ctx *context) GetIntegerv(dst []int32, pname Enum) { 739 ctx.enqueue(call{ 740 args: fnargs{ 741 fn: glfnGetIntegerv, 742 a0: pname.c(), 743 }, 744 parg: unsafe.Pointer(&dst[0]), 745 blocking: true, 746 }) 747 } 748 749 func (ctx *context) GetInteger(pname Enum) int { 750 var v [1]int32 751 ctx.GetIntegerv(v[:], pname) 752 return int(v[0]) 753 } 754 755 func (ctx *context) GetBufferParameteri(target, value Enum) int { 756 return int(ctx.enqueue(call{ 757 args: fnargs{ 758 fn: glfnGetBufferParameteri, 759 a0: target.c(), 760 a1: value.c(), 761 }, 762 blocking: true, 763 })) 764 } 765 766 func (ctx *context) GetError() Enum { 767 return Enum(ctx.enqueue(call{ 768 args: fnargs{ 769 fn: glfnGetError, 770 }, 771 blocking: true, 772 })) 773 } 774 775 func (ctx *context) GetFramebufferAttachmentParameteri(target, attachment, pname Enum) int { 776 return int(ctx.enqueue(call{ 777 args: fnargs{ 778 fn: glfnGetFramebufferAttachmentParameteriv, 779 a0: target.c(), 780 a1: attachment.c(), 781 a2: pname.c(), 782 }, 783 blocking: true, 784 })) 785 } 786 787 func (ctx *context) GetProgrami(p Program, pname Enum) int { 788 return int(ctx.enqueue(call{ 789 args: fnargs{ 790 fn: glfnGetProgramiv, 791 a0: p.c(), 792 a1: pname.c(), 793 }, 794 blocking: true, 795 })) 796 } 797 798 func (ctx *context) GetProgramInfoLog(p Program) string { 799 infoLen := ctx.GetProgrami(p, INFO_LOG_LENGTH) 800 if infoLen == 0 { 801 return "" 802 } 803 buf := make([]byte, infoLen) 804 805 ctx.enqueue(call{ 806 args: fnargs{ 807 fn: glfnGetProgramInfoLog, 808 a0: p.c(), 809 a1: uintptr(infoLen), 810 }, 811 parg: unsafe.Pointer(&buf[0]), 812 blocking: true, 813 }) 814 815 return goString(buf) 816 } 817 818 func (ctx *context) GetRenderbufferParameteri(target, pname Enum) int { 819 return int(ctx.enqueue(call{ 820 args: fnargs{ 821 fn: glfnGetRenderbufferParameteriv, 822 a0: target.c(), 823 a1: pname.c(), 824 }, 825 blocking: true, 826 })) 827 } 828 829 func (ctx *context) GetShaderi(s Shader, pname Enum) int { 830 return int(ctx.enqueue(call{ 831 args: fnargs{ 832 fn: glfnGetShaderiv, 833 a0: s.c(), 834 a1: pname.c(), 835 }, 836 blocking: true, 837 })) 838 } 839 840 func (ctx *context) GetShaderInfoLog(s Shader) string { 841 infoLen := ctx.GetShaderi(s, INFO_LOG_LENGTH) 842 if infoLen == 0 { 843 return "" 844 } 845 buf := make([]byte, infoLen) 846 847 ctx.enqueue(call{ 848 args: fnargs{ 849 fn: glfnGetShaderInfoLog, 850 a0: s.c(), 851 a1: uintptr(infoLen), 852 }, 853 parg: unsafe.Pointer(&buf[0]), 854 blocking: true, 855 }) 856 857 return goString(buf) 858 } 859 860 func (ctx *context) GetShaderPrecisionFormat(shadertype, precisiontype Enum) (rangeLow, rangeHigh, precision int) { 861 var rangeAndPrec [3]int32 862 863 ctx.enqueue(call{ 864 args: fnargs{ 865 fn: glfnGetShaderPrecisionFormat, 866 a0: shadertype.c(), 867 a1: precisiontype.c(), 868 }, 869 parg: unsafe.Pointer(&rangeAndPrec[0]), 870 blocking: true, 871 }) 872 873 return int(rangeAndPrec[0]), int(rangeAndPrec[1]), int(rangeAndPrec[2]) 874 } 875 876 func (ctx *context) GetShaderSource(s Shader) string { 877 sourceLen := ctx.GetShaderi(s, SHADER_SOURCE_LENGTH) 878 if sourceLen == 0 { 879 return "" 880 } 881 buf := make([]byte, sourceLen) 882 883 ctx.enqueue(call{ 884 args: fnargs{ 885 fn: glfnGetShaderSource, 886 a0: s.c(), 887 a1: uintptr(sourceLen), 888 }, 889 parg: unsafe.Pointer(&buf[0]), 890 blocking: true, 891 }) 892 893 return goString(buf) 894 } 895 896 func (ctx *context) GetString(pname Enum) string { 897 ret := ctx.enqueue(call{ 898 args: fnargs{ 899 fn: glfnGetString, 900 a0: pname.c(), 901 }, 902 blocking: true, 903 }) 904 retp := unsafe.Pointer(ret) 905 buf := (*[1 << 24]byte)(retp)[:] 906 return goString(buf) 907 } 908 909 func (ctx *context) GetTexParameterfv(dst []float32, target, pname Enum) { 910 ctx.enqueue(call{ 911 args: fnargs{ 912 fn: glfnGetTexParameterfv, 913 a0: target.c(), 914 a1: pname.c(), 915 }, 916 parg: unsafe.Pointer(&dst[0]), 917 blocking: true, 918 }) 919 } 920 921 func (ctx *context) GetTexParameteriv(dst []int32, target, pname Enum) { 922 ctx.enqueue(call{ 923 args: fnargs{ 924 fn: glfnGetTexParameteriv, 925 a0: target.c(), 926 a1: pname.c(), 927 }, 928 blocking: true, 929 }) 930 } 931 932 func (ctx *context) GetUniformfv(dst []float32, src Uniform, p Program) { 933 ctx.enqueue(call{ 934 args: fnargs{ 935 fn: glfnGetUniformfv, 936 a0: p.c(), 937 a1: src.c(), 938 }, 939 parg: unsafe.Pointer(&dst[0]), 940 blocking: true, 941 }) 942 } 943 944 func (ctx *context) GetUniformiv(dst []int32, src Uniform, p Program) { 945 ctx.enqueue(call{ 946 args: fnargs{ 947 fn: glfnGetUniformiv, 948 a0: p.c(), 949 a1: src.c(), 950 }, 951 parg: unsafe.Pointer(&dst[0]), 952 blocking: true, 953 }) 954 } 955 956 func (ctx *context) GetUniformLocation(p Program, name string) Uniform { 957 s, free := ctx.cString(name) 958 defer free() 959 return Uniform{Value: int32(ctx.enqueue(call{ 960 args: fnargs{ 961 fn: glfnGetUniformLocation, 962 a0: p.c(), 963 a1: s, 964 }, 965 blocking: true, 966 }))} 967 } 968 969 func (ctx *context) GetVertexAttribf(src Attrib, pname Enum) float32 { 970 var params [1]float32 971 ctx.GetVertexAttribfv(params[:], src, pname) 972 return params[0] 973 } 974 975 func (ctx *context) GetVertexAttribfv(dst []float32, src Attrib, pname Enum) { 976 ctx.enqueue(call{ 977 args: fnargs{ 978 fn: glfnGetVertexAttribfv, 979 a0: src.c(), 980 a1: pname.c(), 981 }, 982 parg: unsafe.Pointer(&dst[0]), 983 blocking: true, 984 }) 985 } 986 987 func (ctx *context) GetVertexAttribi(src Attrib, pname Enum) int32 { 988 var params [1]int32 989 ctx.GetVertexAttribiv(params[:], src, pname) 990 return params[0] 991 } 992 993 func (ctx *context) GetVertexAttribiv(dst []int32, src Attrib, pname Enum) { 994 ctx.enqueue(call{ 995 args: fnargs{ 996 fn: glfnGetVertexAttribiv, 997 a0: src.c(), 998 a1: pname.c(), 999 }, 1000 parg: unsafe.Pointer(&dst[0]), 1001 blocking: true, 1002 }) 1003 } 1004 1005 func (ctx *context) Hint(target, mode Enum) { 1006 ctx.enqueue(call{ 1007 args: fnargs{ 1008 fn: glfnHint, 1009 a0: target.c(), 1010 a1: mode.c(), 1011 }, 1012 }) 1013 } 1014 1015 func (ctx *context) IsBuffer(b Buffer) bool { 1016 return 0 != ctx.enqueue(call{ 1017 args: fnargs{ 1018 fn: glfnIsBuffer, 1019 a0: b.c(), 1020 }, 1021 blocking: true, 1022 }) 1023 } 1024 1025 func (ctx *context) IsEnabled(cap Enum) bool { 1026 return 0 != ctx.enqueue(call{ 1027 args: fnargs{ 1028 fn: glfnIsEnabled, 1029 a0: cap.c(), 1030 }, 1031 blocking: true, 1032 }) 1033 } 1034 1035 func (ctx *context) IsFramebuffer(fb Framebuffer) bool { 1036 return 0 != ctx.enqueue(call{ 1037 args: fnargs{ 1038 fn: glfnIsFramebuffer, 1039 a0: fb.c(), 1040 }, 1041 blocking: true, 1042 }) 1043 } 1044 1045 func (ctx *context) IsProgram(p Program) bool { 1046 return 0 != ctx.enqueue(call{ 1047 args: fnargs{ 1048 fn: glfnIsProgram, 1049 a0: p.c(), 1050 }, 1051 blocking: true, 1052 }) 1053 } 1054 1055 func (ctx *context) IsRenderbuffer(rb Renderbuffer) bool { 1056 return 0 != ctx.enqueue(call{ 1057 args: fnargs{ 1058 fn: glfnIsRenderbuffer, 1059 a0: rb.c(), 1060 }, 1061 blocking: true, 1062 }) 1063 } 1064 1065 func (ctx *context) IsShader(s Shader) bool { 1066 return 0 != ctx.enqueue(call{ 1067 args: fnargs{ 1068 fn: glfnIsShader, 1069 a0: s.c(), 1070 }, 1071 blocking: true, 1072 }) 1073 } 1074 1075 func (ctx *context) IsTexture(t Texture) bool { 1076 return 0 != ctx.enqueue(call{ 1077 args: fnargs{ 1078 fn: glfnIsTexture, 1079 a0: t.c(), 1080 }, 1081 blocking: true, 1082 }) 1083 } 1084 1085 func (ctx *context) LineWidth(width float32) { 1086 ctx.enqueue(call{ 1087 args: fnargs{ 1088 fn: glfnLineWidth, 1089 a0: uintptr(math.Float32bits(width)), 1090 }, 1091 }) 1092 } 1093 1094 func (ctx *context) LinkProgram(p Program) { 1095 ctx.enqueue(call{ 1096 args: fnargs{ 1097 fn: glfnLinkProgram, 1098 a0: p.c(), 1099 }, 1100 }) 1101 } 1102 1103 func (ctx *context) PixelStorei(pname Enum, param int32) { 1104 ctx.enqueue(call{ 1105 args: fnargs{ 1106 fn: glfnPixelStorei, 1107 a0: pname.c(), 1108 a1: uintptr(param), 1109 }, 1110 }) 1111 } 1112 1113 func (ctx *context) PolygonOffset(factor, units float32) { 1114 ctx.enqueue(call{ 1115 args: fnargs{ 1116 fn: glfnPolygonOffset, 1117 a0: uintptr(math.Float32bits(factor)), 1118 a1: uintptr(math.Float32bits(units)), 1119 }, 1120 }) 1121 } 1122 1123 func (ctx *context) ReadPixels(dst []byte, x, y, width, height int, format, ty Enum) { 1124 ctx.enqueue(call{ 1125 args: fnargs{ 1126 fn: glfnReadPixels, 1127 // TODO(crawshaw): support PIXEL_PACK_BUFFER in GLES3, uses offset. 1128 a0: uintptr(x), 1129 a1: uintptr(y), 1130 a2: uintptr(width), 1131 a3: uintptr(height), 1132 a4: format.c(), 1133 a5: ty.c(), 1134 }, 1135 parg: unsafe.Pointer(&dst[0]), 1136 blocking: true, 1137 }) 1138 } 1139 1140 func (ctx *context) ReleaseShaderCompiler() { 1141 ctx.enqueue(call{ 1142 args: fnargs{ 1143 fn: glfnReleaseShaderCompiler, 1144 }, 1145 }) 1146 } 1147 1148 func (ctx *context) RenderbufferStorage(target, internalFormat Enum, width, height int) { 1149 ctx.enqueue(call{ 1150 args: fnargs{ 1151 fn: glfnRenderbufferStorage, 1152 a0: target.c(), 1153 a1: internalFormat.c(), 1154 a2: uintptr(width), 1155 a3: uintptr(height), 1156 }, 1157 }) 1158 } 1159 1160 func (ctx *context) SampleCoverage(value float32, invert bool) { 1161 ctx.enqueue(call{ 1162 args: fnargs{ 1163 fn: glfnSampleCoverage, 1164 a0: uintptr(math.Float32bits(value)), 1165 a1: glBoolean(invert), 1166 }, 1167 }) 1168 } 1169 1170 func (ctx *context) Scissor(x, y, width, height int32) { 1171 ctx.enqueue(call{ 1172 args: fnargs{ 1173 fn: glfnScissor, 1174 a0: uintptr(x), 1175 a1: uintptr(y), 1176 a2: uintptr(width), 1177 a3: uintptr(height), 1178 }, 1179 }) 1180 } 1181 1182 func (ctx *context) ShaderSource(s Shader, src string) { 1183 strp, free := ctx.cStringPtr(src) 1184 defer free() 1185 ctx.enqueue(call{ 1186 args: fnargs{ 1187 fn: glfnShaderSource, 1188 a0: s.c(), 1189 a1: 1, 1190 a2: strp, 1191 }, 1192 blocking: true, 1193 }) 1194 } 1195 1196 func (ctx *context) StencilFunc(fn Enum, ref int, mask uint32) { 1197 ctx.enqueue(call{ 1198 args: fnargs{ 1199 fn: glfnStencilFunc, 1200 a0: fn.c(), 1201 a1: uintptr(ref), 1202 a2: uintptr(mask), 1203 }, 1204 }) 1205 } 1206 1207 func (ctx *context) StencilFuncSeparate(face, fn Enum, ref int, mask uint32) { 1208 ctx.enqueue(call{ 1209 args: fnargs{ 1210 fn: glfnStencilFuncSeparate, 1211 a0: face.c(), 1212 a1: fn.c(), 1213 a2: uintptr(ref), 1214 a3: uintptr(mask), 1215 }, 1216 }) 1217 } 1218 1219 func (ctx *context) StencilMask(mask uint32) { 1220 ctx.enqueue(call{ 1221 args: fnargs{ 1222 fn: glfnStencilMask, 1223 a0: uintptr(mask), 1224 }, 1225 }) 1226 } 1227 1228 func (ctx *context) StencilMaskSeparate(face Enum, mask uint32) { 1229 ctx.enqueue(call{ 1230 args: fnargs{ 1231 fn: glfnStencilMaskSeparate, 1232 a0: face.c(), 1233 a1: uintptr(mask), 1234 }, 1235 }) 1236 } 1237 1238 func (ctx *context) StencilOp(fail, zfail, zpass Enum) { 1239 ctx.enqueue(call{ 1240 args: fnargs{ 1241 fn: glfnStencilOp, 1242 a0: fail.c(), 1243 a1: zfail.c(), 1244 a2: zpass.c(), 1245 }, 1246 }) 1247 } 1248 1249 func (ctx *context) StencilOpSeparate(face, sfail, dpfail, dppass Enum) { 1250 ctx.enqueue(call{ 1251 args: fnargs{ 1252 fn: glfnStencilOpSeparate, 1253 a0: face.c(), 1254 a1: sfail.c(), 1255 a2: dpfail.c(), 1256 a3: dppass.c(), 1257 }, 1258 }) 1259 } 1260 1261 func (ctx *context) TexImage2D(target Enum, level int, internalFormat int, width, height int, format Enum, ty Enum, data []byte) { 1262 // It is common to pass TexImage2D a nil data, indicating that a 1263 // bound GL buffer is being used as the source. In that case, it 1264 // is not necessary to block. 1265 parg := unsafe.Pointer(nil) 1266 if len(data) > 0 { 1267 parg = unsafe.Pointer(&data[0]) 1268 } 1269 1270 ctx.enqueue(call{ 1271 args: fnargs{ 1272 fn: glfnTexImage2D, 1273 // TODO(crawshaw): GLES3 offset for PIXEL_UNPACK_BUFFER and PIXEL_PACK_BUFFER. 1274 a0: target.c(), 1275 a1: uintptr(level), 1276 a2: uintptr(internalFormat), 1277 a3: uintptr(width), 1278 a4: uintptr(height), 1279 a5: format.c(), 1280 a6: ty.c(), 1281 }, 1282 parg: parg, 1283 blocking: parg != nil, 1284 }) 1285 } 1286 1287 func (ctx *context) TexSubImage2D(target Enum, level int, x, y, width, height int, format, ty Enum, data []byte) { 1288 // It is common to pass TexSubImage2D a nil data, indicating that a 1289 // bound GL buffer is being used as the source. In that case, it 1290 // is not necessary to block. 1291 parg := unsafe.Pointer(nil) 1292 if len(data) > 0 { 1293 parg = unsafe.Pointer(&data[0]) 1294 } 1295 1296 ctx.enqueue(call{ 1297 args: fnargs{ 1298 fn: glfnTexSubImage2D, 1299 // TODO(crawshaw): GLES3 offset for PIXEL_UNPACK_BUFFER and PIXEL_PACK_BUFFER. 1300 a0: target.c(), 1301 a1: uintptr(level), 1302 a2: uintptr(x), 1303 a3: uintptr(y), 1304 a4: uintptr(width), 1305 a5: uintptr(height), 1306 a6: format.c(), 1307 a7: ty.c(), 1308 }, 1309 parg: parg, 1310 blocking: parg != nil, 1311 }) 1312 } 1313 1314 func (ctx *context) TexParameterf(target, pname Enum, param float32) { 1315 ctx.enqueue(call{ 1316 args: fnargs{ 1317 fn: glfnTexParameterf, 1318 a0: target.c(), 1319 a1: pname.c(), 1320 a2: uintptr(math.Float32bits(param)), 1321 }, 1322 }) 1323 } 1324 1325 func (ctx *context) TexParameterfv(target, pname Enum, params []float32) { 1326 ctx.enqueue(call{ 1327 args: fnargs{ 1328 fn: glfnTexParameterfv, 1329 a0: target.c(), 1330 a1: pname.c(), 1331 }, 1332 parg: unsafe.Pointer(¶ms[0]), 1333 blocking: true, 1334 }) 1335 } 1336 1337 func (ctx *context) TexParameteri(target, pname Enum, param int) { 1338 ctx.enqueue(call{ 1339 args: fnargs{ 1340 fn: glfnTexParameteri, 1341 a0: target.c(), 1342 a1: pname.c(), 1343 a2: uintptr(param), 1344 }, 1345 }) 1346 } 1347 1348 func (ctx *context) TexParameteriv(target, pname Enum, params []int32) { 1349 ctx.enqueue(call{ 1350 args: fnargs{ 1351 fn: glfnTexParameteriv, 1352 a0: target.c(), 1353 a1: pname.c(), 1354 }, 1355 parg: unsafe.Pointer(¶ms[0]), 1356 blocking: true, 1357 }) 1358 } 1359 1360 func (ctx *context) Uniform1f(dst Uniform, v float32) { 1361 ctx.enqueue(call{ 1362 args: fnargs{ 1363 fn: glfnUniform1f, 1364 a0: dst.c(), 1365 a1: uintptr(math.Float32bits(v)), 1366 }, 1367 }) 1368 } 1369 1370 func (ctx *context) Uniform1fv(dst Uniform, src []float32) { 1371 ctx.enqueue(call{ 1372 args: fnargs{ 1373 fn: glfnUniform1fv, 1374 a0: dst.c(), 1375 a1: uintptr(len(src)), 1376 }, 1377 parg: unsafe.Pointer(&src[0]), 1378 blocking: true, 1379 }) 1380 } 1381 1382 func (ctx *context) Uniform1i(dst Uniform, v int) { 1383 ctx.enqueue(call{ 1384 args: fnargs{ 1385 fn: glfnUniform1i, 1386 a0: dst.c(), 1387 a1: uintptr(v), 1388 }, 1389 }) 1390 } 1391 1392 func (ctx *context) Uniform1iv(dst Uniform, src []int32) { 1393 ctx.enqueue(call{ 1394 args: fnargs{ 1395 fn: glfnUniform1iv, 1396 a0: dst.c(), 1397 a1: uintptr(len(src)), 1398 }, 1399 parg: unsafe.Pointer(&src[0]), 1400 blocking: true, 1401 }) 1402 } 1403 1404 func (ctx *context) Uniform2f(dst Uniform, v0, v1 float32) { 1405 ctx.enqueue(call{ 1406 args: fnargs{ 1407 fn: glfnUniform2f, 1408 a0: dst.c(), 1409 a1: uintptr(math.Float32bits(v0)), 1410 a2: uintptr(math.Float32bits(v1)), 1411 }, 1412 }) 1413 } 1414 1415 func (ctx *context) Uniform2fv(dst Uniform, src []float32) { 1416 ctx.enqueue(call{ 1417 args: fnargs{ 1418 fn: glfnUniform2fv, 1419 a0: dst.c(), 1420 a1: uintptr(len(src) / 2), 1421 }, 1422 parg: unsafe.Pointer(&src[0]), 1423 blocking: true, 1424 }) 1425 } 1426 1427 func (ctx *context) Uniform2i(dst Uniform, v0, v1 int) { 1428 ctx.enqueue(call{ 1429 args: fnargs{ 1430 fn: glfnUniform2i, 1431 a0: dst.c(), 1432 a1: uintptr(v0), 1433 a2: uintptr(v1), 1434 }, 1435 }) 1436 } 1437 1438 func (ctx *context) Uniform2iv(dst Uniform, src []int32) { 1439 ctx.enqueue(call{ 1440 args: fnargs{ 1441 fn: glfnUniform2iv, 1442 a0: dst.c(), 1443 a1: uintptr(len(src) / 2), 1444 }, 1445 parg: unsafe.Pointer(&src[0]), 1446 blocking: true, 1447 }) 1448 } 1449 1450 func (ctx *context) Uniform3f(dst Uniform, v0, v1, v2 float32) { 1451 ctx.enqueue(call{ 1452 args: fnargs{ 1453 fn: glfnUniform3f, 1454 a0: dst.c(), 1455 a1: uintptr(math.Float32bits(v0)), 1456 a2: uintptr(math.Float32bits(v1)), 1457 a3: uintptr(math.Float32bits(v2)), 1458 }, 1459 }) 1460 } 1461 1462 func (ctx *context) Uniform3fv(dst Uniform, src []float32) { 1463 ctx.enqueue(call{ 1464 args: fnargs{ 1465 fn: glfnUniform3fv, 1466 a0: dst.c(), 1467 a1: uintptr(len(src) / 3), 1468 }, 1469 parg: unsafe.Pointer(&src[0]), 1470 blocking: true, 1471 }) 1472 } 1473 1474 func (ctx *context) Uniform3i(dst Uniform, v0, v1, v2 int32) { 1475 ctx.enqueue(call{ 1476 args: fnargs{ 1477 fn: glfnUniform3i, 1478 a0: dst.c(), 1479 a1: uintptr(v0), 1480 a2: uintptr(v1), 1481 a3: uintptr(v2), 1482 }, 1483 }) 1484 } 1485 1486 func (ctx *context) Uniform3iv(dst Uniform, src []int32) { 1487 ctx.enqueue(call{ 1488 args: fnargs{ 1489 fn: glfnUniform3iv, 1490 a0: dst.c(), 1491 a1: uintptr(len(src) / 3), 1492 }, 1493 parg: unsafe.Pointer(&src[0]), 1494 blocking: true, 1495 }) 1496 } 1497 1498 func (ctx *context) Uniform4f(dst Uniform, v0, v1, v2, v3 float32) { 1499 ctx.enqueue(call{ 1500 args: fnargs{ 1501 fn: glfnUniform4f, 1502 a0: dst.c(), 1503 a1: uintptr(math.Float32bits(v0)), 1504 a2: uintptr(math.Float32bits(v1)), 1505 a3: uintptr(math.Float32bits(v2)), 1506 a4: uintptr(math.Float32bits(v3)), 1507 }, 1508 }) 1509 } 1510 1511 func (ctx *context) Uniform4fv(dst Uniform, src []float32) { 1512 ctx.enqueue(call{ 1513 args: fnargs{ 1514 fn: glfnUniform4fv, 1515 a0: dst.c(), 1516 a1: uintptr(len(src) / 4), 1517 }, 1518 parg: unsafe.Pointer(&src[0]), 1519 blocking: true, 1520 }) 1521 } 1522 1523 func (ctx *context) Uniform4i(dst Uniform, v0, v1, v2, v3 int32) { 1524 ctx.enqueue(call{ 1525 args: fnargs{ 1526 fn: glfnUniform4i, 1527 a0: dst.c(), 1528 a1: uintptr(v0), 1529 a2: uintptr(v1), 1530 a3: uintptr(v2), 1531 a4: uintptr(v3), 1532 }, 1533 }) 1534 } 1535 1536 func (ctx *context) Uniform4iv(dst Uniform, src []int32) { 1537 ctx.enqueue(call{ 1538 args: fnargs{ 1539 fn: glfnUniform4iv, 1540 a0: dst.c(), 1541 a1: uintptr(len(src) / 4), 1542 }, 1543 parg: unsafe.Pointer(&src[0]), 1544 blocking: true, 1545 }) 1546 } 1547 1548 func (ctx *context) UniformMatrix2fv(dst Uniform, src []float32) { 1549 ctx.enqueue(call{ 1550 args: fnargs{ 1551 fn: glfnUniformMatrix2fv, 1552 // OpenGL ES 2 does not support transpose. 1553 a0: dst.c(), 1554 a1: uintptr(len(src) / 4), 1555 }, 1556 parg: unsafe.Pointer(&src[0]), 1557 blocking: true, 1558 }) 1559 } 1560 1561 func (ctx *context) UniformMatrix3fv(dst Uniform, src []float32) { 1562 ctx.enqueue(call{ 1563 args: fnargs{ 1564 fn: glfnUniformMatrix3fv, 1565 a0: dst.c(), 1566 a1: uintptr(len(src) / 9), 1567 }, 1568 parg: unsafe.Pointer(&src[0]), 1569 blocking: true, 1570 }) 1571 } 1572 1573 func (ctx *context) UniformMatrix4fv(dst Uniform, src []float32) { 1574 ctx.enqueue(call{ 1575 args: fnargs{ 1576 fn: glfnUniformMatrix4fv, 1577 a0: dst.c(), 1578 a1: uintptr(len(src) / 16), 1579 }, 1580 parg: unsafe.Pointer(&src[0]), 1581 blocking: true, 1582 }) 1583 } 1584 1585 func (ctx *context) UseProgram(p Program) { 1586 ctx.enqueue(call{ 1587 args: fnargs{ 1588 fn: glfnUseProgram, 1589 a0: p.c(), 1590 }, 1591 }) 1592 } 1593 1594 func (ctx *context) ValidateProgram(p Program) { 1595 ctx.enqueue(call{ 1596 args: fnargs{ 1597 fn: glfnValidateProgram, 1598 a0: p.c(), 1599 }, 1600 }) 1601 } 1602 1603 func (ctx *context) VertexAttrib1f(dst Attrib, x float32) { 1604 ctx.enqueue(call{ 1605 args: fnargs{ 1606 fn: glfnVertexAttrib1f, 1607 a0: dst.c(), 1608 a1: uintptr(math.Float32bits(x)), 1609 }, 1610 }) 1611 } 1612 1613 func (ctx *context) VertexAttrib1fv(dst Attrib, src []float32) { 1614 ctx.enqueue(call{ 1615 args: fnargs{ 1616 fn: glfnVertexAttrib1fv, 1617 a0: dst.c(), 1618 }, 1619 parg: unsafe.Pointer(&src[0]), 1620 blocking: true, 1621 }) 1622 } 1623 1624 func (ctx *context) VertexAttrib2f(dst Attrib, x, y float32) { 1625 ctx.enqueue(call{ 1626 args: fnargs{ 1627 fn: glfnVertexAttrib2f, 1628 a0: dst.c(), 1629 a1: uintptr(math.Float32bits(x)), 1630 a2: uintptr(math.Float32bits(y)), 1631 }, 1632 }) 1633 } 1634 1635 func (ctx *context) VertexAttrib2fv(dst Attrib, src []float32) { 1636 ctx.enqueue(call{ 1637 args: fnargs{ 1638 fn: glfnVertexAttrib2fv, 1639 a0: dst.c(), 1640 }, 1641 parg: unsafe.Pointer(&src[0]), 1642 blocking: true, 1643 }) 1644 } 1645 1646 func (ctx *context) VertexAttrib3f(dst Attrib, x, y, z float32) { 1647 ctx.enqueue(call{ 1648 args: fnargs{ 1649 fn: glfnVertexAttrib3f, 1650 a0: dst.c(), 1651 a1: uintptr(math.Float32bits(x)), 1652 a2: uintptr(math.Float32bits(y)), 1653 a3: uintptr(math.Float32bits(z)), 1654 }, 1655 }) 1656 } 1657 1658 func (ctx *context) VertexAttrib3fv(dst Attrib, src []float32) { 1659 ctx.enqueue(call{ 1660 args: fnargs{ 1661 fn: glfnVertexAttrib3fv, 1662 a0: dst.c(), 1663 }, 1664 parg: unsafe.Pointer(&src[0]), 1665 blocking: true, 1666 }) 1667 } 1668 1669 func (ctx *context) VertexAttrib4f(dst Attrib, x, y, z, w float32) { 1670 ctx.enqueue(call{ 1671 args: fnargs{ 1672 fn: glfnVertexAttrib4f, 1673 a0: dst.c(), 1674 a1: uintptr(math.Float32bits(x)), 1675 a2: uintptr(math.Float32bits(y)), 1676 a3: uintptr(math.Float32bits(z)), 1677 a4: uintptr(math.Float32bits(w)), 1678 }, 1679 }) 1680 } 1681 1682 func (ctx *context) VertexAttrib4fv(dst Attrib, src []float32) { 1683 ctx.enqueue(call{ 1684 args: fnargs{ 1685 fn: glfnVertexAttrib4fv, 1686 a0: dst.c(), 1687 }, 1688 parg: unsafe.Pointer(&src[0]), 1689 blocking: true, 1690 }) 1691 } 1692 1693 func (ctx *context) VertexAttribPointer(dst Attrib, size int, ty Enum, normalized bool, stride, offset int) { 1694 ctx.enqueue(call{ 1695 args: fnargs{ 1696 fn: glfnVertexAttribPointer, 1697 a0: dst.c(), 1698 a1: uintptr(size), 1699 a2: ty.c(), 1700 a3: glBoolean(normalized), 1701 a4: uintptr(stride), 1702 a5: uintptr(offset), 1703 }, 1704 }) 1705 } 1706 1707 func (ctx *context) Viewport(x, y, width, height int) { 1708 ctx.enqueue(call{ 1709 args: fnargs{ 1710 fn: glfnViewport, 1711 a0: uintptr(x), 1712 a1: uintptr(y), 1713 a2: uintptr(width), 1714 a3: uintptr(height), 1715 }, 1716 }) 1717 } 1718 1719 func (ctx context3) UniformMatrix2x3fv(dst Uniform, src []float32) { 1720 ctx.enqueue(call{ 1721 args: fnargs{ 1722 fn: glfnUniformMatrix2x3fv, 1723 a0: dst.c(), 1724 a1: uintptr(len(src) / 6), 1725 }, 1726 parg: unsafe.Pointer(&src[0]), 1727 blocking: true, 1728 }) 1729 } 1730 1731 func (ctx context3) UniformMatrix3x2fv(dst Uniform, src []float32) { 1732 ctx.enqueue(call{ 1733 args: fnargs{ 1734 fn: glfnUniformMatrix3x2fv, 1735 a0: dst.c(), 1736 a1: uintptr(len(src) / 6), 1737 }, 1738 parg: unsafe.Pointer(&src[0]), 1739 blocking: true, 1740 }) 1741 } 1742 1743 func (ctx context3) UniformMatrix2x4fv(dst Uniform, src []float32) { 1744 ctx.enqueue(call{ 1745 args: fnargs{ 1746 fn: glfnUniformMatrix2x4fv, 1747 a0: dst.c(), 1748 a1: uintptr(len(src) / 8), 1749 }, 1750 parg: unsafe.Pointer(&src[0]), 1751 blocking: true, 1752 }) 1753 } 1754 1755 func (ctx context3) UniformMatrix4x2fv(dst Uniform, src []float32) { 1756 ctx.enqueue(call{ 1757 args: fnargs{ 1758 fn: glfnUniformMatrix4x2fv, 1759 a0: dst.c(), 1760 a1: uintptr(len(src) / 8), 1761 }, 1762 parg: unsafe.Pointer(&src[0]), 1763 blocking: true, 1764 }) 1765 } 1766 1767 func (ctx context3) UniformMatrix3x4fv(dst Uniform, src []float32) { 1768 ctx.enqueue(call{ 1769 args: fnargs{ 1770 fn: glfnUniformMatrix3x4fv, 1771 a0: dst.c(), 1772 a1: uintptr(len(src) / 12), 1773 }, 1774 parg: unsafe.Pointer(&src[0]), 1775 blocking: true, 1776 }) 1777 } 1778 1779 func (ctx context3) UniformMatrix4x3fv(dst Uniform, src []float32) { 1780 ctx.enqueue(call{ 1781 args: fnargs{ 1782 fn: glfnUniformMatrix4x3fv, 1783 a0: dst.c(), 1784 a1: uintptr(len(src) / 12), 1785 }, 1786 parg: unsafe.Pointer(&src[0]), 1787 blocking: true, 1788 }) 1789 } 1790 1791 func (ctx context3) BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1 int, mask uint, filter Enum) { 1792 ctx.enqueue(call{ 1793 args: fnargs{ 1794 fn: glfnBlitFramebuffer, 1795 a0: uintptr(srcX0), 1796 a1: uintptr(srcY0), 1797 a2: uintptr(srcX1), 1798 a3: uintptr(srcY1), 1799 a4: uintptr(dstX0), 1800 a5: uintptr(dstY0), 1801 a6: uintptr(dstX1), 1802 a7: uintptr(dstY1), 1803 a8: uintptr(mask), 1804 a9: filter.c(), 1805 }, 1806 }) 1807 } 1808 1809 func (ctx context3) Uniform1ui(dst Uniform, v uint32) { 1810 ctx.enqueue(call{ 1811 args: fnargs{ 1812 fn: glfnUniform1ui, 1813 a0: dst.c(), 1814 a1: uintptr(v), 1815 }, 1816 }) 1817 } 1818 1819 func (ctx context3) Uniform2ui(dst Uniform, v0, v1 uint32) { 1820 ctx.enqueue(call{ 1821 args: fnargs{ 1822 fn: glfnUniform2ui, 1823 a0: dst.c(), 1824 a1: uintptr(v0), 1825 a2: uintptr(v1), 1826 }, 1827 }) 1828 } 1829 1830 func (ctx context3) Uniform3ui(dst Uniform, v0, v1, v2 uint) { 1831 ctx.enqueue(call{ 1832 args: fnargs{ 1833 fn: glfnUniform3ui, 1834 a0: dst.c(), 1835 a1: uintptr(v0), 1836 a2: uintptr(v1), 1837 a3: uintptr(v2), 1838 }, 1839 }) 1840 } 1841 1842 func (ctx context3) Uniform4ui(dst Uniform, v0, v1, v2, v3 uint32) { 1843 ctx.enqueue(call{ 1844 args: fnargs{ 1845 fn: glfnUniform4ui, 1846 a0: dst.c(), 1847 a1: uintptr(v0), 1848 a2: uintptr(v1), 1849 a3: uintptr(v2), 1850 a4: uintptr(v3), 1851 }, 1852 }) 1853 }