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

package/dist/esm/context/debug/webgl-developer-tools.js

@@ -1,121 +0,0 @@
-import { log, loadScript } from '@luma.gl/api/';
-import GL from '@luma.gl/constants';
-const WEBGL_DEBUG_CDN_URL = 'https://unpkg.com/webgl-debug@2.0.1/index.js';
-const DEFAULT_DEBUG_CONTEXT_PROPS = {
-  debug: true,
-  throwOnError: false,
-  break: [],
-  webgl2: false
-};
-
-function getContextData(gl) {
-  gl.luma = gl.luma || {};
-  return gl.luma;
-}
-
-export async function loadWebGLDeveloperTools() {
-  if (!globalThis.WebGLDebugUtils) {
-    globalThis.global = globalThis.global || globalThis;
-    globalThis.global.module = {};
-    await loadScript(WEBGL_DEBUG_CDN_URL);
-  }
-}
-export function makeDebugContext(gl, props = {}) {
-  if (!gl) {
-    return null;
-  }
-
-  return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
-}
-
-function getRealContext(gl) {
-  const data = getContextData(gl);
-  return data.realContext ? data.realContext : gl;
-}
-
-function getDebugContext(gl, props) {
-  if (!globalThis.WebGLDebugUtils) {
-    log.warn('webgl-debug not loaded')();
-    return gl;
-  }
-
-  const data = getContextData(gl);
-
-  if (data.debugContext) {
-    return data.debugContext;
-  }
-
-  globalThis.WebGLDebugUtils.init({ ...GL,
-    ...gl
-  });
-  const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(gl, onGLError.bind(null, props), onValidateGLFunc.bind(null, props));
-
-  for (const key in GL) {
-    if (!(key in glDebug) && typeof GL[key] === 'number') {
-      glDebug[key] = GL[key];
-    }
-  }
-
-  class WebGLDebugContext {}
-
-  Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl));
-  Object.setPrototypeOf(WebGLDebugContext, glDebug);
-  const debugContext = Object.create(WebGLDebugContext);
-  data.realContext = gl;
-  data.debugContext = debugContext;
-  debugContext.debug = true;
-  return debugContext;
-}
-
-function getFunctionString(functionName, functionArgs) {
-  functionArgs = Array.from(functionArgs).map(arg => arg === undefined ? 'undefined' : arg);
-  let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs);
-  args = "".concat(args.slice(0, 100)).concat(args.length > 100 ? '...' : '');
-  return "gl.".concat(functionName, "(").concat(args, ")");
-}
-
-function onGLError(props, err, functionName, args) {
-  args = Array.from(args).map(arg => arg === undefined ? 'undefined' : arg);
-  const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);
-  const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);
-  const glName = props.webgl2 ? 'gl2' : 'gl1';
-  const message = "".concat(errorMessage, " in ").concat(glName, ".").concat(functionName, "(").concat(functionArgs, ")");
-  log.error(message)();
-  debugger;
-
-  if (props.throwOnError) {
-    throw new Error(message);
-  }
-}
-
-function onValidateGLFunc(props, functionName, functionArgs) {
-  let functionString = '';
-
-  if (log.level >= 1) {
-    functionString = getFunctionString(functionName, functionArgs);
-    log.log(1, functionString)();
-  }
-
-  if (props.break) {
-    functionString = functionString || getFunctionString(functionName, functionArgs);
-    const isBreakpoint = props.break && props.break.every(breakOn => functionString.indexOf(breakOn) !== -1);
-
-    if (isBreakpoint) {
-      debugger;
-    }
-  }
-
-  for (const arg of functionArgs) {
-    if (arg === undefined) {
-      functionString = functionString || getFunctionString(functionName, functionArgs);
-
-      if (props.throwOnError) {
-        throw new Error("Undefined argument: ".concat(functionString));
-      } else {
-        log.error("Undefined argument: ".concat(functionString))();
-        debugger;
-      }
-    }
-  }
-}
-//# sourceMappingURL=webgl-developer-tools.js.map

