webgl2.js (132184B)
1 /* 2 * Copyright 2010 The Closure Compiler Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 // WebGL 2.0 portions: 18 19 /* 20 Copyright (c) 2019 The Khronos Group Inc. 21 Use of this source code is governed by an MIT-style license that can be 22 found in the LICENSE.txt file. 23 */ 24 25 /** 26 * @fileoverview Definitions for WebGL functions as described at 27 * http://www.khronos.org/registry/webgl/specs/latest/1.0 and 28 * http://www.khronos.org/registry/webgl/specs/latest/2.0 29 * 30 * This file is current up to the WebGL 2.0 spec, including extensions. 31 * 32 * This relies on html5.js being included for Canvas and Typed Array support. 33 * 34 * This includes some extensions defined at 35 * http://www.khronos.org/registry/webgl/extensions/ 36 * 37 * This file will be merged back into the Closure workspace as soon as 38 * the WebGL 2.0 changes have been fully tested. 39 * 40 * @externs 41 */ 42 43 /** 44 * @constructor 45 * @noalias 46 * @private 47 */ 48 function WebGLRenderingContextBase() {} 49 50 /** @typedef {number} */ 51 WebGLRenderingContextBase.GLenum; 52 53 /** @type {number} */ 54 WebGLRenderingContextBase.DEPTH_BUFFER_BIT; 55 56 /** @type {number} */ 57 WebGLRenderingContextBase.STENCIL_BUFFER_BIT; 58 59 /** @type {number} */ 60 WebGLRenderingContextBase.COLOR_BUFFER_BIT; 61 62 /** @type {number} */ 63 WebGLRenderingContextBase.POINTS; 64 65 /** @type {number} */ 66 WebGLRenderingContextBase.LINES; 67 68 /** @type {number} */ 69 WebGLRenderingContextBase.LINE_LOOP; 70 71 /** @type {number} */ 72 WebGLRenderingContextBase.LINE_STRIP; 73 74 /** @type {number} */ 75 WebGLRenderingContextBase.TRIANGLES; 76 77 /** @type {number} */ 78 WebGLRenderingContextBase.TRIANGLE_STRIP; 79 80 /** @type {number} */ 81 WebGLRenderingContextBase.TRIANGLE_FAN; 82 83 /** @type {number} */ 84 WebGLRenderingContextBase.ZERO; 85 86 /** @type {number} */ 87 WebGLRenderingContextBase.ONE; 88 89 /** @type {number} */ 90 WebGLRenderingContextBase.SRC_COLOR; 91 92 /** @type {number} */ 93 WebGLRenderingContextBase.ONE_MINUS_SRC_COLOR; 94 95 /** @type {number} */ 96 WebGLRenderingContextBase.SRC_ALPHA; 97 98 /** @type {number} */ 99 WebGLRenderingContextBase.ONE_MINUS_SRC_ALPHA; 100 101 /** @type {number} */ 102 WebGLRenderingContextBase.DST_ALPHA; 103 104 /** @type {number} */ 105 WebGLRenderingContextBase.ONE_MINUS_DST_ALPHA; 106 107 /** @type {number} */ 108 WebGLRenderingContextBase.DST_COLOR; 109 110 /** @type {number} */ 111 WebGLRenderingContextBase.ONE_MINUS_DST_COLOR; 112 113 /** @type {number} */ 114 WebGLRenderingContextBase.SRC_ALPHA_SATURATE; 115 116 /** @type {number} */ 117 WebGLRenderingContextBase.FUNC_ADD; 118 119 /** @type {number} */ 120 WebGLRenderingContextBase.BLEND_EQUATION; 121 122 /** @type {number} */ 123 WebGLRenderingContextBase.BLEND_EQUATION_RGB; 124 125 /** @type {number} */ 126 WebGLRenderingContextBase.BLEND_EQUATION_ALPHA; 127 128 /** @type {number} */ 129 WebGLRenderingContextBase.FUNC_SUBTRACT; 130 131 /** @type {number} */ 132 WebGLRenderingContextBase.FUNC_REVERSE_SUBTRACT; 133 134 /** @type {number} */ 135 WebGLRenderingContextBase.BLEND_DST_RGB; 136 137 /** @type {number} */ 138 WebGLRenderingContextBase.BLEND_SRC_RGB; 139 140 /** @type {number} */ 141 WebGLRenderingContextBase.BLEND_DST_ALPHA; 142 143 /** @type {number} */ 144 WebGLRenderingContextBase.BLEND_SRC_ALPHA; 145 146 /** @type {number} */ 147 WebGLRenderingContextBase.CONSTANT_COLOR; 148 149 /** @type {number} */ 150 WebGLRenderingContextBase.ONE_MINUS_CONSTANT_COLOR; 151 152 /** @type {number} */ 153 WebGLRenderingContextBase.CONSTANT_ALPHA; 154 155 /** @type {number} */ 156 WebGLRenderingContextBase.ONE_MINUS_CONSTANT_ALPHA; 157 158 /** @type {number} */ 159 WebGLRenderingContextBase.BLEND_COLOR; 160 161 /** @type {number} */ 162 WebGLRenderingContextBase.ARRAY_BUFFER; 163 164 /** @type {number} */ 165 WebGLRenderingContextBase.ELEMENT_ARRAY_BUFFER; 166 167 /** @type {number} */ 168 WebGLRenderingContextBase.ARRAY_BUFFER_BINDING; 169 170 /** @type {number} */ 171 WebGLRenderingContextBase.ELEMENT_ARRAY_BUFFER_BINDING; 172 173 /** @type {number} */ 174 WebGLRenderingContextBase.STREAM_DRAW; 175 176 /** @type {number} */ 177 WebGLRenderingContextBase.STATIC_DRAW; 178 179 /** @type {number} */ 180 WebGLRenderingContextBase.DYNAMIC_DRAW; 181 182 /** @type {number} */ 183 WebGLRenderingContextBase.BUFFER_SIZE; 184 185 /** @type {number} */ 186 WebGLRenderingContextBase.BUFFER_USAGE; 187 188 /** @type {number} */ 189 WebGLRenderingContextBase.CURRENT_VERTEX_ATTRIB; 190 191 /** @type {number} */ 192 WebGLRenderingContextBase.FRONT; 193 194 /** @type {number} */ 195 WebGLRenderingContextBase.BACK; 196 197 /** @type {number} */ 198 WebGLRenderingContextBase.FRONT_AND_BACK; 199 200 /** @type {number} */ 201 WebGLRenderingContextBase.CULL_FACE; 202 203 /** @type {number} */ 204 WebGLRenderingContextBase.BLEND; 205 206 /** @type {number} */ 207 WebGLRenderingContextBase.DITHER; 208 209 /** @type {number} */ 210 WebGLRenderingContextBase.STENCIL_TEST; 211 212 /** @type {number} */ 213 WebGLRenderingContextBase.DEPTH_TEST; 214 215 /** @type {number} */ 216 WebGLRenderingContextBase.SCISSOR_TEST; 217 218 /** @type {number} */ 219 WebGLRenderingContextBase.POLYGON_OFFSET_FILL; 220 221 /** @type {number} */ 222 WebGLRenderingContextBase.SAMPLE_ALPHA_TO_COVERAGE; 223 224 /** @type {number} */ 225 WebGLRenderingContextBase.SAMPLE_COVERAGE; 226 227 /** @type {number} */ 228 WebGLRenderingContextBase.NO_ERROR; 229 230 /** @type {number} */ 231 WebGLRenderingContextBase.INVALID_ENUM; 232 233 /** @type {number} */ 234 WebGLRenderingContextBase.INVALID_VALUE; 235 236 /** @type {number} */ 237 WebGLRenderingContextBase.INVALID_OPERATION; 238 239 /** @type {number} */ 240 WebGLRenderingContextBase.OUT_OF_MEMORY; 241 242 /** @type {number} */ 243 WebGLRenderingContextBase.CW; 244 245 /** @type {number} */ 246 WebGLRenderingContextBase.CCW; 247 248 /** @type {number} */ 249 WebGLRenderingContextBase.LINE_WIDTH; 250 251 /** @type {number} */ 252 WebGLRenderingContextBase.ALIASED_POINT_SIZE_RANGE; 253 254 /** @type {number} */ 255 WebGLRenderingContextBase.ALIASED_LINE_WIDTH_RANGE; 256 257 /** @type {number} */ 258 WebGLRenderingContextBase.CULL_FACE_MODE; 259 260 /** @type {number} */ 261 WebGLRenderingContextBase.FRONT_FACE; 262 263 /** @type {number} */ 264 WebGLRenderingContextBase.DEPTH_RANGE; 265 266 /** @type {number} */ 267 WebGLRenderingContextBase.DEPTH_WRITEMASK; 268 269 /** @type {number} */ 270 WebGLRenderingContextBase.DEPTH_CLEAR_VALUE; 271 272 /** @type {number} */ 273 WebGLRenderingContextBase.DEPTH_FUNC; 274 275 /** @type {number} */ 276 WebGLRenderingContextBase.STENCIL_CLEAR_VALUE; 277 278 /** @type {number} */ 279 WebGLRenderingContextBase.STENCIL_FUNC; 280 281 /** @type {number} */ 282 WebGLRenderingContextBase.STENCIL_FAIL; 283 284 /** @type {number} */ 285 WebGLRenderingContextBase.STENCIL_PASS_DEPTH_FAIL; 286 287 /** @type {number} */ 288 WebGLRenderingContextBase.STENCIL_PASS_DEPTH_PASS; 289 290 /** @type {number} */ 291 WebGLRenderingContextBase.STENCIL_REF; 292 293 /** @type {number} */ 294 WebGLRenderingContextBase.STENCIL_VALUE_MASK; 295 296 /** @type {number} */ 297 WebGLRenderingContextBase.STENCIL_WRITEMASK; 298 299 /** @type {number} */ 300 WebGLRenderingContextBase.STENCIL_BACK_FUNC; 301 302 /** @type {number} */ 303 WebGLRenderingContextBase.STENCIL_BACK_FAIL; 304 305 /** @type {number} */ 306 WebGLRenderingContextBase.STENCIL_BACK_PASS_DEPTH_FAIL; 307 308 /** @type {number} */ 309 WebGLRenderingContextBase.STENCIL_BACK_PASS_DEPTH_PASS; 310 311 /** @type {number} */ 312 WebGLRenderingContextBase.STENCIL_BACK_REF; 313 314 /** @type {number} */ 315 WebGLRenderingContextBase.STENCIL_BACK_VALUE_MASK; 316 317 /** @type {number} */ 318 WebGLRenderingContextBase.STENCIL_BACK_WRITEMASK; 319 320 /** @type {number} */ 321 WebGLRenderingContextBase.VIEWPORT; 322 323 /** @type {number} */ 324 WebGLRenderingContextBase.SCISSOR_BOX; 325 326 /** @type {number} */ 327 WebGLRenderingContextBase.COLOR_CLEAR_VALUE; 328 329 /** @type {number} */ 330 WebGLRenderingContextBase.COLOR_WRITEMASK; 331 332 /** @type {number} */ 333 WebGLRenderingContextBase.UNPACK_ALIGNMENT; 334 335 /** @type {number} */ 336 WebGLRenderingContextBase.PACK_ALIGNMENT; 337 338 /** @type {number} */ 339 WebGLRenderingContextBase.MAX_TEXTURE_SIZE; 340 341 /** @type {number} */ 342 WebGLRenderingContextBase.MAX_VIEWPORT_DIMS; 343 344 /** @type {number} */ 345 WebGLRenderingContextBase.SUBPIXEL_BITS; 346 347 /** @type {number} */ 348 WebGLRenderingContextBase.RED_BITS; 349 350 /** @type {number} */ 351 WebGLRenderingContextBase.GREEN_BITS; 352 353 /** @type {number} */ 354 WebGLRenderingContextBase.BLUE_BITS; 355 356 /** @type {number} */ 357 WebGLRenderingContextBase.ALPHA_BITS; 358 359 /** @type {number} */ 360 WebGLRenderingContextBase.DEPTH_BITS; 361 362 /** @type {number} */ 363 WebGLRenderingContextBase.STENCIL_BITS; 364 365 /** @type {number} */ 366 WebGLRenderingContextBase.POLYGON_OFFSET_UNITS; 367 368 /** @type {number} */ 369 WebGLRenderingContextBase.POLYGON_OFFSET_FACTOR; 370 371 /** @type {number} */ 372 WebGLRenderingContextBase.TEXTURE_BINDING_2D; 373 374 /** @type {number} */ 375 WebGLRenderingContextBase.SAMPLE_BUFFERS; 376 377 /** @type {number} */ 378 WebGLRenderingContextBase.SAMPLES; 379 380 /** @type {number} */ 381 WebGLRenderingContextBase.SAMPLE_COVERAGE_VALUE; 382 383 /** @type {number} */ 384 WebGLRenderingContextBase.SAMPLE_COVERAGE_INVERT; 385 386 /** @type {number} */ 387 WebGLRenderingContextBase.COMPRESSED_TEXTURE_FORMATS; 388 389 /** @type {number} */ 390 WebGLRenderingContextBase.DONT_CARE; 391 392 /** @type {number} */ 393 WebGLRenderingContextBase.FASTEST; 394 395 /** @type {number} */ 396 WebGLRenderingContextBase.NICEST; 397 398 /** @type {number} */ 399 WebGLRenderingContextBase.GENERATE_MIPMAP_HINT; 400 401 /** @type {number} */ 402 WebGLRenderingContextBase.BYTE; 403 404 /** @type {number} */ 405 WebGLRenderingContextBase.UNSIGNED_BYTE; 406 407 /** @type {number} */ 408 WebGLRenderingContextBase.SHORT; 409 410 /** @type {number} */ 411 WebGLRenderingContextBase.UNSIGNED_SHORT; 412 413 /** @type {number} */ 414 WebGLRenderingContextBase.INT; 415 416 /** @type {number} */ 417 WebGLRenderingContextBase.UNSIGNED_INT; 418 419 /** @type {number} */ 420 WebGLRenderingContextBase.FLOAT; 421 422 /** @type {number} */ 423 WebGLRenderingContextBase.DEPTH_COMPONENT; 424 425 /** @type {number} */ 426 WebGLRenderingContextBase.ALPHA; 427 428 /** @type {number} */ 429 WebGLRenderingContextBase.RGB; 430 431 /** @type {number} */ 432 WebGLRenderingContextBase.RGBA; 433 434 /** @type {number} */ 435 WebGLRenderingContextBase.LUMINANCE; 436 437 /** @type {number} */ 438 WebGLRenderingContextBase.LUMINANCE_ALPHA; 439 440 /** @type {number} */ 441 WebGLRenderingContextBase.UNSIGNED_SHORT_4_4_4_4; 442 443 /** @type {number} */ 444 WebGLRenderingContextBase.UNSIGNED_SHORT_5_5_5_1; 445 446 /** @type {number} */ 447 WebGLRenderingContextBase.UNSIGNED_SHORT_5_6_5; 448 449 /** @type {number} */ 450 WebGLRenderingContextBase.FRAGMENT_SHADER; 451 452 /** @type {number} */ 453 WebGLRenderingContextBase.VERTEX_SHADER; 454 455 /** @type {number} */ 456 WebGLRenderingContextBase.MAX_VERTEX_ATTRIBS; 457 458 /** @type {number} */ 459 WebGLRenderingContextBase.MAX_VERTEX_UNIFORM_VECTORS; 460 461 /** @type {number} */ 462 WebGLRenderingContextBase.MAX_VARYING_VECTORS; 463 464 /** @type {number} */ 465 WebGLRenderingContextBase.MAX_COMBINED_TEXTURE_IMAGE_UNITS; 466 467 /** @type {number} */ 468 WebGLRenderingContextBase.MAX_VERTEX_TEXTURE_IMAGE_UNITS; 469 470 /** @type {number} */ 471 WebGLRenderingContextBase.MAX_TEXTURE_IMAGE_UNITS; 472 473 /** @type {number} */ 474 WebGLRenderingContextBase.MAX_FRAGMENT_UNIFORM_VECTORS; 475 476 /** @type {number} */ 477 WebGLRenderingContextBase.SHADER_TYPE; 478 479 /** @type {number} */ 480 WebGLRenderingContextBase.DELETE_STATUS; 481 482 /** @type {number} */ 483 WebGLRenderingContextBase.LINK_STATUS; 484 485 /** @type {number} */ 486 WebGLRenderingContextBase.VALIDATE_STATUS; 487 488 /** @type {number} */ 489 WebGLRenderingContextBase.ATTACHED_SHADERS; 490 491 /** @type {number} */ 492 WebGLRenderingContextBase.ACTIVE_UNIFORMS; 493 494 /** @type {number} */ 495 WebGLRenderingContextBase.ACTIVE_ATTRIBUTES; 496 497 /** @type {number} */ 498 WebGLRenderingContextBase.SHADING_LANGUAGE_VERSION; 499 500 /** @type {number} */ 501 WebGLRenderingContextBase.CURRENT_PROGRAM; 502 503 /** @type {number} */ 504 WebGLRenderingContextBase.NEVER; 505 506 /** @type {number} */ 507 WebGLRenderingContextBase.LESS; 508 509 /** @type {number} */ 510 WebGLRenderingContextBase.EQUAL; 511 512 /** @type {number} */ 513 WebGLRenderingContextBase.LEQUAL; 514 515 /** @type {number} */ 516 WebGLRenderingContextBase.GREATER; 517 518 /** @type {number} */ 519 WebGLRenderingContextBase.NOTEQUAL; 520 521 /** @type {number} */ 522 WebGLRenderingContextBase.GEQUAL; 523 524 /** @type {number} */ 525 WebGLRenderingContextBase.ALWAYS; 526 527 /** @type {number} */ 528 WebGLRenderingContextBase.KEEP; 529 530 /** @type {number} */ 531 WebGLRenderingContextBase.REPLACE; 532 533 /** @type {number} */ 534 WebGLRenderingContextBase.INCR; 535 536 /** @type {number} */ 537 WebGLRenderingContextBase.DECR; 538 539 /** @type {number} */ 540 WebGLRenderingContextBase.INVERT; 541 542 /** @type {number} */ 543 WebGLRenderingContextBase.INCR_WRAP; 544 545 /** @type {number} */ 546 WebGLRenderingContextBase.DECR_WRAP; 547 548 /** @type {number} */ 549 WebGLRenderingContextBase.VENDOR; 550 551 /** @type {number} */ 552 WebGLRenderingContextBase.RENDERER; 553 554 /** @type {number} */ 555 WebGLRenderingContextBase.VERSION; 556 557 /** @type {number} */ 558 WebGLRenderingContextBase.NEAREST; 559 560 /** @type {number} */ 561 WebGLRenderingContextBase.LINEAR; 562 563 /** @type {number} */ 564 WebGLRenderingContextBase.NEAREST_MIPMAP_NEAREST; 565 566 /** @type {number} */ 567 WebGLRenderingContextBase.LINEAR_MIPMAP_NEAREST; 568 569 /** @type {number} */ 570 WebGLRenderingContextBase.NEAREST_MIPMAP_LINEAR; 571 572 /** @type {number} */ 573 WebGLRenderingContextBase.LINEAR_MIPMAP_LINEAR; 574 575 /** @type {number} */ 576 WebGLRenderingContextBase.TEXTURE_MAG_FILTER; 577 578 /** @type {number} */ 579 WebGLRenderingContextBase.TEXTURE_MIN_FILTER; 580 581 /** @type {number} */ 582 WebGLRenderingContextBase.TEXTURE_WRAP_S; 583 584 /** @type {number} */ 585 WebGLRenderingContextBase.TEXTURE_WRAP_T; 586 587 /** @type {number} */ 588 WebGLRenderingContextBase.TEXTURE_2D; 589 590 /** @type {number} */ 591 WebGLRenderingContextBase.TEXTURE; 592 593 /** @type {number} */ 594 WebGLRenderingContextBase.TEXTURE_CUBE_MAP; 595 596 /** @type {number} */ 597 WebGLRenderingContextBase.TEXTURE_BINDING_CUBE_MAP; 598 599 /** @type {number} */ 600 WebGLRenderingContextBase.TEXTURE_CUBE_MAP_POSITIVE_X; 601 602 /** @type {number} */ 603 WebGLRenderingContextBase.TEXTURE_CUBE_MAP_NEGATIVE_X; 604 605 /** @type {number} */ 606 WebGLRenderingContextBase.TEXTURE_CUBE_MAP_POSITIVE_Y; 607 608 /** @type {number} */ 609 WebGLRenderingContextBase.TEXTURE_CUBE_MAP_NEGATIVE_Y; 610 611 /** @type {number} */ 612 WebGLRenderingContextBase.TEXTURE_CUBE_MAP_POSITIVE_Z; 613 614 /** @type {number} */ 615 WebGLRenderingContextBase.TEXTURE_CUBE_MAP_NEGATIVE_Z; 616 617 /** @type {number} */ 618 WebGLRenderingContextBase.MAX_CUBE_MAP_TEXTURE_SIZE; 619 620 /** @type {number} */ 621 WebGLRenderingContextBase.TEXTURE0; 622 623 /** @type {number} */ 624 WebGLRenderingContextBase.TEXTURE1; 625 626 /** @type {number} */ 627 WebGLRenderingContextBase.TEXTURE2; 628 629 /** @type {number} */ 630 WebGLRenderingContextBase.TEXTURE3; 631 632 /** @type {number} */ 633 WebGLRenderingContextBase.TEXTURE4; 634 635 /** @type {number} */ 636 WebGLRenderingContextBase.TEXTURE5; 637 638 /** @type {number} */ 639 WebGLRenderingContextBase.TEXTURE6; 640 641 /** @type {number} */ 642 WebGLRenderingContextBase.TEXTURE7; 643 644 /** @type {number} */ 645 WebGLRenderingContextBase.TEXTURE8; 646 647 /** @type {number} */ 648 WebGLRenderingContextBase.TEXTURE9; 649 650 /** @type {number} */ 651 WebGLRenderingContextBase.TEXTURE10; 652 653 /** @type {number} */ 654 WebGLRenderingContextBase.TEXTURE11; 655 656 /** @type {number} */ 657 WebGLRenderingContextBase.TEXTURE12; 658 659 /** @type {number} */ 660 WebGLRenderingContextBase.TEXTURE13; 661 662 /** @type {number} */ 663 WebGLRenderingContextBase.TEXTURE14; 664 665 /** @type {number} */ 666 WebGLRenderingContextBase.TEXTURE15; 667 668 /** @type {number} */ 669 WebGLRenderingContextBase.TEXTURE16; 670 671 /** @type {number} */ 672 WebGLRenderingContextBase.TEXTURE17; 673 674 /** @type {number} */ 675 WebGLRenderingContextBase.TEXTURE18; 676 677 /** @type {number} */ 678 WebGLRenderingContextBase.TEXTURE19; 679 680 /** @type {number} */ 681 WebGLRenderingContextBase.TEXTURE20; 682 683 /** @type {number} */ 684 WebGLRenderingContextBase.TEXTURE21; 685 686 /** @type {number} */ 687 WebGLRenderingContextBase.TEXTURE22; 688 689 /** @type {number} */ 690 WebGLRenderingContextBase.TEXTURE23; 691 692 /** @type {number} */ 693 WebGLRenderingContextBase.TEXTURE24; 694 695 /** @type {number} */ 696 WebGLRenderingContextBase.TEXTURE25; 697 698 /** @type {number} */ 699 WebGLRenderingContextBase.TEXTURE26; 700 701 /** @type {number} */ 702 WebGLRenderingContextBase.TEXTURE27; 703 704 /** @type {number} */ 705 WebGLRenderingContextBase.TEXTURE28; 706 707 /** @type {number} */ 708 WebGLRenderingContextBase.TEXTURE29; 709 710 /** @type {number} */ 711 WebGLRenderingContextBase.TEXTURE30; 712 713 /** @type {number} */ 714 WebGLRenderingContextBase.TEXTURE31; 715 716 /** @type {number} */ 717 WebGLRenderingContextBase.ACTIVE_TEXTURE; 718 719 /** @type {number} */ 720 WebGLRenderingContextBase.REPEAT; 721 722 /** @type {number} */ 723 WebGLRenderingContextBase.CLAMP_TO_EDGE; 724 725 /** @type {number} */ 726 WebGLRenderingContextBase.MIRRORED_REPEAT; 727 728 /** @type {number} */ 729 WebGLRenderingContextBase.FLOAT_VEC2; 730 731 /** @type {number} */ 732 WebGLRenderingContextBase.FLOAT_VEC3; 733 734 /** @type {number} */ 735 WebGLRenderingContextBase.FLOAT_VEC4; 736 737 /** @type {number} */ 738 WebGLRenderingContextBase.INT_VEC2; 739 740 /** @type {number} */ 741 WebGLRenderingContextBase.INT_VEC3; 742 743 /** @type {number} */ 744 WebGLRenderingContextBase.INT_VEC4; 745 746 /** @type {number} */ 747 WebGLRenderingContextBase.BOOL; 748 749 /** @type {number} */ 750 WebGLRenderingContextBase.BOOL_VEC2; 751 752 /** @type {number} */ 753 WebGLRenderingContextBase.BOOL_VEC3; 754 755 /** @type {number} */ 756 WebGLRenderingContextBase.BOOL_VEC4; 757 758 /** @type {number} */ 759 WebGLRenderingContextBase.FLOAT_MAT2; 760 761 /** @type {number} */ 762 WebGLRenderingContextBase.FLOAT_MAT3; 763 764 /** @type {number} */ 765 WebGLRenderingContextBase.FLOAT_MAT4; 766 767 /** @type {number} */ 768 WebGLRenderingContextBase.SAMPLER_2D; 769 770 /** @type {number} */ 771 WebGLRenderingContextBase.SAMPLER_CUBE; 772 773 /** @type {number} */ 774 WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_ENABLED; 775 776 /** @type {number} */ 777 WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_SIZE; 778 779 /** @type {number} */ 780 WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_STRIDE; 781 782 /** @type {number} */ 783 WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_TYPE; 784 785 /** @type {number} */ 786 WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_NORMALIZED; 787 788 /** @type {number} */ 789 WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_POINTER; 790 791 /** @type {number} */ 792 WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING; 793 794 /** @type {number} */ 795 WebGLRenderingContextBase.IMPLEMENTATION_COLOR_READ_TYPE; 796 797 /** @type {number} */ 798 WebGLRenderingContextBase.IMPLEMENTATION_COLOR_READ_FORMAT; 799 800 /** @type {number} */ 801 WebGLRenderingContextBase.COMPILE_STATUS; 802 803 /** @type {number} */ 804 WebGLRenderingContextBase.LOW_FLOAT; 805 806 /** @type {number} */ 807 WebGLRenderingContextBase.MEDIUM_FLOAT; 808 809 /** @type {number} */ 810 WebGLRenderingContextBase.HIGH_FLOAT; 811 812 /** @type {number} */ 813 WebGLRenderingContextBase.LOW_INT; 814 815 /** @type {number} */ 816 WebGLRenderingContextBase.MEDIUM_INT; 817 818 /** @type {number} */ 819 WebGLRenderingContextBase.HIGH_INT; 820 821 /** @type {number} */ 822 WebGLRenderingContextBase.FRAMEBUFFER; 823 824 /** @type {number} */ 825 WebGLRenderingContextBase.RENDERBUFFER; 826 827 /** @type {number} */ 828 WebGLRenderingContextBase.RGBA4; 829 830 /** @type {number} */ 831 WebGLRenderingContextBase.RGB5_A1; 832 833 /** @type {number} */ 834 WebGLRenderingContextBase.RGB565; 835 836 /** @type {number} */ 837 WebGLRenderingContextBase.DEPTH_COMPONENT16; 838 839 /** @type {number} */ 840 WebGLRenderingContextBase.STENCIL_INDEX; 841 842 /** @type {number} */ 843 WebGLRenderingContextBase.STENCIL_INDEX8; 844 845 /** @type {number} */ 846 WebGLRenderingContextBase.DEPTH_STENCIL; 847 848 /** @type {number} */ 849 WebGLRenderingContextBase.RENDERBUFFER_WIDTH; 850 851 /** @type {number} */ 852 WebGLRenderingContextBase.RENDERBUFFER_HEIGHT; 853 854 /** @type {number} */ 855 WebGLRenderingContextBase.RENDERBUFFER_INTERNAL_FORMAT; 856 857 /** @type {number} */ 858 WebGLRenderingContextBase.RENDERBUFFER_RED_SIZE; 859 860 /** @type {number} */ 861 WebGLRenderingContextBase.RENDERBUFFER_GREEN_SIZE; 862 863 /** @type {number} */ 864 WebGLRenderingContextBase.RENDERBUFFER_BLUE_SIZE; 865 866 /** @type {number} */ 867 WebGLRenderingContextBase.RENDERBUFFER_ALPHA_SIZE; 868 869 /** @type {number} */ 870 WebGLRenderingContextBase.RENDERBUFFER_DEPTH_SIZE; 871 872 /** @type {number} */ 873 WebGLRenderingContextBase.RENDERBUFFER_STENCIL_SIZE; 874 875 /** @type {number} */ 876 WebGLRenderingContextBase.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE; 877 878 /** @type {number} */ 879 WebGLRenderingContextBase.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME; 880 881 /** @type {number} */ 882 WebGLRenderingContextBase.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL; 883 884 /** @type {number} */ 885 WebGLRenderingContextBase.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE; 886 887 /** @type {number} */ 888 WebGLRenderingContextBase.COLOR_ATTACHMENT0; 889 890 /** @type {number} */ 891 WebGLRenderingContextBase.DEPTH_ATTACHMENT; 892 893 /** @type {number} */ 894 WebGLRenderingContextBase.STENCIL_ATTACHMENT; 895 896 /** @type {number} */ 897 WebGLRenderingContextBase.DEPTH_STENCIL_ATTACHMENT; 898 899 /** @type {number} */ 900 WebGLRenderingContextBase.NONE; 901 902 /** @type {number} */ 903 WebGLRenderingContextBase.FRAMEBUFFER_COMPLETE; 904 905 /** @type {number} */ 906 WebGLRenderingContextBase.FRAMEBUFFER_INCOMPLETE_ATTACHMENT; 907 908 /** @type {number} */ 909 WebGLRenderingContextBase.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT; 910 911 /** @type {number} */ 912 WebGLRenderingContextBase.FRAMEBUFFER_INCOMPLETE_DIMENSIONS; 913 914 /** @type {number} */ 915 WebGLRenderingContextBase.FRAMEBUFFER_UNSUPPORTED; 916 917 /** @type {number} */ 918 WebGLRenderingContextBase.FRAMEBUFFER_BINDING; 919 920 /** @type {number} */ 921 WebGLRenderingContextBase.RENDERBUFFER_BINDING; 922 923 /** @type {number} */ 924 WebGLRenderingContextBase.MAX_RENDERBUFFER_SIZE; 925 926 /** @type {number} */ 927 WebGLRenderingContextBase.INVALID_FRAMEBUFFER_OPERATION; 928 929 /** @type {number} */ 930 WebGLRenderingContextBase.UNPACK_FLIP_Y_WEBGL; 931 932 /** @type {number} */ 933 WebGLRenderingContextBase.UNPACK_PREMULTIPLY_ALPHA_WEBGL; 934 935 /** @type {number} */ 936 WebGLRenderingContextBase.CONTEXT_LOST_WEBGL; 937 938 /** @type {number} */ 939 WebGLRenderingContextBase.UNPACK_COLORSPACE_CONVERSION_WEBGL; 940 941 /** @type {number} */ 942 WebGLRenderingContextBase.BROWSER_DEFAULT_WEBGL; 943 944 945 /** @type {number} */ 946 WebGLRenderingContextBase.prototype.DEPTH_BUFFER_BIT; 947 948 /** @type {number} */ 949 WebGLRenderingContextBase.prototype.STENCIL_BUFFER_BIT; 950 951 /** @type {number} */ 952 WebGLRenderingContextBase.prototype.COLOR_BUFFER_BIT; 953 954 /** @type {number} */ 955 WebGLRenderingContextBase.prototype.POINTS; 956 957 /** @type {number} */ 958 WebGLRenderingContextBase.prototype.LINES; 959 960 /** @type {number} */ 961 WebGLRenderingContextBase.prototype.LINE_LOOP; 962 963 /** @type {number} */ 964 WebGLRenderingContextBase.prototype.LINE_STRIP; 965 966 /** @type {number} */ 967 WebGLRenderingContextBase.prototype.TRIANGLES; 968 969 /** @type {number} */ 970 WebGLRenderingContextBase.prototype.TRIANGLE_STRIP; 971 972 /** @type {number} */ 973 WebGLRenderingContextBase.prototype.TRIANGLE_FAN; 974 975 /** @type {number} */ 976 WebGLRenderingContextBase.prototype.ZERO; 977 978 /** @type {number} */ 979 WebGLRenderingContextBase.prototype.ONE; 980 981 /** @type {number} */ 982 WebGLRenderingContextBase.prototype.SRC_COLOR; 983 984 /** @type {number} */ 985 WebGLRenderingContextBase.prototype.ONE_MINUS_SRC_COLOR; 986 987 /** @type {number} */ 988 WebGLRenderingContextBase.prototype.SRC_ALPHA; 989 990 /** @type {number} */ 991 WebGLRenderingContextBase.prototype.ONE_MINUS_SRC_ALPHA; 992 993 /** @type {number} */ 994 WebGLRenderingContextBase.prototype.DST_ALPHA; 995 996 /** @type {number} */ 997 WebGLRenderingContextBase.prototype.ONE_MINUS_DST_ALPHA; 998 999 /** @type {number} */ 1000 WebGLRenderingContextBase.prototype.DST_COLOR; 1001 1002 /** @type {number} */ 1003 WebGLRenderingContextBase.prototype.ONE_MINUS_DST_COLOR; 1004 1005 /** @type {number} */ 1006 WebGLRenderingContextBase.prototype.SRC_ALPHA_SATURATE; 1007 1008 /** @type {number} */ 1009 WebGLRenderingContextBase.prototype.FUNC_ADD; 1010 1011 /** @type {number} */ 1012 WebGLRenderingContextBase.prototype.BLEND_EQUATION; 1013 1014 /** @type {number} */ 1015 WebGLRenderingContextBase.prototype.BLEND_EQUATION_RGB; 1016 1017 /** @type {number} */ 1018 WebGLRenderingContextBase.prototype.BLEND_EQUATION_ALPHA; 1019 1020 /** @type {number} */ 1021 WebGLRenderingContextBase.prototype.FUNC_SUBTRACT; 1022 1023 /** @type {number} */ 1024 WebGLRenderingContextBase.prototype.FUNC_REVERSE_SUBTRACT; 1025 1026 /** @type {number} */ 1027 WebGLRenderingContextBase.prototype.BLEND_DST_RGB; 1028 1029 /** @type {number} */ 1030 WebGLRenderingContextBase.prototype.BLEND_SRC_RGB; 1031 1032 /** @type {number} */ 1033 WebGLRenderingContextBase.prototype.BLEND_DST_ALPHA; 1034 1035 /** @type {number} */ 1036 WebGLRenderingContextBase.prototype.BLEND_SRC_ALPHA; 1037 1038 /** @type {number} */ 1039 WebGLRenderingContextBase.prototype.CONSTANT_COLOR; 1040 1041 /** @type {number} */ 1042 WebGLRenderingContextBase.prototype.ONE_MINUS_CONSTANT_COLOR; 1043 1044 /** @type {number} */ 1045 WebGLRenderingContextBase.prototype.CONSTANT_ALPHA; 1046 1047 /** @type {number} */ 1048 WebGLRenderingContextBase.prototype.ONE_MINUS_CONSTANT_ALPHA; 1049 1050 /** @type {number} */ 1051 WebGLRenderingContextBase.prototype.BLEND_COLOR; 1052 1053 /** @type {number} */ 1054 WebGLRenderingContextBase.prototype.ARRAY_BUFFER; 1055 1056 /** @type {number} */ 1057 WebGLRenderingContextBase.prototype.ELEMENT_ARRAY_BUFFER; 1058 1059 /** @type {number} */ 1060 WebGLRenderingContextBase.prototype.ARRAY_BUFFER_BINDING; 1061 1062 /** @type {number} */ 1063 WebGLRenderingContextBase.prototype.ELEMENT_ARRAY_BUFFER_BINDING; 1064 1065 /** @type {number} */ 1066 WebGLRenderingContextBase.prototype.STREAM_DRAW; 1067 1068 /** @type {number} */ 1069 WebGLRenderingContextBase.prototype.STATIC_DRAW; 1070 1071 /** @type {number} */ 1072 WebGLRenderingContextBase.prototype.DYNAMIC_DRAW; 1073 1074 /** @type {number} */ 1075 WebGLRenderingContextBase.prototype.BUFFER_SIZE; 1076 1077 /** @type {number} */ 1078 WebGLRenderingContextBase.prototype.BUFFER_USAGE; 1079 1080 /** @type {number} */ 1081 WebGLRenderingContextBase.prototype.CURRENT_VERTEX_ATTRIB; 1082 1083 /** @type {number} */ 1084 WebGLRenderingContextBase.prototype.FRONT; 1085 1086 /** @type {number} */ 1087 WebGLRenderingContextBase.prototype.BACK; 1088 1089 /** @type {number} */ 1090 WebGLRenderingContextBase.prototype.FRONT_AND_BACK; 1091 1092 /** @type {number} */ 1093 WebGLRenderingContextBase.prototype.CULL_FACE; 1094 1095 /** @type {number} */ 1096 WebGLRenderingContextBase.prototype.BLEND; 1097 1098 /** @type {number} */ 1099 WebGLRenderingContextBase.prototype.DITHER; 1100 1101 /** @type {number} */ 1102 WebGLRenderingContextBase.prototype.STENCIL_TEST; 1103 1104 /** @type {number} */ 1105 WebGLRenderingContextBase.prototype.DEPTH_TEST; 1106 1107 /** @type {number} */ 1108 WebGLRenderingContextBase.prototype.SCISSOR_TEST; 1109 1110 /** @type {number} */ 1111 WebGLRenderingContextBase.prototype.POLYGON_OFFSET_FILL; 1112 1113 /** @type {number} */ 1114 WebGLRenderingContextBase.prototype.SAMPLE_ALPHA_TO_COVERAGE; 1115 1116 /** @type {number} */ 1117 WebGLRenderingContextBase.prototype.SAMPLE_COVERAGE; 1118 1119 /** @type {number} */ 1120 WebGLRenderingContextBase.prototype.NO_ERROR; 1121 1122 /** @type {number} */ 1123 WebGLRenderingContextBase.prototype.INVALID_ENUM; 1124 1125 /** @type {number} */ 1126 WebGLRenderingContextBase.prototype.INVALID_VALUE; 1127 1128 /** @type {number} */ 1129 WebGLRenderingContextBase.prototype.INVALID_OPERATION; 1130 1131 /** @type {number} */ 1132 WebGLRenderingContextBase.prototype.OUT_OF_MEMORY; 1133 1134 /** @type {number} */ 1135 WebGLRenderingContextBase.prototype.CW; 1136 1137 /** @type {number} */ 1138 WebGLRenderingContextBase.prototype.CCW; 1139 1140 /** @type {number} */ 1141 WebGLRenderingContextBase.prototype.LINE_WIDTH; 1142 1143 /** @type {number} */ 1144 WebGLRenderingContextBase.prototype.ALIASED_POINT_SIZE_RANGE; 1145 1146 /** @type {number} */ 1147 WebGLRenderingContextBase.prototype.ALIASED_LINE_WIDTH_RANGE; 1148 1149 /** @type {number} */ 1150 WebGLRenderingContextBase.prototype.CULL_FACE_MODE; 1151 1152 /** @type {number} */ 1153 WebGLRenderingContextBase.prototype.FRONT_FACE; 1154 1155 /** @type {number} */ 1156 WebGLRenderingContextBase.prototype.DEPTH_RANGE; 1157 1158 /** @type {number} */ 1159 WebGLRenderingContextBase.prototype.DEPTH_WRITEMASK; 1160 1161 /** @type {number} */ 1162 WebGLRenderingContextBase.prototype.DEPTH_CLEAR_VALUE; 1163 1164 /** @type {number} */ 1165 WebGLRenderingContextBase.prototype.DEPTH_FUNC; 1166 1167 /** @type {number} */ 1168 WebGLRenderingContextBase.prototype.STENCIL_CLEAR_VALUE; 1169 1170 /** @type {number} */ 1171 WebGLRenderingContextBase.prototype.STENCIL_FUNC; 1172 1173 /** @type {number} */ 1174 WebGLRenderingContextBase.prototype.STENCIL_FAIL; 1175 1176 /** @type {number} */ 1177 WebGLRenderingContextBase.prototype.STENCIL_PASS_DEPTH_FAIL; 1178 1179 /** @type {number} */ 1180 WebGLRenderingContextBase.prototype.STENCIL_PASS_DEPTH_PASS; 1181 1182 /** @type {number} */ 1183 WebGLRenderingContextBase.prototype.STENCIL_REF; 1184 1185 /** @type {number} */ 1186 WebGLRenderingContextBase.prototype.STENCIL_VALUE_MASK; 1187 1188 /** @type {number} */ 1189 WebGLRenderingContextBase.prototype.STENCIL_WRITEMASK; 1190 1191 /** @type {number} */ 1192 WebGLRenderingContextBase.prototype.STENCIL_BACK_FUNC; 1193 1194 /** @type {number} */ 1195 WebGLRenderingContextBase.prototype.STENCIL_BACK_FAIL; 1196 1197 /** @type {number} */ 1198 WebGLRenderingContextBase.prototype.STENCIL_BACK_PASS_DEPTH_FAIL; 1199 1200 /** @type {number} */ 1201 WebGLRenderingContextBase.prototype.STENCIL_BACK_PASS_DEPTH_PASS; 1202 1203 /** @type {number} */ 1204 WebGLRenderingContextBase.prototype.STENCIL_BACK_REF; 1205 1206 /** @type {number} */ 1207 WebGLRenderingContextBase.prototype.STENCIL_BACK_VALUE_MASK; 1208 1209 /** @type {number} */ 1210 WebGLRenderingContextBase.prototype.STENCIL_BACK_WRITEMASK; 1211 1212 /** @type {number} */ 1213 WebGLRenderingContextBase.prototype.VIEWPORT; 1214 1215 /** @type {number} */ 1216 WebGLRenderingContextBase.prototype.SCISSOR_BOX; 1217 1218 /** @type {number} */ 1219 WebGLRenderingContextBase.prototype.COLOR_CLEAR_VALUE; 1220 1221 /** @type {number} */ 1222 WebGLRenderingContextBase.prototype.COLOR_WRITEMASK; 1223 1224 /** @type {number} */ 1225 WebGLRenderingContextBase.prototype.UNPACK_ALIGNMENT; 1226 1227 /** @type {number} */ 1228 WebGLRenderingContextBase.prototype.PACK_ALIGNMENT; 1229 1230 /** @type {number} */ 1231 WebGLRenderingContextBase.prototype.MAX_TEXTURE_SIZE; 1232 1233 /** @type {number} */ 1234 WebGLRenderingContextBase.prototype.MAX_VIEWPORT_DIMS; 1235 1236 /** @type {number} */ 1237 WebGLRenderingContextBase.prototype.SUBPIXEL_BITS; 1238 1239 /** @type {number} */ 1240 WebGLRenderingContextBase.prototype.RED_BITS; 1241 1242 /** @type {number} */ 1243 WebGLRenderingContextBase.prototype.GREEN_BITS; 1244 1245 /** @type {number} */ 1246 WebGLRenderingContextBase.prototype.BLUE_BITS; 1247 1248 /** @type {number} */ 1249 WebGLRenderingContextBase.prototype.ALPHA_BITS; 1250 1251 /** @type {number} */ 1252 WebGLRenderingContextBase.prototype.DEPTH_BITS; 1253 1254 /** @type {number} */ 1255 WebGLRenderingContextBase.prototype.STENCIL_BITS; 1256 1257 /** @type {number} */ 1258 WebGLRenderingContextBase.prototype.POLYGON_OFFSET_UNITS; 1259 1260 /** @type {number} */ 1261 WebGLRenderingContextBase.prototype.POLYGON_OFFSET_FACTOR; 1262 1263 /** @type {number} */ 1264 WebGLRenderingContextBase.prototype.TEXTURE_BINDING_2D; 1265 1266 /** @type {number} */ 1267 WebGLRenderingContextBase.prototype.SAMPLE_BUFFERS; 1268 1269 /** @type {number} */ 1270 WebGLRenderingContextBase.prototype.SAMPLES; 1271 1272 /** @type {number} */ 1273 WebGLRenderingContextBase.prototype.SAMPLE_COVERAGE_VALUE; 1274 1275 /** @type {number} */ 1276 WebGLRenderingContextBase.prototype.SAMPLE_COVERAGE_INVERT; 1277 1278 /** @type {number} */ 1279 WebGLRenderingContextBase.prototype.COMPRESSED_TEXTURE_FORMATS; 1280 1281 /** @type {number} */ 1282 WebGLRenderingContextBase.prototype.DONT_CARE; 1283 1284 /** @type {number} */ 1285 WebGLRenderingContextBase.prototype.FASTEST; 1286 1287 /** @type {number} */ 1288 WebGLRenderingContextBase.prototype.NICEST; 1289 1290 /** @type {number} */ 1291 WebGLRenderingContextBase.prototype.GENERATE_MIPMAP_HINT; 1292 1293 /** @type {number} */ 1294 WebGLRenderingContextBase.prototype.BYTE; 1295 1296 /** @type {number} */ 1297 WebGLRenderingContextBase.prototype.UNSIGNED_BYTE; 1298 1299 /** @type {number} */ 1300 WebGLRenderingContextBase.prototype.SHORT; 1301 1302 /** @type {number} */ 1303 WebGLRenderingContextBase.prototype.UNSIGNED_SHORT; 1304 1305 /** @type {number} */ 1306 WebGLRenderingContextBase.prototype.INT; 1307 1308 /** @type {number} */ 1309 WebGLRenderingContextBase.prototype.UNSIGNED_INT; 1310 1311 /** @type {number} */ 1312 WebGLRenderingContextBase.prototype.FLOAT; 1313 1314 /** @type {number} */ 1315 WebGLRenderingContextBase.prototype.DEPTH_COMPONENT; 1316 1317 /** @type {number} */ 1318 WebGLRenderingContextBase.prototype.ALPHA; 1319 1320 /** @type {number} */ 1321 WebGLRenderingContextBase.prototype.RGB; 1322 1323 /** @type {number} */ 1324 WebGLRenderingContextBase.prototype.RGBA; 1325 1326 /** @type {number} */ 1327 WebGLRenderingContextBase.prototype.LUMINANCE; 1328 1329 /** @type {number} */ 1330 WebGLRenderingContextBase.prototype.LUMINANCE_ALPHA; 1331 1332 /** @type {number} */ 1333 WebGLRenderingContextBase.prototype.UNSIGNED_SHORT_4_4_4_4; 1334 1335 /** @type {number} */ 1336 WebGLRenderingContextBase.prototype.UNSIGNED_SHORT_5_5_5_1; 1337 1338 /** @type {number} */ 1339 WebGLRenderingContextBase.prototype.UNSIGNED_SHORT_5_6_5; 1340 1341 /** @type {number} */ 1342 WebGLRenderingContextBase.prototype.FRAGMENT_SHADER; 1343 1344 /** @type {number} */ 1345 WebGLRenderingContextBase.prototype.VERTEX_SHADER; 1346 1347 /** @type {number} */ 1348 WebGLRenderingContextBase.prototype.MAX_VERTEX_ATTRIBS; 1349 1350 /** @type {number} */ 1351 WebGLRenderingContextBase.prototype.MAX_VERTEX_UNIFORM_VECTORS; 1352 1353 /** @type {number} */ 1354 WebGLRenderingContextBase.prototype.MAX_VARYING_VECTORS; 1355 1356 /** @type {number} */ 1357 WebGLRenderingContextBase.prototype.MAX_COMBINED_TEXTURE_IMAGE_UNITS; 1358 1359 /** @type {number} */ 1360 WebGLRenderingContextBase.prototype.MAX_VERTEX_TEXTURE_IMAGE_UNITS; 1361 1362 /** @type {number} */ 1363 WebGLRenderingContextBase.prototype.MAX_TEXTURE_IMAGE_UNITS; 1364 1365 /** @type {number} */ 1366 WebGLRenderingContextBase.prototype.MAX_FRAGMENT_UNIFORM_VECTORS; 1367 1368 /** @type {number} */ 1369 WebGLRenderingContextBase.prototype.SHADER_TYPE; 1370 1371 /** @type {number} */ 1372 WebGLRenderingContextBase.prototype.DELETE_STATUS; 1373 1374 /** @type {number} */ 1375 WebGLRenderingContextBase.prototype.LINK_STATUS; 1376 1377 /** @type {number} */ 1378 WebGLRenderingContextBase.prototype.VALIDATE_STATUS; 1379 1380 /** @type {number} */ 1381 WebGLRenderingContextBase.prototype.ATTACHED_SHADERS; 1382 1383 /** @type {number} */ 1384 WebGLRenderingContextBase.prototype.ACTIVE_UNIFORMS; 1385 1386 /** @type {number} */ 1387 WebGLRenderingContextBase.prototype.ACTIVE_ATTRIBUTES; 1388 1389 /** @type {number} */ 1390 WebGLRenderingContextBase.prototype.SHADING_LANGUAGE_VERSION; 1391 1392 /** @type {number} */ 1393 WebGLRenderingContextBase.prototype.CURRENT_PROGRAM; 1394 1395 /** @type {number} */ 1396 WebGLRenderingContextBase.prototype.NEVER; 1397 1398 /** @type {number} */ 1399 WebGLRenderingContextBase.prototype.LESS; 1400 1401 /** @type {number} */ 1402 WebGLRenderingContextBase.prototype.EQUAL; 1403 1404 /** @type {number} */ 1405 WebGLRenderingContextBase.prototype.LEQUAL; 1406 1407 /** @type {number} */ 1408 WebGLRenderingContextBase.prototype.GREATER; 1409 1410 /** @type {number} */ 1411 WebGLRenderingContextBase.prototype.NOTEQUAL; 1412 1413 /** @type {number} */ 1414 WebGLRenderingContextBase.prototype.GEQUAL; 1415 1416 /** @type {number} */ 1417 WebGLRenderingContextBase.prototype.ALWAYS; 1418 1419 /** @type {number} */ 1420 WebGLRenderingContextBase.prototype.KEEP; 1421 1422 /** @type {number} */ 1423 WebGLRenderingContextBase.prototype.REPLACE; 1424 1425 /** @type {number} */ 1426 WebGLRenderingContextBase.prototype.INCR; 1427 1428 /** @type {number} */ 1429 WebGLRenderingContextBase.prototype.DECR; 1430 1431 /** @type {number} */ 1432 WebGLRenderingContextBase.prototype.INVERT; 1433 1434 /** @type {number} */ 1435 WebGLRenderingContextBase.prototype.INCR_WRAP; 1436 1437 /** @type {number} */ 1438 WebGLRenderingContextBase.prototype.DECR_WRAP; 1439 1440 /** @type {number} */ 1441 WebGLRenderingContextBase.prototype.VENDOR; 1442 1443 /** @type {number} */ 1444 WebGLRenderingContextBase.prototype.RENDERER; 1445 1446 /** @type {number} */ 1447 WebGLRenderingContextBase.prototype.VERSION; 1448 1449 /** @type {number} */ 1450 WebGLRenderingContextBase.prototype.NEAREST; 1451 1452 /** @type {number} */ 1453 WebGLRenderingContextBase.prototype.LINEAR; 1454 1455 /** @type {number} */ 1456 WebGLRenderingContextBase.prototype.NEAREST_MIPMAP_NEAREST; 1457 1458 /** @type {number} */ 1459 WebGLRenderingContextBase.prototype.LINEAR_MIPMAP_NEAREST; 1460 1461 /** @type {number} */ 1462 WebGLRenderingContextBase.prototype.NEAREST_MIPMAP_LINEAR; 1463 1464 /** @type {number} */ 1465 WebGLRenderingContextBase.prototype.LINEAR_MIPMAP_LINEAR; 1466 1467 /** @type {number} */ 1468 WebGLRenderingContextBase.prototype.TEXTURE_MAG_FILTER; 1469 1470 /** @type {number} */ 1471 WebGLRenderingContextBase.prototype.TEXTURE_MIN_FILTER; 1472 1473 /** @type {number} */ 1474 WebGLRenderingContextBase.prototype.TEXTURE_WRAP_S; 1475 1476 /** @type {number} */ 1477 WebGLRenderingContextBase.prototype.TEXTURE_WRAP_T; 1478 1479 /** @type {number} */ 1480 WebGLRenderingContextBase.prototype.TEXTURE_2D; 1481 1482 /** @type {number} */ 1483 WebGLRenderingContextBase.prototype.TEXTURE; 1484 1485 /** @type {number} */ 1486 WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP; 1487 1488 /** @type {number} */ 1489 WebGLRenderingContextBase.prototype.TEXTURE_BINDING_CUBE_MAP; 1490 1491 /** @type {number} */ 1492 WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_POSITIVE_X; 1493 1494 /** @type {number} */ 1495 WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_NEGATIVE_X; 1496 1497 /** @type {number} */ 1498 WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_POSITIVE_Y; 1499 1500 /** @type {number} */ 1501 WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_NEGATIVE_Y; 1502 1503 /** @type {number} */ 1504 WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_POSITIVE_Z; 1505 1506 /** @type {number} */ 1507 WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_NEGATIVE_Z; 1508 1509 /** @type {number} */ 1510 WebGLRenderingContextBase.prototype.MAX_CUBE_MAP_TEXTURE_SIZE; 1511 1512 /** @type {number} */ 1513 WebGLRenderingContextBase.prototype.TEXTURE0; 1514 1515 /** @type {number} */ 1516 WebGLRenderingContextBase.prototype.TEXTURE1; 1517 1518 /** @type {number} */ 1519 WebGLRenderingContextBase.prototype.TEXTURE2; 1520 1521 /** @type {number} */ 1522 WebGLRenderingContextBase.prototype.TEXTURE3; 1523 1524 /** @type {number} */ 1525 WebGLRenderingContextBase.prototype.TEXTURE4; 1526 1527 /** @type {number} */ 1528 WebGLRenderingContextBase.prototype.TEXTURE5; 1529 1530 /** @type {number} */ 1531 WebGLRenderingContextBase.prototype.TEXTURE6; 1532 1533 /** @type {number} */ 1534 WebGLRenderingContextBase.prototype.TEXTURE7; 1535 1536 /** @type {number} */ 1537 WebGLRenderingContextBase.prototype.TEXTURE8; 1538 1539 /** @type {number} */ 1540 WebGLRenderingContextBase.prototype.TEXTURE9; 1541 1542 /** @type {number} */ 1543 WebGLRenderingContextBase.prototype.TEXTURE10; 1544 1545 /** @type {number} */ 1546 WebGLRenderingContextBase.prototype.TEXTURE11; 1547 1548 /** @type {number} */ 1549 WebGLRenderingContextBase.prototype.TEXTURE12; 1550 1551 /** @type {number} */ 1552 WebGLRenderingContextBase.prototype.TEXTURE13; 1553 1554 /** @type {number} */ 1555 WebGLRenderingContextBase.prototype.TEXTURE14; 1556 1557 /** @type {number} */ 1558 WebGLRenderingContextBase.prototype.TEXTURE15; 1559 1560 /** @type {number} */ 1561 WebGLRenderingContextBase.prototype.TEXTURE16; 1562 1563 /** @type {number} */ 1564 WebGLRenderingContextBase.prototype.TEXTURE17; 1565 1566 /** @type {number} */ 1567 WebGLRenderingContextBase.prototype.TEXTURE18; 1568 1569 /** @type {number} */ 1570 WebGLRenderingContextBase.prototype.TEXTURE19; 1571 1572 /** @type {number} */ 1573 WebGLRenderingContextBase.prototype.TEXTURE20; 1574 1575 /** @type {number} */ 1576 WebGLRenderingContextBase.prototype.TEXTURE21; 1577 1578 /** @type {number} */ 1579 WebGLRenderingContextBase.prototype.TEXTURE22; 1580 1581 /** @type {number} */ 1582 WebGLRenderingContextBase.prototype.TEXTURE23; 1583 1584 /** @type {number} */ 1585 WebGLRenderingContextBase.prototype.TEXTURE24; 1586 1587 /** @type {number} */ 1588 WebGLRenderingContextBase.prototype.TEXTURE25; 1589 1590 /** @type {number} */ 1591 WebGLRenderingContextBase.prototype.TEXTURE26; 1592 1593 /** @type {number} */ 1594 WebGLRenderingContextBase.prototype.TEXTURE27; 1595 1596 /** @type {number} */ 1597 WebGLRenderingContextBase.prototype.TEXTURE28; 1598 1599 /** @type {number} */ 1600 WebGLRenderingContextBase.prototype.TEXTURE29; 1601 1602 /** @type {number} */ 1603 WebGLRenderingContextBase.prototype.TEXTURE30; 1604 1605 /** @type {number} */ 1606 WebGLRenderingContextBase.prototype.TEXTURE31; 1607 1608 /** @type {number} */ 1609 WebGLRenderingContextBase.prototype.ACTIVE_TEXTURE; 1610 1611 /** @type {number} */ 1612 WebGLRenderingContextBase.prototype.REPEAT; 1613 1614 /** @type {number} */ 1615 WebGLRenderingContextBase.prototype.CLAMP_TO_EDGE; 1616 1617 /** @type {number} */ 1618 WebGLRenderingContextBase.prototype.MIRRORED_REPEAT; 1619 1620 /** @type {number} */ 1621 WebGLRenderingContextBase.prototype.FLOAT_VEC2; 1622 1623 /** @type {number} */ 1624 WebGLRenderingContextBase.prototype.FLOAT_VEC3; 1625 1626 /** @type {number} */ 1627 WebGLRenderingContextBase.prototype.FLOAT_VEC4; 1628 1629 /** @type {number} */ 1630 WebGLRenderingContextBase.prototype.INT_VEC2; 1631 1632 /** @type {number} */ 1633 WebGLRenderingContextBase.prototype.INT_VEC3; 1634 1635 /** @type {number} */ 1636 WebGLRenderingContextBase.prototype.INT_VEC4; 1637 1638 /** @type {number} */ 1639 WebGLRenderingContextBase.prototype.BOOL; 1640 1641 /** @type {number} */ 1642 WebGLRenderingContextBase.prototype.BOOL_VEC2; 1643 1644 /** @type {number} */ 1645 WebGLRenderingContextBase.prototype.BOOL_VEC3; 1646 1647 /** @type {number} */ 1648 WebGLRenderingContextBase.prototype.BOOL_VEC4; 1649 1650 /** @type {number} */ 1651 WebGLRenderingContextBase.prototype.FLOAT_MAT2; 1652 1653 /** @type {number} */ 1654 WebGLRenderingContextBase.prototype.FLOAT_MAT3; 1655 1656 /** @type {number} */ 1657 WebGLRenderingContextBase.prototype.FLOAT_MAT4; 1658 1659 /** @type {number} */ 1660 WebGLRenderingContextBase.prototype.SAMPLER_2D; 1661 1662 /** @type {number} */ 1663 WebGLRenderingContextBase.prototype.SAMPLER_CUBE; 1664 1665 /** @type {number} */ 1666 WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_ENABLED; 1667 1668 /** @type {number} */ 1669 WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_SIZE; 1670 1671 /** @type {number} */ 1672 WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_STRIDE; 1673 1674 /** @type {number} */ 1675 WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_TYPE; 1676 1677 /** @type {number} */ 1678 WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_NORMALIZED; 1679 1680 /** @type {number} */ 1681 WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_POINTER; 1682 1683 /** @type {number} */ 1684 WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING; 1685 1686 /** @type {number} */ 1687 WebGLRenderingContextBase.prototype.IMPLEMENTATION_COLOR_READ_TYPE; 1688 1689 /** @type {number} */ 1690 WebGLRenderingContextBase.prototype.IMPLEMENTATION_COLOR_READ_FORMAT; 1691 1692 /** @type {number} */ 1693 WebGLRenderingContextBase.prototype.COMPILE_STATUS; 1694 1695 /** @type {number} */ 1696 WebGLRenderingContextBase.prototype.LOW_FLOAT; 1697 1698 /** @type {number} */ 1699 WebGLRenderingContextBase.prototype.MEDIUM_FLOAT; 1700 1701 /** @type {number} */ 1702 WebGLRenderingContextBase.prototype.HIGH_FLOAT; 1703 1704 /** @type {number} */ 1705 WebGLRenderingContextBase.prototype.LOW_INT; 1706 1707 /** @type {number} */ 1708 WebGLRenderingContextBase.prototype.MEDIUM_INT; 1709 1710 /** @type {number} */ 1711 WebGLRenderingContextBase.prototype.HIGH_INT; 1712 1713 /** @type {number} */ 1714 WebGLRenderingContextBase.prototype.FRAMEBUFFER; 1715 1716 /** @type {number} */ 1717 WebGLRenderingContextBase.prototype.RENDERBUFFER; 1718 1719 /** @type {number} */ 1720 WebGLRenderingContextBase.prototype.RGBA4; 1721 1722 /** @type {number} */ 1723 WebGLRenderingContextBase.prototype.RGB5_A1; 1724 1725 /** @type {number} */ 1726 WebGLRenderingContextBase.prototype.RGB565; 1727 1728 /** @type {number} */ 1729 WebGLRenderingContextBase.prototype.DEPTH_COMPONENT16; 1730 1731 /** @type {number} */ 1732 WebGLRenderingContextBase.prototype.STENCIL_INDEX; 1733 1734 /** @type {number} */ 1735 WebGLRenderingContextBase.prototype.STENCIL_INDEX8; 1736 1737 /** @type {number} */ 1738 WebGLRenderingContextBase.prototype.DEPTH_STENCIL; 1739 1740 /** @type {number} */ 1741 WebGLRenderingContextBase.prototype.RENDERBUFFER_WIDTH; 1742 1743 /** @type {number} */ 1744 WebGLRenderingContextBase.prototype.RENDERBUFFER_HEIGHT; 1745 1746 /** @type {number} */ 1747 WebGLRenderingContextBase.prototype.RENDERBUFFER_INTERNAL_FORMAT; 1748 1749 /** @type {number} */ 1750 WebGLRenderingContextBase.prototype.RENDERBUFFER_RED_SIZE; 1751 1752 /** @type {number} */ 1753 WebGLRenderingContextBase.prototype.RENDERBUFFER_GREEN_SIZE; 1754 1755 /** @type {number} */ 1756 WebGLRenderingContextBase.prototype.RENDERBUFFER_BLUE_SIZE; 1757 1758 /** @type {number} */ 1759 WebGLRenderingContextBase.prototype.RENDERBUFFER_ALPHA_SIZE; 1760 1761 /** @type {number} */ 1762 WebGLRenderingContextBase.prototype.RENDERBUFFER_DEPTH_SIZE; 1763 1764 /** @type {number} */ 1765 WebGLRenderingContextBase.prototype.RENDERBUFFER_STENCIL_SIZE; 1766 1767 /** @type {number} */ 1768 WebGLRenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE; 1769 1770 /** @type {number} */ 1771 WebGLRenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME; 1772 1773 /** @type {number} */ 1774 WebGLRenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL; 1775 1776 /** @type {number} */ 1777 WebGLRenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE; 1778 1779 /** @type {number} */ 1780 WebGLRenderingContextBase.prototype.COLOR_ATTACHMENT0; 1781 1782 /** @type {number} */ 1783 WebGLRenderingContextBase.prototype.DEPTH_ATTACHMENT; 1784 1785 /** @type {number} */ 1786 WebGLRenderingContextBase.prototype.STENCIL_ATTACHMENT; 1787 1788 /** @type {number} */ 1789 WebGLRenderingContextBase.prototype.DEPTH_STENCIL_ATTACHMENT; 1790 1791 /** @type {number} */ 1792 WebGLRenderingContextBase.prototype.NONE; 1793 1794 /** @type {number} */ 1795 WebGLRenderingContextBase.prototype.FRAMEBUFFER_COMPLETE; 1796 1797 /** @type {number} */ 1798 WebGLRenderingContextBase.prototype.FRAMEBUFFER_INCOMPLETE_ATTACHMENT; 1799 1800 /** @type {number} */ 1801 WebGLRenderingContextBase.prototype.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT; 1802 1803 /** @type {number} */ 1804 WebGLRenderingContextBase.prototype.FRAMEBUFFER_INCOMPLETE_DIMENSIONS; 1805 1806 /** @type {number} */ 1807 WebGLRenderingContextBase.prototype.FRAMEBUFFER_UNSUPPORTED; 1808 1809 /** @type {number} */ 1810 WebGLRenderingContextBase.prototype.FRAMEBUFFER_BINDING; 1811 1812 /** @type {number} */ 1813 WebGLRenderingContextBase.prototype.RENDERBUFFER_BINDING; 1814 1815 /** @type {number} */ 1816 WebGLRenderingContextBase.prototype.MAX_RENDERBUFFER_SIZE; 1817 1818 /** @type {number} */ 1819 WebGLRenderingContextBase.prototype.INVALID_FRAMEBUFFER_OPERATION; 1820 1821 /** @type {number} */ 1822 WebGLRenderingContextBase.prototype.UNPACK_FLIP_Y_WEBGL; 1823 1824 /** @type {number} */ 1825 WebGLRenderingContextBase.prototype.UNPACK_PREMULTIPLY_ALPHA_WEBGL; 1826 1827 /** @type {number} */ 1828 WebGLRenderingContextBase.prototype.CONTEXT_LOST_WEBGL; 1829 1830 /** @type {number} */ 1831 WebGLRenderingContextBase.prototype.UNPACK_COLORSPACE_CONVERSION_WEBGL; 1832 1833 /** @type {number} */ 1834 WebGLRenderingContextBase.prototype.BROWSER_DEFAULT_WEBGL; 1835 1836 1837 /** 1838 * @type {!HTMLCanvasElement} 1839 */ 1840 WebGLRenderingContextBase.prototype.canvas; 1841 1842 /** 1843 * @type {number} 1844 */ 1845 WebGLRenderingContextBase.prototype.drawingBufferWidth; 1846 1847 /** 1848 * @type {number} 1849 */ 1850 WebGLRenderingContextBase.prototype.drawingBufferHeight; 1851 1852 /** 1853 * @return {!WebGLContextAttributes} 1854 * @nosideeffects 1855 */ 1856 WebGLRenderingContextBase.prototype.getContextAttributes = function() {}; 1857 1858 /** 1859 * @return {boolean} 1860 * @nosideeffects 1861 */ 1862 WebGLRenderingContextBase.prototype.isContextLost = function() {}; 1863 1864 /** 1865 * @return {!Array.<string>} 1866 * @nosideeffects 1867 */ 1868 WebGLRenderingContextBase.prototype.getSupportedExtensions = function() {}; 1869 1870 /** 1871 * Note that this has side effects by enabling the extension even if the 1872 * result is not used. 1873 * @param {string} name 1874 * @return {Object} 1875 */ 1876 WebGLRenderingContextBase.prototype.getExtension = function(name) {}; 1877 1878 /** 1879 * @param {number} texture 1880 */ 1881 WebGLRenderingContextBase.prototype.activeTexture = function(texture) {}; 1882 1883 /** 1884 * @param {WebGLProgram} program 1885 * @param {WebGLShader} shader 1886 */ 1887 WebGLRenderingContextBase.prototype.attachShader = function(program, shader) {}; 1888 1889 /** 1890 * @param {WebGLProgram} program 1891 * @param {number} index 1892 * @param {string} name 1893 */ 1894 WebGLRenderingContextBase.prototype.bindAttribLocation = function( 1895 program, index, name) {}; 1896 1897 /** 1898 * @param {number} target 1899 * @param {WebGLBuffer} buffer 1900 */ 1901 WebGLRenderingContextBase.prototype.bindBuffer = function(target, buffer) {}; 1902 1903 /** 1904 * @param {number} target 1905 * @param {WebGLFramebuffer} buffer 1906 */ 1907 WebGLRenderingContextBase.prototype.bindFramebuffer = function(target, buffer) {}; 1908 1909 /** 1910 * @param {number} target 1911 * @param {WebGLRenderbuffer} buffer 1912 */ 1913 WebGLRenderingContextBase.prototype.bindRenderbuffer = function(target, buffer) {}; 1914 1915 /** 1916 * @param {number} target 1917 * @param {WebGLTexture} texture 1918 */ 1919 WebGLRenderingContextBase.prototype.bindTexture = function(target, texture) {}; 1920 1921 /** 1922 * @param {number} red 1923 * @param {number} green 1924 * @param {number} blue 1925 * @param {number} alpha 1926 */ 1927 WebGLRenderingContextBase.prototype.blendColor = function( 1928 red, blue, green, alpha) {}; 1929 1930 /** 1931 * @param {number} mode 1932 */ 1933 WebGLRenderingContextBase.prototype.blendEquation = function(mode) {}; 1934 1935 /** 1936 * @param {number} modeRGB 1937 * @param {number} modeAlpha 1938 */ 1939 WebGLRenderingContextBase.prototype.blendEquationSeparate = function( 1940 modeRGB, modeAlpha) {}; 1941 1942 /** 1943 * @param {number} sfactor 1944 * @param {number} dfactor 1945 */ 1946 WebGLRenderingContextBase.prototype.blendFunc = function(sfactor, dfactor) {}; 1947 1948 /** 1949 * @param {number} srcRGB 1950 * @param {number} dstRGB 1951 * @param {number} srcAlpha 1952 * @param {number} dstAlpha 1953 */ 1954 WebGLRenderingContextBase.prototype.blendFuncSeparate = function( 1955 srcRGB, dstRGB, srcAlpha, dstAlpha) {}; 1956 1957 /** 1958 * @param {number} target 1959 * @param {ArrayBufferView|ArrayBuffer|number} data 1960 * @param {number} usage 1961 */ 1962 WebGLRenderingContextBase.prototype.bufferData = function(target, data, usage) {}; 1963 1964 /** 1965 * @param {number} target 1966 * @param {number} offset 1967 * @param {ArrayBufferView|ArrayBuffer} data 1968 */ 1969 WebGLRenderingContextBase.prototype.bufferSubData = function( 1970 target, offset, data) {}; 1971 1972 /** 1973 * @param {number} target 1974 * @return {number} 1975 */ 1976 WebGLRenderingContextBase.prototype.checkFramebufferStatus = function(target) {}; 1977 1978 /** 1979 * @param {number} mask 1980 */ 1981 WebGLRenderingContextBase.prototype.clear = function(mask) {}; 1982 1983 /** 1984 * @param {number} red 1985 * @param {number} green 1986 * @param {number} blue 1987 * @param {number} alpha 1988 */ 1989 WebGLRenderingContextBase.prototype.clearColor = function( 1990 red, green, blue, alpha) {}; 1991 1992 /** 1993 * @param {number} depth 1994 */ 1995 WebGLRenderingContextBase.prototype.clearDepth = function(depth) {}; 1996 1997 /** 1998 * @param {number} s 1999 */ 2000 WebGLRenderingContextBase.prototype.clearStencil = function(s) {}; 2001 2002 /** 2003 * @param {boolean} red 2004 * @param {boolean} green 2005 * @param {boolean} blue 2006 * @param {boolean} alpha 2007 */ 2008 WebGLRenderingContextBase.prototype.colorMask = function( 2009 red, green, blue, alpha) {}; 2010 2011 /** 2012 * @param {WebGLShader} shader 2013 */ 2014 WebGLRenderingContextBase.prototype.compileShader = function(shader) {}; 2015 2016 /** 2017 * @param {number} target 2018 * @param {number} level 2019 * @param {number} internalformat 2020 * @param {number} width 2021 * @param {number} height 2022 * @param {number} border 2023 * @param {ArrayBufferView} data 2024 */ 2025 WebGLRenderingContextBase.prototype.compressedTexImage2D = function( 2026 target, level, internalformat, width, height, border, data) {}; 2027 2028 /** 2029 * @param {number} target 2030 * @param {number} level 2031 * @param {number} xoffset 2032 * @param {number} yoffset 2033 * @param {number} width 2034 * @param {number} height 2035 * @param {number} format 2036 * @param {ArrayBufferView} data 2037 */ 2038 WebGLRenderingContextBase.prototype.compressedTexSubImage2D = function( 2039 target, level, xoffset, yoffset, width, height, format, data) {}; 2040 2041 /** 2042 * @param {number} target 2043 * @param {number} level 2044 * @param {number} format 2045 * @param {number} x 2046 * @param {number} y 2047 * @param {number} width 2048 * @param {number} height 2049 * @param {number} border 2050 */ 2051 WebGLRenderingContextBase.prototype.copyTexImage2D = function( 2052 target, level, format, x, y, width, height, border) {}; 2053 2054 /** 2055 * @param {number} target 2056 * @param {number} level 2057 * @param {number} xoffset 2058 * @param {number} yoffset 2059 * @param {number} x 2060 * @param {number} y 2061 * @param {number} width 2062 * @param {number} height 2063 */ 2064 WebGLRenderingContextBase.prototype.copyTexSubImage2D = function( 2065 target, level, xoffset, yoffset, x, y, width, height) {}; 2066 2067 /** 2068 * @return {!WebGLBuffer} 2069 * @nosideeffects 2070 */ 2071 WebGLRenderingContextBase.prototype.createBuffer = function() {}; 2072 2073 /** 2074 * @return {!WebGLFramebuffer} 2075 * @nosideeffects 2076 */ 2077 WebGLRenderingContextBase.prototype.createFramebuffer = function() {}; 2078 2079 /** 2080 * @return {!WebGLProgram} 2081 * @nosideeffects 2082 */ 2083 WebGLRenderingContextBase.prototype.createProgram = function() {}; 2084 2085 /** 2086 * @return {!WebGLRenderbuffer} 2087 * @nosideeffects 2088 */ 2089 WebGLRenderingContextBase.prototype.createRenderbuffer = function() {}; 2090 2091 /** 2092 * @param {number} type 2093 * @return {!WebGLShader} 2094 * @nosideeffects 2095 */ 2096 WebGLRenderingContextBase.prototype.createShader = function(type) {}; 2097 2098 /** 2099 * @return {!WebGLTexture} 2100 * @nosideeffects 2101 */ 2102 WebGLRenderingContextBase.prototype.createTexture = function() {}; 2103 2104 /** 2105 * @param {number} mode 2106 */ 2107 WebGLRenderingContextBase.prototype.cullFace = function(mode) {}; 2108 2109 /** 2110 * @param {WebGLBuffer} buffer 2111 */ 2112 WebGLRenderingContextBase.prototype.deleteBuffer = function(buffer) {}; 2113 2114 /** 2115 * @param {WebGLFramebuffer} buffer 2116 */ 2117 WebGLRenderingContextBase.prototype.deleteFramebuffer = function(buffer) {}; 2118 2119 /** 2120 * @param {WebGLProgram} program 2121 */ 2122 WebGLRenderingContextBase.prototype.deleteProgram = function(program) {}; 2123 2124 /** 2125 * @param {WebGLRenderbuffer} buffer 2126 */ 2127 WebGLRenderingContextBase.prototype.deleteRenderbuffer = function(buffer) {}; 2128 2129 /** 2130 * @param {WebGLShader} shader 2131 */ 2132 WebGLRenderingContextBase.prototype.deleteShader = function(shader) {}; 2133 2134 /** 2135 * @param {WebGLTexture} texture 2136 */ 2137 WebGLRenderingContextBase.prototype.deleteTexture = function(texture) {}; 2138 2139 /** 2140 * @param {number} func 2141 */ 2142 WebGLRenderingContextBase.prototype.depthFunc = function(func) {}; 2143 2144 /** 2145 * @param {boolean} flag 2146 */ 2147 WebGLRenderingContextBase.prototype.depthMask = function(flag) {}; 2148 2149 /** 2150 * @param {number} nearVal 2151 * @param {number} farVal 2152 */ 2153 WebGLRenderingContextBase.prototype.depthRange = function(nearVal, farVal) {}; 2154 2155 /** 2156 * @param {WebGLProgram} program 2157 * @param {WebGLShader} shader 2158 */ 2159 WebGLRenderingContextBase.prototype.detachShader = function(program, shader) {}; 2160 2161 /** 2162 * @param {number} flags 2163 */ 2164 WebGLRenderingContextBase.prototype.disable = function(flags) {}; 2165 2166 /** 2167 * @param {number} index 2168 */ 2169 WebGLRenderingContextBase.prototype.disableVertexAttribArray = function( 2170 index) {}; 2171 2172 /** 2173 * @param {number} mode 2174 * @param {number} first 2175 * @param {number} count 2176 */ 2177 WebGLRenderingContextBase.prototype.drawArrays = function(mode, first, count) {}; 2178 2179 /** 2180 * @param {number} mode 2181 * @param {number} count 2182 * @param {number} type 2183 * @param {number} offset 2184 */ 2185 WebGLRenderingContextBase.prototype.drawElements = function( 2186 mode, count, type, offset) {}; 2187 2188 /** 2189 * @param {number} cap 2190 */ 2191 WebGLRenderingContextBase.prototype.enable = function(cap) {}; 2192 2193 /** 2194 * @param {number} index 2195 */ 2196 WebGLRenderingContextBase.prototype.enableVertexAttribArray = function( 2197 index) {}; 2198 2199 WebGLRenderingContextBase.prototype.finish = function() {}; 2200 2201 WebGLRenderingContextBase.prototype.flush = function() {}; 2202 2203 /** 2204 * @param {number} target 2205 * @param {number} attachment 2206 * @param {number} renderbuffertarget 2207 * @param {WebGLRenderbuffer} renderbuffer 2208 */ 2209 WebGLRenderingContextBase.prototype.framebufferRenderbuffer = function( 2210 target, attachment, renderbuffertarget, renderbuffer) {}; 2211 2212 /** 2213 * @param {number} target 2214 * @param {number} attachment 2215 * @param {number} textarget 2216 * @param {WebGLTexture} texture 2217 * @param {number} level 2218 */ 2219 WebGLRenderingContextBase.prototype.framebufferTexture2D = function( 2220 target, attachment, textarget, texture, level) {}; 2221 2222 /** 2223 * @param {number} mode 2224 */ 2225 WebGLRenderingContextBase.prototype.frontFace = function(mode) {}; 2226 2227 /** 2228 * @param {number} target 2229 */ 2230 WebGLRenderingContextBase.prototype.generateMipmap = function(target) {}; 2231 2232 /** 2233 * @param {WebGLProgram} program 2234 * @param {number} index 2235 * @return {WebGLActiveInfo} 2236 * @nosideeffects 2237 */ 2238 WebGLRenderingContextBase.prototype.getActiveAttrib = function(program, index) {}; 2239 2240 /** 2241 * @param {WebGLProgram} program 2242 * @param {number} index 2243 * @return {WebGLActiveInfo} 2244 * @nosideeffects 2245 */ 2246 WebGLRenderingContextBase.prototype.getActiveUniform = function(program, index) {}; 2247 2248 /** 2249 * @param {WebGLProgram} program 2250 * @return {!Array.<WebGLShader>} 2251 * @nosideeffects 2252 */ 2253 WebGLRenderingContextBase.prototype.getAttachedShaders = function(program) {}; 2254 2255 /** 2256 * @param {WebGLProgram} program 2257 * @param {string} name 2258 * @return {number} 2259 * @nosideeffects 2260 */ 2261 WebGLRenderingContextBase.prototype.getAttribLocation = function(program, name) {}; 2262 2263 /** 2264 * @param {number} target 2265 * @param {number} pname 2266 * @return {*} 2267 * @nosideeffects 2268 */ 2269 WebGLRenderingContextBase.prototype.getBufferParameter = function(target, pname) {}; 2270 2271 /** 2272 * @param {number} pname 2273 * @return {*} 2274 * @nosideeffects 2275 */ 2276 WebGLRenderingContextBase.prototype.getParameter = function(pname) {}; 2277 2278 /** 2279 * @return {number} 2280 * @nosideeffects 2281 */ 2282 WebGLRenderingContextBase.prototype.getError = function() {}; 2283 2284 /** 2285 * @param {number} target 2286 * @param {number} attachment 2287 * @param {number} pname 2288 * @return {*} 2289 * @nosideeffects 2290 */ 2291 WebGLRenderingContextBase.prototype.getFramebufferAttachmentParameter = function( 2292 target, attachment, pname) {}; 2293 2294 /** 2295 * @param {WebGLProgram} program 2296 * @param {number} pname 2297 * @return {*} 2298 * @nosideeffects 2299 */ 2300 WebGLRenderingContextBase.prototype.getProgramParameter = function( 2301 program, pname) {}; 2302 2303 /** 2304 * @param {WebGLProgram} program 2305 * @return {string} 2306 * @nosideeffects 2307 */ 2308 WebGLRenderingContextBase.prototype.getProgramInfoLog = function(program) {}; 2309 2310 /** 2311 * @param {number} target 2312 * @param {number} pname 2313 * @return {*} 2314 * @nosideeffects 2315 */ 2316 WebGLRenderingContextBase.prototype.getRenderbufferParameter = function( 2317 target, pname) {}; 2318 2319 /** 2320 * @param {WebGLShader} shader 2321 * @param {number} pname 2322 * @return {*} 2323 * @nosideeffects 2324 */ 2325 WebGLRenderingContextBase.prototype.getShaderParameter = function(shader, pname) {}; 2326 2327 /** 2328 * @param {number} shadertype 2329 * @param {number} precisiontype 2330 * @return {WebGLShaderPrecisionFormat} 2331 * @nosideeffects 2332 */ 2333 WebGLRenderingContextBase.prototype.getShaderPrecisionFormat = function(shadertype, 2334 precisiontype) {}; 2335 2336 /** 2337 * @param {WebGLShader} shader 2338 * @return {string} 2339 * @nosideeffects 2340 */ 2341 WebGLRenderingContextBase.prototype.getShaderInfoLog = function(shader) {}; 2342 2343 /** 2344 * @param {WebGLShader} shader 2345 * @return {string} 2346 * @nosideeffects 2347 */ 2348 WebGLRenderingContextBase.prototype.getShaderSource = function(shader) {}; 2349 2350 /** 2351 * @param {number} target 2352 * @param {number} pname 2353 * @return {*} 2354 * @nosideeffects 2355 */ 2356 WebGLRenderingContextBase.prototype.getTexParameter = function(target, pname) {}; 2357 2358 /** 2359 * @param {WebGLProgram} program 2360 * @param {WebGLUniformLocation} location 2361 * @return {*} 2362 * @nosideeffects 2363 */ 2364 WebGLRenderingContextBase.prototype.getUniform = function(program, location) {}; 2365 2366 /** 2367 * @param {WebGLProgram} program 2368 * @param {string} name 2369 * @return {WebGLUniformLocation} 2370 * @nosideeffects 2371 */ 2372 WebGLRenderingContextBase.prototype.getUniformLocation = function(program, name) {}; 2373 2374 /** 2375 * @param {number} index 2376 * @param {number} pname 2377 * @return {*} 2378 * @nosideeffects 2379 */ 2380 WebGLRenderingContextBase.prototype.getVertexAttrib = function(index, pname) {}; 2381 2382 /** 2383 * @param {number} index 2384 * @param {number} pname 2385 * @return {number} 2386 * @nosideeffects 2387 */ 2388 WebGLRenderingContextBase.prototype.getVertexAttribOffset = function( 2389 index, pname) {}; 2390 2391 /** 2392 * @param {number} target 2393 * @param {number} mode 2394 */ 2395 WebGLRenderingContextBase.prototype.hint = function(target, mode) {}; 2396 2397 /** 2398 * @param {WebGLObject} buffer 2399 * @return {boolean} 2400 * @nosideeffects 2401 */ 2402 WebGLRenderingContextBase.prototype.isBuffer = function(buffer) {}; 2403 2404 /** 2405 * @param {number} cap 2406 * @return {boolean} 2407 * @nosideeffects 2408 */ 2409 WebGLRenderingContextBase.prototype.isEnabled = function(cap) {}; 2410 2411 /** 2412 * @param {WebGLObject} framebuffer 2413 * @return {boolean} 2414 * @nosideeffects 2415 */ 2416 WebGLRenderingContextBase.prototype.isFramebuffer = function(framebuffer) {}; 2417 2418 /** 2419 * @param {WebGLObject} program 2420 * @return {boolean} 2421 * @nosideeffects 2422 */ 2423 WebGLRenderingContextBase.prototype.isProgram = function(program) {}; 2424 2425 /** 2426 * @param {WebGLObject} renderbuffer 2427 * @return {boolean} 2428 * @nosideeffects 2429 */ 2430 WebGLRenderingContextBase.prototype.isRenderbuffer = function(renderbuffer) {}; 2431 2432 /** 2433 * @param {WebGLObject} shader 2434 * @return {boolean} 2435 * @nosideeffects 2436 */ 2437 WebGLRenderingContextBase.prototype.isShader = function(shader) {}; 2438 2439 /** 2440 * @param {WebGLObject} texture 2441 * @return {boolean} 2442 * @nosideeffects 2443 */ 2444 WebGLRenderingContextBase.prototype.isTexture = function(texture) {}; 2445 2446 /** 2447 * @param {number} width 2448 */ 2449 WebGLRenderingContextBase.prototype.lineWidth = function(width) {}; 2450 2451 /** 2452 * @param {WebGLProgram} program 2453 */ 2454 WebGLRenderingContextBase.prototype.linkProgram = function(program) {}; 2455 2456 /** 2457 * @param {number} pname 2458 * @param {number} param 2459 */ 2460 WebGLRenderingContextBase.prototype.pixelStorei = function(pname, param) {}; 2461 2462 /** 2463 * @param {number} factor 2464 * @param {number} units 2465 */ 2466 WebGLRenderingContextBase.prototype.polygonOffset = function(factor, units) {}; 2467 2468 /** 2469 * @param {number} x 2470 * @param {number} y 2471 * @param {number} width 2472 * @param {number} height 2473 * @param {number} format 2474 * @param {number} type 2475 * @param {ArrayBufferView} pixels 2476 */ 2477 WebGLRenderingContextBase.prototype.readPixels = function( 2478 x, y, width, height, format, type, pixels) {}; 2479 2480 /** 2481 * @param {number} target 2482 * @param {number} internalformat 2483 * @param {number} width 2484 * @param {number} height 2485 */ 2486 WebGLRenderingContextBase.prototype.renderbufferStorage = function( 2487 target, internalformat, width, height) {}; 2488 2489 /** 2490 * @param {number} coverage 2491 * @param {boolean} invert 2492 */ 2493 WebGLRenderingContextBase.prototype.sampleCoverage = function(coverage, invert) {}; 2494 2495 /** 2496 * @param {number} x 2497 * @param {number} y 2498 * @param {number} width 2499 * @param {number} height 2500 */ 2501 WebGLRenderingContextBase.prototype.scissor = function(x, y, width, height) {}; 2502 2503 /** 2504 * @param {WebGLShader} shader 2505 * @param {string} source 2506 */ 2507 WebGLRenderingContextBase.prototype.shaderSource = function(shader, source) {}; 2508 2509 /** 2510 * @param {number} func 2511 * @param {number} ref 2512 * @param {number} mask 2513 */ 2514 WebGLRenderingContextBase.prototype.stencilFunc = function(func, ref, mask) {}; 2515 2516 /** 2517 * @param {number} face 2518 * @param {number} func 2519 * @param {number} ref 2520 * @param {number} mask 2521 */ 2522 WebGLRenderingContextBase.prototype.stencilFuncSeparate = function( 2523 face, func, ref, mask) {}; 2524 2525 /** 2526 * @param {number} mask 2527 */ 2528 WebGLRenderingContextBase.prototype.stencilMask = function(mask) {}; 2529 2530 /** 2531 * @param {number} face 2532 * @param {number} mask 2533 */ 2534 WebGLRenderingContextBase.prototype.stencilMaskSeparate = function(face, mask) {}; 2535 2536 /** 2537 * @param {number} fail 2538 * @param {number} zfail 2539 * @param {number} zpass 2540 */ 2541 WebGLRenderingContextBase.prototype.stencilOp = function(fail, zfail, zpass) {}; 2542 2543 /** 2544 * @param {number} face 2545 * @param {number} fail 2546 * @param {number} zfail 2547 * @param {number} zpass 2548 */ 2549 WebGLRenderingContextBase.prototype.stencilOpSeparate = function( 2550 face, fail, zfail, zpass) {}; 2551 2552 /** 2553 * @param {number} target 2554 * @param {number} level 2555 * @param {number} internalformat 2556 * @param {number} format or width 2557 * @param {number} type or height 2558 * @param {ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement| 2559 * number} img or border 2560 * @param {number=} opt_format 2561 * @param {number=} opt_type 2562 * @param {ArrayBufferView=} opt_pixels 2563 */ 2564 WebGLRenderingContextBase.prototype.texImage2D = function( 2565 target, level, internalformat, format, type, img, opt_format, opt_type, 2566 opt_pixels) {}; 2567 2568 /** 2569 * @param {number} target 2570 * @param {number} pname 2571 * @param {number} param 2572 */ 2573 WebGLRenderingContextBase.prototype.texParameterf = function( 2574 target, pname, param) {}; 2575 2576 /** 2577 * @param {number} target 2578 * @param {number} pname 2579 * @param {number} param 2580 */ 2581 WebGLRenderingContextBase.prototype.texParameteri = function( 2582 target, pname, param) {}; 2583 2584 /** 2585 * @param {number} target 2586 * @param {number} level 2587 * @param {number} xoffset 2588 * @param {number} yoffset 2589 * @param {number} format or width 2590 * @param {number} type or height 2591 * @param {ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement| 2592 * number} data or format 2593 * @param {number=} opt_type 2594 * @param {ArrayBufferView=} opt_pixels 2595 */ 2596 WebGLRenderingContextBase.prototype.texSubImage2D = function( 2597 target, level, xoffset, yoffset, format, type, data, opt_type, 2598 opt_pixels) {}; 2599 2600 /** 2601 * @param {WebGLUniformLocation} location 2602 * @param {number} value 2603 */ 2604 WebGLRenderingContextBase.prototype.uniform1f = function(location, value) {}; 2605 2606 /** 2607 * @param {WebGLUniformLocation} location 2608 * @param {Float32Array|Array.<number>} value 2609 */ 2610 WebGLRenderingContextBase.prototype.uniform1fv = function(location, value) {}; 2611 2612 /** 2613 * @param {WebGLUniformLocation} location 2614 * @param {number} value 2615 */ 2616 WebGLRenderingContextBase.prototype.uniform1i = function(location, value) {}; 2617 2618 /** 2619 * @param {WebGLUniformLocation} location 2620 * @param {Int32Array|Array.<number>} value 2621 */ 2622 WebGLRenderingContextBase.prototype.uniform1iv = function(location, value) {}; 2623 2624 /** 2625 * @param {WebGLUniformLocation} location 2626 * @param {number} value1 2627 * @param {number} value2 2628 */ 2629 WebGLRenderingContextBase.prototype.uniform2f = function( 2630 location, value1, value2) {}; 2631 2632 /** 2633 * @param {WebGLUniformLocation} location 2634 * @param {Float32Array|Array.<number>} value 2635 */ 2636 WebGLRenderingContextBase.prototype.uniform2fv = function(location, value) {}; 2637 2638 /** 2639 * @param {WebGLUniformLocation} location 2640 * @param {number} value1 2641 * @param {number} value2 2642 */ 2643 WebGLRenderingContextBase.prototype.uniform2i = function( 2644 location, value1, value2) {}; 2645 2646 /** 2647 * @param {WebGLUniformLocation} location 2648 * @param {Int32Array|Array.<number>} value 2649 */ 2650 WebGLRenderingContextBase.prototype.uniform2iv = function(location, value) {}; 2651 2652 /** 2653 * @param {WebGLUniformLocation} location 2654 * @param {number} value1 2655 * @param {number} value2 2656 * @param {number} value3 2657 */ 2658 WebGLRenderingContextBase.prototype.uniform3f = function( 2659 location, value1, value2, value3) {}; 2660 2661 /** 2662 * @param {WebGLUniformLocation} location 2663 * @param {Float32Array|Array.<number>} value 2664 */ 2665 WebGLRenderingContextBase.prototype.uniform3fv = function(location, value) {}; 2666 2667 /** 2668 * @param {WebGLUniformLocation} location 2669 * @param {number} value1 2670 * @param {number} value2 2671 * @param {number} value3 2672 */ 2673 WebGLRenderingContextBase.prototype.uniform3i = function( 2674 location, value1, value2, value3) {}; 2675 2676 /** 2677 * @param {WebGLUniformLocation} location 2678 * @param {Int32Array|Array.<number>} value 2679 */ 2680 WebGLRenderingContextBase.prototype.uniform3iv = function(location, value) {}; 2681 2682 /** 2683 * @param {WebGLUniformLocation} location 2684 * @param {number} value1 2685 * @param {number} value2 2686 * @param {number} value3 2687 * @param {number} value4 2688 */ 2689 WebGLRenderingContextBase.prototype.uniform4f = function( 2690 location, value1, value2, value3, value4) {}; 2691 2692 /** 2693 * @param {WebGLUniformLocation} location 2694 * @param {Float32Array|Array.<number>} value 2695 */ 2696 WebGLRenderingContextBase.prototype.uniform4fv = function(location, value) {}; 2697 2698 /** 2699 * @param {WebGLUniformLocation} location 2700 * @param {number} value1 2701 * @param {number} value2 2702 * @param {number} value3 2703 * @param {number} value4 2704 */ 2705 WebGLRenderingContextBase.prototype.uniform4i = function( 2706 location, value1, value2, value3, value4) {}; 2707 2708 /** 2709 * @param {WebGLUniformLocation} location 2710 * @param {Int32Array|Array.<number>} value 2711 */ 2712 WebGLRenderingContextBase.prototype.uniform4iv = function(location, value) {}; 2713 2714 /** 2715 * @param {WebGLUniformLocation} location 2716 * @param {boolean} transpose 2717 * @param {Float32Array|Array.<number>} data 2718 */ 2719 WebGLRenderingContextBase.prototype.uniformMatrix2fv = function( 2720 location, transpose, data) {}; 2721 2722 /** 2723 * @param {WebGLUniformLocation} location 2724 * @param {boolean} transpose 2725 * @param {Float32Array|Array.<number>} data 2726 */ 2727 WebGLRenderingContextBase.prototype.uniformMatrix3fv = function( 2728 location, transpose, data) {}; 2729 2730 /** 2731 * @param {WebGLUniformLocation} location 2732 * @param {boolean} transpose 2733 * @param {Float32Array|Array.<number>} data 2734 */ 2735 WebGLRenderingContextBase.prototype.uniformMatrix4fv = function( 2736 location, transpose, data) {}; 2737 2738 /** 2739 * @param {WebGLProgram} program 2740 */ 2741 WebGLRenderingContextBase.prototype.useProgram = function(program) {}; 2742 2743 /** 2744 * @param {WebGLProgram} program 2745 */ 2746 WebGLRenderingContextBase.prototype.validateProgram = function(program) {}; 2747 2748 /** 2749 * @param {number} indx 2750 * @param {number} x 2751 */ 2752 WebGLRenderingContextBase.prototype.vertexAttrib1f = function(indx, x) {}; 2753 2754 /** 2755 * @param {number} indx 2756 * @param {Float32Array|Array.<number>} values 2757 */ 2758 WebGLRenderingContextBase.prototype.vertexAttrib1fv = function(indx, values) {}; 2759 2760 /** 2761 * @param {number} indx 2762 * @param {number} x 2763 * @param {number} y 2764 */ 2765 WebGLRenderingContextBase.prototype.vertexAttrib2f = function( 2766 indx, x, y) {}; 2767 2768 /** 2769 * @param {number} indx 2770 * @param {Float32Array|Array.<number>} values 2771 */ 2772 WebGLRenderingContextBase.prototype.vertexAttrib2fv = function( 2773 indx, values) {}; 2774 2775 /** 2776 * @param {number} indx 2777 * @param {number} x 2778 * @param {number} y 2779 * @param {number} z 2780 */ 2781 WebGLRenderingContextBase.prototype.vertexAttrib3f = function( 2782 indx, x, y, z) {}; 2783 2784 /** 2785 * @param {number} indx 2786 * @param {Float32Array|Array.<number>} values 2787 */ 2788 WebGLRenderingContextBase.prototype.vertexAttrib3fv = function(indx, values) {}; 2789 2790 /** 2791 * @param {number} indx 2792 * @param {number} x 2793 * @param {number} y 2794 * @param {number} z 2795 * @param {number} w 2796 */ 2797 WebGLRenderingContextBase.prototype.vertexAttrib4f = function( 2798 indx, x, y, z, w) {}; 2799 2800 /** 2801 * @param {number} indx 2802 * @param {Float32Array|Array.<number>} values 2803 */ 2804 WebGLRenderingContextBase.prototype.vertexAttrib4fv = function(indx, values) {}; 2805 2806 /** 2807 * @param {number} indx 2808 * @param {number} size 2809 * @param {number} type 2810 * @param {boolean} normalized 2811 * @param {number} stride 2812 * @param {number} offset 2813 */ 2814 WebGLRenderingContextBase.prototype.vertexAttribPointer = function( 2815 indx, size, type, normalized, stride, offset) {}; 2816 2817 /** 2818 * @param {number} x 2819 * @param {number} y 2820 * @param {number} width 2821 * @param {number} height 2822 */ 2823 WebGLRenderingContextBase.prototype.viewport = function(x, y, width, height) {}; 2824 2825 2826 /** 2827 * @constructor 2828 * @noalias 2829 */ 2830 function WebGLContextAttributes() {} 2831 2832 /** 2833 * @type {boolean} 2834 */ 2835 WebGLContextAttributes.prototype.alpha; 2836 2837 /** 2838 * @type {boolean} 2839 */ 2840 WebGLContextAttributes.prototype.depth; 2841 2842 /** 2843 * @type {boolean} 2844 */ 2845 WebGLContextAttributes.prototype.stencil; 2846 2847 /** 2848 * @type {boolean} 2849 */ 2850 WebGLContextAttributes.prototype.antialias; 2851 2852 /** 2853 * @type {boolean} 2854 */ 2855 WebGLContextAttributes.prototype.premultipliedAlpha; 2856 2857 /** 2858 * @type {boolean} 2859 */ 2860 WebGLContextAttributes.prototype.preserveDrawingBuffer; 2861 2862 2863 /** 2864 * @param {string} eventType 2865 * @constructor 2866 * @noalias 2867 * @extends {Event} 2868 */ 2869 function WebGLContextEvent(eventType) {} 2870 2871 /** 2872 * @type {string} 2873 */ 2874 WebGLContextEvent.prototype.statusMessage; 2875 2876 2877 /** 2878 * @constructor 2879 * @noalias 2880 */ 2881 function WebGLShaderPrecisionFormat() {} 2882 2883 /** 2884 * @type {number} 2885 */ 2886 WebGLShaderPrecisionFormat.prototype.rangeMin; 2887 2888 /** 2889 * @type {number} 2890 */ 2891 WebGLShaderPrecisionFormat.prototype.rangeMax; 2892 2893 /** 2894 * @type {number} 2895 */ 2896 WebGLShaderPrecisionFormat.prototype.precision; 2897 2898 2899 /** 2900 * @constructor 2901 * @noalias 2902 */ 2903 function WebGLObject() {} 2904 2905 2906 /** 2907 * @constructor 2908 * @noalias 2909 * @extends {WebGLObject} 2910 */ 2911 function WebGLBuffer() {} 2912 2913 2914 /** 2915 * @constructor 2916 * @noalias 2917 * @extends {WebGLObject} 2918 */ 2919 function WebGLFramebuffer() {} 2920 2921 2922 /** 2923 * @constructor 2924 * @noalias 2925 * @extends {WebGLObject} 2926 */ 2927 function WebGLProgram() {} 2928 2929 2930 /** 2931 * @constructor 2932 * @noalias 2933 * @extends {WebGLObject} 2934 */ 2935 function WebGLRenderbuffer() {} 2936 2937 2938 /** 2939 * @constructor 2940 * @noalias 2941 * @extends {WebGLObject} 2942 */ 2943 function WebGLShader() {} 2944 2945 2946 /** 2947 * @constructor 2948 * @noalias 2949 * @extends {WebGLObject} 2950 */ 2951 function WebGLTexture() {} 2952 2953 2954 /** 2955 * @constructor 2956 * @noalias 2957 */ 2958 function WebGLActiveInfo() {} 2959 2960 /** @type {number} */ 2961 WebGLActiveInfo.prototype.size; 2962 2963 /** @type {number} */ 2964 WebGLActiveInfo.prototype.type; 2965 2966 /** @type {string} */ 2967 WebGLActiveInfo.prototype.name; 2968 2969 2970 /** 2971 * @constructor 2972 * @noalias 2973 */ 2974 function WebGLUniformLocation() {} 2975 2976 2977 /** 2978 * @see http://www.khronos.org/registry/webgl/extensions/OES_texture_float/ 2979 * @constructor 2980 * @noalias 2981 */ 2982 function OES_texture_float() {} 2983 2984 2985 /** 2986 * @see http://www.khronos.org/registry/webgl/extensions/OES_texture_half_float/ 2987 * @constructor 2988 * @noalias 2989 */ 2990 function OES_texture_half_float() {} 2991 2992 /** @type {number} */ 2993 OES_texture_half_float.prototype.HALF_FLOAT_OES; 2994 2995 2996 /** 2997 * @see http://www.khronos.org/registry/webgl/extensions/WEBGL_lose_context/ 2998 * @constructor 2999 * @noalias 3000 */ 3001 function WEBGL_lose_context() {} 3002 3003 WEBGL_lose_context.prototype.loseContext = function() {}; 3004 3005 WEBGL_lose_context.prototype.restoreContext = function() {}; 3006 3007 3008 /** 3009 * @see http://www.khronos.org/registry/webgl/extensions/OES_standard_derivatives/ 3010 * @constructor 3011 * @noalias 3012 */ 3013 function OES_standard_derivatives() {} 3014 3015 /** @type {number} */ 3016 OES_standard_derivatives.prototype.FRAGMENT_SHADER_DERIVATIVE_HINT_OES; 3017 3018 3019 /** 3020 * @see http://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/ 3021 * @constructor 3022 * @noalias 3023 * @extends {WebGLObject} 3024 */ 3025 function WebGLVertexArrayObjectOES() {} 3026 3027 3028 /** 3029 * @see http://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/ 3030 * @constructor 3031 * @noalias 3032 */ 3033 function OES_vertex_array_object() {} 3034 3035 /** @type {number} */ 3036 OES_vertex_array_object.prototype.VERTEX_ARRAY_BINDING_OES; 3037 3038 /** 3039 * @return {WebGLVertexArrayObjectOES} 3040 * @nosideeffects 3041 */ 3042 OES_vertex_array_object.prototype.createVertexArrayOES = function() {}; 3043 3044 /** 3045 * @param {WebGLVertexArrayObjectOES} arrayObject 3046 */ 3047 OES_vertex_array_object.prototype.deleteVertexArrayOES = 3048 function(arrayObject) {}; 3049 3050 /** 3051 * @param {WebGLVertexArrayObjectOES} arrayObject 3052 * @return {boolean} 3053 * @nosideeffects 3054 */ 3055 OES_vertex_array_object.prototype.isVertexArrayOES = function(arrayObject) {}; 3056 3057 /** 3058 * @param {WebGLVertexArrayObjectOES} arrayObject 3059 */ 3060 OES_vertex_array_object.prototype.bindVertexArrayOES = function(arrayObject) {}; 3061 3062 3063 /** 3064 * @see http://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/ 3065 * @constructor 3066 * @noalias 3067 */ 3068 function WEBGL_debug_renderer_info() {} 3069 3070 /** @type {number} */ 3071 WEBGL_debug_renderer_info.prototype.UNMASKED_VENDOR_WEBGL; 3072 3073 /** @type {number} */ 3074 WEBGL_debug_renderer_info.prototype.UNMASKED_RENDERER_WEBGL; 3075 3076 3077 /** 3078 * @see http://www.khronos.org/registry/webgl/extensions/WEBGL_debug_shaders/ 3079 * @constructor 3080 * @noalias 3081 */ 3082 function WEBGL_debug_shaders() {} 3083 3084 /** 3085 * @param {WebGLShader} shader 3086 * @return {string} 3087 * @nosideeffects 3088 */ 3089 WEBGL_debug_shaders.prototype.getTranslatedShaderSource = function(shader) {}; 3090 3091 3092 /** 3093 * @see http://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_s3tc/ 3094 * @constructor 3095 * @noalias 3096 */ 3097 function WEBGL_compressed_texture_s3tc() {} 3098 3099 /** @type {number} */ 3100 WEBGL_compressed_texture_s3tc.prototype.COMPRESSED_RGB_S3TC_DXT1_EXT; 3101 3102 /** @type {number} */ 3103 WEBGL_compressed_texture_s3tc.prototype.COMPRESSED_RGBA_S3TC_DXT1_EXT; 3104 3105 /** @type {number} */ 3106 WEBGL_compressed_texture_s3tc.prototype.COMPRESSED_RGBA_S3TC_DXT3_EXT; 3107 3108 /** @type {number} */ 3109 WEBGL_compressed_texture_s3tc.prototype.COMPRESSED_RGBA_S3TC_DXT5_EXT; 3110 3111 3112 /** 3113 * @see http://www.khronos.org/registry/webgl/extensions/OES_depth_texture/ 3114 * @constructor 3115 * @noalias 3116 */ 3117 function OES_depth_texture() {} 3118 3119 3120 /** 3121 * @see http://www.khronos.org/registry/webgl/extensions/OES_element_index_uint/ 3122 * @constructor 3123 * @noalias 3124 */ 3125 function OES_element_index_uint() {} 3126 3127 3128 /** 3129 * @see http://www.khronos.org/registry/webgl/extensions/EXT_texture_filter_anisotropic/ 3130 * @constructor 3131 * @noalias 3132 */ 3133 function EXT_texture_filter_anisotropic() {} 3134 3135 /** @type {number} */ 3136 EXT_texture_filter_anisotropic.prototype.TEXTURE_MAX_ANISOTROPY_EXT; 3137 3138 /** @type {number} */ 3139 EXT_texture_filter_anisotropic.prototype.MAX_TEXTURE_MAX_ANISOTROPY_EXT; 3140 3141 3142 3143 /** 3144 * @see http://www.khronos.org/registry/webgl/extensions/ANGLE_instanced_arrays/ 3145 * @constructor 3146 * @noalias 3147 */ 3148 function ANGLE_instanced_arrays() {} 3149 3150 3151 /** @type {number} */ 3152 ANGLE_instanced_arrays.prototype.VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE; 3153 3154 3155 /** 3156 * @param {number} mode Primitive type. 3157 * @param {number} first First vertex. 3158 * @param {number} count Number of vertices per instance. 3159 * @param {number} primcount Number of instances. 3160 */ 3161 ANGLE_instanced_arrays.prototype.drawArraysInstancedANGLE = function( 3162 mode, first, count, primcount) {}; 3163 3164 3165 /** 3166 * @param {number} mode Primitive type. 3167 * @param {number} count Number of vertex indices per instance. 3168 * @param {number} type Type of a vertex index. 3169 * @param {number} offset Offset to the first vertex index. 3170 * @param {number} primcount Number of instances. 3171 */ 3172 ANGLE_instanced_arrays.prototype.drawElementsInstancedANGLE = function( 3173 mode, count, type, offset, primcount) {}; 3174 3175 3176 /** 3177 * @param {number} index Attribute index. 3178 * @param {number} divisor Instance divisor. 3179 */ 3180 ANGLE_instanced_arrays.prototype.vertexAttribDivisorANGLE = function( 3181 index, divisor) {}; 3182 3183 3184 /** 3185 * @constructor 3186 * @noalias 3187 * @extends {WebGLRenderingContextBase} 3188 */ 3189 function WebGLRenderingContext() {} 3190 3191 3192 /** 3193 * @constructor 3194 * @private 3195 * @noalias 3196 * @extends {WebGLRenderingContextBase} 3197 */ 3198 function WebGL2RenderingContextBase() {} 3199 3200 3201 /** @type {number} */ 3202 WebGL2RenderingContextBase.READ_BUFFER; 3203 3204 /** @type {number} */ 3205 WebGL2RenderingContextBase.UNPACK_ROW_LENGTH; 3206 3207 /** @type {number} */ 3208 WebGL2RenderingContextBase.UNPACK_SKIP_ROWS; 3209 3210 /** @type {number} */ 3211 WebGL2RenderingContextBase.UNPACK_SKIP_PIXELS; 3212 3213 /** @type {number} */ 3214 WebGL2RenderingContextBase.PACK_ROW_LENGTH; 3215 3216 /** @type {number} */ 3217 WebGL2RenderingContextBase.PACK_SKIP_ROWS; 3218 3219 /** @type {number} */ 3220 WebGL2RenderingContextBase.PACK_SKIP_PIXELS; 3221 3222 /** @type {number} */ 3223 WebGL2RenderingContextBase.COLOR; 3224 3225 /** @type {number} */ 3226 WebGL2RenderingContextBase.DEPTH; 3227 3228 /** @type {number} */ 3229 WebGL2RenderingContextBase.STENCIL; 3230 3231 /** @type {number} */ 3232 WebGL2RenderingContextBase.RED; 3233 3234 /** @type {number} */ 3235 WebGL2RenderingContextBase.RGB8; 3236 3237 /** @type {number} */ 3238 WebGL2RenderingContextBase.RGBA8; 3239 3240 /** @type {number} */ 3241 WebGL2RenderingContextBase.RGB10_A2; 3242 3243 /** @type {number} */ 3244 WebGL2RenderingContextBase.TEXTURE_BINDING_3D; 3245 3246 /** @type {number} */ 3247 WebGL2RenderingContextBase.UNPACK_SKIP_IMAGES; 3248 3249 /** @type {number} */ 3250 WebGL2RenderingContextBase.UNPACK_IMAGE_HEIGHT; 3251 3252 /** @type {number} */ 3253 WebGL2RenderingContextBase.TEXTURE_3D; 3254 3255 /** @type {number} */ 3256 WebGL2RenderingContextBase.TEXTURE_WRAP_R; 3257 3258 /** @type {number} */ 3259 WebGL2RenderingContextBase.MAX_3D_TEXTURE_SIZE; 3260 3261 /** @type {number} */ 3262 WebGL2RenderingContextBase.UNSIGNED_INT_2_10_10_10_REV; 3263 3264 /** @type {number} */ 3265 WebGL2RenderingContextBase.MAX_ELEMENTS_VERTICES; 3266 3267 /** @type {number} */ 3268 WebGL2RenderingContextBase.MAX_ELEMENTS_INDICES; 3269 3270 /** @type {number} */ 3271 WebGL2RenderingContextBase.TEXTURE_MIN_LOD; 3272 3273 /** @type {number} */ 3274 WebGL2RenderingContextBase.TEXTURE_MAX_LOD; 3275 3276 /** @type {number} */ 3277 WebGL2RenderingContextBase.TEXTURE_BASE_LEVEL; 3278 3279 /** @type {number} */ 3280 WebGL2RenderingContextBase.TEXTURE_MAX_LEVEL; 3281 3282 /** @type {number} */ 3283 WebGL2RenderingContextBase.MIN; 3284 3285 /** @type {number} */ 3286 WebGL2RenderingContextBase.MAX; 3287 3288 /** @type {number} */ 3289 WebGL2RenderingContextBase.DEPTH_COMPONENT24; 3290 3291 /** @type {number} */ 3292 WebGL2RenderingContextBase.MAX_TEXTURE_LOD_BIAS; 3293 3294 /** @type {number} */ 3295 WebGL2RenderingContextBase.TEXTURE_COMPARE_MODE; 3296 3297 /** @type {number} */ 3298 WebGL2RenderingContextBase.TEXTURE_COMPARE_FUNC; 3299 3300 /** @type {number} */ 3301 WebGL2RenderingContextBase.CURRENT_QUERY; 3302 3303 /** @type {number} */ 3304 WebGL2RenderingContextBase.QUERY_RESULT; 3305 3306 /** @type {number} */ 3307 WebGL2RenderingContextBase.QUERY_RESULT_AVAILABLE; 3308 3309 /** @type {number} */ 3310 WebGL2RenderingContextBase.STREAM_READ; 3311 3312 /** @type {number} */ 3313 WebGL2RenderingContextBase.STREAM_COPY; 3314 3315 /** @type {number} */ 3316 WebGL2RenderingContextBase.STATIC_READ; 3317 3318 /** @type {number} */ 3319 WebGL2RenderingContextBase.STATIC_COPY; 3320 3321 /** @type {number} */ 3322 WebGL2RenderingContextBase.DYNAMIC_READ; 3323 3324 /** @type {number} */ 3325 WebGL2RenderingContextBase.DYNAMIC_COPY; 3326 3327 /** @type {number} */ 3328 WebGL2RenderingContextBase.MAX_DRAW_BUFFERS; 3329 3330 /** @type {number} */ 3331 WebGL2RenderingContextBase.DRAW_BUFFER0; 3332 3333 /** @type {number} */ 3334 WebGL2RenderingContextBase.DRAW_BUFFER1; 3335 3336 /** @type {number} */ 3337 WebGL2RenderingContextBase.DRAW_BUFFER2; 3338 3339 /** @type {number} */ 3340 WebGL2RenderingContextBase.DRAW_BUFFER3; 3341 3342 /** @type {number} */ 3343 WebGL2RenderingContextBase.DRAW_BUFFER4; 3344 3345 /** @type {number} */ 3346 WebGL2RenderingContextBase.DRAW_BUFFER5; 3347 3348 /** @type {number} */ 3349 WebGL2RenderingContextBase.DRAW_BUFFER6; 3350 3351 /** @type {number} */ 3352 WebGL2RenderingContextBase.DRAW_BUFFER7; 3353 3354 /** @type {number} */ 3355 WebGL2RenderingContextBase.DRAW_BUFFER8; 3356 3357 /** @type {number} */ 3358 WebGL2RenderingContextBase.DRAW_BUFFER9; 3359 3360 /** @type {number} */ 3361 WebGL2RenderingContextBase.DRAW_BUFFER10; 3362 3363 /** @type {number} */ 3364 WebGL2RenderingContextBase.DRAW_BUFFER11; 3365 3366 /** @type {number} */ 3367 WebGL2RenderingContextBase.DRAW_BUFFER12; 3368 3369 /** @type {number} */ 3370 WebGL2RenderingContextBase.DRAW_BUFFER13; 3371 3372 /** @type {number} */ 3373 WebGL2RenderingContextBase.DRAW_BUFFER14; 3374 3375 /** @type {number} */ 3376 WebGL2RenderingContextBase.DRAW_BUFFER15; 3377 3378 /** @type {number} */ 3379 WebGL2RenderingContextBase.MAX_FRAGMENT_UNIFORM_COMPONENTS; 3380 3381 /** @type {number} */ 3382 WebGL2RenderingContextBase.MAX_VERTEX_UNIFORM_COMPONENTS; 3383 3384 /** @type {number} */ 3385 WebGL2RenderingContextBase.SAMPLER_3D; 3386 3387 /** @type {number} */ 3388 WebGL2RenderingContextBase.SAMPLER_2D_SHADOW; 3389 3390 /** @type {number} */ 3391 WebGL2RenderingContextBase.FRAGMENT_SHADER_DERIVATIVE_HINT; 3392 3393 /** @type {number} */ 3394 WebGL2RenderingContextBase.PIXEL_PACK_BUFFER; 3395 3396 /** @type {number} */ 3397 WebGL2RenderingContextBase.PIXEL_UNPACK_BUFFER; 3398 3399 /** @type {number} */ 3400 WebGL2RenderingContextBase.PIXEL_PACK_BUFFER_BINDING; 3401 3402 /** @type {number} */ 3403 WebGL2RenderingContextBase.PIXEL_UNPACK_BUFFER_BINDING; 3404 3405 /** @type {number} */ 3406 WebGL2RenderingContextBase.FLOAT_MAT2x3; 3407 3408 /** @type {number} */ 3409 WebGL2RenderingContextBase.FLOAT_MAT2x4; 3410 3411 /** @type {number} */ 3412 WebGL2RenderingContextBase.FLOAT_MAT3x2; 3413 3414 /** @type {number} */ 3415 WebGL2RenderingContextBase.FLOAT_MAT3x4; 3416 3417 /** @type {number} */ 3418 WebGL2RenderingContextBase.FLOAT_MAT4x2; 3419 3420 /** @type {number} */ 3421 WebGL2RenderingContextBase.FLOAT_MAT4x3; 3422 3423 /** @type {number} */ 3424 WebGL2RenderingContextBase.SRGB; 3425 3426 /** @type {number} */ 3427 WebGL2RenderingContextBase.SRGB8; 3428 3429 /** @type {number} */ 3430 WebGL2RenderingContextBase.SRGB8_ALPHA8; 3431 3432 /** @type {number} */ 3433 WebGL2RenderingContextBase.COMPARE_REF_TO_TEXTURE; 3434 3435 /** @type {number} */ 3436 WebGL2RenderingContextBase.RGBA32F; 3437 3438 /** @type {number} */ 3439 WebGL2RenderingContextBase.RGB32F; 3440 3441 /** @type {number} */ 3442 WebGL2RenderingContextBase.RGBA16F; 3443 3444 /** @type {number} */ 3445 WebGL2RenderingContextBase.RGB16F; 3446 3447 /** @type {number} */ 3448 WebGL2RenderingContextBase.VERTEX_ATTRIB_ARRAY_INTEGER; 3449 3450 /** @type {number} */ 3451 WebGL2RenderingContextBase.MAX_ARRAY_TEXTURE_LAYERS; 3452 3453 /** @type {number} */ 3454 WebGL2RenderingContextBase.MIN_PROGRAM_TEXEL_OFFSET; 3455 3456 /** @type {number} */ 3457 WebGL2RenderingContextBase.MAX_PROGRAM_TEXEL_OFFSET; 3458 3459 /** @type {number} */ 3460 WebGL2RenderingContextBase.MAX_VARYING_COMPONENTS; 3461 3462 /** @type {number} */ 3463 WebGL2RenderingContextBase.TEXTURE_2D_ARRAY; 3464 3465 /** @type {number} */ 3466 WebGL2RenderingContextBase.TEXTURE_BINDING_2D_ARRAY; 3467 3468 /** @type {number} */ 3469 WebGL2RenderingContextBase.R11F_G11F_B10F; 3470 3471 /** @type {number} */ 3472 WebGL2RenderingContextBase.UNSIGNED_INT_10F_11F_11F_REV; 3473 3474 /** @type {number} */ 3475 WebGL2RenderingContextBase.RGB9_E5; 3476 3477 /** @type {number} */ 3478 WebGL2RenderingContextBase.UNSIGNED_INT_5_9_9_9_REV; 3479 3480 /** @type {number} */ 3481 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER_MODE; 3482 3483 /** @type {number} */ 3484 WebGL2RenderingContextBase.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS; 3485 3486 /** @type {number} */ 3487 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_VARYINGS; 3488 3489 /** @type {number} */ 3490 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER_START; 3491 3492 /** @type {number} */ 3493 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER_SIZE; 3494 3495 /** @type {number} */ 3496 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN; 3497 3498 /** @type {number} */ 3499 WebGL2RenderingContextBase.RASTERIZER_DISCARD; 3500 3501 /** @type {number} */ 3502 WebGL2RenderingContextBase.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS; 3503 3504 /** @type {number} */ 3505 WebGL2RenderingContextBase.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS; 3506 3507 /** @type {number} */ 3508 WebGL2RenderingContextBase.INTERLEAVED_ATTRIBS; 3509 3510 /** @type {number} */ 3511 WebGL2RenderingContextBase.SEPARATE_ATTRIBS; 3512 3513 /** @type {number} */ 3514 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER; 3515 3516 /** @type {number} */ 3517 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER_BINDING; 3518 3519 /** @type {number} */ 3520 WebGL2RenderingContextBase.RGBA32UI; 3521 3522 /** @type {number} */ 3523 WebGL2RenderingContextBase.RGB32UI; 3524 3525 /** @type {number} */ 3526 WebGL2RenderingContextBase.RGBA16UI; 3527 3528 /** @type {number} */ 3529 WebGL2RenderingContextBase.RGB16UI; 3530 3531 /** @type {number} */ 3532 WebGL2RenderingContextBase.RGBA8UI; 3533 3534 /** @type {number} */ 3535 WebGL2RenderingContextBase.RGB8UI; 3536 3537 /** @type {number} */ 3538 WebGL2RenderingContextBase.RGBA32I; 3539 3540 /** @type {number} */ 3541 WebGL2RenderingContextBase.RGB32I; 3542 3543 /** @type {number} */ 3544 WebGL2RenderingContextBase.RGBA16I; 3545 3546 /** @type {number} */ 3547 WebGL2RenderingContextBase.RGB16I; 3548 3549 /** @type {number} */ 3550 WebGL2RenderingContextBase.RGBA8I; 3551 3552 /** @type {number} */ 3553 WebGL2RenderingContextBase.RGB8I; 3554 3555 /** @type {number} */ 3556 WebGL2RenderingContextBase.RED_INTEGER; 3557 3558 /** @type {number} */ 3559 WebGL2RenderingContextBase.RGB_INTEGER; 3560 3561 /** @type {number} */ 3562 WebGL2RenderingContextBase.RGBA_INTEGER; 3563 3564 /** @type {number} */ 3565 WebGL2RenderingContextBase.SAMPLER_2D_ARRAY; 3566 3567 /** @type {number} */ 3568 WebGL2RenderingContextBase.SAMPLER_2D_ARRAY_SHADOW; 3569 3570 /** @type {number} */ 3571 WebGL2RenderingContextBase.SAMPLER_CUBE_SHADOW; 3572 3573 /** @type {number} */ 3574 WebGL2RenderingContextBase.UNSIGNED_INT_VEC2; 3575 3576 /** @type {number} */ 3577 WebGL2RenderingContextBase.UNSIGNED_INT_VEC3; 3578 3579 /** @type {number} */ 3580 WebGL2RenderingContextBase.UNSIGNED_INT_VEC4; 3581 3582 /** @type {number} */ 3583 WebGL2RenderingContextBase.INT_SAMPLER_2D; 3584 3585 /** @type {number} */ 3586 WebGL2RenderingContextBase.INT_SAMPLER_3D; 3587 3588 /** @type {number} */ 3589 WebGL2RenderingContextBase.INT_SAMPLER_CUBE; 3590 3591 /** @type {number} */ 3592 WebGL2RenderingContextBase.INT_SAMPLER_2D_ARRAY; 3593 3594 /** @type {number} */ 3595 WebGL2RenderingContextBase.UNSIGNED_INT_SAMPLER_2D; 3596 3597 /** @type {number} */ 3598 WebGL2RenderingContextBase.UNSIGNED_INT_SAMPLER_3D; 3599 3600 /** @type {number} */ 3601 WebGL2RenderingContextBase.UNSIGNED_INT_SAMPLER_CUBE; 3602 3603 /** @type {number} */ 3604 WebGL2RenderingContextBase.UNSIGNED_INT_SAMPLER_2D_ARRAY; 3605 3606 /** @type {number} */ 3607 WebGL2RenderingContextBase.DEPTH_COMPONENT32F; 3608 3609 /** @type {number} */ 3610 WebGL2RenderingContextBase.DEPTH32F_STENCIL8; 3611 3612 /** @type {number} */ 3613 WebGL2RenderingContextBase.FLOAT_32_UNSIGNED_INT_24_8_REV; 3614 3615 /** @type {number} */ 3616 WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING; 3617 3618 /** @type {number} */ 3619 WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE; 3620 3621 /** @type {number} */ 3622 WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_RED_SIZE; 3623 3624 /** @type {number} */ 3625 WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE; 3626 3627 /** @type {number} */ 3628 WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE; 3629 3630 /** @type {number} */ 3631 WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE; 3632 3633 /** @type {number} */ 3634 WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE; 3635 3636 /** @type {number} */ 3637 WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE; 3638 3639 /** @type {number} */ 3640 WebGL2RenderingContextBase.FRAMEBUFFER_DEFAULT; 3641 3642 /** @type {number} */ 3643 WebGL2RenderingContextBase.DEPTH_STENCIL_ATTACHMENT; 3644 3645 /** @type {number} */ 3646 WebGL2RenderingContextBase.DEPTH_STENCIL; 3647 3648 /** @type {number} */ 3649 WebGL2RenderingContextBase.UNSIGNED_INT_24_8; 3650 3651 /** @type {number} */ 3652 WebGL2RenderingContextBase.DEPTH24_STENCIL8; 3653 3654 /** @type {number} */ 3655 WebGL2RenderingContextBase.UNSIGNED_NORMALIZED; 3656 3657 // Same as FRAMEBUFFER_BINDING 3658 /** @type {number} */ 3659 WebGL2RenderingContextBase.DRAW_FRAMEBUFFER_BINDING; 3660 3661 /** @type {number} */ 3662 WebGL2RenderingContextBase.READ_FRAMEBUFFER; 3663 3664 /** @type {number} */ 3665 WebGL2RenderingContextBase.DRAW_FRAMEBUFFER; 3666 3667 /** @type {number} */ 3668 WebGL2RenderingContextBase.READ_FRAMEBUFFER_BINDING; 3669 3670 /** @type {number} */ 3671 WebGL2RenderingContextBase.RENDERBUFFER_SAMPLES; 3672 3673 /** @type {number} */ 3674 WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER; 3675 3676 /** @type {number} */ 3677 WebGL2RenderingContextBase.MAX_COLOR_ATTACHMENTS; 3678 3679 /** @type {number} */ 3680 WebGL2RenderingContextBase.COLOR_ATTACHMENT1; 3681 3682 /** @type {number} */ 3683 WebGL2RenderingContextBase.COLOR_ATTACHMENT2; 3684 3685 /** @type {number} */ 3686 WebGL2RenderingContextBase.COLOR_ATTACHMENT3; 3687 3688 /** @type {number} */ 3689 WebGL2RenderingContextBase.COLOR_ATTACHMENT4; 3690 3691 /** @type {number} */ 3692 WebGL2RenderingContextBase.COLOR_ATTACHMENT5; 3693 3694 /** @type {number} */ 3695 WebGL2RenderingContextBase.COLOR_ATTACHMENT6; 3696 3697 /** @type {number} */ 3698 WebGL2RenderingContextBase.COLOR_ATTACHMENT7; 3699 3700 /** @type {number} */ 3701 WebGL2RenderingContextBase.COLOR_ATTACHMENT8; 3702 3703 /** @type {number} */ 3704 WebGL2RenderingContextBase.COLOR_ATTACHMENT9; 3705 3706 /** @type {number} */ 3707 WebGL2RenderingContextBase.COLOR_ATTACHMENT10; 3708 3709 /** @type {number} */ 3710 WebGL2RenderingContextBase.COLOR_ATTACHMENT11; 3711 3712 /** @type {number} */ 3713 WebGL2RenderingContextBase.COLOR_ATTACHMENT12; 3714 3715 /** @type {number} */ 3716 WebGL2RenderingContextBase.COLOR_ATTACHMENT13; 3717 3718 /** @type {number} */ 3719 WebGL2RenderingContextBase.COLOR_ATTACHMENT14; 3720 3721 /** @type {number} */ 3722 WebGL2RenderingContextBase.COLOR_ATTACHMENT15; 3723 3724 /** @type {number} */ 3725 WebGL2RenderingContextBase.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE; 3726 3727 /** @type {number} */ 3728 WebGL2RenderingContextBase.MAX_SAMPLES; 3729 3730 /** @type {number} */ 3731 WebGL2RenderingContextBase.HALF_FLOAT; 3732 3733 /** @type {number} */ 3734 WebGL2RenderingContextBase.RG; 3735 3736 /** @type {number} */ 3737 WebGL2RenderingContextBase.RG_INTEGER; 3738 3739 /** @type {number} */ 3740 WebGL2RenderingContextBase.R8; 3741 3742 /** @type {number} */ 3743 WebGL2RenderingContextBase.RG8; 3744 3745 /** @type {number} */ 3746 WebGL2RenderingContextBase.R16F; 3747 3748 /** @type {number} */ 3749 WebGL2RenderingContextBase.R32F; 3750 3751 /** @type {number} */ 3752 WebGL2RenderingContextBase.RG16F; 3753 3754 /** @type {number} */ 3755 WebGL2RenderingContextBase.RG32F; 3756 3757 /** @type {number} */ 3758 WebGL2RenderingContextBase.R8I; 3759 3760 /** @type {number} */ 3761 WebGL2RenderingContextBase.R8UI; 3762 3763 /** @type {number} */ 3764 WebGL2RenderingContextBase.R16I; 3765 3766 /** @type {number} */ 3767 WebGL2RenderingContextBase.R16UI; 3768 3769 /** @type {number} */ 3770 WebGL2RenderingContextBase.R32I; 3771 3772 /** @type {number} */ 3773 WebGL2RenderingContextBase.R32UI; 3774 3775 /** @type {number} */ 3776 WebGL2RenderingContextBase.RG8I; 3777 3778 /** @type {number} */ 3779 WebGL2RenderingContextBase.RG8UI; 3780 3781 /** @type {number} */ 3782 WebGL2RenderingContextBase.RG16I; 3783 3784 /** @type {number} */ 3785 WebGL2RenderingContextBase.RG16UI; 3786 3787 /** @type {number} */ 3788 WebGL2RenderingContextBase.RG32I; 3789 3790 /** @type {number} */ 3791 WebGL2RenderingContextBase.RG32UI; 3792 3793 /** @type {number} */ 3794 WebGL2RenderingContextBase.VERTEX_ARRAY_BINDING; 3795 3796 /** @type {number} */ 3797 WebGL2RenderingContextBase.R8_SNORM; 3798 3799 /** @type {number} */ 3800 WebGL2RenderingContextBase.RG8_SNORM; 3801 3802 /** @type {number} */ 3803 WebGL2RenderingContextBase.RGB8_SNORM; 3804 3805 /** @type {number} */ 3806 WebGL2RenderingContextBase.RGBA8_SNORM; 3807 3808 /** @type {number} */ 3809 WebGL2RenderingContextBase.SIGNED_NORMALIZED; 3810 3811 /** @type {number} */ 3812 WebGL2RenderingContextBase.COPY_READ_BUFFER; 3813 3814 /** @type {number} */ 3815 WebGL2RenderingContextBase.COPY_WRITE_BUFFER; 3816 3817 // Same as COPY_READ_BUFFER 3818 /** @type {number} */ 3819 WebGL2RenderingContextBase.COPY_READ_BUFFER_BINDING; 3820 3821 // Same as COPY_WRITE_BUFFER 3822 /** @type {number} */ 3823 WebGL2RenderingContextBase.COPY_WRITE_BUFFER_BINDING; 3824 3825 /** @type {number} */ 3826 WebGL2RenderingContextBase.UNIFORM_BUFFER; 3827 3828 /** @type {number} */ 3829 WebGL2RenderingContextBase.UNIFORM_BUFFER_BINDING; 3830 3831 /** @type {number} */ 3832 WebGL2RenderingContextBase.UNIFORM_BUFFER_START; 3833 3834 /** @type {number} */ 3835 WebGL2RenderingContextBase.UNIFORM_BUFFER_SIZE; 3836 3837 /** @type {number} */ 3838 WebGL2RenderingContextBase.MAX_VERTEX_UNIFORM_BLOCKS; 3839 3840 /** @type {number} */ 3841 WebGL2RenderingContextBase.MAX_FRAGMENT_UNIFORM_BLOCKS; 3842 3843 /** @type {number} */ 3844 WebGL2RenderingContextBase.MAX_COMBINED_UNIFORM_BLOCKS; 3845 3846 /** @type {number} */ 3847 WebGL2RenderingContextBase.MAX_UNIFORM_BUFFER_BINDINGS; 3848 3849 /** @type {number} */ 3850 WebGL2RenderingContextBase.MAX_UNIFORM_BLOCK_SIZE; 3851 3852 /** @type {number} */ 3853 WebGL2RenderingContextBase.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS; 3854 3855 /** @type {number} */ 3856 WebGL2RenderingContextBase.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS; 3857 3858 /** @type {number} */ 3859 WebGL2RenderingContextBase.UNIFORM_BUFFER_OFFSET_ALIGNMENT; 3860 3861 /** @type {number} */ 3862 WebGL2RenderingContextBase.ACTIVE_UNIFORM_BLOCKS; 3863 3864 /** @type {number} */ 3865 WebGL2RenderingContextBase.UNIFORM_TYPE; 3866 3867 /** @type {number} */ 3868 WebGL2RenderingContextBase.UNIFORM_SIZE; 3869 3870 /** @type {number} */ 3871 WebGL2RenderingContextBase.UNIFORM_BLOCK_INDEX; 3872 3873 /** @type {number} */ 3874 WebGL2RenderingContextBase.UNIFORM_OFFSET; 3875 3876 /** @type {number} */ 3877 WebGL2RenderingContextBase.UNIFORM_ARRAY_STRIDE; 3878 3879 /** @type {number} */ 3880 WebGL2RenderingContextBase.UNIFORM_MATRIX_STRIDE; 3881 3882 /** @type {number} */ 3883 WebGL2RenderingContextBase.UNIFORM_IS_ROW_MAJOR; 3884 3885 /** @type {number} */ 3886 WebGL2RenderingContextBase.UNIFORM_BLOCK_BINDING; 3887 3888 /** @type {number} */ 3889 WebGL2RenderingContextBase.UNIFORM_BLOCK_DATA_SIZE; 3890 3891 /** @type {number} */ 3892 WebGL2RenderingContextBase.UNIFORM_BLOCK_ACTIVE_UNIFORMS; 3893 3894 /** @type {number} */ 3895 WebGL2RenderingContextBase.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES; 3896 3897 /** @type {number} */ 3898 WebGL2RenderingContextBase.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER; 3899 3900 /** @type {number} */ 3901 WebGL2RenderingContextBase.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER; 3902 3903 /** @type {number} */ 3904 WebGL2RenderingContextBase.INVALID_INDEX; 3905 3906 /** @type {number} */ 3907 WebGL2RenderingContextBase.MAX_VERTEX_OUTPUT_COMPONENTS; 3908 3909 /** @type {number} */ 3910 WebGL2RenderingContextBase.MAX_FRAGMENT_INPUT_COMPONENTS; 3911 3912 /** @type {number} */ 3913 WebGL2RenderingContextBase.MAX_SERVER_WAIT_TIMEOUT; 3914 3915 /** @type {number} */ 3916 WebGL2RenderingContextBase.OBJECT_TYPE; 3917 3918 /** @type {number} */ 3919 WebGL2RenderingContextBase.SYNC_CONDITION; 3920 3921 /** @type {number} */ 3922 WebGL2RenderingContextBase.SYNC_STATUS; 3923 3924 /** @type {number} */ 3925 WebGL2RenderingContextBase.SYNC_FLAGS; 3926 3927 /** @type {number} */ 3928 WebGL2RenderingContextBase.SYNC_FENCE; 3929 3930 /** @type {number} */ 3931 WebGL2RenderingContextBase.SYNC_GPU_COMMANDS_COMPLETE; 3932 3933 /** @type {number} */ 3934 WebGL2RenderingContextBase.UNSIGNALED; 3935 3936 /** @type {number} */ 3937 WebGL2RenderingContextBase.SIGNALED; 3938 3939 /** @type {number} */ 3940 WebGL2RenderingContextBase.ALREADY_SIGNALED; 3941 3942 /** @type {number} */ 3943 WebGL2RenderingContextBase.TIMEOUT_EXPIRED; 3944 3945 /** @type {number} */ 3946 WebGL2RenderingContextBase.CONDITION_SATISFIED; 3947 3948 /** @type {number} */ 3949 WebGL2RenderingContextBase.WAIT_FAILED; 3950 3951 /** @type {number} */ 3952 WebGL2RenderingContextBase.SYNC_FLUSH_COMMANDS_BIT; 3953 3954 /** @type {number} */ 3955 WebGL2RenderingContextBase.VERTEX_ATTRIB_ARRAY_DIVISOR; 3956 3957 /** @type {number} */ 3958 WebGL2RenderingContextBase.ANY_SAMPLES_PASSED; 3959 3960 /** @type {number} */ 3961 WebGL2RenderingContextBase.ANY_SAMPLES_PASSED_CONSERVATIVE; 3962 3963 /** @type {number} */ 3964 WebGL2RenderingContextBase.SAMPLER_BINDING; 3965 3966 /** @type {number} */ 3967 WebGL2RenderingContextBase.RGB10_A2UI; 3968 3969 /** @type {number} */ 3970 WebGL2RenderingContextBase.INT_2_10_10_10_REV; 3971 3972 /** @type {number} */ 3973 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK; 3974 3975 /** @type {number} */ 3976 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_PAUSED; 3977 3978 /** @type {number} */ 3979 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_ACTIVE; 3980 3981 /** @type {number} */ 3982 WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BINDING; 3983 3984 /** @type {number} */ 3985 WebGL2RenderingContextBase.TEXTURE_IMMUTABLE_FORMAT; 3986 3987 /** @type {number} */ 3988 WebGL2RenderingContextBase.MAX_ELEMENT_INDEX; 3989 3990 /** @type {number} */ 3991 WebGL2RenderingContextBase.NUM_SAMPLE_COUNTS; 3992 3993 /** @type {number} */ 3994 WebGL2RenderingContextBase.TEXTURE_IMMUTABLE_LEVELS; 3995 3996 /** @type {number} */ 3997 WebGL2RenderingContextBase.TIMEOUT_IGNORED; 3998 3999 4000 /** @type {number} */ 4001 WebGL2RenderingContextBase.prototype.READ_BUFFER; 4002 4003 /** @type {number} */ 4004 WebGL2RenderingContextBase.prototype.UNPACK_ROW_LENGTH; 4005 4006 /** @type {number} */ 4007 WebGL2RenderingContextBase.prototype.UNPACK_SKIP_ROWS; 4008 4009 /** @type {number} */ 4010 WebGL2RenderingContextBase.prototype.UNPACK_SKIP_PIXELS; 4011 4012 /** @type {number} */ 4013 WebGL2RenderingContextBase.prototype.PACK_ROW_LENGTH; 4014 4015 /** @type {number} */ 4016 WebGL2RenderingContextBase.prototype.PACK_SKIP_ROWS; 4017 4018 /** @type {number} */ 4019 WebGL2RenderingContextBase.prototype.PACK_SKIP_PIXELS; 4020 4021 /** @type {number} */ 4022 WebGL2RenderingContextBase.prototype.COLOR; 4023 4024 /** @type {number} */ 4025 WebGL2RenderingContextBase.prototype.DEPTH; 4026 4027 /** @type {number} */ 4028 WebGL2RenderingContextBase.prototype.STENCIL; 4029 4030 /** @type {number} */ 4031 WebGL2RenderingContextBase.prototype.RED; 4032 4033 /** @type {number} */ 4034 WebGL2RenderingContextBase.prototype.RGB8; 4035 4036 /** @type {number} */ 4037 WebGL2RenderingContextBase.prototype.RGBA8; 4038 4039 /** @type {number} */ 4040 WebGL2RenderingContextBase.prototype.RGB10_A2; 4041 4042 /** @type {number} */ 4043 WebGL2RenderingContextBase.prototype.TEXTURE_BINDING_3D; 4044 4045 /** @type {number} */ 4046 WebGL2RenderingContextBase.prototype.UNPACK_SKIP_IMAGES; 4047 4048 /** @type {number} */ 4049 WebGL2RenderingContextBase.prototype.UNPACK_IMAGE_HEIGHT; 4050 4051 /** @type {number} */ 4052 WebGL2RenderingContextBase.prototype.TEXTURE_3D; 4053 4054 /** @type {number} */ 4055 WebGL2RenderingContextBase.prototype.TEXTURE_WRAP_R; 4056 4057 /** @type {number} */ 4058 WebGL2RenderingContextBase.prototype.MAX_3D_TEXTURE_SIZE; 4059 4060 /** @type {number} */ 4061 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_2_10_10_10_REV; 4062 4063 /** @type {number} */ 4064 WebGL2RenderingContextBase.prototype.MAX_ELEMENTS_VERTICES; 4065 4066 /** @type {number} */ 4067 WebGL2RenderingContextBase.prototype.MAX_ELEMENTS_INDICES; 4068 4069 /** @type {number} */ 4070 WebGL2RenderingContextBase.prototype.TEXTURE_MIN_LOD; 4071 4072 /** @type {number} */ 4073 WebGL2RenderingContextBase.prototype.TEXTURE_MAX_LOD; 4074 4075 /** @type {number} */ 4076 WebGL2RenderingContextBase.prototype.TEXTURE_BASE_LEVEL; 4077 4078 /** @type {number} */ 4079 WebGL2RenderingContextBase.prototype.TEXTURE_MAX_LEVEL; 4080 4081 /** @type {number} */ 4082 WebGL2RenderingContextBase.prototype.MIN; 4083 4084 /** @type {number} */ 4085 WebGL2RenderingContextBase.prototype.MAX; 4086 4087 /** @type {number} */ 4088 WebGL2RenderingContextBase.prototype.DEPTH_COMPONENT24; 4089 4090 /** @type {number} */ 4091 WebGL2RenderingContextBase.prototype.MAX_TEXTURE_LOD_BIAS; 4092 4093 /** @type {number} */ 4094 WebGL2RenderingContextBase.prototype.TEXTURE_COMPARE_MODE; 4095 4096 /** @type {number} */ 4097 WebGL2RenderingContextBase.prototype.TEXTURE_COMPARE_FUNC; 4098 4099 /** @type {number} */ 4100 WebGL2RenderingContextBase.prototype.CURRENT_QUERY; 4101 4102 /** @type {number} */ 4103 WebGL2RenderingContextBase.prototype.QUERY_RESULT; 4104 4105 /** @type {number} */ 4106 WebGL2RenderingContextBase.prototype.QUERY_RESULT_AVAILABLE; 4107 4108 /** @type {number} */ 4109 WebGL2RenderingContextBase.prototype.STREAM_READ; 4110 4111 /** @type {number} */ 4112 WebGL2RenderingContextBase.prototype.STREAM_COPY; 4113 4114 /** @type {number} */ 4115 WebGL2RenderingContextBase.prototype.STATIC_READ; 4116 4117 /** @type {number} */ 4118 WebGL2RenderingContextBase.prototype.STATIC_COPY; 4119 4120 /** @type {number} */ 4121 WebGL2RenderingContextBase.prototype.DYNAMIC_READ; 4122 4123 /** @type {number} */ 4124 WebGL2RenderingContextBase.prototype.DYNAMIC_COPY; 4125 4126 /** @type {number} */ 4127 WebGL2RenderingContextBase.prototype.MAX_DRAW_BUFFERS; 4128 4129 /** @type {number} */ 4130 WebGL2RenderingContextBase.prototype.DRAW_BUFFER0; 4131 4132 /** @type {number} */ 4133 WebGL2RenderingContextBase.prototype.DRAW_BUFFER1; 4134 4135 /** @type {number} */ 4136 WebGL2RenderingContextBase.prototype.DRAW_BUFFER2; 4137 4138 /** @type {number} */ 4139 WebGL2RenderingContextBase.prototype.DRAW_BUFFER3; 4140 4141 /** @type {number} */ 4142 WebGL2RenderingContextBase.prototype.DRAW_BUFFER4; 4143 4144 /** @type {number} */ 4145 WebGL2RenderingContextBase.prototype.DRAW_BUFFER5; 4146 4147 /** @type {number} */ 4148 WebGL2RenderingContextBase.prototype.DRAW_BUFFER6; 4149 4150 /** @type {number} */ 4151 WebGL2RenderingContextBase.prototype.DRAW_BUFFER7; 4152 4153 /** @type {number} */ 4154 WebGL2RenderingContextBase.prototype.DRAW_BUFFER8; 4155 4156 /** @type {number} */ 4157 WebGL2RenderingContextBase.prototype.DRAW_BUFFER9; 4158 4159 /** @type {number} */ 4160 WebGL2RenderingContextBase.prototype.DRAW_BUFFER10; 4161 4162 /** @type {number} */ 4163 WebGL2RenderingContextBase.prototype.DRAW_BUFFER11; 4164 4165 /** @type {number} */ 4166 WebGL2RenderingContextBase.prototype.DRAW_BUFFER12; 4167 4168 /** @type {number} */ 4169 WebGL2RenderingContextBase.prototype.DRAW_BUFFER13; 4170 4171 /** @type {number} */ 4172 WebGL2RenderingContextBase.prototype.DRAW_BUFFER14; 4173 4174 /** @type {number} */ 4175 WebGL2RenderingContextBase.prototype.DRAW_BUFFER15; 4176 4177 /** @type {number} */ 4178 WebGL2RenderingContextBase.prototype.MAX_FRAGMENT_UNIFORM_COMPONENTS; 4179 4180 /** @type {number} */ 4181 WebGL2RenderingContextBase.prototype.MAX_VERTEX_UNIFORM_COMPONENTS; 4182 4183 /** @type {number} */ 4184 WebGL2RenderingContextBase.prototype.SAMPLER_3D; 4185 4186 /** @type {number} */ 4187 WebGL2RenderingContextBase.prototype.SAMPLER_2D_SHADOW; 4188 4189 /** @type {number} */ 4190 WebGL2RenderingContextBase.prototype.FRAGMENT_SHADER_DERIVATIVE_HINT; 4191 4192 /** @type {number} */ 4193 WebGL2RenderingContextBase.prototype.PIXEL_PACK_BUFFER; 4194 4195 /** @type {number} */ 4196 WebGL2RenderingContextBase.prototype.PIXEL_UNPACK_BUFFER; 4197 4198 /** @type {number} */ 4199 WebGL2RenderingContextBase.prototype.PIXEL_PACK_BUFFER_BINDING; 4200 4201 /** @type {number} */ 4202 WebGL2RenderingContextBase.prototype.PIXEL_UNPACK_BUFFER_BINDING; 4203 4204 /** @type {number} */ 4205 WebGL2RenderingContextBase.prototype.FLOAT_MAT2x3; 4206 4207 /** @type {number} */ 4208 WebGL2RenderingContextBase.prototype.FLOAT_MAT2x4; 4209 4210 /** @type {number} */ 4211 WebGL2RenderingContextBase.prototype.FLOAT_MAT3x2; 4212 4213 /** @type {number} */ 4214 WebGL2RenderingContextBase.prototype.FLOAT_MAT3x4; 4215 4216 /** @type {number} */ 4217 WebGL2RenderingContextBase.prototype.FLOAT_MAT4x2; 4218 4219 /** @type {number} */ 4220 WebGL2RenderingContextBase.prototype.FLOAT_MAT4x3; 4221 4222 /** @type {number} */ 4223 WebGL2RenderingContextBase.prototype.SRGB; 4224 4225 /** @type {number} */ 4226 WebGL2RenderingContextBase.prototype.SRGB8; 4227 4228 /** @type {number} */ 4229 WebGL2RenderingContextBase.prototype.SRGB8_ALPHA8; 4230 4231 /** @type {number} */ 4232 WebGL2RenderingContextBase.prototype.COMPARE_REF_TO_TEXTURE; 4233 4234 /** @type {number} */ 4235 WebGL2RenderingContextBase.prototype.RGBA32F; 4236 4237 /** @type {number} */ 4238 WebGL2RenderingContextBase.prototype.RGB32F; 4239 4240 /** @type {number} */ 4241 WebGL2RenderingContextBase.prototype.RGBA16F; 4242 4243 /** @type {number} */ 4244 WebGL2RenderingContextBase.prototype.RGB16F; 4245 4246 /** @type {number} */ 4247 WebGL2RenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_INTEGER; 4248 4249 /** @type {number} */ 4250 WebGL2RenderingContextBase.prototype.MAX_ARRAY_TEXTURE_LAYERS; 4251 4252 /** @type {number} */ 4253 WebGL2RenderingContextBase.prototype.MIN_PROGRAM_TEXEL_OFFSET; 4254 4255 /** @type {number} */ 4256 WebGL2RenderingContextBase.prototype.MAX_PROGRAM_TEXEL_OFFSET; 4257 4258 /** @type {number} */ 4259 WebGL2RenderingContextBase.prototype.MAX_VARYING_COMPONENTS; 4260 4261 /** @type {number} */ 4262 WebGL2RenderingContextBase.prototype.TEXTURE_2D_ARRAY; 4263 4264 /** @type {number} */ 4265 WebGL2RenderingContextBase.prototype.TEXTURE_BINDING_2D_ARRAY; 4266 4267 /** @type {number} */ 4268 WebGL2RenderingContextBase.prototype.R11F_G11F_B10F; 4269 4270 /** @type {number} */ 4271 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_10F_11F_11F_REV; 4272 4273 /** @type {number} */ 4274 WebGL2RenderingContextBase.prototype.RGB9_E5; 4275 4276 /** @type {number} */ 4277 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_5_9_9_9_REV; 4278 4279 /** @type {number} */ 4280 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BUFFER_MODE; 4281 4282 /** @type {number} */ 4283 WebGL2RenderingContextBase.prototype.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS; 4284 4285 /** @type {number} */ 4286 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_VARYINGS; 4287 4288 /** @type {number} */ 4289 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BUFFER_START; 4290 4291 /** @type {number} */ 4292 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BUFFER_SIZE; 4293 4294 /** @type {number} */ 4295 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN; 4296 4297 /** @type {number} */ 4298 WebGL2RenderingContextBase.prototype.RASTERIZER_DISCARD; 4299 4300 /** @type {number} */ 4301 WebGL2RenderingContextBase.prototype.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS; 4302 4303 /** @type {number} */ 4304 WebGL2RenderingContextBase.prototype.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS; 4305 4306 /** @type {number} */ 4307 WebGL2RenderingContextBase.prototype.INTERLEAVED_ATTRIBS; 4308 4309 /** @type {number} */ 4310 WebGL2RenderingContextBase.prototype.SEPARATE_ATTRIBS; 4311 4312 /** @type {number} */ 4313 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BUFFER; 4314 4315 /** @type {number} */ 4316 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BUFFER_BINDING; 4317 4318 /** @type {number} */ 4319 WebGL2RenderingContextBase.prototype.RGBA32UI; 4320 4321 /** @type {number} */ 4322 WebGL2RenderingContextBase.prototype.RGB32UI; 4323 4324 /** @type {number} */ 4325 WebGL2RenderingContextBase.prototype.RGBA16UI; 4326 4327 /** @type {number} */ 4328 WebGL2RenderingContextBase.prototype.RGB16UI; 4329 4330 /** @type {number} */ 4331 WebGL2RenderingContextBase.prototype.RGBA8UI; 4332 4333 /** @type {number} */ 4334 WebGL2RenderingContextBase.prototype.RGB8UI; 4335 4336 /** @type {number} */ 4337 WebGL2RenderingContextBase.prototype.RGBA32I; 4338 4339 /** @type {number} */ 4340 WebGL2RenderingContextBase.prototype.RGB32I; 4341 4342 /** @type {number} */ 4343 WebGL2RenderingContextBase.prototype.RGBA16I; 4344 4345 /** @type {number} */ 4346 WebGL2RenderingContextBase.prototype.RGB16I; 4347 4348 /** @type {number} */ 4349 WebGL2RenderingContextBase.prototype.RGBA8I; 4350 4351 /** @type {number} */ 4352 WebGL2RenderingContextBase.prototype.RGB8I; 4353 4354 /** @type {number} */ 4355 WebGL2RenderingContextBase.prototype.RED_INTEGER; 4356 4357 /** @type {number} */ 4358 WebGL2RenderingContextBase.prototype.RGB_INTEGER; 4359 4360 /** @type {number} */ 4361 WebGL2RenderingContextBase.prototype.RGBA_INTEGER; 4362 4363 /** @type {number} */ 4364 WebGL2RenderingContextBase.prototype.SAMPLER_2D_ARRAY; 4365 4366 /** @type {number} */ 4367 WebGL2RenderingContextBase.prototype.SAMPLER_2D_ARRAY_SHADOW; 4368 4369 /** @type {number} */ 4370 WebGL2RenderingContextBase.prototype.SAMPLER_CUBE_SHADOW; 4371 4372 /** @type {number} */ 4373 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_VEC2; 4374 4375 /** @type {number} */ 4376 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_VEC3; 4377 4378 /** @type {number} */ 4379 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_VEC4; 4380 4381 /** @type {number} */ 4382 WebGL2RenderingContextBase.prototype.INT_SAMPLER_2D; 4383 4384 /** @type {number} */ 4385 WebGL2RenderingContextBase.prototype.INT_SAMPLER_3D; 4386 4387 /** @type {number} */ 4388 WebGL2RenderingContextBase.prototype.INT_SAMPLER_CUBE; 4389 4390 /** @type {number} */ 4391 WebGL2RenderingContextBase.prototype.INT_SAMPLER_2D_ARRAY; 4392 4393 /** @type {number} */ 4394 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_SAMPLER_2D; 4395 4396 /** @type {number} */ 4397 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_SAMPLER_3D; 4398 4399 /** @type {number} */ 4400 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_SAMPLER_CUBE; 4401 4402 /** @type {number} */ 4403 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_SAMPLER_2D_ARRAY; 4404 4405 /** @type {number} */ 4406 WebGL2RenderingContextBase.prototype.DEPTH_COMPONENT32F; 4407 4408 /** @type {number} */ 4409 WebGL2RenderingContextBase.prototype.DEPTH32F_STENCIL8; 4410 4411 /** @type {number} */ 4412 WebGL2RenderingContextBase.prototype.FLOAT_32_UNSIGNED_INT_24_8_REV; 4413 4414 /** @type {number} */ 4415 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING; 4416 4417 /** @type {number} */ 4418 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE; 4419 4420 /** @type {number} */ 4421 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_RED_SIZE; 4422 4423 /** @type {number} */ 4424 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE; 4425 4426 /** @type {number} */ 4427 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE; 4428 4429 /** @type {number} */ 4430 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE; 4431 4432 /** @type {number} */ 4433 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE; 4434 4435 /** @type {number} */ 4436 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE; 4437 4438 /** @type {number} */ 4439 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_DEFAULT; 4440 4441 /** @type {number} */ 4442 WebGL2RenderingContextBase.prototype.DEPTH_STENCIL_ATTACHMENT; 4443 4444 /** @type {number} */ 4445 WebGL2RenderingContextBase.prototype.DEPTH_STENCIL; 4446 4447 /** @type {number} */ 4448 WebGL2RenderingContextBase.prototype.UNSIGNED_INT_24_8; 4449 4450 /** @type {number} */ 4451 WebGL2RenderingContextBase.prototype.DEPTH24_STENCIL8; 4452 4453 /** @type {number} */ 4454 WebGL2RenderingContextBase.prototype.UNSIGNED_NORMALIZED; 4455 4456 // Same as FRAMEBUFFER_BINDING 4457 /** @type {number} */ 4458 WebGL2RenderingContextBase.prototype.DRAW_FRAMEBUFFER_BINDING; 4459 4460 /** @type {number} */ 4461 WebGL2RenderingContextBase.prototype.READ_FRAMEBUFFER; 4462 4463 /** @type {number} */ 4464 WebGL2RenderingContextBase.prototype.DRAW_FRAMEBUFFER; 4465 4466 /** @type {number} */ 4467 WebGL2RenderingContextBase.prototype.READ_FRAMEBUFFER_BINDING; 4468 4469 /** @type {number} */ 4470 WebGL2RenderingContextBase.prototype.RENDERBUFFER_SAMPLES; 4471 4472 /** @type {number} */ 4473 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER; 4474 4475 /** @type {number} */ 4476 WebGL2RenderingContextBase.prototype.MAX_COLOR_ATTACHMENTS; 4477 4478 /** @type {number} */ 4479 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT1; 4480 4481 /** @type {number} */ 4482 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT2; 4483 4484 /** @type {number} */ 4485 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT3; 4486 4487 /** @type {number} */ 4488 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT4; 4489 4490 /** @type {number} */ 4491 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT5; 4492 4493 /** @type {number} */ 4494 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT6; 4495 4496 /** @type {number} */ 4497 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT7; 4498 4499 /** @type {number} */ 4500 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT8; 4501 4502 /** @type {number} */ 4503 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT9; 4504 4505 /** @type {number} */ 4506 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT10; 4507 4508 /** @type {number} */ 4509 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT11; 4510 4511 /** @type {number} */ 4512 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT12; 4513 4514 /** @type {number} */ 4515 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT13; 4516 4517 /** @type {number} */ 4518 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT14; 4519 4520 /** @type {number} */ 4521 WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT15; 4522 4523 /** @type {number} */ 4524 WebGL2RenderingContextBase.prototype.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE; 4525 4526 /** @type {number} */ 4527 WebGL2RenderingContextBase.prototype.MAX_SAMPLES; 4528 4529 /** @type {number} */ 4530 WebGL2RenderingContextBase.prototype.HALF_FLOAT; 4531 4532 /** @type {number} */ 4533 WebGL2RenderingContextBase.prototype.RG; 4534 4535 /** @type {number} */ 4536 WebGL2RenderingContextBase.prototype.RG_INTEGER; 4537 4538 /** @type {number} */ 4539 WebGL2RenderingContextBase.prototype.R8; 4540 4541 /** @type {number} */ 4542 WebGL2RenderingContextBase.prototype.RG8; 4543 4544 /** @type {number} */ 4545 WebGL2RenderingContextBase.prototype.R16F; 4546 4547 /** @type {number} */ 4548 WebGL2RenderingContextBase.prototype.R32F; 4549 4550 /** @type {number} */ 4551 WebGL2RenderingContextBase.prototype.RG16F; 4552 4553 /** @type {number} */ 4554 WebGL2RenderingContextBase.prototype.RG32F; 4555 4556 /** @type {number} */ 4557 WebGL2RenderingContextBase.prototype.R8I; 4558 4559 /** @type {number} */ 4560 WebGL2RenderingContextBase.prototype.R8UI; 4561 4562 /** @type {number} */ 4563 WebGL2RenderingContextBase.prototype.R16I; 4564 4565 /** @type {number} */ 4566 WebGL2RenderingContextBase.prototype.R16UI; 4567 4568 /** @type {number} */ 4569 WebGL2RenderingContextBase.prototype.R32I; 4570 4571 /** @type {number} */ 4572 WebGL2RenderingContextBase.prototype.R32UI; 4573 4574 /** @type {number} */ 4575 WebGL2RenderingContextBase.prototype.RG8I; 4576 4577 /** @type {number} */ 4578 WebGL2RenderingContextBase.prototype.RG8UI; 4579 4580 /** @type {number} */ 4581 WebGL2RenderingContextBase.prototype.RG16I; 4582 4583 /** @type {number} */ 4584 WebGL2RenderingContextBase.prototype.RG16UI; 4585 4586 /** @type {number} */ 4587 WebGL2RenderingContextBase.prototype.RG32I; 4588 4589 /** @type {number} */ 4590 WebGL2RenderingContextBase.prototype.RG32UI; 4591 4592 /** @type {number} */ 4593 WebGL2RenderingContextBase.prototype.VERTEX_ARRAY_BINDING; 4594 4595 /** @type {number} */ 4596 WebGL2RenderingContextBase.prototype.R8_SNORM; 4597 4598 /** @type {number} */ 4599 WebGL2RenderingContextBase.prototype.RG8_SNORM; 4600 4601 /** @type {number} */ 4602 WebGL2RenderingContextBase.prototype.RGB8_SNORM; 4603 4604 /** @type {number} */ 4605 WebGL2RenderingContextBase.prototype.RGBA8_SNORM; 4606 4607 /** @type {number} */ 4608 WebGL2RenderingContextBase.prototype.SIGNED_NORMALIZED; 4609 4610 /** @type {number} */ 4611 WebGL2RenderingContextBase.prototype.COPY_READ_BUFFER; 4612 4613 /** @type {number} */ 4614 WebGL2RenderingContextBase.prototype.COPY_WRITE_BUFFER; 4615 4616 // Same as COPY_READ_BUFFER 4617 /** @type {number} */ 4618 WebGL2RenderingContextBase.prototype.COPY_READ_BUFFER_BINDING; 4619 4620 // Same as COPY_WRITE_BUFFER 4621 /** @type {number} */ 4622 WebGL2RenderingContextBase.prototype.COPY_WRITE_BUFFER_BINDING; 4623 4624 /** @type {number} */ 4625 WebGL2RenderingContextBase.prototype.UNIFORM_BUFFER; 4626 4627 /** @type {number} */ 4628 WebGL2RenderingContextBase.prototype.UNIFORM_BUFFER_BINDING; 4629 4630 /** @type {number} */ 4631 WebGL2RenderingContextBase.prototype.UNIFORM_BUFFER_START; 4632 4633 /** @type {number} */ 4634 WebGL2RenderingContextBase.prototype.UNIFORM_BUFFER_SIZE; 4635 4636 /** @type {number} */ 4637 WebGL2RenderingContextBase.prototype.MAX_VERTEX_UNIFORM_BLOCKS; 4638 4639 /** @type {number} */ 4640 WebGL2RenderingContextBase.prototype.MAX_FRAGMENT_UNIFORM_BLOCKS; 4641 4642 /** @type {number} */ 4643 WebGL2RenderingContextBase.prototype.MAX_COMBINED_UNIFORM_BLOCKS; 4644 4645 /** @type {number} */ 4646 WebGL2RenderingContextBase.prototype.MAX_UNIFORM_BUFFER_BINDINGS; 4647 4648 /** @type {number} */ 4649 WebGL2RenderingContextBase.prototype.MAX_UNIFORM_BLOCK_SIZE; 4650 4651 /** @type {number} */ 4652 WebGL2RenderingContextBase.prototype.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS; 4653 4654 /** @type {number} */ 4655 WebGL2RenderingContextBase.prototype.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS; 4656 4657 /** @type {number} */ 4658 WebGL2RenderingContextBase.prototype.UNIFORM_BUFFER_OFFSET_ALIGNMENT; 4659 4660 /** @type {number} */ 4661 WebGL2RenderingContextBase.prototype.ACTIVE_UNIFORM_BLOCKS; 4662 4663 /** @type {number} */ 4664 WebGL2RenderingContextBase.prototype.UNIFORM_TYPE; 4665 4666 /** @type {number} */ 4667 WebGL2RenderingContextBase.prototype.UNIFORM_SIZE; 4668 4669 /** @type {number} */ 4670 WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_INDEX; 4671 4672 /** @type {number} */ 4673 WebGL2RenderingContextBase.prototype.UNIFORM_OFFSET; 4674 4675 /** @type {number} */ 4676 WebGL2RenderingContextBase.prototype.UNIFORM_ARRAY_STRIDE; 4677 4678 /** @type {number} */ 4679 WebGL2RenderingContextBase.prototype.UNIFORM_MATRIX_STRIDE; 4680 4681 /** @type {number} */ 4682 WebGL2RenderingContextBase.prototype.UNIFORM_IS_ROW_MAJOR; 4683 4684 /** @type {number} */ 4685 WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_BINDING; 4686 4687 /** @type {number} */ 4688 WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_DATA_SIZE; 4689 4690 /** @type {number} */ 4691 WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_ACTIVE_UNIFORMS; 4692 4693 /** @type {number} */ 4694 WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES; 4695 4696 /** @type {number} */ 4697 WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER; 4698 4699 /** @type {number} */ 4700 WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER; 4701 4702 /** @type {number} */ 4703 WebGL2RenderingContextBase.prototype.INVALID_INDEX; 4704 4705 /** @type {number} */ 4706 WebGL2RenderingContextBase.prototype.MAX_VERTEX_OUTPUT_COMPONENTS; 4707 4708 /** @type {number} */ 4709 WebGL2RenderingContextBase.prototype.MAX_FRAGMENT_INPUT_COMPONENTS; 4710 4711 /** @type {number} */ 4712 WebGL2RenderingContextBase.prototype.MAX_SERVER_WAIT_TIMEOUT; 4713 4714 /** @type {number} */ 4715 WebGL2RenderingContextBase.prototype.OBJECT_TYPE; 4716 4717 /** @type {number} */ 4718 WebGL2RenderingContextBase.prototype.SYNC_CONDITION; 4719 4720 /** @type {number} */ 4721 WebGL2RenderingContextBase.prototype.SYNC_STATUS; 4722 4723 /** @type {number} */ 4724 WebGL2RenderingContextBase.prototype.SYNC_FLAGS; 4725 4726 /** @type {number} */ 4727 WebGL2RenderingContextBase.prototype.SYNC_FENCE; 4728 4729 /** @type {number} */ 4730 WebGL2RenderingContextBase.prototype.SYNC_GPU_COMMANDS_COMPLETE; 4731 4732 /** @type {number} */ 4733 WebGL2RenderingContextBase.prototype.UNSIGNALED; 4734 4735 /** @type {number} */ 4736 WebGL2RenderingContextBase.prototype.SIGNALED; 4737 4738 /** @type {number} */ 4739 WebGL2RenderingContextBase.prototype.ALREADY_SIGNALED; 4740 4741 /** @type {number} */ 4742 WebGL2RenderingContextBase.prototype.TIMEOUT_EXPIRED; 4743 4744 /** @type {number} */ 4745 WebGL2RenderingContextBase.prototype.CONDITION_SATISFIED; 4746 4747 /** @type {number} */ 4748 WebGL2RenderingContextBase.prototype.WAIT_FAILED; 4749 4750 /** @type {number} */ 4751 WebGL2RenderingContextBase.prototype.SYNC_FLUSH_COMMANDS_BIT; 4752 4753 /** @type {number} */ 4754 WebGL2RenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_DIVISOR; 4755 4756 /** @type {number} */ 4757 WebGL2RenderingContextBase.prototype.ANY_SAMPLES_PASSED; 4758 4759 /** @type {number} */ 4760 WebGL2RenderingContextBase.prototype.ANY_SAMPLES_PASSED_CONSERVATIVE; 4761 4762 /** @type {number} */ 4763 WebGL2RenderingContextBase.prototype.SAMPLER_BINDING; 4764 4765 /** @type {number} */ 4766 WebGL2RenderingContextBase.prototype.RGB10_A2UI; 4767 4768 /** @type {number} */ 4769 WebGL2RenderingContextBase.prototype.INT_2_10_10_10_REV; 4770 4771 /** @type {number} */ 4772 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK; 4773 4774 /** @type {number} */ 4775 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_PAUSED; 4776 4777 /** @type {number} */ 4778 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_ACTIVE; 4779 4780 /** @type {number} */ 4781 WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BINDING; 4782 4783 /** @type {number} */ 4784 WebGL2RenderingContextBase.prototype.TEXTURE_IMMUTABLE_FORMAT; 4785 4786 /** @type {number} */ 4787 WebGL2RenderingContextBase.prototype.MAX_ELEMENT_INDEX; 4788 4789 /** @type {number} */ 4790 WebGL2RenderingContextBase.prototype.NUM_SAMPLE_COUNTS; 4791 4792 /** @type {number} */ 4793 WebGL2RenderingContextBase.prototype.TEXTURE_IMMUTABLE_LEVELS; 4794 4795 /** @type {number} */ 4796 WebGL2RenderingContextBase.prototype.TIMEOUT_IGNORED; 4797 4798 /** 4799 * @constructor 4800 * @noalias 4801 * @extends {WebGLObject} 4802 */ 4803 function WebGLQuery() {} 4804 4805 4806 /** 4807 * @constructor 4808 * @noalias 4809 * @extends {WebGLObject} 4810 */ 4811 function WebGLSampler() {} 4812 4813 4814 /** 4815 * @constructor 4816 * @noalias 4817 * @extends {WebGLObject} 4818 */ 4819 function WebGLSync() {} 4820 4821 4822 /** 4823 * @constructor 4824 * @noalias 4825 * @extends {WebGLObject} 4826 */ 4827 function WebGLTransformFeedback() {} 4828 4829 4830 /** 4831 * @constructor 4832 * @noalias 4833 * @extends {WebGLObject} 4834 */ 4835 function WebGLVertexArrayObject() {} 4836 4837 4838 /** 4839 * @param {number} target 4840 * @param {WebGLQuery} query 4841 */ 4842 WebGL2RenderingContextBase.prototype.beginQuery = function(target, query) {}; 4843 4844 /** 4845 * @param {number} primitiveMode 4846 */ 4847 WebGL2RenderingContextBase.prototype.beginTransformFeedback = function(primitiveMode) {}; 4848 4849 /** 4850 * @param {number} target 4851 * @param {number} index 4852 * @param {WebGLBuffer} buffer 4853 */ 4854 WebGL2RenderingContextBase.prototype.bindBufferBase = function(target, index, buffer) {}; 4855 4856 /** 4857 * @param {number} target 4858 * @param {number} index 4859 * @param {WebGLBuffer} buffer 4860 * @param {number} offset 4861 * @param {number} size 4862 */ 4863 WebGL2RenderingContextBase.prototype.bindBufferRange = function(target, index, buffer, offset, size) {}; 4864 4865 /** 4866 * @param {number} unit 4867 * @param {WebGLSampler} sampler 4868 */ 4869 WebGL2RenderingContextBase.prototype.bindSampler = function(unit, sampler) {}; 4870 4871 /** 4872 * @param {number} target 4873 * @param {WebGLTransformFeedback} id 4874 */ 4875 WebGL2RenderingContextBase.prototype.bindTransformFeedback = function(target, id) {}; 4876 4877 /** 4878 * @param {WebGLVertexArrayObject} array 4879 */ 4880 WebGL2RenderingContextBase.prototype.bindVertexArray = function(array) {}; 4881 4882 /** 4883 * @param {number} srcX0 4884 * @param {number} srcY0 4885 * @param {number} srcX1 4886 * @param {number} srcY1 4887 * @param {number} dstX0 4888 * @param {number} dstY0 4889 * @param {number} dstX1 4890 * @param {number} dstY1 4891 * @param {number} mask 4892 * @param {number} filter 4893 */ 4894 WebGL2RenderingContextBase.prototype.blitFramebuffer = function( 4895 srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, 4896 dstX1, dstY1, mask, filter) {}; 4897 4898 /** 4899 * @param {number} buffer 4900 * @param {number} drawbuffer 4901 * @param {Int32Array|Array.<number>} value 4902 */ 4903 WebGL2RenderingContextBase.prototype.clearBufferiv = function(buffer, drawbuffer, value) {}; 4904 4905 /** 4906 * @param {number} buffer 4907 * @param {number} drawbuffer 4908 * @param {Uint32Array|Array.<number>} value 4909 */ 4910 WebGL2RenderingContextBase.prototype.clearBufferuiv = function(buffer, drawbuffer, value) {}; 4911 4912 /** 4913 * @param {number} buffer 4914 * @param {number} drawbuffer 4915 * @param {Float32Array|Array.<number>} value 4916 */ 4917 WebGL2RenderingContextBase.prototype.clearBufferfv = function(buffer, drawbuffer, value) {}; 4918 4919 /** 4920 * @param {number} buffer 4921 * @param {number} drawbuffer 4922 * @param {number} depth 4923 * @param {number} stencil 4924 */ 4925 WebGL2RenderingContextBase.prototype.clearBufferfi = function(buffer, drawbuffer, depth, stencil) {}; 4926 4927 /** 4928 * @param {WebGLSync} sync 4929 * @param {number} flags 4930 * @param {number} timeout 4931 * @return {number} 4932 */ 4933 WebGL2RenderingContextBase.prototype.clientWaitSync = function(sync, flags, timeout) {}; 4934 4935 /** 4936 * @param {number} target 4937 * @param {number} level 4938 * @param {number} internalformat 4939 * @param {number} width 4940 * @param {number} height 4941 * @param {number} depth 4942 * @param {number} border 4943 * @param {ArrayBufferView} data 4944 */ 4945 WebGL2RenderingContextBase.prototype.compressedTexImage3D = function( 4946 target, level, internalformat, width, height, depth, border, data) {}; 4947 4948 /** 4949 * @param {number} target 4950 * @param {number} level 4951 * @param {number} xoffset 4952 * @param {number} yoffset 4953 * @param {number} zoffset 4954 * @param {number} width 4955 * @param {number} height 4956 * @param {number} depth 4957 * @param {number} format 4958 * @param {ArrayBufferView} data 4959 */ 4960 WebGL2RenderingContextBase.prototype.compressedTexSubImage3D = function( 4961 target, level, xoffset, yoffset, zoffset, width, height, depth, format, data) {}; 4962 4963 /** 4964 * @param {number} readTarget 4965 * @param {number} writeTarget 4966 * @param {number} readOffset 4967 * @param {number} writeOffset 4968 * @param {number} size 4969 */ 4970 WebGL2RenderingContextBase.prototype.copyBufferSubData = function( 4971 readTarget, writeTarget, readOffset, writeOffset, size) {}; 4972 4973 /** 4974 * @param {number} target 4975 * @param {number} level 4976 * @param {number} xoffset 4977 * @param {number} yoffset 4978 * @param {number} zoffset 4979 * @param {number} x 4980 * @param {number} y 4981 * @param {number} width 4982 * @param {number} height 4983 */ 4984 WebGL2RenderingContextBase.prototype.copyTexSubImage3D = function( 4985 target, level, xoffset, yoffset, zoffset, x, y, width, height) {}; 4986 4987 /** 4988 * @return {!WebGLQuery} 4989 * @nosideeffects 4990 */ 4991 WebGL2RenderingContextBase.prototype.createQuery = function() {}; 4992 4993 /** 4994 * @return {!WebGLSampler} 4995 * @nosideeffects 4996 */ 4997 WebGL2RenderingContextBase.prototype.createSampler = function() {}; 4998 4999 /** 5000 * @return {!WebGLTransformFeedback} 5001 * @nosideeffects 5002 */ 5003 WebGL2RenderingContextBase.prototype.createTransformFeedback = function() {}; 5004 5005 /** 5006 * @return {!WebGLVertexArrayObject} 5007 * @nosideeffects 5008 */ 5009 WebGL2RenderingContextBase.prototype.createVertexArray = function() {}; 5010 5011 5012 /** 5013 * @param {WebGLQuery} query 5014 */ 5015 WebGL2RenderingContextBase.prototype.deleteQuery = function(query) {}; 5016 5017 /** 5018 * @param {WebGLSampler} sampler 5019 */ 5020 WebGL2RenderingContextBase.prototype.deleteSampler = function(sampler) {}; 5021 5022 /** 5023 * @param {WebGLSync} sync 5024 */ 5025 WebGL2RenderingContextBase.prototype.deleteSync = function(sync) {}; 5026 5027 /** 5028 * @param {WebGLTransformFeedback} feedback 5029 */ 5030 WebGL2RenderingContextBase.prototype.deleteTransformFeedback = function(feedback) {}; 5031 5032 /** 5033 * @param {WebGLVertexArrayObject} vertexArray 5034 */ 5035 WebGL2RenderingContextBase.prototype.deleteVertexArray = function(vertexArray) {}; 5036 5037 /** 5038 * @param {number} mode 5039 * @param {number} first 5040 * @param {number} count 5041 * @param {number} instanceCount 5042 */ 5043 WebGL2RenderingContextBase.prototype.drawArraysInstanced = function(mode, first, count, instanceCount) {}; 5044 5045 /** 5046 * @param {number} mode 5047 * @param {number} count 5048 * @param {number} type 5049 * @param {number} offset 5050 * @param {number} instanceCount 5051 */ 5052 WebGL2RenderingContextBase.prototype.drawElementsInstanced = function(mode, count, type, offset, instanceCount) {}; 5053 5054 /** 5055 * @param {number} mode 5056 * @param {number} start 5057 * @param {number} end 5058 * @param {number} count 5059 * @param {number} type 5060 * @param {number} offset 5061 */ 5062 WebGL2RenderingContextBase.prototype.drawRangeElements = function(mode, start, end, count, type, offset) {}; 5063 5064 /** 5065 * @param {Array.<number>} buffers 5066 */ 5067 WebGL2RenderingContextBase.prototype.drawBuffers = function(buffers) {}; 5068 5069 /** 5070 * @param {number} target 5071 */ 5072 WebGL2RenderingContextBase.prototype.endQuery = function(target) {}; 5073 5074 /** 5075 */ 5076 WebGL2RenderingContextBase.prototype.endTransformFeedback = function() {}; 5077 5078 /** 5079 * @param {number} condition 5080 * @param {number} flags 5081 * @return {WebGLSync} 5082 */ 5083 WebGL2RenderingContextBase.prototype.fenceSync = function(condition, flags) {}; 5084 5085 /** 5086 * @param {number} target 5087 * @param {number} attachment 5088 * @param {WebGLTexture} texture 5089 * @param {number} level 5090 * @param {number} layer 5091 */ 5092 WebGL2RenderingContextBase.prototype.framebufferTextureLayer = function( 5093 target, attachment, texture, level, layer) {}; 5094 5095 /** 5096 * @param {WebGLProgram} program 5097 * @param {number} uniformBlockIndex 5098 * @return {string} 5099 * @nosideeffects 5100 */ 5101 WebGL2RenderingContextBase.prototype.getActiveUniformBlockName = function(program, uniformBlockIndex) {}; 5102 5103 /** 5104 * @param {WebGLProgram} program 5105 * @param {number} uniformBlockIndex 5106 * @param {number} pname 5107 * @return {*} 5108 * @nosideeffects 5109 */ 5110 WebGL2RenderingContextBase.prototype.getActiveUniformBlockParameter = function( 5111 program, uniformBlockIndex, pname) {}; 5112 5113 /** 5114 * @param {WebGLProgram} program 5115 * @param {Array.<number>} uniformIndices 5116 * @param {number} pname 5117 * @return {Array.<number>} 5118 * @nosideeffects 5119 */ 5120 WebGL2RenderingContextBase.prototype.getActiveUniforms = function( 5121 program, uniformIndices, pname) {}; 5122 5123 /** 5124 * @param {number} target 5125 * @param {number} offset 5126 * @param {ArrayBuffer} returnedData 5127 * @nosideeffects 5128 */ 5129 WebGL2RenderingContextBase.prototype.getBufferSubData = function( 5130 target, offset, returnedData) {}; 5131 5132 /** 5133 * @param {WebGLProgram} program 5134 * @param {string} name 5135 * @return {number} 5136 * @nosideeffects 5137 */ 5138 WebGL2RenderingContextBase.prototype.getFragDataLocation = function(program, name) {}; 5139 5140 /** 5141 * @param {number} target 5142 * @param {number} index 5143 * @return {*} 5144 * @nosideeffects 5145 */ 5146 WebGL2RenderingContextBase.prototype.getIndexedParameter = function(target, index) {}; 5147 5148 /** 5149 * @param {number} target 5150 * @param {number} internalformat 5151 * @param {number} pname 5152 * @return {*} 5153 * @nosideeffects 5154 */ 5155 WebGL2RenderingContextBase.prototype.getInternalformatParameter = function(target, internalformat, pname) {}; 5156 5157 /** 5158 * @param {number} target 5159 * @param {number} pname 5160 * @return {WebGLQuery} 5161 * @nosideeffects 5162 */ 5163 WebGL2RenderingContextBase.prototype.getQuery = function(target, pname) {}; 5164 5165 /** 5166 * @param {WebGLQuery} query 5167 * @param {number} pname 5168 * @return {*} 5169 * @nosideeffects 5170 */ 5171 WebGL2RenderingContextBase.prototype.getQueryParameter = function(query, pname) {}; 5172 5173 /** 5174 * @param {WebGLSampler} sampler 5175 * @param {number} pname 5176 * @return {*} 5177 * @nosideeffects 5178 */ 5179 WebGL2RenderingContextBase.prototype.getSamplerParameter = function(sampler, pname) {}; 5180 5181 /** 5182 * @param {WebGLSync} sync 5183 * @param {number} pname 5184 * @return {*} 5185 * @nosideeffects 5186 */ 5187 WebGL2RenderingContextBase.prototype.getSyncParameter = function(sync, pname) {}; 5188 5189 /** 5190 * @param {WebGLProgram} program 5191 * @param {number} index 5192 * @return {WebGLActiveInfo} 5193 * @nosideeffects 5194 */ 5195 WebGL2RenderingContextBase.prototype.getTransformFeedbackVarying = function(program, index) {}; 5196 5197 /** 5198 * @param {WebGLProgram} program 5199 * @param {string} uniformBlockName 5200 * @return {number} 5201 * @nosideeffects 5202 */ 5203 WebGL2RenderingContextBase.prototype.getUniformBlockIndex = function(program, uniformBlockName) {}; 5204 5205 /** 5206 * @param {WebGLProgram} program 5207 * @param {Array.<string>} uniformNames 5208 * @return {Array.<number>} 5209 * @nosideeffects 5210 */ 5211 WebGL2RenderingContextBase.prototype.getUniformIndices = function(program, uniformNames) {}; 5212 5213 /** 5214 * @param {number} target 5215 * @param {Array.<number>} attachments 5216 */ 5217 WebGL2RenderingContextBase.prototype.invalidateFramebuffer = function(target, attachments) {}; 5218 5219 /** 5220 * @param {number} target 5221 * @param {Array.<number>} attachments 5222 * @param {number} x 5223 * @param {number} y 5224 * @param {number} width 5225 * @param {number} height 5226 */ 5227 WebGL2RenderingContextBase.prototype.invalidateSubFramebuffer = function( 5228 target, attachments, x, y, width, height) {}; 5229 5230 /** 5231 * @param {WebGLQuery} query 5232 * @return {boolean} 5233 * @nosideeffects 5234 */ 5235 WebGL2RenderingContextBase.prototype.isQuery = function(query) {}; 5236 5237 /** 5238 * @param {WebGLSampler} sampler 5239 * @return {boolean} 5240 * @nosideeffects 5241 */ 5242 WebGL2RenderingContextBase.prototype.isSampler = function(sampler) {}; 5243 5244 /** 5245 * @param {WebGLSync} sync 5246 * @return {boolean} 5247 * @nosideeffects 5248 */ 5249 WebGL2RenderingContextBase.prototype.isSync = function(sync) {}; 5250 5251 /** 5252 * @param {WebGLTransformFeedback} feedback 5253 * @return {boolean} 5254 * @nosideeffects 5255 */ 5256 WebGL2RenderingContextBase.prototype.isTransformFeedback = function(feedback) {}; 5257 5258 /** 5259 * @param {WebGLVertexArrayObject} vertexArray 5260 * @return {boolean} 5261 * @nosideeffects 5262 */ 5263 WebGL2RenderingContextBase.prototype.isVertexArray = function(vertexArray) {}; 5264 5265 /** 5266 */ 5267 WebGL2RenderingContextBase.prototype.pauseTransformFeedback = function() {}; 5268 5269 /** 5270 * @param {number} src 5271 */ 5272 WebGL2RenderingContextBase.prototype.readBuffer = function(src) {}; 5273 5274 /** 5275 * @param {number} target 5276 * @param {number} samples 5277 * @param {number} internalformat 5278 * @param {number} width 5279 * @param {number} height 5280 */ 5281 WebGL2RenderingContextBase.prototype.renderbufferStorageMultisample = function( 5282 target, samples, internalformat, width, height) {}; 5283 5284 /** 5285 */ 5286 WebGL2RenderingContextBase.prototype.resumeTransformFeedback = function() {}; 5287 5288 /** 5289 * @param {WebGLSampler} sampler 5290 * @param {number} pname 5291 * @param {number} param 5292 */ 5293 WebGL2RenderingContextBase.prototype.samplerParameteri = function(sampler, pname, param) {}; 5294 5295 /** 5296 * @param {WebGLSampler} sampler 5297 * @param {number} pname 5298 * @param {number} param 5299 */ 5300 WebGL2RenderingContextBase.prototype.samplerParameterf = function(sampler, pname, param) {}; 5301 5302 /** 5303 * @param {number} target 5304 * @param {number} levels 5305 * @param {number} internalformat 5306 * @param {number} width 5307 * @param {number} height 5308 */ 5309 WebGL2RenderingContextBase.prototype.texStorage2D = function(target, levels, internalformat, width, height) {}; 5310 5311 /** 5312 * @param {number} target 5313 * @param {number} levels 5314 * @param {number} internalformat 5315 * @param {number} width 5316 * @param {number} height 5317 * @param {number} depth 5318 */ 5319 WebGL2RenderingContextBase.prototype.texStorage3D = function(target, levels, internalformat, width, height, depth) {}; 5320 5321 /** 5322 * @param {number} target 5323 * @param {number} level 5324 * @param {number} internalformat 5325 * @param {number} width 5326 * @param {number} height 5327 * @param {number} depth 5328 * @param {number} border 5329 * @param {number} format 5330 * @param {number} type 5331 * @param {ArrayBufferView} pixels 5332 */ 5333 WebGL2RenderingContextBase.prototype.texImage3D = function( 5334 target, level, internalformat, width, height, depth, border, format, type, pixels) {}; 5335 5336 /** 5337 * @param {number} target 5338 * @param {number} level 5339 * @param {number} xoffset 5340 * @param {number} yoffset 5341 * @param {number} zoffset 5342 * @param {number} format or width 5343 * @param {number} type or height 5344 * @param {ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement| 5345 * number} source or depth 5346 * @param {number=} opt_format 5347 * @param {number=} opt_type 5348 * @param {ArrayBufferView=} opt_pixels 5349 */ 5350 WebGL2RenderingContextBase.prototype.texSubImage3D = function( 5351 target, level, xoffset, yoffset, zoffset, format, type, source, opt_format, opt_type, opt_pixels) {}; 5352 5353 /** 5354 * @param {WebGLProgram} program 5355 * @param {Array.<string>} varyings 5356 * @param {number} bufferMode 5357 */ 5358 WebGL2RenderingContextBase.prototype.transformFeedbackVaryings = function(program, varyings, bufferMode) {}; 5359 5360 /** 5361 * @param {WebGLUniformLocation} location 5362 * @param {number} v0 5363 */ 5364 WebGL2RenderingContextBase.prototype.uniform1ui = function(location, v0) {}; 5365 5366 /** 5367 * @param {WebGLUniformLocation} location 5368 * @param {number} v0 5369 * @param {number} v1 5370 */ 5371 WebGL2RenderingContextBase.prototype.uniform2ui = function(location, v0, v1) {}; 5372 5373 /** 5374 * @param {WebGLUniformLocation} location 5375 * @param {number} v0 5376 * @param {number} v1 5377 * @param {number} v2 5378 */ 5379 WebGL2RenderingContextBase.prototype.uniform3ui = function(location, v0, v1, v2) {}; 5380 5381 /** 5382 * @param {WebGLUniformLocation} location 5383 * @param {number} v0 5384 * @param {number} v1 5385 * @param {number} v2 5386 * @param {number} v3 5387 */ 5388 WebGL2RenderingContextBase.prototype.uniform4ui = function(location, v0, v1, v2, v3) {}; 5389 5390 /** 5391 * @param {WebGLUniformLocation} location 5392 * @param {Uint32Array|Array.<number>} value 5393 */ 5394 WebGL2RenderingContextBase.prototype.uniform1uiv = function(location, value) {}; 5395 5396 /** 5397 * @param {WebGLUniformLocation} location 5398 * @param {Uint32Array|Array.<number>} value 5399 */ 5400 WebGL2RenderingContextBase.prototype.uniform2uiv = function(location, value) {}; 5401 5402 /** 5403 * @param {WebGLUniformLocation} location 5404 * @param {Uint32Array|Array.<number>} value 5405 */ 5406 WebGL2RenderingContextBase.prototype.uniform3uiv = function(location, value) {}; 5407 5408 /** 5409 * @param {WebGLUniformLocation} location 5410 * @param {Uint32Array|Array.<number>} value 5411 */ 5412 WebGL2RenderingContextBase.prototype.uniform4uiv = function(location, value) {}; 5413 5414 /** 5415 * @param {WebGLProgram} program 5416 * @param {number} uniformBlockIndex 5417 * @param {number} uniformBlockBinding 5418 */ 5419 WebGL2RenderingContextBase.prototype.uniformBlockBinding = function(program, uniformBlockIndex, uniformBlockBinding) {}; 5420 5421 /** 5422 * @param {WebGLUniformLocation} location 5423 * @param {boolean} transpose 5424 * @param {Float32Array|Array.<number>} value 5425 */ 5426 WebGL2RenderingContextBase.prototype.uniformMatrix2x3fv = function(location, transpose, value) {}; 5427 5428 /** 5429 * @param {WebGLUniformLocation} location 5430 * @param {boolean} transpose 5431 * @param {Float32Array|Array.<number>} value 5432 */ 5433 WebGL2RenderingContextBase.prototype.uniformMatrix3x2fv = function(location, transpose, value) {}; 5434 5435 /** 5436 * @param {WebGLUniformLocation} location 5437 * @param {boolean} transpose 5438 * @param {Float32Array|Array.<number>} value 5439 */ 5440 WebGL2RenderingContextBase.prototype.uniformMatrix2x4fv = function(location, transpose, value) {}; 5441 5442 /** 5443 * @param {WebGLUniformLocation} location 5444 * @param {boolean} transpose 5445 * @param {Float32Array|Array.<number>} value 5446 */ 5447 WebGL2RenderingContextBase.prototype.uniformMatrix4x2fv = function(location, transpose, value) {}; 5448 5449 /** 5450 * @param {WebGLUniformLocation} location 5451 * @param {boolean} transpose 5452 * @param {Float32Array|Array.<number>} value 5453 */ 5454 WebGL2RenderingContextBase.prototype.uniformMatrix3x4fv = function(location, transpose, value) {}; 5455 5456 /** 5457 * @param {WebGLUniformLocation} location 5458 * @param {boolean} transpose 5459 * @param {Float32Array|Array.<number>} value 5460 */ 5461 WebGL2RenderingContextBase.prototype.uniformMatrix4x3fv = function(location, transpose, value) {}; 5462 5463 /** 5464 * @param {number} index 5465 * @param {number} x 5466 * @param {number} y 5467 * @param {number} z 5468 * @param {number} w 5469 */ 5470 WebGL2RenderingContextBase.prototype.vertexAttribI4i = function(index, x, y, z, w) {}; 5471 5472 /** 5473 * @param {number} index 5474 * @param {(Array.<number>|Int32Array)} v 5475 */ 5476 WebGL2RenderingContextBase.prototype.vertexAttribI4iv = function(index, v) {}; 5477 5478 /** 5479 * @param {number} index 5480 * @param {number} x 5481 * @param {number} y 5482 * @param {number} z 5483 * @param {number} w 5484 */ 5485 WebGL2RenderingContextBase.prototype.vertexAttribI4ui = function(index, x, y, z, w) {}; 5486 5487 /** 5488 * @param {number} index 5489 * @param {(Array.<number>|Uint32Array)} v 5490 */ 5491 WebGL2RenderingContextBase.prototype.vertexAttribI4uiv = function(index, v) {}; 5492 5493 /** 5494 * @param {number} index 5495 * @param {number} size 5496 * @param {number} type 5497 * @param {number} stride 5498 * @param {number} offset 5499 */ 5500 WebGL2RenderingContextBase.prototype.vertexAttribIPointer = function(index, size, type, stride, offset) {}; 5501 5502 /** 5503 * @param {number} index 5504 * @param {number} divisor 5505 */ 5506 WebGL2RenderingContextBase.prototype.vertexAttribDivisor = function(index, divisor) {}; 5507 5508 /** 5509 * @param {WebGLSync} sync 5510 * @param {number} flags 5511 * @param {number} timeout 5512 */ 5513 WebGL2RenderingContextBase.prototype.waitSync = function(sync, flags, timeout) {}; 5514 5515 /** 5516 * @constructor 5517 * @noalias 5518 * @extends {WebGL2RenderingContextBase} 5519 */ 5520 function WebGL2RenderingContext() {}