@luma.gl/webgl 9.0.0-alpha.9 → 9.0.0-beta.2

package/dist/context/parameters/webgl-parameter-tables.js

@@ -1,263 +1,251 @@
-import GL from '@luma.gl/constants';
-import { isWebGL2 } from '../context/webgl-checks';
+import { isWebGL2 } from "../context/webgl-checks.js";
 export const GL_PARAMETER_DEFAULTS = {
-  [GL.BLEND]: false,
-  [GL.BLEND_COLOR]: new Float32Array([0, 0, 0, 0]),
-  [GL.BLEND_EQUATION_RGB]: GL.FUNC_ADD,
-  [GL.BLEND_EQUATION_ALPHA]: GL.FUNC_ADD,
-  [GL.BLEND_SRC_RGB]: GL.ONE,
-  [GL.BLEND_DST_RGB]: GL.ZERO,
-  [GL.BLEND_SRC_ALPHA]: GL.ONE,
-  [GL.BLEND_DST_ALPHA]: GL.ZERO,
-  [GL.COLOR_CLEAR_VALUE]: new Float32Array([0, 0, 0, 0]),
-  [GL.COLOR_WRITEMASK]: [true, true, true, true],
-  [GL.CULL_FACE]: false,
-  [GL.CULL_FACE_MODE]: GL.BACK,
-  [GL.DEPTH_TEST]: false,
-  [GL.DEPTH_CLEAR_VALUE]: 1,
-  [GL.DEPTH_FUNC]: GL.LESS,
-  [GL.DEPTH_RANGE]: new Float32Array([0, 1]),
-  [GL.DEPTH_WRITEMASK]: true,
-  [GL.DITHER]: true,
-  [GL.CURRENT_PROGRAM]: null,
-  [GL.FRAMEBUFFER_BINDING]: null,
-  [GL.RENDERBUFFER_BINDING]: null,
-  [GL.VERTEX_ARRAY_BINDING]: null,
-  [GL.ARRAY_BUFFER_BINDING]: null,
-  [GL.FRONT_FACE]: GL.CCW,
-  [GL.GENERATE_MIPMAP_HINT]: GL.DONT_CARE,
-  [GL.LINE_WIDTH]: 1,
-  [GL.POLYGON_OFFSET_FILL]: false,
-  [GL.POLYGON_OFFSET_FACTOR]: 0,
-  [GL.POLYGON_OFFSET_UNITS]: 0,
-  [GL.SAMPLE_ALPHA_TO_COVERAGE]: false,
-  [GL.SAMPLE_COVERAGE]: false,
-  [GL.SAMPLE_COVERAGE_VALUE]: 1.0,
-  [GL.SAMPLE_COVERAGE_INVERT]: false,
-  [GL.SCISSOR_TEST]: false,
-  [GL.SCISSOR_BOX]: new Int32Array([0, 0, 1024, 1024]),
-  [GL.STENCIL_TEST]: false,
-  [GL.STENCIL_CLEAR_VALUE]: 0,
-  [GL.STENCIL_WRITEMASK]: 0xffffffff,
-  [GL.STENCIL_BACK_WRITEMASK]: 0xffffffff,
-  [GL.STENCIL_FUNC]: GL.ALWAYS,
-  [GL.STENCIL_REF]: 0,
-  [GL.STENCIL_VALUE_MASK]: 0xffffffff,
-  [GL.STENCIL_BACK_FUNC]: GL.ALWAYS,
-  [GL.STENCIL_BACK_REF]: 0,
-  [GL.STENCIL_BACK_VALUE_MASK]: 0xffffffff,
-  [GL.STENCIL_FAIL]: GL.KEEP,
-  [GL.STENCIL_PASS_DEPTH_FAIL]: GL.KEEP,
-  [GL.STENCIL_PASS_DEPTH_PASS]: GL.KEEP,
-  [GL.STENCIL_BACK_FAIL]: GL.KEEP,
-  [GL.STENCIL_BACK_PASS_DEPTH_FAIL]: GL.KEEP,
-  [GL.STENCIL_BACK_PASS_DEPTH_PASS]: GL.KEEP,
-  [GL.VIEWPORT]: [0, 0, 1024, 1024],
-  [GL.PACK_ALIGNMENT]: 4,
-  [GL.UNPACK_ALIGNMENT]: 4,
-  [GL.UNPACK_FLIP_Y_WEBGL]: false,
-  [GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,
-  [GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: GL.BROWSER_DEFAULT_WEBGL,
-  [GL.TRANSFORM_FEEDBACK_BINDING]: null,
-  [GL.COPY_READ_BUFFER_BINDING]: null,
-  [GL.COPY_WRITE_BUFFER_BINDING]: null,
-  [GL.PIXEL_PACK_BUFFER_BINDING]: null,
-  [GL.PIXEL_UNPACK_BUFFER_BINDING]: null,
-  [GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: GL.DONT_CARE,
-  [GL.READ_FRAMEBUFFER_BINDING]: null,
-  [GL.RASTERIZER_DISCARD]: false,
-  [GL.PACK_ROW_LENGTH]: 0,
-  [GL.PACK_SKIP_PIXELS]: 0,
-  [GL.PACK_SKIP_ROWS]: 0,
-  [GL.UNPACK_ROW_LENGTH]: 0,
-  [GL.UNPACK_IMAGE_HEIGHT]: 0,
-  [GL.UNPACK_SKIP_PIXELS]: 0,
-  [GL.UNPACK_SKIP_ROWS]: 0,
-  [GL.UNPACK_SKIP_IMAGES]: 0
+  [3042]: false,
+  [32773]: new Float32Array([0, 0, 0, 0]),
+  [32777]: 32774,
+  [34877]: 32774,
+  [32969]: 1,
+  [32968]: 0,
+  [32971]: 1,
+  [32970]: 0,
+  [3106]: new Float32Array([0, 0, 0, 0]),
+  [3107]: [true, true, true, true],
+  [2884]: false,
+  [2885]: 1029,
+  [2929]: false,
+  [2931]: 1,
+  [2932]: 513,
+  [2928]: new Float32Array([0, 1]),
+  [2930]: true,
+  [3024]: true,
+  [35725]: null,
+  [36006]: null,
+  [36007]: null,
+  [34229]: null,
+  [34964]: null,
+  [2886]: 2305,
+  [33170]: 4352,
+  [2849]: 1,
+  [32823]: false,
+  [32824]: 0,
+  [10752]: 0,
+  [32926]: false,
+  [32928]: false,
+  [32938]: 1.0,
+  [32939]: false,
+  [3089]: false,
+  [3088]: new Int32Array([0, 0, 1024, 1024]),
+  [2960]: false,
+  [2961]: 0,
+  [2968]: 0xffffffff,
+  [36005]: 0xffffffff,
+  [2962]: 519,
+  [2967]: 0,
+  [2963]: 0xffffffff,
+  [34816]: 519,
+  [36003]: 0,
+  [36004]: 0xffffffff,
+  [2964]: 7680,
+  [2965]: 7680,
+  [2966]: 7680,
+  [34817]: 7680,
+  [34818]: 7680,
+  [34819]: 7680,
+  [2978]: [0, 0, 1024, 1024],
+  [3333]: 4,
+  [3317]: 4,
+  [37440]: false,
+  [37441]: false,
+  [37443]: 37444,
+  [36389]: null,
+  [36662]: null,
+  [36663]: null,
+  [35053]: null,
+  [35055]: null,
+  [35723]: 4352,
+  [36010]: null,
+  [35977]: false,
+  [3330]: 0,
+  [3332]: 0,
+  [3331]: 0,
+  [3314]: 0,
+  [32878]: 0,
+  [3316]: 0,
+  [3315]: 0,
+  [32877]: 0
 };
-
 const enable = (gl, value, key) => value ? gl.enable(key) : gl.disable(key);
-
 const hint = (gl, value, key) => gl.hint(key, value);
-
 const pixelStorei = (gl, value, key) => gl.pixelStorei(key, value);
-
 const bindFramebuffer = (gl, value, key) => {
   let target;
-
-  if (key === GL.FRAMEBUFFER_BINDING) {
-    target = isWebGL2(gl) ? GL.DRAW_FRAMEBUFFER : GL.FRAMEBUFFER;
+  if (key === 36006) {
+    target = isWebGL2(gl) ? 36009 : 36160;
   } else {
-    target = GL.READ_FRAMEBUFFER;
+    target = 36008;
   }
-
   return gl.bindFramebuffer(target, value);
 };
-
 const bindBuffer = (gl, value, key) => {
-  const target = {
-    [GL.ARRAY_BUFFER_BINDING]: [GL.ARRAY_BUFFER],
-    [GL.COPY_READ_BUFFER_BINDING]: [GL.COPY_READ_BUFFER],
-    [GL.COPY_WRITE_BUFFER_BINDING]: [GL.COPY_WRITE_BUFFER],
-    [GL.PIXEL_PACK_BUFFER_BINDING]: [GL.PIXEL_PACK_BUFFER],
-    [GL.PIXEL_UNPACK_BUFFER_BINDING]: [GL.PIXEL_UNPACK_BUFFER]
-  }[key];
-  gl.bindBuffer(target, value);
+  const bindingMap = {
+    [34964]: 34962,
+    [36662]: 36662,
+    [36663]: 36663,
+    [35053]: 35051,
+    [35055]: 35052
+  };
+  const glTarget = bindingMap[key];
+  gl.bindBuffer(glTarget, value);
 };
-
 function isArray(array) {
-  return Array.isArray(array) || ArrayBuffer.isView(array);
+  return Array.isArray(array) || ArrayBuffer.isView(array) && !(array instanceof DataView);
 }
-
 export const GL_PARAMETER_SETTERS = {
-  [GL.BLEND]: enable,
-  [GL.BLEND_COLOR]: (gl, value) => gl.blendColor(...value),
-  [GL.BLEND_EQUATION_RGB]: 'blendEquation',
-  [GL.BLEND_EQUATION_ALPHA]: 'blendEquation',
-  [GL.BLEND_SRC_RGB]: 'blendFunc',
-  [GL.BLEND_DST_RGB]: 'blendFunc',
-  [GL.BLEND_SRC_ALPHA]: 'blendFunc',
-  [GL.BLEND_DST_ALPHA]: 'blendFunc',
-  [GL.COLOR_CLEAR_VALUE]: (gl, value) => gl.clearColor(...value),
-  [GL.COLOR_WRITEMASK]: (gl, value) => gl.colorMask(...value),
-  [GL.CULL_FACE]: enable,
-  [GL.CULL_FACE_MODE]: (gl, value) => gl.cullFace(value),
-  [GL.DEPTH_TEST]: enable,
-  [GL.DEPTH_CLEAR_VALUE]: (gl, value) => gl.clearDepth(value),
-  [GL.DEPTH_FUNC]: (gl, value) => gl.depthFunc(value),
-  [GL.DEPTH_RANGE]: (gl, value) => gl.depthRange(...value),
-  [GL.DEPTH_WRITEMASK]: (gl, value) => gl.depthMask(value),
-  [GL.DITHER]: enable,
-  [GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: hint,
-  [GL.CURRENT_PROGRAM]: (gl, value) => gl.useProgram(value),
-  [GL.RENDERBUFFER_BINDING]: (gl, value) => gl.bindRenderbuffer(GL.RENDERBUFFER, value),
-  [GL.TRANSFORM_FEEDBACK_BINDING]: (gl, value) => {
-    var _gl$bindTransformFeed;
-
-    return (_gl$bindTransformFeed = gl.bindTransformFeedback) === null || _gl$bindTransformFeed === void 0 ? void 0 : _gl$bindTransformFeed.call(gl, GL.TRANSFORM_FEEDBACK, value);
+  [3042]: enable,
+  [32773]: (gl, value) => gl.blendColor(...value),
+  [32777]: 'blendEquation',
+  [34877]: 'blendEquation',
+  [32969]: 'blendFunc',
+  [32968]: 'blendFunc',
+  [32971]: 'blendFunc',
+  [32970]: 'blendFunc',
+  [3106]: (gl, value) => gl.clearColor(...value),
+  [3107]: (gl, value) => gl.colorMask(...value),
+  [2884]: enable,
+  [2885]: (gl, value) => gl.cullFace(value),
+  [2929]: enable,
+  [2931]: (gl, value) => gl.clearDepth(value),
+  [2932]: (gl, value) => gl.depthFunc(value),
+  [2928]: (gl, value) => gl.depthRange(...value),
+  [2930]: (gl, value) => gl.depthMask(value),
+  [3024]: enable,
+  [35723]: hint,
+  [35725]: (gl, value) => gl.useProgram(value),
+  [36007]: (gl, value) => gl.bindRenderbuffer(36161, value),
+  [36389]: (gl, value) => {
+    var _bindTransformFeedbac, _ref;
+    return (_bindTransformFeedbac = (_ref = gl).bindTransformFeedback) === null || _bindTransformFeedbac === void 0 ? void 0 : _bindTransformFeedbac.call(_ref, 36386, value);
   },
-  [GL.VERTEX_ARRAY_BINDING]: (gl, value) => gl.bindVertexArray(value),
-  [GL.FRAMEBUFFER_BINDING]: bindFramebuffer,
-  [GL.READ_FRAMEBUFFER_BINDING]: bindFramebuffer,
-  [GL.ARRAY_BUFFER_BINDING]: bindBuffer,
-  [GL.COPY_READ_BUFFER_BINDING]: bindBuffer,
-  [GL.COPY_WRITE_BUFFER_BINDING]: bindBuffer,
-  [GL.PIXEL_PACK_BUFFER_BINDING]: bindBuffer,
-  [GL.PIXEL_UNPACK_BUFFER_BINDING]: bindBuffer,
-  [GL.FRONT_FACE]: (gl, value) => gl.frontFace(value),
-  [GL.GENERATE_MIPMAP_HINT]: hint,
-  [GL.LINE_WIDTH]: (gl, value) => gl.lineWidth(value),
-  [GL.POLYGON_OFFSET_FILL]: enable,
-  [GL.POLYGON_OFFSET_FACTOR]: 'polygonOffset',
-  [GL.POLYGON_OFFSET_UNITS]: 'polygonOffset',
-  [GL.RASTERIZER_DISCARD]: enable,
-  [GL.SAMPLE_ALPHA_TO_COVERAGE]: enable,
-  [GL.SAMPLE_COVERAGE]: enable,
-  [GL.SAMPLE_COVERAGE_VALUE]: 'sampleCoverage',
-  [GL.SAMPLE_COVERAGE_INVERT]: 'sampleCoverage',
-  [GL.SCISSOR_TEST]: enable,
-  [GL.SCISSOR_BOX]: (gl, value) => gl.scissor(...value),
-  [GL.STENCIL_TEST]: enable,
-  [GL.STENCIL_CLEAR_VALUE]: (gl, value) => gl.clearStencil(value),
-  [GL.STENCIL_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(GL.FRONT, value),
-  [GL.STENCIL_BACK_WRITEMASK]: (gl, value) => gl.stencilMaskSeparate(GL.BACK, value),
-  [GL.STENCIL_FUNC]: 'stencilFuncFront',
-  [GL.STENCIL_REF]: 'stencilFuncFront',
-  [GL.STENCIL_VALUE_MASK]: 'stencilFuncFront',
-  [GL.STENCIL_BACK_FUNC]: 'stencilFuncBack',
-  [GL.STENCIL_BACK_REF]: 'stencilFuncBack',
-  [GL.STENCIL_BACK_VALUE_MASK]: 'stencilFuncBack',
-  [GL.STENCIL_FAIL]: 'stencilOpFront',
-  [GL.STENCIL_PASS_DEPTH_FAIL]: 'stencilOpFront',
-  [GL.STENCIL_PASS_DEPTH_PASS]: 'stencilOpFront',
-  [GL.STENCIL_BACK_FAIL]: 'stencilOpBack',
-  [GL.STENCIL_BACK_PASS_DEPTH_FAIL]: 'stencilOpBack',
-  [GL.STENCIL_BACK_PASS_DEPTH_PASS]: 'stencilOpBack',
-  [GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
-  [GL.PACK_ALIGNMENT]: pixelStorei,
-  [GL.UNPACK_ALIGNMENT]: pixelStorei,
-  [GL.UNPACK_FLIP_Y_WEBGL]: pixelStorei,
-  [GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: pixelStorei,
-  [GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: pixelStorei,
-  [GL.PACK_ROW_LENGTH]: pixelStorei,
-  [GL.PACK_SKIP_PIXELS]: pixelStorei,
-  [GL.PACK_SKIP_ROWS]: pixelStorei,
-  [GL.UNPACK_ROW_LENGTH]: pixelStorei,
-  [GL.UNPACK_IMAGE_HEIGHT]: pixelStorei,
-  [GL.UNPACK_SKIP_PIXELS]: pixelStorei,
-  [GL.UNPACK_SKIP_ROWS]: pixelStorei,
-  [GL.UNPACK_SKIP_IMAGES]: pixelStorei,
+  [34229]: (gl, value) => gl.bindVertexArray(value),
+  [36006]: bindFramebuffer,
+  [36010]: bindFramebuffer,
+  [34964]: bindBuffer,
+  [36662]: bindBuffer,
+  [36663]: bindBuffer,
+  [35053]: bindBuffer,
+  [35055]: bindBuffer,
+  [2886]: (gl, value) => gl.frontFace(value),
+  [33170]: hint,
+  [2849]: (gl, value) => gl.lineWidth(value),
+  [32823]: enable,
+  [32824]: 'polygonOffset',
+  [10752]: 'polygonOffset',
+  [35977]: enable,
+  [32926]: enable,
+  [32928]: enable,
+  [32938]: 'sampleCoverage',
+  [32939]: 'sampleCoverage',
+  [3089]: enable,
+  [3088]: (gl, value) => gl.scissor(...value),
+  [2960]: enable,
+  [2961]: (gl, value) => gl.clearStencil(value),
+  [2968]: (gl, value) => gl.stencilMaskSeparate(1028, value),
+  [36005]: (gl, value) => gl.stencilMaskSeparate(1029, value),
+  [2962]: 'stencilFuncFront',
+  [2967]: 'stencilFuncFront',
+  [2963]: 'stencilFuncFront',
+  [34816]: 'stencilFuncBack',
+  [36003]: 'stencilFuncBack',
+  [36004]: 'stencilFuncBack',
+  [2964]: 'stencilOpFront',
+  [2965]: 'stencilOpFront',
+  [2966]: 'stencilOpFront',
+  [34817]: 'stencilOpBack',
+  [34818]: 'stencilOpBack',
+  [34819]: 'stencilOpBack',
+  [2978]: (gl, value) => gl.viewport(...value),
+  [3333]: pixelStorei,
+  [3317]: pixelStorei,
+  [37440]: pixelStorei,
+  [37441]: pixelStorei,
+  [37443]: pixelStorei,
+  [3330]: pixelStorei,
+  [3332]: pixelStorei,
+  [3331]: pixelStorei,
+  [3314]: pixelStorei,
+  [32878]: pixelStorei,
+  [3316]: pixelStorei,
+  [3315]: pixelStorei,
+  [32877]: pixelStorei,
   framebuffer: (gl, framebuffer) => {
     const handle = framebuffer && 'handle' in framebuffer ? framebuffer.handle : framebuffer;
-    return gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
+    return gl.bindFramebuffer(36160, handle);
   },
-  blend: (gl, value) => value ? gl.enable(GL.BLEND) : gl.disable(GL.BLEND),
+  blend: (gl, value) => value ? gl.enable(3042) : gl.disable(3042),
   blendColor: (gl, value) => gl.blendColor(...value),
   blendEquation: (gl, args) => {
-    args = isArray(args) ? args : [args, args];
-    gl.blendEquationSeparate(...args);
+    const separateModes = typeof args === 'number' ? [args, args] : args;
+    gl.blendEquationSeparate(...separateModes);
   },
   blendFunc: (gl, args) => {
-    args = isArray(args) && args.length === 2 ? [...args, ...args] : args;
-    gl.blendFuncSeparate(...args);
+    const separateFuncs = (args === null || args === void 0 ? void 0 : args.length) === 2 ? [...args, ...args] : args;
+    gl.blendFuncSeparate(...separateFuncs);
   },
   clearColor: (gl, value) => gl.clearColor(...value),
   clearDepth: (gl, value) => gl.clearDepth(value),
   clearStencil: (gl, value) => gl.clearStencil(value),
   colorMask: (gl, value) => gl.colorMask(...value),
-  cull: (gl, value) => value ? gl.enable(GL.CULL_FACE) : gl.disable(GL.CULL_FACE),
+  cull: (gl, value) => value ? gl.enable(2884) : gl.disable(2884),
   cullFace: (gl, value) => gl.cullFace(value),
-  depthTest: (gl, value) => value ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST),
+  depthTest: (gl, value) => value ? gl.enable(2929) : gl.disable(2929),
   depthFunc: (gl, value) => gl.depthFunc(value),
   depthMask: (gl, value) => gl.depthMask(value),
   depthRange: (gl, value) => gl.depthRange(...value),
-  dither: (gl, value) => value ? gl.enable(GL.DITHER) : gl.disable(GL.DITHER),
+  dither: (gl, value) => value ? gl.enable(3024) : gl.disable(3024),
   derivativeHint: (gl, value) => {
-    gl.hint(GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
+    gl.hint(35723, value);
   },
   frontFace: (gl, value) => gl.frontFace(value),
-  mipmapHint: (gl, value) => gl.hint(GL.GENERATE_MIPMAP_HINT, value),
+  mipmapHint: (gl, value) => gl.hint(33170, value),
   lineWidth: (gl, value) => gl.lineWidth(value),
-  polygonOffsetFill: (gl, value) => value ? gl.enable(GL.POLYGON_OFFSET_FILL) : gl.disable(GL.POLYGON_OFFSET_FILL),
+  polygonOffsetFill: (gl, value) => value ? gl.enable(32823) : gl.disable(32823),
   polygonOffset: (gl, value) => gl.polygonOffset(...value),
   sampleCoverage: (gl, value) => gl.sampleCoverage(...value),
-  scissorTest: (gl, value) => value ? gl.enable(GL.SCISSOR_TEST) : gl.disable(GL.SCISSOR_TEST),
+  scissorTest: (gl, value) => value ? gl.enable(3089) : gl.disable(3089),
   scissor: (gl, value) => gl.scissor(...value),
-  stencilTest: (gl, value) => value ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST),
+  stencilTest: (gl, value) => value ? gl.enable(2960) : gl.disable(2960),
   stencilMask: (gl, value) => {
     value = isArray(value) ? value : [value, value];
     const [mask, backMask] = value;
-    gl.stencilMaskSeparate(GL.FRONT, mask);
-    gl.stencilMaskSeparate(GL.BACK, backMask);
+    gl.stencilMaskSeparate(1028, mask);
+    gl.stencilMaskSeparate(1029, backMask);
   },
   stencilFunc: (gl, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [func, ref, mask, backFunc, backRef, backMask] = args;
-    gl.stencilFuncSeparate(GL.FRONT, func, ref, mask);
-    gl.stencilFuncSeparate(GL.BACK, backFunc, backRef, backMask);
+    gl.stencilFuncSeparate(1028, func, ref, mask);
+    gl.stencilFuncSeparate(1029, backFunc, backRef, backMask);
   },
   stencilOp: (gl, args) => {
     args = isArray(args) && args.length === 3 ? [...args, ...args] : args;
     const [sfail, dpfail, dppass, backSfail, backDpfail, backDppass] = args;
-    gl.stencilOpSeparate(GL.FRONT, sfail, dpfail, dppass);
-    gl.stencilOpSeparate(GL.BACK, backSfail, backDpfail, backDppass);
+    gl.stencilOpSeparate(1028, sfail, dpfail, dppass);
+    gl.stencilOpSeparate(1029, backSfail, backDpfail, backDppass);
   },
   viewport: (gl, value) => gl.viewport(...value)
 };
-
 function getValue(glEnum, values, cache) {
   return values[glEnum] !== undefined ? values[glEnum] : cache[glEnum];
 }
-
 export const GL_COMPOSITE_PARAMETER_SETTERS = {
-  blendEquation: (gl, values, cache) => gl.blendEquationSeparate(getValue(GL.BLEND_EQUATION_RGB, values, cache), getValue(GL.BLEND_EQUATION_ALPHA, values, cache)),
-  blendFunc: (gl, values, cache) => gl.blendFuncSeparate(getValue(GL.BLEND_SRC_RGB, values, cache), getValue(GL.BLEND_DST_RGB, values, cache), getValue(GL.BLEND_SRC_ALPHA, values, cache), getValue(GL.BLEND_DST_ALPHA, values, cache)),
-  polygonOffset: (gl, values, cache) => gl.polygonOffset(getValue(GL.POLYGON_OFFSET_FACTOR, values, cache), getValue(GL.POLYGON_OFFSET_UNITS, values, cache)),
-  sampleCoverage: (gl, values, cache) => gl.sampleCoverage(getValue(GL.SAMPLE_COVERAGE_VALUE, values, cache), getValue(GL.SAMPLE_COVERAGE_INVERT, values, cache)),
-  stencilFuncFront: (gl, values, cache) => gl.stencilFuncSeparate(GL.FRONT, getValue(GL.STENCIL_FUNC, values, cache), getValue(GL.STENCIL_REF, values, cache), getValue(GL.STENCIL_VALUE_MASK, values, cache)),
-  stencilFuncBack: (gl, values, cache) => gl.stencilFuncSeparate(GL.BACK, getValue(GL.STENCIL_BACK_FUNC, values, cache), getValue(GL.STENCIL_BACK_REF, values, cache), getValue(GL.STENCIL_BACK_VALUE_MASK, values, cache)),
-  stencilOpFront: (gl, values, cache) => gl.stencilOpSeparate(GL.FRONT, getValue(GL.STENCIL_FAIL, values, cache), getValue(GL.STENCIL_PASS_DEPTH_FAIL, values, cache), getValue(GL.STENCIL_PASS_DEPTH_PASS, values, cache)),
-  stencilOpBack: (gl, values, cache) => gl.stencilOpSeparate(GL.BACK, getValue(GL.STENCIL_BACK_FAIL, values, cache), getValue(GL.STENCIL_BACK_PASS_DEPTH_FAIL, values, cache), getValue(GL.STENCIL_BACK_PASS_DEPTH_PASS, values, cache))
+  blendEquation: (gl, values, cache) => gl.blendEquationSeparate(getValue(32777, values, cache), getValue(34877, values, cache)),
+  blendFunc: (gl, values, cache) => gl.blendFuncSeparate(getValue(32969, values, cache), getValue(32968, values, cache), getValue(32971, values, cache), getValue(32970, values, cache)),
+  polygonOffset: (gl, values, cache) => gl.polygonOffset(getValue(32824, values, cache), getValue(10752, values, cache)),
+  sampleCoverage: (gl, values, cache) => gl.sampleCoverage(getValue(32938, values, cache), getValue(32939, values, cache)),
+  stencilFuncFront: (gl, values, cache) => gl.stencilFuncSeparate(1028, getValue(2962, values, cache), getValue(2967, values, cache), getValue(2963, values, cache)),
+  stencilFuncBack: (gl, values, cache) => gl.stencilFuncSeparate(1029, getValue(34816, values, cache), getValue(36003, values, cache), getValue(36004, values, cache)),
+  stencilOpFront: (gl, values, cache) => gl.stencilOpSeparate(1028, getValue(2964, values, cache), getValue(2965, values, cache), getValue(2966, values, cache)),
+  stencilOpBack: (gl, values, cache) => gl.stencilOpSeparate(1029, getValue(34817, values, cache), getValue(34818, values, cache), getValue(34819, values, cache))
 };
 export const GL_HOOKED_SETTERS = {
   enable: (update, capability) => update({
@@ -273,173 +261,166 @@ export const GL_HOOKED_SETTERS = {
     [pname]: hint
   }),
   useProgram: (update, value) => update({
-    [GL.CURRENT_PROGRAM]: value
+    [35725]: value
   }),
   bindRenderbuffer: (update, target, value) => update({
-    [GL.RENDERBUFFER_BINDING]: value
+    [36007]: value
   }),
   bindTransformFeedback: (update, target, value) => update({
-    [GL.TRANSFORM_FEEDBACK_BINDING]: value
+    [36389]: value
   }),
   bindVertexArray: (update, value) => update({
-    [GL.VERTEX_ARRAY_BINDING]: value
+    [34229]: value
   }),
   bindFramebuffer: (update, target, framebuffer) => {
     switch (target) {
-      case GL.FRAMEBUFFER:
+      case 36160:
         return update({
-          [GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer,
-          [GL.READ_FRAMEBUFFER_BINDING]: framebuffer
+          [36006]: framebuffer,
+          [36010]: framebuffer
         });
-
-      case GL.DRAW_FRAMEBUFFER:
+      case 36009:
         return update({
-          [GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer
+          [36006]: framebuffer
         });
-
-      case GL.READ_FRAMEBUFFER:
+      case 36008:
         return update({
-          [GL.READ_FRAMEBUFFER_BINDING]: framebuffer
+          [36010]: framebuffer
         });
-
       default:
         return null;
     }
   },
   bindBuffer: (update, target, buffer) => {
     const pname = {
-      [GL.ARRAY_BUFFER]: [GL.ARRAY_BUFFER_BINDING],
-      [GL.COPY_READ_BUFFER]: [GL.COPY_READ_BUFFER_BINDING],
-      [GL.COPY_WRITE_BUFFER]: [GL.COPY_WRITE_BUFFER_BINDING],
-      [GL.PIXEL_PACK_BUFFER]: [GL.PIXEL_PACK_BUFFER_BINDING],
-      [GL.PIXEL_UNPACK_BUFFER]: [GL.PIXEL_UNPACK_BUFFER_BINDING]
+      [34962]: [34964],
+      [36662]: [36662],
+      [36663]: [36663],
+      [35051]: [35053],
+      [35052]: [35055]
     }[target];
-
     if (pname) {
       return update({
         [pname]: buffer
       });
     }
-
     return {
       valueChanged: true
     };
   },
   blendColor: (update, r, g, b, a) => update({
-    [GL.BLEND_COLOR]: new Float32Array([r, g, b, a])
+    [32773]: new Float32Array([r, g, b, a])
   }),
   blendEquation: (update, mode) => update({
-    [GL.BLEND_EQUATION_RGB]: mode,
-    [GL.BLEND_EQUATION_ALPHA]: mode
+    [32777]: mode,
+    [34877]: mode
   }),
   blendEquationSeparate: (update, modeRGB, modeAlpha) => update({
-    [GL.BLEND_EQUATION_RGB]: modeRGB,
-    [GL.BLEND_EQUATION_ALPHA]: modeAlpha
+    [32777]: modeRGB,
+    [34877]: modeAlpha
   }),
   blendFunc: (update, src, dst) => update({
-    [GL.BLEND_SRC_RGB]: src,
-    [GL.BLEND_DST_RGB]: dst,
-    [GL.BLEND_SRC_ALPHA]: src,
-    [GL.BLEND_DST_ALPHA]: dst
+    [32969]: src,
+    [32968]: dst,
+    [32971]: src,
+    [32970]: dst
   }),
   blendFuncSeparate: (update, srcRGB, dstRGB, srcAlpha, dstAlpha) => update({
-    [GL.BLEND_SRC_RGB]: srcRGB,
-    [GL.BLEND_DST_RGB]: dstRGB,
-    [GL.BLEND_SRC_ALPHA]: srcAlpha,
-    [GL.BLEND_DST_ALPHA]: dstAlpha
+    [32969]: srcRGB,
+    [32968]: dstRGB,
+    [32971]: srcAlpha,
+    [32970]: dstAlpha
   }),
   clearColor: (update, r, g, b, a) => update({
-    [GL.COLOR_CLEAR_VALUE]: new Float32Array([r, g, b, a])
+    [3106]: new Float32Array([r, g, b, a])
   }),
   clearDepth: (update, depth) => update({
-    [GL.DEPTH_CLEAR_VALUE]: depth
+    [2931]: depth
   }),
   clearStencil: (update, s) => update({
-    [GL.STENCIL_CLEAR_VALUE]: s
+    [2961]: s
   }),
   colorMask: (update, r, g, b, a) => update({
-    [GL.COLOR_WRITEMASK]: [r, g, b, a]
+    [3107]: [r, g, b, a]
   }),
   cullFace: (update, mode) => update({
-    [GL.CULL_FACE_MODE]: mode
+    [2885]: mode
   }),
   depthFunc: (update, func) => update({
-    [GL.DEPTH_FUNC]: func
+    [2932]: func
   }),
   depthRange: (update, zNear, zFar) => update({
-    [GL.DEPTH_RANGE]: new Float32Array([zNear, zFar])
+    [2928]: new Float32Array([zNear, zFar])
   }),
   depthMask: (update, mask) => update({
-    [GL.DEPTH_WRITEMASK]: mask
+    [2930]: mask
   }),
   frontFace: (update, face) => update({
-    [GL.FRONT_FACE]: face
+    [2886]: face
   }),
   lineWidth: (update, width) => update({
-    [GL.LINE_WIDTH]: width
+    [2849]: width
   }),
   polygonOffset: (update, factor, units) => update({
-    [GL.POLYGON_OFFSET_FACTOR]: factor,
-    [GL.POLYGON_OFFSET_UNITS]: units
+    [32824]: factor,
+    [10752]: units
   }),
   sampleCoverage: (update, value, invert) => update({
-    [GL.SAMPLE_COVERAGE_VALUE]: value,
-    [GL.SAMPLE_COVERAGE_INVERT]: invert
+    [32938]: value,
+    [32939]: invert
   }),
   scissor: (update, x, y, width, height) => update({
-    [GL.SCISSOR_BOX]: new Int32Array([x, y, width, height])
+    [3088]: new Int32Array([x, y, width, height])
   }),
   stencilMask: (update, mask) => update({
-    [GL.STENCIL_WRITEMASK]: mask,
-    [GL.STENCIL_BACK_WRITEMASK]: mask
+    [2968]: mask,
+    [36005]: mask
   }),
   stencilMaskSeparate: (update, face, mask) => update({
-    [face === GL.FRONT ? GL.STENCIL_WRITEMASK : GL.STENCIL_BACK_WRITEMASK]: mask
+    [face === 1028 ? 2968 : 36005]: mask
   }),
   stencilFunc: (update, func, ref, mask) => update({
-    [GL.STENCIL_FUNC]: func,
-    [GL.STENCIL_REF]: ref,
-    [GL.STENCIL_VALUE_MASK]: mask,
-    [GL.STENCIL_BACK_FUNC]: func,
-    [GL.STENCIL_BACK_REF]: ref,
-    [GL.STENCIL_BACK_VALUE_MASK]: mask
+    [2962]: func,
+    [2967]: ref,
+    [2963]: mask,
+    [34816]: func,
+    [36003]: ref,
+    [36004]: mask
   }),
   stencilFuncSeparate: (update, face, func, ref, mask) => update({
-    [face === GL.FRONT ? GL.STENCIL_FUNC : GL.STENCIL_BACK_FUNC]: func,
-    [face === GL.FRONT ? GL.STENCIL_REF : GL.STENCIL_BACK_REF]: ref,
-    [face === GL.FRONT ? GL.STENCIL_VALUE_MASK : GL.STENCIL_BACK_VALUE_MASK]: mask
+    [face === 1028 ? 2962 : 34816]: func,
+    [face === 1028 ? 2967 : 36003]: ref,
+    [face === 1028 ? 2963 : 36004]: mask
   }),
   stencilOp: (update, fail, zfail, zpass) => update({
-    [GL.STENCIL_FAIL]: fail,
-    [GL.STENCIL_PASS_DEPTH_FAIL]: zfail,
-    [GL.STENCIL_PASS_DEPTH_PASS]: zpass,
-    [GL.STENCIL_BACK_FAIL]: fail,
-    [GL.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,
-    [GL.STENCIL_BACK_PASS_DEPTH_PASS]: zpass
+    [2964]: fail,
+    [2965]: zfail,
+    [2966]: zpass,
+    [34817]: fail,
+    [34818]: zfail,
+    [34819]: zpass
   }),
   stencilOpSeparate: (update, face, fail, zfail, zpass) => update({
-    [face === GL.FRONT ? GL.STENCIL_FAIL : GL.STENCIL_BACK_FAIL]: fail,
-    [face === GL.FRONT ? GL.STENCIL_PASS_DEPTH_FAIL : GL.STENCIL_BACK_PASS_DEPTH_FAIL]: zfail,
-    [face === GL.FRONT ? GL.STENCIL_PASS_DEPTH_PASS : GL.STENCIL_BACK_PASS_DEPTH_PASS]: zpass
+    [face === 1028 ? 2964 : 34817]: fail,
+    [face === 1028 ? 2965 : 34818]: zfail,
+    [face === 1028 ? 2966 : 34819]: zpass
   }),
   viewport: (update, x, y, width, height) => update({
-    [GL.VIEWPORT]: [x, y, width, height]
+    [2978]: [x, y, width, height]
   })
 };
-
 const isEnabled = (gl, key) => gl.isEnabled(key);
-
 export const GL_PARAMETER_GETTERS = {
-  [GL.BLEND]: isEnabled,
-  [GL.CULL_FACE]: isEnabled,
-  [GL.DEPTH_TEST]: isEnabled,
-  [GL.DITHER]: isEnabled,
-  [GL.POLYGON_OFFSET_FILL]: isEnabled,
-  [GL.SAMPLE_ALPHA_TO_COVERAGE]: isEnabled,
-  [GL.SAMPLE_COVERAGE]: isEnabled,
-  [GL.SCISSOR_TEST]: isEnabled,
-  [GL.STENCIL_TEST]: isEnabled,
-  [GL.RASTERIZER_DISCARD]: isEnabled
+  [3042]: isEnabled,
+  [2884]: isEnabled,
+  [2929]: isEnabled,
+  [3024]: isEnabled,
+  [32823]: isEnabled,
+  [32926]: isEnabled,
+  [32928]: isEnabled,
+  [3089]: isEnabled,
+  [2960]: isEnabled,
+  [35977]: isEnabled
 };
-export const NON_CACHE_PARAMETERS = new Set([GL.ACTIVE_TEXTURE, GL.TRANSFORM_FEEDBACK_ACTIVE, GL.TRANSFORM_FEEDBACK_PAUSED, GL.TRANSFORM_FEEDBACK_BUFFER_BINDING, GL.UNIFORM_BUFFER_BINDING, GL.ELEMENT_ARRAY_BUFFER_BINDING, GL.IMPLEMENTATION_COLOR_READ_FORMAT, GL.IMPLEMENTATION_COLOR_READ_TYPE, GL.READ_BUFFER, GL.DRAW_BUFFER0, GL.DRAW_BUFFER1, GL.DRAW_BUFFER2, GL.DRAW_BUFFER3, GL.DRAW_BUFFER4, GL.DRAW_BUFFER5, GL.DRAW_BUFFER6, GL.DRAW_BUFFER7, GL.DRAW_BUFFER8, GL.DRAW_BUFFER9, GL.DRAW_BUFFER10, GL.DRAW_BUFFER11, GL.DRAW_BUFFER12, GL.DRAW_BUFFER13, GL.DRAW_BUFFER14, GL.DRAW_BUFFER15, GL.SAMPLER_BINDING, GL.TEXTURE_BINDING_2D, GL.TEXTURE_BINDING_2D_ARRAY, GL.TEXTURE_BINDING_3D, GL.TEXTURE_BINDING_CUBE_MAP]);
+export const NON_CACHE_PARAMETERS = new Set([34016, 36388, 36387, 35983, 35368, 34965, 35739, 35738, 3074, 34853, 34854, 34855, 34856, 34857, 34858, 34859, 34860, 34861, 34862, 34863, 34864, 34865, 34866, 34867, 34868, 35097, 32873, 35869, 32874, 34068]);
 //# sourceMappingURL=webgl-parameter-tables.js.map