package/dist/esm/context/debug/webgl-developer-tools.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/context/debug/webgl-developer-tools.ts"],"names":["log","loadScript","GL","WEBGL_DEBUG_CDN_URL","DEFAULT_DEBUG_CONTEXT_PROPS","debug","throwOnError","break","webgl2","getContextData","gl","luma","loadWebGLDeveloperTools","globalThis","WebGLDebugUtils","global","module","makeDebugContext","props","getDebugContext","getRealContext","data","realContext","warn","debugContext","init","glDebug","onGLError","bind","onValidateGLFunc","key","WebGLDebugContext","Object","setPrototypeOf","getPrototypeOf","create","getFunctionString","functionName","functionArgs","Array","from","map","arg","undefined","args","glFunctionArgsToString","slice","length","err","errorMessage","glEnumToString","glName","message","error","Error","functionString","level","isBreakpoint","every","breakOn","indexOf"],"mappings":"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","sourcesContent":["// luma.gl, MIT license\nimport {log, loadScript} from '@luma.gl/api/';\nimport GL from '@luma.gl/constants';\n\nconst WEBGL_DEBUG_CDN_URL = 'https://unpkg.com/webgl-debug@2.0.1/index.js';\n\ntype DebugContextProps = {\n  debug?: boolean;\n  throwOnError?: boolean;\n  break?: string[];\n  webgl2?: boolean;\n};\n\nconst DEFAULT_DEBUG_CONTEXT_PROPS: Required<DebugContextProps> = {\n  debug: true,\n  throwOnError: false,\n  break: [],\n  webgl2: false,\n}\n\n// Helper to get shared context data\nfunction getContextData(gl: any) {\n  gl.luma = gl.luma || {};\n  return gl.luma;\n}\n\ndeclare global {\n  var WebGLDebugUtils: any;\n}\n\n/**\n * Loads Khronos WebGLDeveloperTools from CDN if not already installed \n * const WebGLDebugUtils = require('webgl-debug');\n * @see https://github.com/KhronosGroup/WebGLDeveloperTools\n * @see https://github.com/vorg/webgl-debug\n */\nexport async function loadWebGLDeveloperTools(): Promise<void> {\n  if (!globalThis.WebGLDebugUtils) {\n    // @ts-expect-error Developer tools expects global to be set\n    globalThis.global = globalThis.global || globalThis;\n    // @ts-expect-error Developer tools expects global to be set\n    globalThis.global.module = {};\n    await loadScript(WEBGL_DEBUG_CDN_URL);\n  }\n}\n\n// Returns (a potentially new) context with debug instrumentation turned off or on.\n// Note that this actually returns a new context\nexport function makeDebugContext(gl: WebGLRenderingContext, props: DebugContextProps = {}): WebGLRenderingContext | null {\n  // Return null to ensure we don't try to create a context in this case (TODO what case is that?)\n  if (!gl) {\n    return null;\n  }\n\n  return props.debug ? getDebugContext(gl, props) : getRealContext(gl);\n}\n\n// Returns the real context from either of the real/debug contexts\nfunction getRealContext(gl: WebGLRenderingContext): WebGLRenderingContext {\n  const data = getContextData(gl);\n  // If the context has a realContext member, it is a debug context so return the realContext\n  return data.realContext ? data.realContext : gl;\n}\n\n// Returns the debug context from either of the real/debug contexts\nfunction getDebugContext(gl: WebGLRenderingContext, props: DebugContextProps): WebGLRenderingContext {\n  if (!globalThis.WebGLDebugUtils) {\n    log.warn('webgl-debug not loaded')();\n    return gl;\n  }\n\n  const data = getContextData(gl);\n\n  // If this already has a debug context, return it.\n  if (data.debugContext) {\n    return data.debugContext;\n  }\n\n  // Create a new debug context\n  globalThis.WebGLDebugUtils.init({...GL, ...gl});\n  const glDebug = globalThis.WebGLDebugUtils.makeDebugContext(\n    gl,\n    onGLError.bind(null, props),\n    onValidateGLFunc.bind(null, props)\n  );\n\n  // Make sure we have all WebGL2 and extension constants (todo dynamic import to circumvent minification?)\n  for (const key in GL) {\n    if (!(key in glDebug) && typeof GL[key] === 'number') {\n      glDebug[key] = GL[key];\n    }\n  }\n  \n  // Ensure we have a clean prototype on the instrumented object\n  // Note: setPrototypeOf does come with perf warnings, but we already take a bigger perf reduction\n  // by synchronizing the WebGL errors after each WebGL call.\n  class WebGLDebugContext {}\n  Object.setPrototypeOf(glDebug, Object.getPrototypeOf(gl));\n  Object.setPrototypeOf(WebGLDebugContext, glDebug);\n  const debugContext = Object.create(WebGLDebugContext);\n  // Store the debug context\n  data.realContext = gl;\n  data.debugContext = debugContext;\n  debugContext.debug = true;\n\n  // Return it\n  return debugContext;\n}\n\n// DEBUG TRACING\n\nfunction getFunctionString(functionName: string, functionArgs): string {\n  // Cover bug in webgl-debug-tools\n  functionArgs = Array.from(functionArgs).map(arg => arg === undefined ? 'undefined' : arg);\n  let args = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, functionArgs);\n  args = `${args.slice(0, 100)}${args.length > 100 ? '...' : ''}`;\n  return `gl.${functionName}(${args})`;\n}\n\nfunction onGLError(props: DebugContextProps, err, functionName: string, args: any[]): void {\n  // Cover bug in webgl-debug-tools\n  args = Array.from(args).map(arg => arg === undefined ? 'undefined' : arg);\n  const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);\n  const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);\n  const glName = props.webgl2 ? 'gl2' : 'gl1';\n  const message = `${errorMessage} in ${glName}.${functionName}(${functionArgs})`;\n  log.error(message)();\n  debugger; // eslint-disable-line\n  if (props.throwOnError) {\n    throw new Error(message);\n  }\n}\n\n// Don't generate function string until it is needed\nfunction onValidateGLFunc(props: DebugContextProps, functionName: string, functionArgs: any[]): void {\n  let functionString: string = '';\n  if (log.level >= 1) {\n    functionString = getFunctionString(functionName, functionArgs);\n    log.log(1, functionString)();\n  }\n\n  if (props.break) {\n    functionString = functionString || getFunctionString(functionName, functionArgs);\n    const isBreakpoint =\n      props.break && props.break.every((breakOn: string) => functionString.indexOf(breakOn) !== -1);\n    if (isBreakpoint) {\n      debugger; // eslint-disable-line\n    }\n  }\n\n  for (const arg of functionArgs) {\n    if (arg === undefined) {\n      functionString = functionString || getFunctionString(functionName, functionArgs);\n      if (props.throwOnError) {\n        throw new Error(`Undefined argument: ${functionString}`);\n      } else {\n        log.error(`Undefined argument: ${functionString}`)();\n        debugger; // eslint-disable-line\n      }\n    }\n  }\n}\n"],"file":"webgl-developer-tools.js"}

