diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/webgl2.js')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/webgl2.js | 5537 |
1 files changed, 5537 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/webgl2.js b/dom/canvas/test/webgl-conf/checkout/deqp/webgl2.js new file mode 100644 index 000000000..5e3680d69 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/webgl2.js @@ -0,0 +1,5537 @@ +/* + * Copyright 2010 The Closure Compiler Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// WebGL 2.0 portions: + +/* +** Copyright (c) 2015 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/** + * @fileoverview Definitions for WebGL functions as described at + * http://www.khronos.org/registry/webgl/specs/latest/1.0 and + * http://www.khronos.org/registry/webgl/specs/latest/2.0 + * + * This file is current up to the WebGL 2.0 spec, including extensions. + * + * This relies on html5.js being included for Canvas and Typed Array support. + * + * This includes some extensions defined at + * http://www.khronos.org/registry/webgl/extensions/ + * + * This file will be merged back into the Closure workspace as soon as + * the WebGL 2.0 changes have been fully tested. + * + * @externs + */ + +/** + * @constructor + * @noalias + * @private + */ +function WebGLRenderingContextBase() {} + +/** @typedef {number} */ +WebGLRenderingContextBase.GLenum; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_BUFFER_BIT; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_BUFFER_BIT; + +/** @type {number} */ +WebGLRenderingContextBase.COLOR_BUFFER_BIT; + +/** @type {number} */ +WebGLRenderingContextBase.POINTS; + +/** @type {number} */ +WebGLRenderingContextBase.LINES; + +/** @type {number} */ +WebGLRenderingContextBase.LINE_LOOP; + +/** @type {number} */ +WebGLRenderingContextBase.LINE_STRIP; + +/** @type {number} */ +WebGLRenderingContextBase.TRIANGLES; + +/** @type {number} */ +WebGLRenderingContextBase.TRIANGLE_STRIP; + +/** @type {number} */ +WebGLRenderingContextBase.TRIANGLE_FAN; + +/** @type {number} */ +WebGLRenderingContextBase.ZERO; + +/** @type {number} */ +WebGLRenderingContextBase.ONE; + +/** @type {number} */ +WebGLRenderingContextBase.SRC_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.ONE_MINUS_SRC_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.SRC_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.ONE_MINUS_SRC_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.DST_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.ONE_MINUS_DST_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.DST_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.ONE_MINUS_DST_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.SRC_ALPHA_SATURATE; + +/** @type {number} */ +WebGLRenderingContextBase.FUNC_ADD; + +/** @type {number} */ +WebGLRenderingContextBase.BLEND_EQUATION; + +/** @type {number} */ +WebGLRenderingContextBase.BLEND_EQUATION_RGB; + +/** @type {number} */ +WebGLRenderingContextBase.BLEND_EQUATION_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.FUNC_SUBTRACT; + +/** @type {number} */ +WebGLRenderingContextBase.FUNC_REVERSE_SUBTRACT; + +/** @type {number} */ +WebGLRenderingContextBase.BLEND_DST_RGB; + +/** @type {number} */ +WebGLRenderingContextBase.BLEND_SRC_RGB; + +/** @type {number} */ +WebGLRenderingContextBase.BLEND_DST_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.BLEND_SRC_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.CONSTANT_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.ONE_MINUS_CONSTANT_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.CONSTANT_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.ONE_MINUS_CONSTANT_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.BLEND_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.ARRAY_BUFFER; + +/** @type {number} */ +WebGLRenderingContextBase.ELEMENT_ARRAY_BUFFER; + +/** @type {number} */ +WebGLRenderingContextBase.ARRAY_BUFFER_BINDING; + +/** @type {number} */ +WebGLRenderingContextBase.ELEMENT_ARRAY_BUFFER_BINDING; + +/** @type {number} */ +WebGLRenderingContextBase.STREAM_DRAW; + +/** @type {number} */ +WebGLRenderingContextBase.STATIC_DRAW; + +/** @type {number} */ +WebGLRenderingContextBase.DYNAMIC_DRAW; + +/** @type {number} */ +WebGLRenderingContextBase.BUFFER_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.BUFFER_USAGE; + +/** @type {number} */ +WebGLRenderingContextBase.CURRENT_VERTEX_ATTRIB; + +/** @type {number} */ +WebGLRenderingContextBase.FRONT; + +/** @type {number} */ +WebGLRenderingContextBase.BACK; + +/** @type {number} */ +WebGLRenderingContextBase.FRONT_AND_BACK; + +/** @type {number} */ +WebGLRenderingContextBase.CULL_FACE; + +/** @type {number} */ +WebGLRenderingContextBase.BLEND; + +/** @type {number} */ +WebGLRenderingContextBase.DITHER; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_TEST; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_TEST; + +/** @type {number} */ +WebGLRenderingContextBase.SCISSOR_TEST; + +/** @type {number} */ +WebGLRenderingContextBase.POLYGON_OFFSET_FILL; + +/** @type {number} */ +WebGLRenderingContextBase.SAMPLE_ALPHA_TO_COVERAGE; + +/** @type {number} */ +WebGLRenderingContextBase.SAMPLE_COVERAGE; + +/** @type {number} */ +WebGLRenderingContextBase.NO_ERROR; + +/** @type {number} */ +WebGLRenderingContextBase.INVALID_ENUM; + +/** @type {number} */ +WebGLRenderingContextBase.INVALID_VALUE; + +/** @type {number} */ +WebGLRenderingContextBase.INVALID_OPERATION; + +/** @type {number} */ +WebGLRenderingContextBase.OUT_OF_MEMORY; + +/** @type {number} */ +WebGLRenderingContextBase.CW; + +/** @type {number} */ +WebGLRenderingContextBase.CCW; + +/** @type {number} */ +WebGLRenderingContextBase.LINE_WIDTH; + +/** @type {number} */ +WebGLRenderingContextBase.ALIASED_POINT_SIZE_RANGE; + +/** @type {number} */ +WebGLRenderingContextBase.ALIASED_LINE_WIDTH_RANGE; + +/** @type {number} */ +WebGLRenderingContextBase.CULL_FACE_MODE; + +/** @type {number} */ +WebGLRenderingContextBase.FRONT_FACE; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_RANGE; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_WRITEMASK; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_CLEAR_VALUE; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_FUNC; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_CLEAR_VALUE; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_FUNC; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_FAIL; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_PASS_DEPTH_FAIL; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_PASS_DEPTH_PASS; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_REF; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_VALUE_MASK; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_WRITEMASK; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_BACK_FUNC; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_BACK_FAIL; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_BACK_PASS_DEPTH_FAIL; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_BACK_PASS_DEPTH_PASS; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_BACK_REF; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_BACK_VALUE_MASK; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_BACK_WRITEMASK; + +/** @type {number} */ +WebGLRenderingContextBase.VIEWPORT; + +/** @type {number} */ +WebGLRenderingContextBase.SCISSOR_BOX; + +/** @type {number} */ +WebGLRenderingContextBase.COLOR_CLEAR_VALUE; + +/** @type {number} */ +WebGLRenderingContextBase.COLOR_WRITEMASK; + +/** @type {number} */ +WebGLRenderingContextBase.UNPACK_ALIGNMENT; + +/** @type {number} */ +WebGLRenderingContextBase.PACK_ALIGNMENT; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_TEXTURE_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_VIEWPORT_DIMS; + +/** @type {number} */ +WebGLRenderingContextBase.SUBPIXEL_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.RED_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.GREEN_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.BLUE_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.ALPHA_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.POLYGON_OFFSET_UNITS; + +/** @type {number} */ +WebGLRenderingContextBase.POLYGON_OFFSET_FACTOR; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_BINDING_2D; + +/** @type {number} */ +WebGLRenderingContextBase.SAMPLE_BUFFERS; + +/** @type {number} */ +WebGLRenderingContextBase.SAMPLES; + +/** @type {number} */ +WebGLRenderingContextBase.SAMPLE_COVERAGE_VALUE; + +/** @type {number} */ +WebGLRenderingContextBase.SAMPLE_COVERAGE_INVERT; + +/** @type {number} */ +WebGLRenderingContextBase.COMPRESSED_TEXTURE_FORMATS; + +/** @type {number} */ +WebGLRenderingContextBase.DONT_CARE; + +/** @type {number} */ +WebGLRenderingContextBase.FASTEST; + +/** @type {number} */ +WebGLRenderingContextBase.NICEST; + +/** @type {number} */ +WebGLRenderingContextBase.GENERATE_MIPMAP_HINT; + +/** @type {number} */ +WebGLRenderingContextBase.BYTE; + +/** @type {number} */ +WebGLRenderingContextBase.UNSIGNED_BYTE; + +/** @type {number} */ +WebGLRenderingContextBase.SHORT; + +/** @type {number} */ +WebGLRenderingContextBase.UNSIGNED_SHORT; + +/** @type {number} */ +WebGLRenderingContextBase.INT; + +/** @type {number} */ +WebGLRenderingContextBase.UNSIGNED_INT; + +/** @type {number} */ +WebGLRenderingContextBase.FLOAT; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_COMPONENT; + +/** @type {number} */ +WebGLRenderingContextBase.ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.RGB; + +/** @type {number} */ +WebGLRenderingContextBase.RGBA; + +/** @type {number} */ +WebGLRenderingContextBase.LUMINANCE; + +/** @type {number} */ +WebGLRenderingContextBase.LUMINANCE_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.UNSIGNED_SHORT_4_4_4_4; + +/** @type {number} */ +WebGLRenderingContextBase.UNSIGNED_SHORT_5_5_5_1; + +/** @type {number} */ +WebGLRenderingContextBase.UNSIGNED_SHORT_5_6_5; + +/** @type {number} */ +WebGLRenderingContextBase.FRAGMENT_SHADER; + +/** @type {number} */ +WebGLRenderingContextBase.VERTEX_SHADER; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_VERTEX_ATTRIBS; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_VERTEX_UNIFORM_VECTORS; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_VARYING_VECTORS; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_COMBINED_TEXTURE_IMAGE_UNITS; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_VERTEX_TEXTURE_IMAGE_UNITS; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_TEXTURE_IMAGE_UNITS; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_FRAGMENT_UNIFORM_VECTORS; + +/** @type {number} */ +WebGLRenderingContextBase.SHADER_TYPE; + +/** @type {number} */ +WebGLRenderingContextBase.DELETE_STATUS; + +/** @type {number} */ +WebGLRenderingContextBase.LINK_STATUS; + +/** @type {number} */ +WebGLRenderingContextBase.VALIDATE_STATUS; + +/** @type {number} */ +WebGLRenderingContextBase.ATTACHED_SHADERS; + +/** @type {number} */ +WebGLRenderingContextBase.ACTIVE_UNIFORMS; + +/** @type {number} */ +WebGLRenderingContextBase.ACTIVE_ATTRIBUTES; + +/** @type {number} */ +WebGLRenderingContextBase.SHADING_LANGUAGE_VERSION; + +/** @type {number} */ +WebGLRenderingContextBase.CURRENT_PROGRAM; + +/** @type {number} */ +WebGLRenderingContextBase.NEVER; + +/** @type {number} */ +WebGLRenderingContextBase.LESS; + +/** @type {number} */ +WebGLRenderingContextBase.EQUAL; + +/** @type {number} */ +WebGLRenderingContextBase.LEQUAL; + +/** @type {number} */ +WebGLRenderingContextBase.GREATER; + +/** @type {number} */ +WebGLRenderingContextBase.NOTEQUAL; + +/** @type {number} */ +WebGLRenderingContextBase.GEQUAL; + +/** @type {number} */ +WebGLRenderingContextBase.ALWAYS; + +/** @type {number} */ +WebGLRenderingContextBase.KEEP; + +/** @type {number} */ +WebGLRenderingContextBase.REPLACE; + +/** @type {number} */ +WebGLRenderingContextBase.INCR; + +/** @type {number} */ +WebGLRenderingContextBase.DECR; + +/** @type {number} */ +WebGLRenderingContextBase.INVERT; + +/** @type {number} */ +WebGLRenderingContextBase.INCR_WRAP; + +/** @type {number} */ +WebGLRenderingContextBase.DECR_WRAP; + +/** @type {number} */ +WebGLRenderingContextBase.VENDOR; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERER; + +/** @type {number} */ +WebGLRenderingContextBase.VERSION; + +/** @type {number} */ +WebGLRenderingContextBase.NEAREST; + +/** @type {number} */ +WebGLRenderingContextBase.LINEAR; + +/** @type {number} */ +WebGLRenderingContextBase.NEAREST_MIPMAP_NEAREST; + +/** @type {number} */ +WebGLRenderingContextBase.LINEAR_MIPMAP_NEAREST; + +/** @type {number} */ +WebGLRenderingContextBase.NEAREST_MIPMAP_LINEAR; + +/** @type {number} */ +WebGLRenderingContextBase.LINEAR_MIPMAP_LINEAR; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_MAG_FILTER; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_MIN_FILTER; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_WRAP_S; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_WRAP_T; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_2D; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_CUBE_MAP; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_BINDING_CUBE_MAP; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_CUBE_MAP_POSITIVE_X; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_CUBE_MAP_NEGATIVE_X; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_CUBE_MAP_POSITIVE_Y; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_CUBE_MAP_NEGATIVE_Y; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_CUBE_MAP_POSITIVE_Z; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE_CUBE_MAP_NEGATIVE_Z; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_CUBE_MAP_TEXTURE_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE0; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE1; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE2; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE3; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE4; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE5; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE6; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE7; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE8; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE9; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE10; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE11; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE12; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE13; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE14; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE15; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE16; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE17; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE18; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE19; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE20; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE21; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE22; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE23; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE24; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE25; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE26; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE27; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE28; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE29; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE30; + +/** @type {number} */ +WebGLRenderingContextBase.TEXTURE31; + +/** @type {number} */ +WebGLRenderingContextBase.ACTIVE_TEXTURE; + +/** @type {number} */ +WebGLRenderingContextBase.REPEAT; + +/** @type {number} */ +WebGLRenderingContextBase.CLAMP_TO_EDGE; + +/** @type {number} */ +WebGLRenderingContextBase.MIRRORED_REPEAT; + +/** @type {number} */ +WebGLRenderingContextBase.FLOAT_VEC2; + +/** @type {number} */ +WebGLRenderingContextBase.FLOAT_VEC3; + +/** @type {number} */ +WebGLRenderingContextBase.FLOAT_VEC4; + +/** @type {number} */ +WebGLRenderingContextBase.INT_VEC2; + +/** @type {number} */ +WebGLRenderingContextBase.INT_VEC3; + +/** @type {number} */ +WebGLRenderingContextBase.INT_VEC4; + +/** @type {number} */ +WebGLRenderingContextBase.BOOL; + +/** @type {number} */ +WebGLRenderingContextBase.BOOL_VEC2; + +/** @type {number} */ +WebGLRenderingContextBase.BOOL_VEC3; + +/** @type {number} */ +WebGLRenderingContextBase.BOOL_VEC4; + +/** @type {number} */ +WebGLRenderingContextBase.FLOAT_MAT2; + +/** @type {number} */ +WebGLRenderingContextBase.FLOAT_MAT3; + +/** @type {number} */ +WebGLRenderingContextBase.FLOAT_MAT4; + +/** @type {number} */ +WebGLRenderingContextBase.SAMPLER_2D; + +/** @type {number} */ +WebGLRenderingContextBase.SAMPLER_CUBE; + +/** @type {number} */ +WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_ENABLED; + +/** @type {number} */ +WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_STRIDE; + +/** @type {number} */ +WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_TYPE; + +/** @type {number} */ +WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_NORMALIZED; + +/** @type {number} */ +WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_POINTER; + +/** @type {number} */ +WebGLRenderingContextBase.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING; + +/** @type {number} */ +WebGLRenderingContextBase.IMPLEMENTATION_COLOR_READ_TYPE; + +/** @type {number} */ +WebGLRenderingContextBase.IMPLEMENTATION_COLOR_READ_FORMAT; + +/** @type {number} */ +WebGLRenderingContextBase.COMPILE_STATUS; + +/** @type {number} */ +WebGLRenderingContextBase.LOW_FLOAT; + +/** @type {number} */ +WebGLRenderingContextBase.MEDIUM_FLOAT; + +/** @type {number} */ +WebGLRenderingContextBase.HIGH_FLOAT; + +/** @type {number} */ +WebGLRenderingContextBase.LOW_INT; + +/** @type {number} */ +WebGLRenderingContextBase.MEDIUM_INT; + +/** @type {number} */ +WebGLRenderingContextBase.HIGH_INT; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER; + +/** @type {number} */ +WebGLRenderingContextBase.RGBA4; + +/** @type {number} */ +WebGLRenderingContextBase.RGB5_A1; + +/** @type {number} */ +WebGLRenderingContextBase.RGB565; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_COMPONENT16; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_INDEX; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_INDEX8; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_STENCIL; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER_WIDTH; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER_HEIGHT; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER_INTERNAL_FORMAT; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER_RED_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER_GREEN_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER_BLUE_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER_ALPHA_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER_DEPTH_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER_STENCIL_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE; + +/** @type {number} */ +WebGLRenderingContextBase.COLOR_ATTACHMENT0; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_ATTACHMENT; + +/** @type {number} */ +WebGLRenderingContextBase.STENCIL_ATTACHMENT; + +/** @type {number} */ +WebGLRenderingContextBase.DEPTH_STENCIL_ATTACHMENT; + +/** @type {number} */ +WebGLRenderingContextBase.NONE; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER_COMPLETE; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER_INCOMPLETE_ATTACHMENT; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER_INCOMPLETE_DIMENSIONS; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER_UNSUPPORTED; + +/** @type {number} */ +WebGLRenderingContextBase.FRAMEBUFFER_BINDING; + +/** @type {number} */ +WebGLRenderingContextBase.RENDERBUFFER_BINDING; + +/** @type {number} */ +WebGLRenderingContextBase.MAX_RENDERBUFFER_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.INVALID_FRAMEBUFFER_OPERATION; + +/** @type {number} */ +WebGLRenderingContextBase.UNPACK_FLIP_Y_WEBGL; + +/** @type {number} */ +WebGLRenderingContextBase.UNPACK_PREMULTIPLY_ALPHA_WEBGL; + +/** @type {number} */ +WebGLRenderingContextBase.CONTEXT_LOST_WEBGL; + +/** @type {number} */ +WebGLRenderingContextBase.UNPACK_COLORSPACE_CONVERSION_WEBGL; + +/** @type {number} */ +WebGLRenderingContextBase.BROWSER_DEFAULT_WEBGL; + + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_BUFFER_BIT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_BUFFER_BIT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.COLOR_BUFFER_BIT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.POINTS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LINES; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LINE_LOOP; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LINE_STRIP; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TRIANGLES; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TRIANGLE_STRIP; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TRIANGLE_FAN; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ZERO; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ONE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SRC_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ONE_MINUS_SRC_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SRC_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ONE_MINUS_SRC_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DST_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ONE_MINUS_DST_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DST_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ONE_MINUS_DST_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SRC_ALPHA_SATURATE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FUNC_ADD; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BLEND_EQUATION; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BLEND_EQUATION_RGB; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BLEND_EQUATION_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FUNC_SUBTRACT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FUNC_REVERSE_SUBTRACT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BLEND_DST_RGB; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BLEND_SRC_RGB; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BLEND_DST_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BLEND_SRC_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.CONSTANT_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ONE_MINUS_CONSTANT_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.CONSTANT_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ONE_MINUS_CONSTANT_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BLEND_COLOR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ARRAY_BUFFER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ELEMENT_ARRAY_BUFFER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ARRAY_BUFFER_BINDING; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ELEMENT_ARRAY_BUFFER_BINDING; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STREAM_DRAW; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STATIC_DRAW; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DYNAMIC_DRAW; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BUFFER_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BUFFER_USAGE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.CURRENT_VERTEX_ATTRIB; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRONT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BACK; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRONT_AND_BACK; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.CULL_FACE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BLEND; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DITHER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_TEST; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_TEST; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SCISSOR_TEST; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.POLYGON_OFFSET_FILL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SAMPLE_ALPHA_TO_COVERAGE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SAMPLE_COVERAGE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.NO_ERROR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INVALID_ENUM; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INVALID_VALUE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INVALID_OPERATION; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.OUT_OF_MEMORY; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.CW; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.CCW; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LINE_WIDTH; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ALIASED_POINT_SIZE_RANGE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ALIASED_LINE_WIDTH_RANGE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.CULL_FACE_MODE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRONT_FACE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_RANGE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_WRITEMASK; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_CLEAR_VALUE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_FUNC; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_CLEAR_VALUE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_FUNC; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_FAIL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_PASS_DEPTH_FAIL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_PASS_DEPTH_PASS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_REF; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_VALUE_MASK; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_WRITEMASK; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_BACK_FUNC; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_BACK_FAIL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_BACK_PASS_DEPTH_FAIL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_BACK_PASS_DEPTH_PASS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_BACK_REF; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_BACK_VALUE_MASK; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_BACK_WRITEMASK; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VIEWPORT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SCISSOR_BOX; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.COLOR_CLEAR_VALUE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.COLOR_WRITEMASK; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.UNPACK_ALIGNMENT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.PACK_ALIGNMENT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_TEXTURE_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_VIEWPORT_DIMS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SUBPIXEL_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RED_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.GREEN_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BLUE_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ALPHA_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_BITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.POLYGON_OFFSET_UNITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.POLYGON_OFFSET_FACTOR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_BINDING_2D; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SAMPLE_BUFFERS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SAMPLES; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SAMPLE_COVERAGE_VALUE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SAMPLE_COVERAGE_INVERT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.COMPRESSED_TEXTURE_FORMATS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DONT_CARE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FASTEST; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.NICEST; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.GENERATE_MIPMAP_HINT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BYTE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.UNSIGNED_BYTE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SHORT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.UNSIGNED_SHORT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.UNSIGNED_INT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FLOAT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_COMPONENT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RGB; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RGBA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LUMINANCE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LUMINANCE_ALPHA; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.UNSIGNED_SHORT_4_4_4_4; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.UNSIGNED_SHORT_5_5_5_1; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.UNSIGNED_SHORT_5_6_5; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAGMENT_SHADER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VERTEX_SHADER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_VERTEX_ATTRIBS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_VERTEX_UNIFORM_VECTORS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_VARYING_VECTORS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_COMBINED_TEXTURE_IMAGE_UNITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_VERTEX_TEXTURE_IMAGE_UNITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_TEXTURE_IMAGE_UNITS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_FRAGMENT_UNIFORM_VECTORS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SHADER_TYPE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DELETE_STATUS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LINK_STATUS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VALIDATE_STATUS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ATTACHED_SHADERS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ACTIVE_UNIFORMS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ACTIVE_ATTRIBUTES; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SHADING_LANGUAGE_VERSION; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.CURRENT_PROGRAM; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.NEVER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LESS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.EQUAL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LEQUAL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.GREATER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.NOTEQUAL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.GEQUAL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ALWAYS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.KEEP; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.REPLACE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INCR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DECR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INVERT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INCR_WRAP; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DECR_WRAP; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VENDOR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VERSION; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.NEAREST; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LINEAR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.NEAREST_MIPMAP_NEAREST; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LINEAR_MIPMAP_NEAREST; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.NEAREST_MIPMAP_LINEAR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LINEAR_MIPMAP_LINEAR; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_MAG_FILTER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_MIN_FILTER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_WRAP_S; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_WRAP_T; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_2D; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_BINDING_CUBE_MAP; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_POSITIVE_X; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_NEGATIVE_X; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_POSITIVE_Y; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_NEGATIVE_Y; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_POSITIVE_Z; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE_CUBE_MAP_NEGATIVE_Z; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_CUBE_MAP_TEXTURE_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE0; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE1; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE2; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE3; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE4; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE5; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE6; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE7; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE8; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE9; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE10; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE11; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE12; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE13; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE14; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE15; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE16; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE17; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE18; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE19; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE20; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE21; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE22; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE23; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE24; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE25; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE26; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE27; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE28; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE29; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE30; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.TEXTURE31; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.ACTIVE_TEXTURE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.REPEAT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.CLAMP_TO_EDGE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MIRRORED_REPEAT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FLOAT_VEC2; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FLOAT_VEC3; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FLOAT_VEC4; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INT_VEC2; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INT_VEC3; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INT_VEC4; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BOOL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BOOL_VEC2; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BOOL_VEC3; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BOOL_VEC4; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FLOAT_MAT2; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FLOAT_MAT3; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FLOAT_MAT4; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SAMPLER_2D; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.SAMPLER_CUBE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_ENABLED; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_STRIDE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_TYPE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_NORMALIZED; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_POINTER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.IMPLEMENTATION_COLOR_READ_TYPE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.IMPLEMENTATION_COLOR_READ_FORMAT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.COMPILE_STATUS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LOW_FLOAT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MEDIUM_FLOAT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.HIGH_FLOAT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.LOW_INT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MEDIUM_INT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.HIGH_INT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RGBA4; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RGB5_A1; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RGB565; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_COMPONENT16; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_INDEX; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_INDEX8; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_STENCIL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER_WIDTH; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER_HEIGHT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER_INTERNAL_FORMAT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER_RED_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER_GREEN_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER_BLUE_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER_ALPHA_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER_DEPTH_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER_STENCIL_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.COLOR_ATTACHMENT0; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_ATTACHMENT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.STENCIL_ATTACHMENT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.DEPTH_STENCIL_ATTACHMENT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.NONE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER_COMPLETE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER_INCOMPLETE_ATTACHMENT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER_INCOMPLETE_DIMENSIONS; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER_UNSUPPORTED; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.FRAMEBUFFER_BINDING; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.RENDERBUFFER_BINDING; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.MAX_RENDERBUFFER_SIZE; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.INVALID_FRAMEBUFFER_OPERATION; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.UNPACK_FLIP_Y_WEBGL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.UNPACK_PREMULTIPLY_ALPHA_WEBGL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.CONTEXT_LOST_WEBGL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.UNPACK_COLORSPACE_CONVERSION_WEBGL; + +/** @type {number} */ +WebGLRenderingContextBase.prototype.BROWSER_DEFAULT_WEBGL; + + +/** + * @type {!HTMLCanvasElement} + */ +WebGLRenderingContextBase.prototype.canvas; + +/** + * @type {number} + */ +WebGLRenderingContextBase.prototype.drawingBufferWidth; + +/** + * @type {number} + */ +WebGLRenderingContextBase.prototype.drawingBufferHeight; + +/** + * @return {!WebGLContextAttributes} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getContextAttributes = function() {}; + +/** + * @return {boolean} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.isContextLost = function() {}; + +/** + * @return {!Array.<string>} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getSupportedExtensions = function() {}; + +/** + * Note that this has side effects by enabling the extension even if the + * result is not used. + * @param {string} name + * @return {Object} + */ +WebGLRenderingContextBase.prototype.getExtension = function(name) {}; + +/** + * @param {number} texture + */ +WebGLRenderingContextBase.prototype.activeTexture = function(texture) {}; + +/** + * @param {WebGLProgram} program + * @param {WebGLShader} shader + */ +WebGLRenderingContextBase.prototype.attachShader = function(program, shader) {}; + +/** + * @param {WebGLProgram} program + * @param {number} index + * @param {string} name + */ +WebGLRenderingContextBase.prototype.bindAttribLocation = function( + program, index, name) {}; + +/** + * @param {number} target + * @param {WebGLBuffer} buffer + */ +WebGLRenderingContextBase.prototype.bindBuffer = function(target, buffer) {}; + +/** + * @param {number} target + * @param {WebGLFramebuffer} buffer + */ +WebGLRenderingContextBase.prototype.bindFramebuffer = function(target, buffer) {}; + +/** + * @param {number} target + * @param {WebGLRenderbuffer} buffer + */ +WebGLRenderingContextBase.prototype.bindRenderbuffer = function(target, buffer) {}; + +/** + * @param {number} target + * @param {WebGLTexture} texture + */ +WebGLRenderingContextBase.prototype.bindTexture = function(target, texture) {}; + +/** + * @param {number} red + * @param {number} green + * @param {number} blue + * @param {number} alpha + */ +WebGLRenderingContextBase.prototype.blendColor = function( + red, blue, green, alpha) {}; + +/** + * @param {number} mode + */ +WebGLRenderingContextBase.prototype.blendEquation = function(mode) {}; + +/** + * @param {number} modeRGB + * @param {number} modeAlpha + */ +WebGLRenderingContextBase.prototype.blendEquationSeparate = function( + modeRGB, modeAlpha) {}; + +/** + * @param {number} sfactor + * @param {number} dfactor + */ +WebGLRenderingContextBase.prototype.blendFunc = function(sfactor, dfactor) {}; + +/** + * @param {number} srcRGB + * @param {number} dstRGB + * @param {number} srcAlpha + * @param {number} dstAlpha + */ +WebGLRenderingContextBase.prototype.blendFuncSeparate = function( + srcRGB, dstRGB, srcAlpha, dstAlpha) {}; + +/** + * @param {number} target + * @param {ArrayBufferView|ArrayBuffer|number} data + * @param {number} usage + */ +WebGLRenderingContextBase.prototype.bufferData = function(target, data, usage) {}; + +/** + * @param {number} target + * @param {number} offset + * @param {ArrayBufferView|ArrayBuffer} data + */ +WebGLRenderingContextBase.prototype.bufferSubData = function( + target, offset, data) {}; + +/** + * @param {number} target + * @return {number} + */ +WebGLRenderingContextBase.prototype.checkFramebufferStatus = function(target) {}; + +/** + * @param {number} mask + */ +WebGLRenderingContextBase.prototype.clear = function(mask) {}; + +/** + * @param {number} red + * @param {number} green + * @param {number} blue + * @param {number} alpha + */ +WebGLRenderingContextBase.prototype.clearColor = function( + red, green, blue, alpha) {}; + +/** + * @param {number} depth + */ +WebGLRenderingContextBase.prototype.clearDepth = function(depth) {}; + +/** + * @param {number} s + */ +WebGLRenderingContextBase.prototype.clearStencil = function(s) {}; + +/** + * @param {boolean} red + * @param {boolean} green + * @param {boolean} blue + * @param {boolean} alpha + */ +WebGLRenderingContextBase.prototype.colorMask = function( + red, green, blue, alpha) {}; + +/** + * @param {WebGLShader} shader + */ +WebGLRenderingContextBase.prototype.compileShader = function(shader) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} internalformat + * @param {number} width + * @param {number} height + * @param {number} border + * @param {ArrayBufferView} data + */ +WebGLRenderingContextBase.prototype.compressedTexImage2D = function( + target, level, internalformat, width, height, border, data) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} xoffset + * @param {number} yoffset + * @param {number} width + * @param {number} height + * @param {number} format + * @param {ArrayBufferView} data + */ +WebGLRenderingContextBase.prototype.compressedTexSubImage2D = function( + target, level, xoffset, yoffset, width, height, format, data) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} format + * @param {number} x + * @param {number} y + * @param {number} width + * @param {number} height + * @param {number} border + */ +WebGLRenderingContextBase.prototype.copyTexImage2D = function( + target, level, format, x, y, width, height, border) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} xoffset + * @param {number} yoffset + * @param {number} x + * @param {number} y + * @param {number} width + * @param {number} height + */ +WebGLRenderingContextBase.prototype.copyTexSubImage2D = function( + target, level, xoffset, yoffset, x, y, width, height) {}; + +/** + * @return {!WebGLBuffer} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.createBuffer = function() {}; + +/** + * @return {!WebGLFramebuffer} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.createFramebuffer = function() {}; + +/** + * @return {!WebGLProgram} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.createProgram = function() {}; + +/** + * @return {!WebGLRenderbuffer} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.createRenderbuffer = function() {}; + +/** + * @param {number} type + * @return {!WebGLShader} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.createShader = function(type) {}; + +/** + * @return {!WebGLTexture} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.createTexture = function() {}; + +/** + * @param {number} mode + */ +WebGLRenderingContextBase.prototype.cullFace = function(mode) {}; + +/** + * @param {WebGLBuffer} buffer + */ +WebGLRenderingContextBase.prototype.deleteBuffer = function(buffer) {}; + +/** + * @param {WebGLFramebuffer} buffer + */ +WebGLRenderingContextBase.prototype.deleteFramebuffer = function(buffer) {}; + +/** + * @param {WebGLProgram} program + */ +WebGLRenderingContextBase.prototype.deleteProgram = function(program) {}; + +/** + * @param {WebGLRenderbuffer} buffer + */ +WebGLRenderingContextBase.prototype.deleteRenderbuffer = function(buffer) {}; + +/** + * @param {WebGLShader} shader + */ +WebGLRenderingContextBase.prototype.deleteShader = function(shader) {}; + +/** + * @param {WebGLTexture} texture + */ +WebGLRenderingContextBase.prototype.deleteTexture = function(texture) {}; + +/** + * @param {number} func + */ +WebGLRenderingContextBase.prototype.depthFunc = function(func) {}; + +/** + * @param {boolean} flag + */ +WebGLRenderingContextBase.prototype.depthMask = function(flag) {}; + +/** + * @param {number} nearVal + * @param {number} farVal + */ +WebGLRenderingContextBase.prototype.depthRange = function(nearVal, farVal) {}; + +/** + * @param {WebGLProgram} program + * @param {WebGLShader} shader + */ +WebGLRenderingContextBase.prototype.detachShader = function(program, shader) {}; + +/** + * @param {number} flags + */ +WebGLRenderingContextBase.prototype.disable = function(flags) {}; + +/** + * @param {number} index + */ +WebGLRenderingContextBase.prototype.disableVertexAttribArray = function( + index) {}; + +/** + * @param {number} mode + * @param {number} first + * @param {number} count + */ +WebGLRenderingContextBase.prototype.drawArrays = function(mode, first, count) {}; + +/** + * @param {number} mode + * @param {number} count + * @param {number} type + * @param {number} offset + */ +WebGLRenderingContextBase.prototype.drawElements = function( + mode, count, type, offset) {}; + +/** + * @param {number} cap + */ +WebGLRenderingContextBase.prototype.enable = function(cap) {}; + +/** + * @param {number} index + */ +WebGLRenderingContextBase.prototype.enableVertexAttribArray = function( + index) {}; + +WebGLRenderingContextBase.prototype.finish = function() {}; + +WebGLRenderingContextBase.prototype.flush = function() {}; + +/** + * @param {number} target + * @param {number} attachment + * @param {number} renderbuffertarget + * @param {WebGLRenderbuffer} renderbuffer + */ +WebGLRenderingContextBase.prototype.framebufferRenderbuffer = function( + target, attachment, renderbuffertarget, renderbuffer) {}; + +/** + * @param {number} target + * @param {number} attachment + * @param {number} textarget + * @param {WebGLTexture} texture + * @param {number} level + */ +WebGLRenderingContextBase.prototype.framebufferTexture2D = function( + target, attachment, textarget, texture, level) {}; + +/** + * @param {number} mode + */ +WebGLRenderingContextBase.prototype.frontFace = function(mode) {}; + +/** + * @param {number} target + */ +WebGLRenderingContextBase.prototype.generateMipmap = function(target) {}; + +/** + * @param {WebGLProgram} program + * @param {number} index + * @return {WebGLActiveInfo} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getActiveAttrib = function(program, index) {}; + +/** + * @param {WebGLProgram} program + * @param {number} index + * @return {WebGLActiveInfo} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getActiveUniform = function(program, index) {}; + +/** + * @param {WebGLProgram} program + * @return {!Array.<WebGLShader>} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getAttachedShaders = function(program) {}; + +/** + * @param {WebGLProgram} program + * @param {string} name + * @return {number} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getAttribLocation = function(program, name) {}; + +/** + * @param {number} target + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getBufferParameter = function(target, pname) {}; + +/** + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getParameter = function(pname) {}; + +/** + * @return {number} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getError = function() {}; + +/** + * @param {number} target + * @param {number} attachment + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getFramebufferAttachmentParameter = function( + target, attachment, pname) {}; + +/** + * @param {WebGLProgram} program + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getProgramParameter = function( + program, pname) {}; + +/** + * @param {WebGLProgram} program + * @return {string} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getProgramInfoLog = function(program) {}; + +/** + * @param {number} target + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getRenderbufferParameter = function( + target, pname) {}; + +/** + * @param {WebGLShader} shader + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getShaderParameter = function(shader, pname) {}; + +/** + * @param {number} shadertype + * @param {number} precisiontype + * @return {WebGLShaderPrecisionFormat} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getShaderPrecisionFormat = function(shadertype, + precisiontype) {}; + +/** + * @param {WebGLShader} shader + * @return {string} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getShaderInfoLog = function(shader) {}; + +/** + * @param {WebGLShader} shader + * @return {string} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getShaderSource = function(shader) {}; + +/** + * @param {number} target + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getTexParameter = function(target, pname) {}; + +/** + * @param {WebGLProgram} program + * @param {WebGLUniformLocation} location + * @return {*} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getUniform = function(program, location) {}; + +/** + * @param {WebGLProgram} program + * @param {string} name + * @return {WebGLUniformLocation} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getUniformLocation = function(program, name) {}; + +/** + * @param {number} index + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getVertexAttrib = function(index, pname) {}; + +/** + * @param {number} index + * @param {number} pname + * @return {number} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.getVertexAttribOffset = function( + index, pname) {}; + +/** + * @param {number} target + * @param {number} mode + */ +WebGLRenderingContextBase.prototype.hint = function(target, mode) {}; + +/** + * @param {WebGLObject} buffer + * @return {boolean} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.isBuffer = function(buffer) {}; + +/** + * @param {number} cap + * @return {boolean} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.isEnabled = function(cap) {}; + +/** + * @param {WebGLObject} framebuffer + * @return {boolean} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.isFramebuffer = function(framebuffer) {}; + +/** + * @param {WebGLObject} program + * @return {boolean} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.isProgram = function(program) {}; + +/** + * @param {WebGLObject} renderbuffer + * @return {boolean} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.isRenderbuffer = function(renderbuffer) {}; + +/** + * @param {WebGLObject} shader + * @return {boolean} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.isShader = function(shader) {}; + +/** + * @param {WebGLObject} texture + * @return {boolean} + * @nosideeffects + */ +WebGLRenderingContextBase.prototype.isTexture = function(texture) {}; + +/** + * @param {number} width + */ +WebGLRenderingContextBase.prototype.lineWidth = function(width) {}; + +/** + * @param {WebGLProgram} program + */ +WebGLRenderingContextBase.prototype.linkProgram = function(program) {}; + +/** + * @param {number} pname + * @param {number} param + */ +WebGLRenderingContextBase.prototype.pixelStorei = function(pname, param) {}; + +/** + * @param {number} factor + * @param {number} units + */ +WebGLRenderingContextBase.prototype.polygonOffset = function(factor, units) {}; + +/** + * @param {number} x + * @param {number} y + * @param {number} width + * @param {number} height + * @param {number} format + * @param {number} type + * @param {ArrayBufferView} pixels + */ +WebGLRenderingContextBase.prototype.readPixels = function( + x, y, width, height, format, type, pixels) {}; + +/** + * @param {number} target + * @param {number} internalformat + * @param {number} width + * @param {number} height + */ +WebGLRenderingContextBase.prototype.renderbufferStorage = function( + target, internalformat, width, height) {}; + +/** + * @param {number} coverage + * @param {boolean} invert + */ +WebGLRenderingContextBase.prototype.sampleCoverage = function(coverage, invert) {}; + +/** + * @param {number} x + * @param {number} y + * @param {number} width + * @param {number} height + */ +WebGLRenderingContextBase.prototype.scissor = function(x, y, width, height) {}; + +/** + * @param {WebGLShader} shader + * @param {string} source + */ +WebGLRenderingContextBase.prototype.shaderSource = function(shader, source) {}; + +/** + * @param {number} func + * @param {number} ref + * @param {number} mask + */ +WebGLRenderingContextBase.prototype.stencilFunc = function(func, ref, mask) {}; + +/** + * @param {number} face + * @param {number} func + * @param {number} ref + * @param {number} mask + */ +WebGLRenderingContextBase.prototype.stencilFuncSeparate = function( + face, func, ref, mask) {}; + +/** + * @param {number} mask + */ +WebGLRenderingContextBase.prototype.stencilMask = function(mask) {}; + +/** + * @param {number} face + * @param {number} mask + */ +WebGLRenderingContextBase.prototype.stencilMaskSeparate = function(face, mask) {}; + +/** + * @param {number} fail + * @param {number} zfail + * @param {number} zpass + */ +WebGLRenderingContextBase.prototype.stencilOp = function(fail, zfail, zpass) {}; + +/** + * @param {number} face + * @param {number} fail + * @param {number} zfail + * @param {number} zpass + */ +WebGLRenderingContextBase.prototype.stencilOpSeparate = function( + face, fail, zfail, zpass) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} internalformat + * @param {number} format or width + * @param {number} type or height + * @param {ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement| + * number} img or border + * @param {number=} opt_format + * @param {number=} opt_type + * @param {ArrayBufferView=} opt_pixels + */ +WebGLRenderingContextBase.prototype.texImage2D = function( + target, level, internalformat, format, type, img, opt_format, opt_type, + opt_pixels) {}; + +/** + * @param {number} target + * @param {number} pname + * @param {number} param + */ +WebGLRenderingContextBase.prototype.texParameterf = function( + target, pname, param) {}; + +/** + * @param {number} target + * @param {number} pname + * @param {number} param + */ +WebGLRenderingContextBase.prototype.texParameteri = function( + target, pname, param) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} xoffset + * @param {number} yoffset + * @param {number} format or width + * @param {number} type or height + * @param {ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement| + * number} data or format + * @param {number=} opt_type + * @param {ArrayBufferView=} opt_pixels + */ +WebGLRenderingContextBase.prototype.texSubImage2D = function( + target, level, xoffset, yoffset, format, type, data, opt_type, + opt_pixels) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} value + */ +WebGLRenderingContextBase.prototype.uniform1f = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Float32Array|Array.<number>} value + */ +WebGLRenderingContextBase.prototype.uniform1fv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} value + */ +WebGLRenderingContextBase.prototype.uniform1i = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Int32Array|Array.<number>} value + */ +WebGLRenderingContextBase.prototype.uniform1iv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} value1 + * @param {number} value2 + */ +WebGLRenderingContextBase.prototype.uniform2f = function( + location, value1, value2) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Float32Array|Array.<number>} value + */ +WebGLRenderingContextBase.prototype.uniform2fv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} value1 + * @param {number} value2 + */ +WebGLRenderingContextBase.prototype.uniform2i = function( + location, value1, value2) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Int32Array|Array.<number>} value + */ +WebGLRenderingContextBase.prototype.uniform2iv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} value1 + * @param {number} value2 + * @param {number} value3 + */ +WebGLRenderingContextBase.prototype.uniform3f = function( + location, value1, value2, value3) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Float32Array|Array.<number>} value + */ +WebGLRenderingContextBase.prototype.uniform3fv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} value1 + * @param {number} value2 + * @param {number} value3 + */ +WebGLRenderingContextBase.prototype.uniform3i = function( + location, value1, value2, value3) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Int32Array|Array.<number>} value + */ +WebGLRenderingContextBase.prototype.uniform3iv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} value1 + * @param {number} value2 + * @param {number} value3 + * @param {number} value4 + */ +WebGLRenderingContextBase.prototype.uniform4f = function( + location, value1, value2, value3, value4) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Float32Array|Array.<number>} value + */ +WebGLRenderingContextBase.prototype.uniform4fv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} value1 + * @param {number} value2 + * @param {number} value3 + * @param {number} value4 + */ +WebGLRenderingContextBase.prototype.uniform4i = function( + location, value1, value2, value3, value4) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Int32Array|Array.<number>} value + */ +WebGLRenderingContextBase.prototype.uniform4iv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {boolean} transpose + * @param {Float32Array|Array.<number>} data + */ +WebGLRenderingContextBase.prototype.uniformMatrix2fv = function( + location, transpose, data) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {boolean} transpose + * @param {Float32Array|Array.<number>} data + */ +WebGLRenderingContextBase.prototype.uniformMatrix3fv = function( + location, transpose, data) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {boolean} transpose + * @param {Float32Array|Array.<number>} data + */ +WebGLRenderingContextBase.prototype.uniformMatrix4fv = function( + location, transpose, data) {}; + +/** + * @param {WebGLProgram} program + */ +WebGLRenderingContextBase.prototype.useProgram = function(program) {}; + +/** + * @param {WebGLProgram} program + */ +WebGLRenderingContextBase.prototype.validateProgram = function(program) {}; + +/** + * @param {number} indx + * @param {number} x + */ +WebGLRenderingContextBase.prototype.vertexAttrib1f = function(indx, x) {}; + +/** + * @param {number} indx + * @param {Float32Array|Array.<number>} values + */ +WebGLRenderingContextBase.prototype.vertexAttrib1fv = function(indx, values) {}; + +/** + * @param {number} indx + * @param {number} x + * @param {number} y + */ +WebGLRenderingContextBase.prototype.vertexAttrib2f = function( + indx, x, y) {}; + +/** + * @param {number} indx + * @param {Float32Array|Array.<number>} values + */ +WebGLRenderingContextBase.prototype.vertexAttrib2fv = function( + indx, values) {}; + +/** + * @param {number} indx + * @param {number} x + * @param {number} y + * @param {number} z + */ +WebGLRenderingContextBase.prototype.vertexAttrib3f = function( + indx, x, y, z) {}; + +/** + * @param {number} indx + * @param {Float32Array|Array.<number>} values + */ +WebGLRenderingContextBase.prototype.vertexAttrib3fv = function(indx, values) {}; + +/** + * @param {number} indx + * @param {number} x + * @param {number} y + * @param {number} z + * @param {number} w + */ +WebGLRenderingContextBase.prototype.vertexAttrib4f = function( + indx, x, y, z, w) {}; + +/** + * @param {number} indx + * @param {Float32Array|Array.<number>} values + */ +WebGLRenderingContextBase.prototype.vertexAttrib4fv = function(indx, values) {}; + +/** + * @param {number} indx + * @param {number} size + * @param {number} type + * @param {boolean} normalized + * @param {number} stride + * @param {number} offset + */ +WebGLRenderingContextBase.prototype.vertexAttribPointer = function( + indx, size, type, normalized, stride, offset) {}; + +/** + * @param {number} x + * @param {number} y + * @param {number} width + * @param {number} height + */ +WebGLRenderingContextBase.prototype.viewport = function(x, y, width, height) {}; + + +/** + * @constructor + * @noalias + */ +function WebGLContextAttributes() {} + +/** + * @type {boolean} + */ +WebGLContextAttributes.prototype.alpha; + +/** + * @type {boolean} + */ +WebGLContextAttributes.prototype.depth; + +/** + * @type {boolean} + */ +WebGLContextAttributes.prototype.stencil; + +/** + * @type {boolean} + */ +WebGLContextAttributes.prototype.antialias; + +/** + * @type {boolean} + */ +WebGLContextAttributes.prototype.premultipliedAlpha; + +/** + * @type {boolean} + */ +WebGLContextAttributes.prototype.preserveDrawingBuffer; + + +/** + * @param {string} eventType + * @constructor + * @noalias + * @extends {Event} + */ +function WebGLContextEvent(eventType) {} + +/** + * @type {string} + */ +WebGLContextEvent.prototype.statusMessage; + + +/** + * @constructor + * @noalias + */ +function WebGLShaderPrecisionFormat() {} + +/** + * @type {number} + */ +WebGLShaderPrecisionFormat.prototype.rangeMin; + +/** + * @type {number} + */ +WebGLShaderPrecisionFormat.prototype.rangeMax; + +/** + * @type {number} + */ +WebGLShaderPrecisionFormat.prototype.precision; + + +/** + * @constructor + * @noalias + */ +function WebGLObject() {} + + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLBuffer() {} + + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLFramebuffer() {} + + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLProgram() {} + + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLRenderbuffer() {} + + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLShader() {} + + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLTexture() {} + + +/** + * @constructor + * @noalias + */ +function WebGLActiveInfo() {} + +/** @type {number} */ +WebGLActiveInfo.prototype.size; + +/** @type {number} */ +WebGLActiveInfo.prototype.type; + +/** @type {string} */ +WebGLActiveInfo.prototype.name; + + +/** + * @constructor + * @noalias + */ +function WebGLUniformLocation() {} + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/OES_texture_float/ + * @constructor + * @noalias + */ +function OES_texture_float() {} + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/OES_texture_half_float/ + * @constructor + * @noalias + */ +function OES_texture_half_float() {} + +/** @type {number} */ +OES_texture_half_float.prototype.HALF_FLOAT_OES; + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/WEBGL_lose_context/ + * @constructor + * @noalias + */ +function WEBGL_lose_context() {} + +WEBGL_lose_context.prototype.loseContext = function() {}; + +WEBGL_lose_context.prototype.restoreContext = function() {}; + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/OES_standard_derivatives/ + * @constructor + * @noalias + */ +function OES_standard_derivatives() {} + +/** @type {number} */ +OES_standard_derivatives.prototype.FRAGMENT_SHADER_DERIVATIVE_HINT_OES; + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/ + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLVertexArrayObjectOES() {} + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/ + * @constructor + * @noalias + */ +function OES_vertex_array_object() {} + +/** @type {number} */ +OES_vertex_array_object.prototype.VERTEX_ARRAY_BINDING_OES; + +/** + * @return {WebGLVertexArrayObjectOES} + * @nosideeffects + */ +OES_vertex_array_object.prototype.createVertexArrayOES = function() {}; + +/** + * @param {WebGLVertexArrayObjectOES} arrayObject + */ +OES_vertex_array_object.prototype.deleteVertexArrayOES = + function(arrayObject) {}; + +/** + * @param {WebGLVertexArrayObjectOES} arrayObject + * @return {boolean} + * @nosideeffects + */ +OES_vertex_array_object.prototype.isVertexArrayOES = function(arrayObject) {}; + +/** + * @param {WebGLVertexArrayObjectOES} arrayObject + */ +OES_vertex_array_object.prototype.bindVertexArrayOES = function(arrayObject) {}; + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/ + * @constructor + * @noalias + */ +function WEBGL_debug_renderer_info() {} + +/** @type {number} */ +WEBGL_debug_renderer_info.prototype.UNMASKED_VENDOR_WEBGL; + +/** @type {number} */ +WEBGL_debug_renderer_info.prototype.UNMASKED_RENDERER_WEBGL; + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/WEBGL_debug_shaders/ + * @constructor + * @noalias + */ +function WEBGL_debug_shaders() {} + +/** + * @param {WebGLShader} shader + * @return {string} + * @nosideeffects + */ +WEBGL_debug_shaders.prototype.getTranslatedShaderSource = function(shader) {}; + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_s3tc/ + * @constructor + * @noalias + */ +function WEBGL_compressed_texture_s3tc() {} + +/** @type {number} */ +WEBGL_compressed_texture_s3tc.prototype.COMPRESSED_RGB_S3TC_DXT1_EXT; + +/** @type {number} */ +WEBGL_compressed_texture_s3tc.prototype.COMPRESSED_RGBA_S3TC_DXT1_EXT; + +/** @type {number} */ +WEBGL_compressed_texture_s3tc.prototype.COMPRESSED_RGBA_S3TC_DXT3_EXT; + +/** @type {number} */ +WEBGL_compressed_texture_s3tc.prototype.COMPRESSED_RGBA_S3TC_DXT5_EXT; + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/OES_depth_texture/ + * @constructor + * @noalias + */ +function OES_depth_texture() {} + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/OES_element_index_uint/ + * @constructor + * @noalias + */ +function OES_element_index_uint() {} + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/EXT_texture_filter_anisotropic/ + * @constructor + * @noalias + */ +function EXT_texture_filter_anisotropic() {} + +/** @type {number} */ +EXT_texture_filter_anisotropic.prototype.TEXTURE_MAX_ANISOTROPY_EXT; + +/** @type {number} */ +EXT_texture_filter_anisotropic.prototype.MAX_TEXTURE_MAX_ANISOTROPY_EXT; + + + +/** + * @see http://www.khronos.org/registry/webgl/extensions/ANGLE_instanced_arrays/ + * @constructor + * @noalias + */ +function ANGLE_instanced_arrays() {} + + +/** @type {number} */ +ANGLE_instanced_arrays.prototype.VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE; + + +/** + * @param {number} mode Primitive type. + * @param {number} first First vertex. + * @param {number} count Number of vertices per instance. + * @param {number} primcount Number of instances. + */ +ANGLE_instanced_arrays.prototype.drawArraysInstancedANGLE = function( + mode, first, count, primcount) {}; + + +/** + * @param {number} mode Primitive type. + * @param {number} count Number of vertex indices per instance. + * @param {number} type Type of a vertex index. + * @param {number} offset Offset to the first vertex index. + * @param {number} primcount Number of instances. + */ +ANGLE_instanced_arrays.prototype.drawElementsInstancedANGLE = function( + mode, count, type, offset, primcount) {}; + + +/** + * @param {number} index Attribute index. + * @param {number} divisor Instance divisor. + */ +ANGLE_instanced_arrays.prototype.vertexAttribDivisorANGLE = function( + index, divisor) {}; + + +/** + * @constructor + * @noalias + * @extends {WebGLRenderingContextBase} + */ +function WebGLRenderingContext() {} + + +/** + * @constructor + * @private + * @noalias + * @extends {WebGLRenderingContextBase} + */ +function WebGL2RenderingContextBase() {} + + +/** @type {number} */ +WebGL2RenderingContextBase.READ_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.UNPACK_ROW_LENGTH; + +/** @type {number} */ +WebGL2RenderingContextBase.UNPACK_SKIP_ROWS; + +/** @type {number} */ +WebGL2RenderingContextBase.UNPACK_SKIP_PIXELS; + +/** @type {number} */ +WebGL2RenderingContextBase.PACK_ROW_LENGTH; + +/** @type {number} */ +WebGL2RenderingContextBase.PACK_SKIP_ROWS; + +/** @type {number} */ +WebGL2RenderingContextBase.PACK_SKIP_PIXELS; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR; + +/** @type {number} */ +WebGL2RenderingContextBase.DEPTH; + +/** @type {number} */ +WebGL2RenderingContextBase.STENCIL; + +/** @type {number} */ +WebGL2RenderingContextBase.RED; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB8; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA8; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB10_A2; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_BINDING_3D; + +/** @type {number} */ +WebGL2RenderingContextBase.UNPACK_SKIP_IMAGES; + +/** @type {number} */ +WebGL2RenderingContextBase.UNPACK_IMAGE_HEIGHT; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_3D; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_WRAP_R; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_3D_TEXTURE_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_2_10_10_10_REV; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_ELEMENTS_VERTICES; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_ELEMENTS_INDICES; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_MIN_LOD; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_MAX_LOD; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_BASE_LEVEL; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_MAX_LEVEL; + +/** @type {number} */ +WebGL2RenderingContextBase.MIN; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX; + +/** @type {number} */ +WebGL2RenderingContextBase.DEPTH_COMPONENT24; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_TEXTURE_LOD_BIAS; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_COMPARE_MODE; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_COMPARE_FUNC; + +/** @type {number} */ +WebGL2RenderingContextBase.CURRENT_QUERY; + +/** @type {number} */ +WebGL2RenderingContextBase.QUERY_RESULT; + +/** @type {number} */ +WebGL2RenderingContextBase.QUERY_RESULT_AVAILABLE; + +/** @type {number} */ +WebGL2RenderingContextBase.STREAM_READ; + +/** @type {number} */ +WebGL2RenderingContextBase.STREAM_COPY; + +/** @type {number} */ +WebGL2RenderingContextBase.STATIC_READ; + +/** @type {number} */ +WebGL2RenderingContextBase.STATIC_COPY; + +/** @type {number} */ +WebGL2RenderingContextBase.DYNAMIC_READ; + +/** @type {number} */ +WebGL2RenderingContextBase.DYNAMIC_COPY; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_DRAW_BUFFERS; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER0; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER1; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER2; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER3; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER4; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER5; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER6; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER7; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER8; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER9; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER10; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER11; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER12; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER13; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER14; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_BUFFER15; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_FRAGMENT_UNIFORM_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_VERTEX_UNIFORM_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.SAMPLER_3D; + +/** @type {number} */ +WebGL2RenderingContextBase.SAMPLER_2D_SHADOW; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAGMENT_SHADER_DERIVATIVE_HINT; + +/** @type {number} */ +WebGL2RenderingContextBase.PIXEL_PACK_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.PIXEL_UNPACK_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.PIXEL_PACK_BUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.PIXEL_UNPACK_BUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.FLOAT_MAT2x3; + +/** @type {number} */ +WebGL2RenderingContextBase.FLOAT_MAT2x4; + +/** @type {number} */ +WebGL2RenderingContextBase.FLOAT_MAT3x2; + +/** @type {number} */ +WebGL2RenderingContextBase.FLOAT_MAT3x4; + +/** @type {number} */ +WebGL2RenderingContextBase.FLOAT_MAT4x2; + +/** @type {number} */ +WebGL2RenderingContextBase.FLOAT_MAT4x3; + +/** @type {number} */ +WebGL2RenderingContextBase.SRGB; + +/** @type {number} */ +WebGL2RenderingContextBase.SRGB8; + +/** @type {number} */ +WebGL2RenderingContextBase.SRGB8_ALPHA8; + +/** @type {number} */ +WebGL2RenderingContextBase.COMPARE_REF_TO_TEXTURE; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA32F; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB32F; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA16F; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB16F; + +/** @type {number} */ +WebGL2RenderingContextBase.VERTEX_ATTRIB_ARRAY_INTEGER; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_ARRAY_TEXTURE_LAYERS; + +/** @type {number} */ +WebGL2RenderingContextBase.MIN_PROGRAM_TEXEL_OFFSET; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_PROGRAM_TEXEL_OFFSET; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_VARYING_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_2D_ARRAY; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_BINDING_2D_ARRAY; + +/** @type {number} */ +WebGL2RenderingContextBase.R11F_G11F_B10F; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_10F_11F_11F_REV; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB9_E5; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_5_9_9_9_REV; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER_MODE; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_VARYINGS; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER_START; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN; + +/** @type {number} */ +WebGL2RenderingContextBase.RASTERIZER_DISCARD; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS; + +/** @type {number} */ +WebGL2RenderingContextBase.INTERLEAVED_ATTRIBS; + +/** @type {number} */ +WebGL2RenderingContextBase.SEPARATE_ATTRIBS; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA32UI; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB32UI; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA16UI; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB16UI; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA8UI; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB8UI; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA32I; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB32I; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA16I; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB16I; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA8I; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB8I; + +/** @type {number} */ +WebGL2RenderingContextBase.RED_INTEGER; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB_INTEGER; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA_INTEGER; + +/** @type {number} */ +WebGL2RenderingContextBase.SAMPLER_2D_ARRAY; + +/** @type {number} */ +WebGL2RenderingContextBase.SAMPLER_2D_ARRAY_SHADOW; + +/** @type {number} */ +WebGL2RenderingContextBase.SAMPLER_CUBE_SHADOW; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_VEC2; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_VEC3; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_VEC4; + +/** @type {number} */ +WebGL2RenderingContextBase.INT_SAMPLER_2D; + +/** @type {number} */ +WebGL2RenderingContextBase.INT_SAMPLER_3D; + +/** @type {number} */ +WebGL2RenderingContextBase.INT_SAMPLER_CUBE; + +/** @type {number} */ +WebGL2RenderingContextBase.INT_SAMPLER_2D_ARRAY; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_SAMPLER_2D; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_SAMPLER_3D; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_SAMPLER_CUBE; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_SAMPLER_2D_ARRAY; + +/** @type {number} */ +WebGL2RenderingContextBase.DEPTH_COMPONENT32F; + +/** @type {number} */ +WebGL2RenderingContextBase.DEPTH32F_STENCIL8; + +/** @type {number} */ +WebGL2RenderingContextBase.FLOAT_32_UNSIGNED_INT_24_8_REV; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_RED_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_DEFAULT; + +/** @type {number} */ +WebGL2RenderingContextBase.DEPTH_STENCIL_ATTACHMENT; + +/** @type {number} */ +WebGL2RenderingContextBase.DEPTH_STENCIL; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_INT_24_8; + +/** @type {number} */ +WebGL2RenderingContextBase.DEPTH24_STENCIL8; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNED_NORMALIZED; + +// Same as FRAMEBUFFER_BINDING +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_FRAMEBUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.READ_FRAMEBUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.DRAW_FRAMEBUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.READ_FRAMEBUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.RENDERBUFFER_SAMPLES; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_COLOR_ATTACHMENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT1; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT2; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT3; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT4; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT5; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT6; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT7; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT8; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT9; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT10; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT11; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT12; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT13; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT14; + +/** @type {number} */ +WebGL2RenderingContextBase.COLOR_ATTACHMENT15; + +/** @type {number} */ +WebGL2RenderingContextBase.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_SAMPLES; + +/** @type {number} */ +WebGL2RenderingContextBase.HALF_FLOAT; + +/** @type {number} */ +WebGL2RenderingContextBase.RG; + +/** @type {number} */ +WebGL2RenderingContextBase.RG_INTEGER; + +/** @type {number} */ +WebGL2RenderingContextBase.R8; + +/** @type {number} */ +WebGL2RenderingContextBase.RG8; + +/** @type {number} */ +WebGL2RenderingContextBase.R16F; + +/** @type {number} */ +WebGL2RenderingContextBase.R32F; + +/** @type {number} */ +WebGL2RenderingContextBase.RG16F; + +/** @type {number} */ +WebGL2RenderingContextBase.RG32F; + +/** @type {number} */ +WebGL2RenderingContextBase.R8I; + +/** @type {number} */ +WebGL2RenderingContextBase.R8UI; + +/** @type {number} */ +WebGL2RenderingContextBase.R16I; + +/** @type {number} */ +WebGL2RenderingContextBase.R16UI; + +/** @type {number} */ +WebGL2RenderingContextBase.R32I; + +/** @type {number} */ +WebGL2RenderingContextBase.R32UI; + +/** @type {number} */ +WebGL2RenderingContextBase.RG8I; + +/** @type {number} */ +WebGL2RenderingContextBase.RG8UI; + +/** @type {number} */ +WebGL2RenderingContextBase.RG16I; + +/** @type {number} */ +WebGL2RenderingContextBase.RG16UI; + +/** @type {number} */ +WebGL2RenderingContextBase.RG32I; + +/** @type {number} */ +WebGL2RenderingContextBase.RG32UI; + +/** @type {number} */ +WebGL2RenderingContextBase.VERTEX_ARRAY_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.R8_SNORM; + +/** @type {number} */ +WebGL2RenderingContextBase.RG8_SNORM; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB8_SNORM; + +/** @type {number} */ +WebGL2RenderingContextBase.RGBA8_SNORM; + +/** @type {number} */ +WebGL2RenderingContextBase.SIGNED_NORMALIZED; + +/** @type {number} */ +WebGL2RenderingContextBase.COPY_READ_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.COPY_WRITE_BUFFER; + +// Same as COPY_READ_BUFFER +/** @type {number} */ +WebGL2RenderingContextBase.COPY_READ_BUFFER_BINDING; + +// Same as COPY_WRITE_BUFFER +/** @type {number} */ +WebGL2RenderingContextBase.COPY_WRITE_BUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BUFFER_START; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BUFFER_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_VERTEX_UNIFORM_BLOCKS; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_FRAGMENT_UNIFORM_BLOCKS; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_COMBINED_UNIFORM_BLOCKS; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_UNIFORM_BUFFER_BINDINGS; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_UNIFORM_BLOCK_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BUFFER_OFFSET_ALIGNMENT; + +/** @type {number} */ +WebGL2RenderingContextBase.ACTIVE_UNIFORM_BLOCKS; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_TYPE; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BLOCK_INDEX; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_OFFSET; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_ARRAY_STRIDE; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_MATRIX_STRIDE; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_IS_ROW_MAJOR; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BLOCK_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BLOCK_DATA_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BLOCK_ACTIVE_UNIFORMS; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER; + +/** @type {number} */ +WebGL2RenderingContextBase.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER; + +/** @type {number} */ +WebGL2RenderingContextBase.INVALID_INDEX; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_VERTEX_OUTPUT_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_FRAGMENT_INPUT_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_SERVER_WAIT_TIMEOUT; + +/** @type {number} */ +WebGL2RenderingContextBase.OBJECT_TYPE; + +/** @type {number} */ +WebGL2RenderingContextBase.SYNC_CONDITION; + +/** @type {number} */ +WebGL2RenderingContextBase.SYNC_STATUS; + +/** @type {number} */ +WebGL2RenderingContextBase.SYNC_FLAGS; + +/** @type {number} */ +WebGL2RenderingContextBase.SYNC_FENCE; + +/** @type {number} */ +WebGL2RenderingContextBase.SYNC_GPU_COMMANDS_COMPLETE; + +/** @type {number} */ +WebGL2RenderingContextBase.UNSIGNALED; + +/** @type {number} */ +WebGL2RenderingContextBase.SIGNALED; + +/** @type {number} */ +WebGL2RenderingContextBase.ALREADY_SIGNALED; + +/** @type {number} */ +WebGL2RenderingContextBase.TIMEOUT_EXPIRED; + +/** @type {number} */ +WebGL2RenderingContextBase.CONDITION_SATISFIED; + +/** @type {number} */ +WebGL2RenderingContextBase.WAIT_FAILED; + +/** @type {number} */ +WebGL2RenderingContextBase.SYNC_FLUSH_COMMANDS_BIT; + +/** @type {number} */ +WebGL2RenderingContextBase.VERTEX_ATTRIB_ARRAY_DIVISOR; + +/** @type {number} */ +WebGL2RenderingContextBase.ANY_SAMPLES_PASSED; + +/** @type {number} */ +WebGL2RenderingContextBase.ANY_SAMPLES_PASSED_CONSERVATIVE; + +/** @type {number} */ +WebGL2RenderingContextBase.SAMPLER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.RGB10_A2UI; + +/** @type {number} */ +WebGL2RenderingContextBase.INT_2_10_10_10_REV; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_PAUSED; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_ACTIVE; + +/** @type {number} */ +WebGL2RenderingContextBase.TRANSFORM_FEEDBACK_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_IMMUTABLE_FORMAT; + +/** @type {number} */ +WebGL2RenderingContextBase.MAX_ELEMENT_INDEX; + +/** @type {number} */ +WebGL2RenderingContextBase.NUM_SAMPLE_COUNTS; + +/** @type {number} */ +WebGL2RenderingContextBase.TEXTURE_IMMUTABLE_LEVELS; + +/** @type {number} */ +WebGL2RenderingContextBase.TIMEOUT_IGNORED; + + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.READ_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNPACK_ROW_LENGTH; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNPACK_SKIP_ROWS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNPACK_SKIP_PIXELS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.PACK_ROW_LENGTH; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.PACK_SKIP_ROWS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.PACK_SKIP_PIXELS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DEPTH; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.STENCIL; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RED; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB10_A2; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_BINDING_3D; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNPACK_SKIP_IMAGES; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNPACK_IMAGE_HEIGHT; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_3D; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_WRAP_R; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_3D_TEXTURE_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_2_10_10_10_REV; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_ELEMENTS_VERTICES; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_ELEMENTS_INDICES; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_MIN_LOD; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_MAX_LOD; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_BASE_LEVEL; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_MAX_LEVEL; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MIN; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DEPTH_COMPONENT24; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_TEXTURE_LOD_BIAS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_COMPARE_MODE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_COMPARE_FUNC; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.CURRENT_QUERY; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.QUERY_RESULT; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.QUERY_RESULT_AVAILABLE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.STREAM_READ; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.STREAM_COPY; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.STATIC_READ; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.STATIC_COPY; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DYNAMIC_READ; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DYNAMIC_COPY; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_DRAW_BUFFERS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER0; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER1; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER2; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER3; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER4; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER5; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER6; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER7; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER9; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER10; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER11; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER12; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER13; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER14; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_BUFFER15; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_FRAGMENT_UNIFORM_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_VERTEX_UNIFORM_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SAMPLER_3D; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SAMPLER_2D_SHADOW; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAGMENT_SHADER_DERIVATIVE_HINT; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.PIXEL_PACK_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.PIXEL_UNPACK_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.PIXEL_PACK_BUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.PIXEL_UNPACK_BUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FLOAT_MAT2x3; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FLOAT_MAT2x4; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FLOAT_MAT3x2; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FLOAT_MAT3x4; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FLOAT_MAT4x2; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FLOAT_MAT4x3; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SRGB; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SRGB8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SRGB8_ALPHA8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COMPARE_REF_TO_TEXTURE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA32F; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB32F; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA16F; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB16F; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_INTEGER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_ARRAY_TEXTURE_LAYERS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MIN_PROGRAM_TEXEL_OFFSET; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_PROGRAM_TEXEL_OFFSET; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_VARYING_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_2D_ARRAY; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_BINDING_2D_ARRAY; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R11F_G11F_B10F; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_10F_11F_11F_REV; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB9_E5; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_5_9_9_9_REV; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BUFFER_MODE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_VARYINGS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BUFFER_START; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BUFFER_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RASTERIZER_DISCARD; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.INTERLEAVED_ATTRIBS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SEPARATE_ATTRIBS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA32UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB32UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA16UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB16UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA8UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB8UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA32I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB32I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA16I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB16I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA8I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB8I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RED_INTEGER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB_INTEGER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA_INTEGER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SAMPLER_2D_ARRAY; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SAMPLER_2D_ARRAY_SHADOW; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SAMPLER_CUBE_SHADOW; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_VEC2; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_VEC3; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_VEC4; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.INT_SAMPLER_2D; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.INT_SAMPLER_3D; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.INT_SAMPLER_CUBE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.INT_SAMPLER_2D_ARRAY; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_SAMPLER_2D; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_SAMPLER_3D; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_SAMPLER_CUBE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_SAMPLER_2D_ARRAY; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DEPTH_COMPONENT32F; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DEPTH32F_STENCIL8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FLOAT_32_UNSIGNED_INT_24_8_REV; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_RED_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_DEFAULT; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DEPTH_STENCIL_ATTACHMENT; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DEPTH_STENCIL; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_INT_24_8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DEPTH24_STENCIL8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNED_NORMALIZED; + +// Same as FRAMEBUFFER_BINDING +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_FRAMEBUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.READ_FRAMEBUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.DRAW_FRAMEBUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.READ_FRAMEBUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RENDERBUFFER_SAMPLES; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_COLOR_ATTACHMENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT1; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT2; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT3; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT4; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT5; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT6; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT7; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT9; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT10; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT11; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT12; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT13; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT14; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COLOR_ATTACHMENT15; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_SAMPLES; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.HALF_FLOAT; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG_INTEGER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG8; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R16F; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R32F; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG16F; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG32F; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R8I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R8UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R16I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R16UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R32I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R32UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG8I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG8UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG16I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG16UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG32I; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG32UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.VERTEX_ARRAY_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.R8_SNORM; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RG8_SNORM; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB8_SNORM; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGBA8_SNORM; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SIGNED_NORMALIZED; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COPY_READ_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COPY_WRITE_BUFFER; + +// Same as COPY_READ_BUFFER +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COPY_READ_BUFFER_BINDING; + +// Same as COPY_WRITE_BUFFER +/** @type {number} */ +WebGL2RenderingContextBase.prototype.COPY_WRITE_BUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BUFFER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BUFFER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BUFFER_START; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BUFFER_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_VERTEX_UNIFORM_BLOCKS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_FRAGMENT_UNIFORM_BLOCKS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_COMBINED_UNIFORM_BLOCKS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_UNIFORM_BUFFER_BINDINGS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_UNIFORM_BLOCK_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BUFFER_OFFSET_ALIGNMENT; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.ACTIVE_UNIFORM_BLOCKS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_TYPE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_INDEX; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_OFFSET; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_ARRAY_STRIDE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_MATRIX_STRIDE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_IS_ROW_MAJOR; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_DATA_SIZE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_ACTIVE_UNIFORMS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.INVALID_INDEX; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_VERTEX_OUTPUT_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_FRAGMENT_INPUT_COMPONENTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_SERVER_WAIT_TIMEOUT; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.OBJECT_TYPE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SYNC_CONDITION; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SYNC_STATUS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SYNC_FLAGS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SYNC_FENCE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SYNC_GPU_COMMANDS_COMPLETE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.UNSIGNALED; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SIGNALED; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.ALREADY_SIGNALED; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TIMEOUT_EXPIRED; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.CONDITION_SATISFIED; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.WAIT_FAILED; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SYNC_FLUSH_COMMANDS_BIT; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.VERTEX_ATTRIB_ARRAY_DIVISOR; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.ANY_SAMPLES_PASSED; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.ANY_SAMPLES_PASSED_CONSERVATIVE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.SAMPLER_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.RGB10_A2UI; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.INT_2_10_10_10_REV; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_PAUSED; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_ACTIVE; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TRANSFORM_FEEDBACK_BINDING; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_IMMUTABLE_FORMAT; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.MAX_ELEMENT_INDEX; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.NUM_SAMPLE_COUNTS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TEXTURE_IMMUTABLE_LEVELS; + +/** @type {number} */ +WebGL2RenderingContextBase.prototype.TIMEOUT_IGNORED; + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLQuery() {} + + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLSampler() {} + + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLSync() {} + + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLTransformFeedback() {} + + +/** + * @constructor + * @noalias + * @extends {WebGLObject} + */ +function WebGLVertexArrayObject() {} + + +/** + * @param {number} target + * @param {WebGLQuery} query + */ +WebGL2RenderingContextBase.prototype.beginQuery = function(target, query) {}; + +/** + * @param {number} primitiveMode + */ +WebGL2RenderingContextBase.prototype.beginTransformFeedback = function(primitiveMode) {}; + +/** + * @param {number} target + * @param {number} index + * @param {WebGLBuffer} buffer + */ +WebGL2RenderingContextBase.prototype.bindBufferBase = function(target, index, buffer) {}; + +/** + * @param {number} target + * @param {number} index + * @param {WebGLBuffer} buffer + * @param {number} offset + * @param {number} size + */ +WebGL2RenderingContextBase.prototype.bindBufferRange = function(target, index, buffer, offset, size) {}; + +/** + * @param {number} unit + * @param {WebGLSampler} sampler + */ +WebGL2RenderingContextBase.prototype.bindSampler = function(unit, sampler) {}; + +/** + * @param {number} target + * @param {WebGLTransformFeedback} id + */ +WebGL2RenderingContextBase.prototype.bindTransformFeedback = function(target, id) {}; + +/** + * @param {WebGLVertexArrayObject} array + */ +WebGL2RenderingContextBase.prototype.bindVertexArray = function(array) {}; + +/** + * @param {number} srcX0 + * @param {number} srcY0 + * @param {number} srcX1 + * @param {number} srcY1 + * @param {number} dstX0 + * @param {number} dstY0 + * @param {number} dstX1 + * @param {number} dstY1 + * @param {number} mask + * @param {number} filter + */ +WebGL2RenderingContextBase.prototype.blitFramebuffer = function( + srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, + dstX1, dstY1, mask, filter) {}; + +/** + * @param {number} buffer + * @param {number} drawbuffer + * @param {Int32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.clearBufferiv = function(buffer, drawbuffer, value) {}; + +/** + * @param {number} buffer + * @param {number} drawbuffer + * @param {Uint32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.clearBufferuiv = function(buffer, drawbuffer, value) {}; + +/** + * @param {number} buffer + * @param {number} drawbuffer + * @param {Float32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.clearBufferfv = function(buffer, drawbuffer, value) {}; + +/** + * @param {number} buffer + * @param {number} drawbuffer + * @param {number} depth + * @param {number} stencil + */ +WebGL2RenderingContextBase.prototype.clearBufferfi = function(buffer, drawbuffer, depth, stencil) {}; + +/** + * @param {WebGLSync} sync + * @param {number} flags + * @param {number} timeout + * @return {number} + */ +WebGL2RenderingContextBase.prototype.clientWaitSync = function(sync, flags, timeout) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} internalformat + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} border + * @param {ArrayBufferView} data + */ +WebGL2RenderingContextBase.prototype.compressedTexImage3D = function( + target, level, internalformat, width, height, depth, border, data) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} xoffset + * @param {number} yoffset + * @param {number} zoffset + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} format + * @param {ArrayBufferView} data + */ +WebGL2RenderingContextBase.prototype.compressedTexSubImage3D = function( + target, level, xoffset, yoffset, zoffset, width, height, depth, format, data) {}; + +/** + * @param {number} readTarget + * @param {number} writeTarget + * @param {number} readOffset + * @param {number} writeOffset + * @param {number} size + */ +WebGL2RenderingContextBase.prototype.copyBufferSubData = function( + readTarget, writeTarget, readOffset, writeOffset, size) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} xoffset + * @param {number} yoffset + * @param {number} zoffset + * @param {number} x + * @param {number} y + * @param {number} width + * @param {number} height + */ +WebGL2RenderingContextBase.prototype.copyTexSubImage3D = function( + target, level, xoffset, yoffset, zoffset, x, y, width, height) {}; + +/** + * @return {!WebGLQuery} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.createQuery = function() {}; + +/** + * @return {!WebGLSampler} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.createSampler = function() {}; + +/** + * @return {!WebGLTransformFeedback} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.createTransformFeedback = function() {}; + +/** + * @return {!WebGLVertexArrayObject} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.createVertexArray = function() {}; + + +/** + * @param {WebGLQuery} query + */ +WebGL2RenderingContextBase.prototype.deleteQuery = function(query) {}; + +/** + * @param {WebGLSampler} sampler + */ +WebGL2RenderingContextBase.prototype.deleteSampler = function(sampler) {}; + +/** + * @param {WebGLSync} sync + */ +WebGL2RenderingContextBase.prototype.deleteSync = function(sync) {}; + +/** + * @param {WebGLTransformFeedback} feedback + */ +WebGL2RenderingContextBase.prototype.deleteTransformFeedback = function(feedback) {}; + +/** + * @param {WebGLVertexArrayObject} vertexArray + */ +WebGL2RenderingContextBase.prototype.deleteVertexArray = function(vertexArray) {}; + +/** + * @param {number} mode + * @param {number} first + * @param {number} count + * @param {number} instanceCount + */ +WebGL2RenderingContextBase.prototype.drawArraysInstanced = function(mode, first, count, instanceCount) {}; + +/** + * @param {number} mode + * @param {number} count + * @param {number} type + * @param {number} offset + * @param {number} instanceCount + */ +WebGL2RenderingContextBase.prototype.drawElementsInstanced = function(mode, count, type, offset, instanceCount) {}; + +/** + * @param {number} mode + * @param {number} start + * @param {number} end + * @param {number} count + * @param {number} type + * @param {number} offset + */ +WebGL2RenderingContextBase.prototype.drawRangeElements = function(mode, start, end, count, type, offset) {}; + +/** + * @param {Array.<number>} buffers + */ +WebGL2RenderingContextBase.prototype.drawBuffers = function(buffers) {}; + +/** + * @param {number} target + */ +WebGL2RenderingContextBase.prototype.endQuery = function(target) {}; + +/** + */ +WebGL2RenderingContextBase.prototype.endTransformFeedback = function() {}; + +/** + * @param {number} condition + * @param {number} flags + * @return {WebGLSync} + */ +WebGL2RenderingContextBase.prototype.fenceSync = function(condition, flags) {}; + +/** + * @param {number} target + * @param {number} attachment + * @param {WebGLTexture} texture + * @param {number} level + * @param {number} layer + */ +WebGL2RenderingContextBase.prototype.framebufferTextureLayer = function( + target, attachment, texture, level, layer) {}; + +/** + * @param {WebGLProgram} program + * @param {number} uniformBlockIndex + * @return {string} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getActiveUniformBlockName = function(program, uniformBlockIndex) {}; + +/** + * @param {WebGLProgram} program + * @param {number} uniformBlockIndex + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getActiveUniformBlockParameter = function( + program, uniformBlockIndex, pname) {}; + +/** + * @param {WebGLProgram} program + * @param {Array.<number>} uniformIndices + * @param {number} pname + * @return {Array.<number>} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getActiveUniforms = function( + program, uniformIndices, pname) {}; + +/** + * @param {number} target + * @param {number} offset + * @param {ArrayBuffer} returnedData + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getBufferSubData = function( + target, offset, returnedData) {}; + +/** + * @param {WebGLProgram} program + * @param {string} name + * @return {number} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getFragDataLocation = function(program, name) {}; + +/** + * @param {number} target + * @param {number} index + * @return {*} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getIndexedParameter = function(target, index) {}; + +/** + * @param {number} target + * @param {number} internalformat + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getInternalformatParameter = function(target, internalformat, pname) {}; + +/** + * @param {number} target + * @param {number} pname + * @return {WebGLQuery} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getQuery = function(target, pname) {}; + +/** + * @param {WebGLQuery} query + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getQueryParameter = function(query, pname) {}; + +/** + * @param {WebGLSampler} sampler + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getSamplerParameter = function(sampler, pname) {}; + +/** + * @param {WebGLSync} sync + * @param {number} pname + * @return {*} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getSyncParameter = function(sync, pname) {}; + +/** + * @param {WebGLProgram} program + * @param {number} index + * @return {WebGLActiveInfo} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getTransformFeedbackVarying = function(program, index) {}; + +/** + * @param {WebGLProgram} program + * @param {string} uniformBlockName + * @return {number} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getUniformBlockIndex = function(program, uniformBlockName) {}; + +/** + * @param {WebGLProgram} program + * @param {Array.<string>} uniformNames + * @return {Array.<number>} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.getUniformIndices = function(program, uniformNames) {}; + +/** + * @param {number} target + * @param {Array.<number>} attachments + */ +WebGL2RenderingContextBase.prototype.invalidateFramebuffer = function(target, attachments) {}; + +/** + * @param {number} target + * @param {Array.<number>} attachments + * @param {number} x + * @param {number} y + * @param {number} width + * @param {number} height + */ +WebGL2RenderingContextBase.prototype.invalidateSubFramebuffer = function( + target, attachments, x, y, width, height) {}; + +/** + * @param {WebGLQuery} query + * @return {boolean} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.isQuery = function(query) {}; + +/** + * @param {WebGLSampler} sampler + * @return {boolean} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.isSampler = function(sampler) {}; + +/** + * @param {WebGLSync} sync + * @return {boolean} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.isSync = function(sync) {}; + +/** + * @param {WebGLTransformFeedback} feedback + * @return {boolean} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.isTransformFeedback = function(feedback) {}; + +/** + * @param {WebGLVertexArrayObject} vertexArray + * @return {boolean} + * @nosideeffects + */ +WebGL2RenderingContextBase.prototype.isVertexArray = function(vertexArray) {}; + +/** + */ +WebGL2RenderingContextBase.prototype.pauseTransformFeedback = function() {}; + +/** + * @param {number} src + */ +WebGL2RenderingContextBase.prototype.readBuffer = function(src) {}; + +/** + * @param {number} target + * @param {number} samples + * @param {number} internalformat + * @param {number} width + * @param {number} height + */ +WebGL2RenderingContextBase.prototype.renderbufferStorageMultisample = function( + target, samples, internalformat, width, height) {}; + +/** + */ +WebGL2RenderingContextBase.prototype.resumeTransformFeedback = function() {}; + +/** + * @param {WebGLSampler} sampler + * @param {number} pname + * @param {number} param + */ +WebGL2RenderingContextBase.prototype.samplerParameteri = function(sampler, pname, param) {}; + +/** + * @param {WebGLSampler} sampler + * @param {number} pname + * @param {number} param + */ +WebGL2RenderingContextBase.prototype.samplerParameterf = function(sampler, pname, param) {}; + +/** + * @param {number} target + * @param {number} levels + * @param {number} internalformat + * @param {number} width + * @param {number} height + */ +WebGL2RenderingContextBase.prototype.texStorage2D = function(target, levels, internalformat, width, height) {}; + +/** + * @param {number} target + * @param {number} levels + * @param {number} internalformat + * @param {number} width + * @param {number} height + * @param {number} depth + */ +WebGL2RenderingContextBase.prototype.texStorage3D = function(target, levels, internalformat, width, height, depth) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} internalformat + * @param {number} width + * @param {number} height + * @param {number} depth + * @param {number} border + * @param {number} format + * @param {number} type + * @param {ArrayBufferView} pixels + */ +WebGL2RenderingContextBase.prototype.texImage3D = function( + target, level, internalformat, width, height, depth, border, format, type, pixels) {}; + +/** + * @param {number} target + * @param {number} level + * @param {number} xoffset + * @param {number} yoffset + * @param {number} zoffset + * @param {number} format or width + * @param {number} type or height + * @param {ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement| + * number} source or depth + * @param {number=} opt_format + * @param {number=} opt_type + * @param {ArrayBufferView=} opt_pixels + */ +WebGL2RenderingContextBase.prototype.texSubImage3D = function( + target, level, xoffset, yoffset, zoffset, format, type, source, opt_format, opt_type, opt_pixels) {}; + +/** + * @param {WebGLProgram} program + * @param {Array.<string>} varyings + * @param {number} bufferMode + */ +WebGL2RenderingContextBase.prototype.transformFeedbackVaryings = function(program, varyings, bufferMode) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} v0 + */ +WebGL2RenderingContextBase.prototype.uniform1ui = function(location, v0) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} v0 + * @param {number} v1 + */ +WebGL2RenderingContextBase.prototype.uniform2ui = function(location, v0, v1) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} v0 + * @param {number} v1 + * @param {number} v2 + */ +WebGL2RenderingContextBase.prototype.uniform3ui = function(location, v0, v1, v2) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {number} v0 + * @param {number} v1 + * @param {number} v2 + * @param {number} v3 + */ +WebGL2RenderingContextBase.prototype.uniform4ui = function(location, v0, v1, v2, v3) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Uint32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.uniform1uiv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Uint32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.uniform2uiv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Uint32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.uniform3uiv = function(location, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {Uint32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.uniform4uiv = function(location, value) {}; + +/** + * @param {WebGLProgram} program + * @param {number} uniformBlockIndex + * @param {number} uniformBlockBinding + */ +WebGL2RenderingContextBase.prototype.uniformBlockBinding = function(program, uniformBlockIndex, uniformBlockBinding) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {boolean} transpose + * @param {Float32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.uniformMatrix2x3fv = function(location, transpose, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {boolean} transpose + * @param {Float32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.uniformMatrix3x2fv = function(location, transpose, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {boolean} transpose + * @param {Float32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.uniformMatrix2x4fv = function(location, transpose, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {boolean} transpose + * @param {Float32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.uniformMatrix4x2fv = function(location, transpose, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {boolean} transpose + * @param {Float32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.uniformMatrix3x4fv = function(location, transpose, value) {}; + +/** + * @param {WebGLUniformLocation} location + * @param {boolean} transpose + * @param {Float32Array|Array.<number>} value + */ +WebGL2RenderingContextBase.prototype.uniformMatrix4x3fv = function(location, transpose, value) {}; + +/** + * @param {number} index + * @param {number} x + * @param {number} y + * @param {number} z + * @param {number} w + */ +WebGL2RenderingContextBase.prototype.vertexAttribI4i = function(index, x, y, z, w) {}; + +/** + * @param {number} index + * @param {(Array.<number>|Int32Array)} v + */ +WebGL2RenderingContextBase.prototype.vertexAttribI4iv = function(index, v) {}; + +/** + * @param {number} index + * @param {number} x + * @param {number} y + * @param {number} z + * @param {number} w + */ +WebGL2RenderingContextBase.prototype.vertexAttribI4ui = function(index, x, y, z, w) {}; + +/** + * @param {number} index + * @param {(Array.<number>|Uint32Array)} v + */ +WebGL2RenderingContextBase.prototype.vertexAttribI4uiv = function(index, v) {}; + +/** + * @param {number} index + * @param {number} size + * @param {number} type + * @param {number} stride + * @param {number} offset + */ +WebGL2RenderingContextBase.prototype.vertexAttribIPointer = function(index, size, type, stride, offset) {}; + +/** + * @param {number} index + * @param {number} divisor + */ +WebGL2RenderingContextBase.prototype.vertexAttribDivisor = function(index, divisor) {}; + +/** + * @param {WebGLSync} sync + * @param {number} flags + * @param {number} timeout + */ +WebGL2RenderingContextBase.prototype.waitSync = function(sync, flags, timeout) {}; + +/** + * @constructor + * @noalias + * @extends {WebGL2RenderingContextBase} + */ +function WebGL2RenderingContext() {} |