package/dist/esm/context/parameters/unified-parameter-api.js

@@ -1,63 +0,0 @@
-import { GL_PARAMETER_DEFAULTS, GL_PARAMETER_SETTERS, GL_COMPOSITE_PARAMETER_SETTERS, GL_PARAMETER_GETTERS } from './webgl-parameter-tables';
-import WebGLDevice from '../../adapter/webgl-device';
-export function setParameters(device, parameters) {
-  const webglDevice = WebGLDevice.attach(device);
-  const gl = webglDevice.gl;
-
-  if (isObjectEmpty(parameters)) {
-    return;
-  }
-
-  const compositeSetters = {};
-
-  for (const key in parameters) {
-    const glConstant = Number(key);
-    const setter = GL_PARAMETER_SETTERS[key];
-
-    if (setter) {
-      if (typeof setter === 'string') {
-        compositeSetters[setter] = true;
-      } else {
-        setter(gl, parameters[key], glConstant);
-      }
-    }
-  }
-
-  const cache = gl.state && gl.state.cache;
-
-  if (cache) {
-    for (const key in compositeSetters) {
-      const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key];
-      compositeSetter(gl, parameters, cache);
-    }
-  }
-}
-export function getParameters(gl, parameters = GL_PARAMETER_DEFAULTS) {
-  if (typeof parameters === 'number') {
-    const key = parameters;
-    const getter = GL_PARAMETER_GETTERS[key];
-    return getter ? getter(gl, key) : gl.getParameter(key);
-  }
-
-  const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters);
-  const state = {};
-
-  for (const key of parameterKeys) {
-    const getter = GL_PARAMETER_GETTERS[key];
-    state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key));
-  }
-
-  return state;
-}
-export function resetParameters(gl) {
-  setParameters(gl, GL_PARAMETER_DEFAULTS);
-}
-
-function isObjectEmpty(object) {
-  for (const key in object) {
-    return false;
-  }
-
-  return true;
-}
-//# sourceMappingURL=unified-parameter-api.js.map

package/dist/esm/context/parameters/unified-parameter-api.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/context/parameters/unified-parameter-api.ts"],"names":["GL_PARAMETER_DEFAULTS","GL_PARAMETER_SETTERS","GL_COMPOSITE_PARAMETER_SETTERS","GL_PARAMETER_GETTERS","WebGLDevice","setParameters","device","parameters","webglDevice","attach","gl","isObjectEmpty","compositeSetters","key","glConstant","Number","setter","cache","state","compositeSetter","getParameters","getter","getParameter","parameterKeys","Array","isArray","Object","keys","resetParameters","object"],"mappings":"AAKA,SACEA,qBADF,EAEEC,oBAFF,EAGEC,8BAHF,EAIEC,oBAJF,QAKO,0BALP;AAQA,OAAOC,WAAP,MAAwB,4BAAxB;AAUA,OAAO,SAASC,aAAT,CACLC,MADK,EAELC,UAFK,EAGC;AACN,QAAMC,WAAW,GAAGJ,WAAW,CAACK,MAAZ,CAAmBH,MAAnB,CAApB;AACA,QAAMI,EAAE,GAAGF,WAAW,CAACE,EAAvB;;AAEA,MAAIC,aAAa,CAACJ,UAAD,CAAjB,EAA+B;AAC7B;AACD;;AAED,QAAMK,gBAAgB,GAAG,EAAzB;;AAIA,OAAK,MAAMC,GAAX,IAAkBN,UAAlB,EAA8B;AAC5B,UAAMO,UAAU,GAAGC,MAAM,CAACF,GAAD,CAAzB;AACA,UAAMG,MAAM,GAAGf,oBAAoB,CAACY,GAAD,CAAnC;;AACA,QAAIG,MAAJ,EAAY;AAEV,UAAI,OAAOA,MAAP,KAAkB,QAAtB,EAAgC;AAC9BJ,QAAAA,gBAAgB,CAACI,MAAD,CAAhB,GAA2B,IAA3B;AACD,OAFD,MAEO;AAKLA,QAAAA,MAAM,CAACN,EAAD,EAAKH,UAAU,CAACM,GAAD,CAAf,EAAsBC,UAAtB,CAAN;AACD;AACF;AACF;;AAUD,QAAMG,KAAK,GAAGP,EAAE,CAACQ,KAAH,IAAYR,EAAE,CAACQ,KAAH,CAASD,KAAnC;;AACA,MAAIA,KAAJ,EAAW;AACT,SAAK,MAAMJ,GAAX,IAAkBD,gBAAlB,EAAoC;AAElC,YAAMO,eAAe,GAAGjB,8BAA8B,CAACW,GAAD,CAAtD;AAGAM,MAAAA,eAAe,CAACT,EAAD,EAAKH,UAAL,EAAiBU,KAAjB,CAAf;AACD;AACF;AAGF;AAgBD,OAAO,SAASG,aAAT,CACLV,EADK,EAELH,UAAsE,GAAGP,qBAFpE,EAGS;AAGd,MAAI,OAAOO,UAAP,KAAsB,QAA1B,EAAoC;AAElC,UAAMM,GAAG,GAAGN,UAAZ;AACA,UAAMc,MAAM,GAAGlB,oBAAoB,CAACU,GAAD,CAAnC;AACA,WAAOQ,MAAM,GAAGA,MAAM,CAACX,EAAD,EAAKG,GAAL,CAAT,GAAqBH,EAAE,CAACY,YAAH,CAAgBT,GAAhB,CAAlC;AACD;;AAED,QAAMU,aAAa,GAAGC,KAAK,CAACC,OAAN,CAAclB,UAAd,IAA4BA,UAA5B,GAAyCmB,MAAM,CAACC,IAAP,CAAYpB,UAAZ,CAA/D;AAEA,QAAMW,KAAK,GAAG,EAAd;;AACA,OAAK,MAAML,GAAX,IAAkBU,aAAlB,EAAiC;AAC/B,UAAMF,MAAM,GAAGlB,oBAAoB,CAACU,GAAD,CAAnC;AACAK,IAAAA,KAAK,CAACL,GAAD,CAAL,GAAaQ,MAAM,GAAGA,MAAM,CAACX,EAAD,EAAKK,MAAM,CAACF,GAAD,CAAX,CAAT,GAA6BH,EAAE,CAACY,YAAH,CAAgBP,MAAM,CAACF,GAAD,CAAtB,CAAhD;AACD;;AACD,SAAOK,KAAP;AACD;AAQD,OAAO,SAASU,eAAT,CAAyBlB,EAAzB,EAA0D;AAC/DL,EAAAA,aAAa,CAACK,EAAD,EAAKV,qBAAL,CAAb;AACD;;AAKD,SAASW,aAAT,CAAuBkB,MAAvB,EAA+B;AAC7B,OAAK,MAAMhB,GAAX,IAAkBgB,MAAlB,EAA0B;AACxB,WAAO,KAAP;AACD;;AACD,SAAO,IAAP;AACD","sourcesContent":["// Provides a unified API for getting and setting any WebGL parameter\n// Also knows default values of all parameters, enabling fast cache initialization\n// Provides base functionality for the state caching.\nimport {Device} from '@luma.gl/api';\nimport type {GLParameters} from '../../types/webgl';\nimport {\n  GL_PARAMETER_DEFAULTS,\n  GL_PARAMETER_SETTERS,\n  GL_COMPOSITE_PARAMETER_SETTERS,\n  GL_PARAMETER_GETTERS\n} from './webgl-parameter-tables';\n\nimport {isWebGL} from '../context/webgl-checks';\nimport WebGLDevice from '../../adapter/webgl-device';\n\nexport type {GLParameters};\n\n/**\n * Sets any GL parameter regardless of function (gl.blendMode, ...)\n *\n * @note requires a `cache` object to be set on the context (gl.state.cache)\n * This object is used to fill in any missing values for composite setter functions\n */\nexport function setParameters(\n  device: Device | WebGLRenderingContext,\n  parameters: GLParameters\n): void {\n  const webglDevice = WebGLDevice.attach(device);\n  const gl = webglDevice.gl;\n\n  if (isObjectEmpty(parameters)) {\n    return;\n  }\n\n  const compositeSetters = {};\n\n  // HANDLE PRIMITIVE SETTERS (and make note of any composite setters)\n\n  for (const key in parameters) {\n    const glConstant = Number(key);\n    const setter = GL_PARAMETER_SETTERS[key];\n    if (setter) {\n      // Composite setters should only be called once, so save them\n      if (typeof setter === 'string') {\n        compositeSetters[setter] = true;\n      } else {\n        // if (gl[glConstant] !== undefined) {\n        // TODO - added above check since this is being called on WebGL2 parameters in WebGL1...\n        // TODO - deep equal on values? only call setter if value has changed?\n        // NOTE - the setter will automatically update this.state\n        setter(gl, parameters[key], glConstant);\n      }\n    }\n  }\n\n  // HANDLE COMPOSITE SETTERS\n\n  // NOTE: any non-provided values needed by composite setters are filled in from state cache\n  // The cache parameter is automatically retrieved from the context\n  // This depends on `trackContextState`, which is technically a \"circular\" dependency.\n  // But it is too inconvenient to always require a cache parameter here.\n  // This is the ONLY external dependency in this module/\n  // @ts-expect-error\n  const cache = gl.state && gl.state.cache;\n  if (cache) {\n    for (const key in compositeSetters) {\n      // TODO - avoid calling composite setters if values have not changed.\n      const compositeSetter = GL_COMPOSITE_PARAMETER_SETTERS[key];\n      // Note - if `trackContextState` has been called,\n      // the setter will automatically update this.state.cache\n      compositeSetter(gl, parameters, cache);\n    }\n  }\n\n  // Add a log for the else case?\n}\n\n/**\n * Reads the entire WebGL state from a context\n\n  // default to querying all parameters\n\n  * @returns - a newly created map, with values keyed by GL parameters\n *\n * @note Copies the state from a context (gl.getParameter should not be overriden)\n * Reads the entire WebGL state from a context\n *\n * @note This can generates a huge amount of synchronous driver roundtrips and should be\n * considered a very slow operation, to be used only if/when a context already manipulated\n * by external code needs to be synchronized for the first time\n */\nexport function getParameters(\n  gl: WebGLRenderingContext,\n  parameters: keyof GLParameters | (keyof GLParameters)[] | GLParameters = GL_PARAMETER_DEFAULTS\n): GLParameters {\n  // support both arrays of parameters and objects (keys represent parameters)\n\n  if (typeof parameters === 'number') {\n    // single GL enum\n    const key = parameters;\n    const getter = GL_PARAMETER_GETTERS[key];\n    return getter ? getter(gl, key) : gl.getParameter(key);\n  }\n\n  const parameterKeys = Array.isArray(parameters) ? parameters : Object.keys(parameters);\n\n  const state = {};\n  for (const key of parameterKeys) {\n    const getter = GL_PARAMETER_GETTERS[key];\n    state[key] = getter ? getter(gl, Number(key)) : gl.getParameter(Number(key));\n  }\n  return state;\n}\n\n/**\n * Reset all parameters to a (almost) pure context state\n * @note viewport and scissor will be set to the values in GL_PARAMETER_DEFAULTS,\n * NOT the canvas size dimensions, so they will have to be properly set after\n * calling this function.\n */\nexport function resetParameters(gl: WebGLRenderingContext): void {\n  setParameters(gl, GL_PARAMETER_DEFAULTS);\n}\n\n// Helpers\n\n// Returns true if given object is empty, false otherwise.\nfunction isObjectEmpty(object) {\n  for (const key in object) {\n    return false;\n  }\n  return true;\n}\n"],"file":"unified-parameter-api.js"}

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

@@ -1,445 +0,0 @@
-import GL from '@luma.gl/constants';
-import { isWebGL2 } from '../context/webgl-checks';
-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
-};
-
-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;
-  } else {
-    target = GL.READ_FRAMEBUFFER;
-  }
-
-  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);
-};
-
-function isArray(array) {
-  return Array.isArray(array) || ArrayBuffer.isView(array);
-}
-
-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);
-  },
-  [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,
-  framebuffer: (gl, framebuffer) => {
-    const handle = framebuffer && 'handle' in framebuffer ? framebuffer.handle : framebuffer;
-    return gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
-  },
-  blend: (gl, value) => value ? gl.enable(GL.BLEND) : gl.disable(GL.BLEND),
-  blendColor: (gl, value) => gl.blendColor(...value),
-  blendEquation: (gl, args) => {
-    args = isArray(args) ? args : [args, args];
-    gl.blendEquationSeparate(...args);
-  },
-  blendFunc: (gl, args) => {
-    args = isArray(args) && args.length === 2 ? [...args, ...args] : args;
-    gl.blendFuncSeparate(...args);
-  },
-  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),
-  cullFace: (gl, value) => gl.cullFace(value),
-  depthTest: (gl, value) => value ? gl.enable(GL.DEPTH_TEST) : gl.disable(GL.DEPTH_TEST),
-  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),
-  derivativeHint: (gl, value) => {
-    gl.hint(GL.FRAGMENT_SHADER_DERIVATIVE_HINT, value);
-  },
-  frontFace: (gl, value) => gl.frontFace(value),
-  mipmapHint: (gl, value) => gl.hint(GL.GENERATE_MIPMAP_HINT, value),
-  lineWidth: (gl, value) => gl.lineWidth(value),
-  polygonOffsetFill: (gl, value) => value ? gl.enable(GL.POLYGON_OFFSET_FILL) : gl.disable(GL.POLYGON_OFFSET_FILL),
-  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),
-  scissor: (gl, value) => gl.scissor(...value),
-  stencilTest: (gl, value) => value ? gl.enable(GL.STENCIL_TEST) : gl.disable(GL.STENCIL_TEST),
-  stencilMask: (gl, value) => {
-    value = isArray(value) ? value : [value, value];
-    const [mask, backMask] = value;
-    gl.stencilMaskSeparate(GL.FRONT, mask);
-    gl.stencilMaskSeparate(GL.BACK, 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);
-  },
-  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);
-  },
-  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))
-};
-export const GL_HOOKED_SETTERS = {
-  enable: (update, capability) => update({
-    [capability]: true
-  }),
-  disable: (update, capability) => update({
-    [capability]: false
-  }),
-  pixelStorei: (update, pname, value) => update({
-    [pname]: value
-  }),
-  hint: (update, pname, hint) => update({
-    [pname]: hint
-  }),
-  useProgram: (update, value) => update({
-    [GL.CURRENT_PROGRAM]: value
-  }),
-  bindRenderbuffer: (update, target, value) => update({
-    [GL.RENDERBUFFER_BINDING]: value
-  }),
-  bindTransformFeedback: (update, target, value) => update({
-    [GL.TRANSFORM_FEEDBACK_BINDING]: value
-  }),
-  bindVertexArray: (update, value) => update({
-    [GL.VERTEX_ARRAY_BINDING]: value
-  }),
-  bindFramebuffer: (update, target, framebuffer) => {
-    switch (target) {
-      case GL.FRAMEBUFFER:
-        return update({
-          [GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer,
-          [GL.READ_FRAMEBUFFER_BINDING]: framebuffer
-        });
-
-      case GL.DRAW_FRAMEBUFFER:
-        return update({
-          [GL.DRAW_FRAMEBUFFER_BINDING]: framebuffer
-        });
-
-      case GL.READ_FRAMEBUFFER:
-        return update({
-          [GL.READ_FRAMEBUFFER_BINDING]: 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]
-    }[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])
-  }),
-  blendEquation: (update, mode) => update({
-    [GL.BLEND_EQUATION_RGB]: mode,
-    [GL.BLEND_EQUATION_ALPHA]: mode
-  }),
-  blendEquationSeparate: (update, modeRGB, modeAlpha) => update({
-    [GL.BLEND_EQUATION_RGB]: modeRGB,
-    [GL.BLEND_EQUATION_ALPHA]: 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
-  }),
-  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
-  }),
-  clearColor: (update, r, g, b, a) => update({
-    [GL.COLOR_CLEAR_VALUE]: new Float32Array([r, g, b, a])
-  }),
-  clearDepth: (update, depth) => update({
-    [GL.DEPTH_CLEAR_VALUE]: depth
-  }),
-  clearStencil: (update, s) => update({
-    [GL.STENCIL_CLEAR_VALUE]: s
-  }),
-  colorMask: (update, r, g, b, a) => update({
-    [GL.COLOR_WRITEMASK]: [r, g, b, a]
-  }),
-  cullFace: (update, mode) => update({
-    [GL.CULL_FACE_MODE]: mode
-  }),
-  depthFunc: (update, func) => update({
-    [GL.DEPTH_FUNC]: func
-  }),
-  depthRange: (update, zNear, zFar) => update({
-    [GL.DEPTH_RANGE]: new Float32Array([zNear, zFar])
-  }),
-  depthMask: (update, mask) => update({
-    [GL.DEPTH_WRITEMASK]: mask
-  }),
-  frontFace: (update, face) => update({
-    [GL.FRONT_FACE]: face
-  }),
-  lineWidth: (update, width) => update({
-    [GL.LINE_WIDTH]: width
-  }),
-  polygonOffset: (update, factor, units) => update({
-    [GL.POLYGON_OFFSET_FACTOR]: factor,
-    [GL.POLYGON_OFFSET_UNITS]: units
-  }),
-  sampleCoverage: (update, value, invert) => update({
-    [GL.SAMPLE_COVERAGE_VALUE]: value,
-    [GL.SAMPLE_COVERAGE_INVERT]: invert
-  }),
-  scissor: (update, x, y, width, height) => update({
-    [GL.SCISSOR_BOX]: new Int32Array([x, y, width, height])
-  }),
-  stencilMask: (update, mask) => update({
-    [GL.STENCIL_WRITEMASK]: mask,
-    [GL.STENCIL_BACK_WRITEMASK]: mask
-  }),
-  stencilMaskSeparate: (update, face, mask) => update({
-    [face === GL.FRONT ? GL.STENCIL_WRITEMASK : GL.STENCIL_BACK_WRITEMASK]: 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
-  }),
-  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
-  }),
-  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
-  }),
-  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
-  }),
-  viewport: (update, x, y, width, height) => update({
-    [GL.VIEWPORT]: [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
-};
-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]);
-//# sourceMappingURL=webgl-parameter-tables.js.map