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

package/src/context/context/device-pixels.ts

@@ -1,158 +0,0 @@
-import {log} from '@luma.gl/api';
-import {getContextState} from './context-state';
-
-/**
- * Returns multiplier need to convert CSS size to Device size
- */
-export function cssToDeviceRatio(gl: WebGLRenderingContext): number {
-  const state = getContextState(gl);
-
-  if (gl.canvas && state) {
-    // For headless gl we might have used custom width and height
-    // hence use cached clientWidth
-    const {clientWidth} = state._canvasSizeInfo;
-    return clientWidth ? gl.drawingBufferWidth / clientWidth : 1;
-  }
-  // use default device pixel ratio
-  return 1;
-}
-
-/**
- * Maps CSS pixel position to device pixel position
- */
- export function cssToDevicePixels(
-  gl: WebGLRenderingContext,
-  cssPixel: number[],
-  yInvert: boolean = true
-): {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-} {
-  const ratio = cssToDeviceRatio(gl);
-  const width = gl.drawingBufferWidth;
-  const height = gl.drawingBufferHeight;
-  return scalePixels(cssPixel, ratio, width, height, yInvert);
-}
-
-/**
- * Calulates device pixel ratio, used during context creation
- *
- * @param useDevicePixels - boolean or a number
- * @return - device pixel ratio
- */
- export function getDevicePixelRatio(useDevicePixels: boolean | number): number {
-  const windowRatio = typeof window === 'undefined' ? 1 : window.devicePixelRatio || 1;
-  if (Number.isFinite(useDevicePixels)) {
-    // @ts-expect-error Can no longer be boolean after previous line
-    return useDevicePixels <= 0 ? 1 : useDevicePixels;
-  }
-  return useDevicePixels ? windowRatio : 1;
-}
-
-// use devicePixelRatio to set canvas width and height
-export function setDevicePixelRatio(gl: WebGLRenderingContext, devicePixelRatio: number, options: {width?: number, height?: number} = {}) {
-  if (!(gl.canvas instanceof HTMLCanvasElement)) {
-    return;
-  }
-
-  const canvas: HTMLCanvasElement = gl.canvas;
-
-  // NOTE: if options.width and options.height not used remove in v8
-  let clientWidth = 'width' in options ? options.width : canvas.clientWidth;
-  let clientHeight = 'height' in options ? options.height : canvas.clientHeight;
-
-  if (!clientWidth || !clientHeight) {
-    log.log(1, 'Canvas clientWidth/clientHeight is 0')();
-    // by forcing devicePixel ratio to 1, we do not scale canvas.width and height in each frame.
-    devicePixelRatio = 1;
-    clientWidth = canvas.width || 1;
-    clientHeight = canvas.height || 1;
-  }
-
-  const contextState = getContextState(gl);
-  const cachedSize = contextState._canvasSizeInfo;
-  // Check if canvas needs to be resized
-  if (
-    cachedSize.clientWidth !== clientWidth ||
-    cachedSize.clientHeight !== clientHeight ||
-    cachedSize.devicePixelRatio !== devicePixelRatio
-  ) {
-    let clampedPixelRatio = devicePixelRatio;
-
-    const canvasWidth = Math.floor(clientWidth * clampedPixelRatio);
-    const canvasHeight = Math.floor(clientHeight * clampedPixelRatio);
-    canvas.width = canvasWidth;
-    canvas.height = canvasHeight;
-
-    // Note: when devicePixelRatio is too high, it is possible we might hit system limit for
-    // drawing buffer width and hight, in those cases they get clamped and resulting aspect ration may not be maintained
-    // for those cases, reduce devicePixelRatio.
-    if (gl.drawingBufferWidth !== canvasWidth || gl.drawingBufferHeight !== canvasHeight) {
-      log.warn(`Device pixel ratio clamped`)();
-      clampedPixelRatio = Math.min(
-        gl.drawingBufferWidth / clientWidth,
-        gl.drawingBufferHeight / clientHeight
-      );
-
-      canvas.width = Math.floor(clientWidth * clampedPixelRatio);
-      canvas.height = Math.floor(clientHeight * clampedPixelRatio);
-    }
-
-    Object.assign(contextState._canvasSizeInfo, {clientWidth, clientHeight, devicePixelRatio});
-  }
-}
-
-
-// PRIVATE
-
-function scalePixels(pixel: number[], ratio: number, width: number, height: number, yInvert: boolean): {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-} {
-  const x = scaleX(pixel[0], ratio, width);
-  let y = scaleY(pixel[1], ratio, height, yInvert);
-
-  // Find boundaries of next pixel to provide valid range of device pixel locaitons
-
-  let t = scaleX(pixel[0] + 1, ratio, width);
-  // If next pixel's position is clamped to boundary, use it as is, otherwise subtract 1 for current pixel boundary
-  const xHigh = t === width - 1 ? t : t - 1;
-
-  t = scaleY(pixel[1] + 1, ratio, height, yInvert);
-  let yHigh;
-  if (yInvert) {
-    // If next pixel's position is clamped to boundary, use it as is, otherwise clamp it to valid range
-    t = t === 0 ? t : t + 1;
-    // swap y and yHigh
-    yHigh = y;
-    y = t;
-  } else {
-    // If next pixel's position is clamped to boundary, use it as is, otherwise clamp it to valid range
-    yHigh = t === height - 1 ? t : t - 1;
-    // y remains same
-  }
-  return {
-    x,
-    y,
-    // when ratio < 1, current css pixel and next css pixel may point to same device pixel, set width/height to 1 in those cases.
-    width: Math.max(xHigh - x + 1, 1),
-    height: Math.max(yHigh - y + 1, 1)
-  };
-}
-
-function scaleX(x: number, ratio: number, width: number): number {
-  // since we are rounding to nearest, when ratio > 1, edge pixels may point to out of bounds value, clamp to the limit
-  const r = Math.min(Math.round(x * ratio), width - 1);
-  return r;
-}
-
-function scaleY(y: number, ratio: number, height: number, yInvert: boolean): number {
-  // since we are rounding to nearest, when ratio > 1, edge pixels may point to out of bounds value, clamp to the limit
-  return yInvert
-    ? Math.max(0, height - 1 - Math.round(y * ratio))
-    : Math.min(Math.round(y * ratio), height - 1);
-}

package/src/context/context/webgl-checks.ts

@@ -1,49 +0,0 @@
-// luma.gl, MIT license
-import {assert} from '@luma.gl/api';
-
-const ERR_CONTEXT = 'Invalid WebGLRenderingContext';
-export const ERR_WEBGL = ERR_CONTEXT;
-export const ERR_WEBGL2 = 'Requires WebGL2';
-
-
-/** Check if supplied parameter is a WebGLRenderingContext */
-export function isWebGL(gl: any): boolean {
-  if (typeof WebGLRenderingContext !== 'undefined' && gl instanceof WebGLRenderingContext) {
-    return true;
-  }
-  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
-    return true;
-  }
-  // Look for debug contexts, headless gl etc
-  return Boolean(gl && Number.isFinite(gl._version));
-}
-
-
-/** Check if supplied parameter is a WebGL2RenderingContext */
-export function isWebGL2(gl: any): boolean {
-  if (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) {
-    return true;
-  }
-  // Look for debug contexts, headless gl etc
-  return Boolean(gl && gl._version === 2);
-}
-
-
-/** Returns a properly typed WebGL2RenderingContext from a WebGL1 context, or null */
-export function getWebGL2Context(gl: WebGLRenderingContext): WebGL2RenderingContext | null {
-  // @ts-expect-error
-  return isWebGL2(gl) ? gl : null;
-}
-
-
-/** Throw if supplied parameter is not a WebGLRenderingContext, otherwise return properly typed value */
-export function assertWebGLContext(gl: any): WebGLRenderingContext {
-  assert(isWebGL(gl), ERR_CONTEXT);
-  return gl;
-}
-
-/** Throw if supplied parameter is not a WebGL2RenderingContext, otherwise return properly typed value */
-export function assertWebGL2Context(gl: any): WebGL2RenderingContext {
-  assert(isWebGL2(gl), ERR_WEBGL2);
-  return gl;
-}

package/src/context/polyfill/get-parameter-polyfill.ts

@@ -1,118 +0,0 @@
-/* eslint-disable no-inline-comments, max-len, camelcase */
-import GL from '@luma.gl/constants';
-import {isWebGL2} from '../context/webgl-checks';
-
-const OES_element_index = 'OES_element_index';
-const WEBGL_draw_buffers = 'WEBGL_draw_buffers';
-const EXT_disjoint_timer_query = 'EXT_disjoint_timer_query';
-const EXT_disjoint_timer_query_webgl2 = 'EXT_disjoint_timer_query_webgl2';
-const EXT_texture_filter_anisotropic = 'EXT_texture_filter_anisotropic';
-const WEBGL_debug_renderer_info = 'WEBGL_debug_renderer_info';
-
-const GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8b8b;
-const GL_DONT_CARE = 0x1100;
-const GL_GPU_DISJOINT_EXT = 0x8fbb;
-const GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84ff;
-const GL_UNMASKED_VENDOR_WEBGL = 0x9245; // vendor string of the graphics driver.
-const GL_UNMASKED_RENDERER_WEBGL = 0x9246; // renderer string of the graphics driver.
-
-const getWebGL2ValueOrZero = (gl) => (!isWebGL2(gl) ? 0 : undefined);
-
-// if a function returns undefined in this table,
-// the original getParameter will be called, defeating the override
-const WEBGL_PARAMETERS = {
-  [GL.READ_BUFFER]: (gl) => (!isWebGL2(gl) ? GL.COLOR_ATTACHMENT0 : undefined),
-
-  // WebGL2 context parameters
-  [GL_FRAGMENT_SHADER_DERIVATIVE_HINT]: (gl) => (!isWebGL2(gl) ? GL_DONT_CARE : undefined),
-
-  [GL.RASTERIZER_DISCARD]: getWebGL2ValueOrZero,
-
-  [GL.SAMPLES]: getWebGL2ValueOrZero,
-
-  // WebGL2 extension context parameters
-  [GL_GPU_DISJOINT_EXT]: (gl, getParameter) => {
-    const ext = isWebGL2(gl)
-      ? gl.getExtension(EXT_disjoint_timer_query_webgl2)
-      : gl.getExtension(EXT_disjoint_timer_query);
-    return ext && ext.GPU_DISJOINT_EXT ? getParameter(ext.GPU_DISJOINT_EXT) : 0;
-  },
-
-  // Extension fixed values
-  [GL_UNMASKED_VENDOR_WEBGL]: (gl, getParameter) => {
-    const ext = gl.getExtension(WEBGL_debug_renderer_info);
-    return getParameter((ext && ext.UNMASKED_VENDOR_WEBGL) || GL.VENDOR);
-  },
-
-  [GL_UNMASKED_RENDERER_WEBGL]: (gl, getParameter) => {
-    const ext = gl.getExtension(WEBGL_debug_renderer_info);
-    return getParameter((ext && ext.UNMASKED_RENDERER_WEBGL) || GL.RENDERER);
-  },
-
-  // Extension LIMITS
-  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => {
-    const ext = gl.luma?.extensions?.[EXT_texture_filter_anisotropic] ||
-      gl.getExtension('EXT_texture_filter_anisotropic');
-    return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1.0;
-  },
-
-  // WebGL2 Limits
-  [GL.MAX_3D_TEXTURE_SIZE]: getWebGL2ValueOrZero,
-  [GL.MAX_ARRAY_TEXTURE_LAYERS]: getWebGL2ValueOrZero,
-  [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: getWebGL2ValueOrZero,
-  [GL.MAX_COLOR_ATTACHMENTS]: (gl, getParameter) => {
-    if (!isWebGL2(gl)) {
-      const ext = gl.getExtension(WEBGL_draw_buffers);
-      return ext ? getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 0;
-    }
-    return undefined;
-  },
-  [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_COMBINED_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
-  [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_DRAW_BUFFERS]: (gl) => {
-    if (!isWebGL2(gl)) {
-      const ext = gl.getExtension(WEBGL_draw_buffers);
-      return ext ? ext.MAX_DRAW_BUFFERS_WEBGL : 0;
-    }
-    return undefined;
-  },
-  [GL.MAX_ELEMENT_INDEX]:
-    // Guess: per webglstats.com 99.6% of webgl2 supports 2147483647
-    (gl) => (gl.getExtension(OES_element_index) ? 2147483647 : 65535),
-  [GL.MAX_ELEMENTS_INDICES]:
-    // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
-    (gl) => (gl.getExtension(OES_element_index) ? 16777216 : 65535),
-  [GL.MAX_ELEMENTS_VERTICES]:
-    // Guess: "Reasonably safe" per webglstats.com - could be higher/lower (on some mobile devices)
-    (gl) => 16777216,
-  [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
-  [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_SAMPLES]: getWebGL2ValueOrZero,
-  [GL.MAX_SERVER_WAIT_TIMEOUT]: getWebGL2ValueOrZero,
-  [GL.MAX_TEXTURE_LOD_BIAS]: getWebGL2ValueOrZero,
-  [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: getWebGL2ValueOrZero,
-  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_UNIFORM_BLOCK_SIZE]: getWebGL2ValueOrZero,
-  [GL.MAX_UNIFORM_BUFFER_BINDINGS]: getWebGL2ValueOrZero,
-  [GL.MAX_VARYING_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MAX_VERTEX_UNIFORM_BLOCKS]: getWebGL2ValueOrZero,
-  [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: getWebGL2ValueOrZero,
-  [GL.MIN_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
-  [GL.MAX_PROGRAM_TEXEL_OFFSET]: getWebGL2ValueOrZero,
-  [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: getWebGL2ValueOrZero
-};
-
-// A "replacement" gl.getParameter that accepts "enums" from extensions and WebGL2
-// and returns reasonably safe defaults
-export function getParameterPolyfill(gl, originalGetParameter, pname) {
-  // Return mock limits (usually 0) for WebGL2 constants to ensure these
-  // can be queries without error
-  const limit = WEBGL_PARAMETERS[pname];
-  const value = typeof limit === 'function' ? limit(gl, originalGetParameter, pname) : limit;
-  const result = value !== undefined ? value : originalGetParameter(pname);
-  return result;
-}

package/src/context/polyfill/polyfill-context.ts

@@ -1,97 +0,0 @@
-// WebGL1/WebGL2 extension polyfill support
-//
-// Provides a function that creates polyfills for WebGL2 functions based
-// on available extensions and installs them on a supplied target (could be
-// the WebGLContext or its prototype, or a separate object).
-//
-// This is intended to be a stand-alone file with minimal dependencies,
-// easy to reuse or repurpose in other projects.
-
-import {assert} from '@luma.gl/api';
-import {polyfillVertexArrayObject} from './polyfill-vertex-array-object';
-
-import {WEBGL2_CONTEXT_POLYFILLS, WEBGL2_CONTEXT_OVERRIDES} from './polyfill-table';
-import {getContextState} from '../context/context-state';
-
-/**
- * Registers extensions, polyfills or mock functions for extensions in the polyfills list
- */
-export function polyfillContext(gl: WebGLRenderingContext): WebGL2RenderingContext {
-  const contextState = getContextState(gl);
-
-  if (!contextState._polyfilled) {
-    polyfillVertexArrayObject(gl);
-    initializeExtensions(gl);
-    installPolyfills(gl, WEBGL2_CONTEXT_POLYFILLS);
-    installOverrides(gl, {target: contextState, target2: gl});
-    contextState._polyfilled = true;
-  }
-
-  // Note - only supports a subset of WebGL2
-  return gl as WebGL2RenderingContext;
-}
-
-function initializeExtensions(gl: WebGLRenderingContext): void {
-  const contextState = getContextState(gl);
-  // `getSupportedExtensions` can return null when context is lost.
-  const EXTENSIONS = gl.getSupportedExtensions() || [];
-  for (const extensionName of EXTENSIONS) {
-    const extension = gl.getExtension(extensionName);
-    contextState._extensions[extensionName] = extension;
-  }
-}
-
-function installPolyfills(gl: WebGLRenderingContext, polyfills): void {
-  const contextState = getContextState(gl);
-  for (const extension of Object.getOwnPropertyNames(polyfills)) {
-    if (extension !== 'overrides') {
-      polyfillExtension(gl, {extension, target: contextState, target2: gl});
-    }
-  }
-}
-
-/** Polyfills a single WebGL extension into the `target` object */
-function polyfillExtension(gl: WebGLRenderingContext, {extension, target, target2}): void {
-  const defaults = WEBGL2_CONTEXT_POLYFILLS[extension];
-  assert(defaults);
-
-  const {meta = {}} = defaults;
-  const {suffix = ''} = meta;
-
-  const ext = gl.getExtension(extension);
-
-  for (const key of Object.keys(defaults)) {
-    const extKey = `${key}${suffix}`;
-
-    let polyfill: Function | null = null;
-    if (key === 'meta') {
-      // ignore
-    } else if (typeof gl[key] === 'function') {
-      // WebGL2 implementation is already
-    } else if (ext && typeof ext[extKey] === 'function') {
-      // pick extension implementation,if available
-      polyfill = (...args) => ext[extKey](...args);
-    } else if (typeof defaults[key] === 'function') {
-      // pick the mock implementation, if no implementation was detected
-      polyfill = defaults[key].bind(target);
-    }
-
-    if (polyfill) {
-      target[key] = polyfill;
-      target2[key] = polyfill;
-    }
-  }
-}
-
-/** Install simple overrides (mostly get* functions) */
-function installOverrides(gl, {target, target2}) {
-  Object.keys(WEBGL2_CONTEXT_OVERRIDES).forEach((key) => {
-    if (typeof WEBGL2_CONTEXT_OVERRIDES[key] === 'function') {
-      // install an override, if no implementation was detected
-      const originalFunc = gl[key] ? gl[key].bind(gl) : () => {};
-      const polyfill = WEBGL2_CONTEXT_OVERRIDES[key].bind(null, gl, originalFunc);
-      target[key] = polyfill;
-      target2[key] = polyfill;
-    }
-  });
-}

package/src/context/polyfill/polyfill-table.ts

@@ -1,162 +0,0 @@
-import {assert} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import {isWebGL2} from '../context/webgl-checks';
-
-import {getParameterPolyfill} from './get-parameter-polyfill';
-import {getContextState} from '../context/context-state';
-
-const OES_vertex_array_object = 'OES_vertex_array_object';
-const ANGLE_instanced_arrays = 'ANGLE_instanced_arrays';
-const WEBGL_draw_buffers = 'WEBGL_draw_buffers';
-const EXT_disjoint_timer_query = 'EXT_disjoint_timer_query';
-const EXT_texture_filter_anisotropic = 'EXT_texture_filter_anisotropic';
-
-const ERR_VAO_NOT_SUPPORTED = 'VertexArray requires WebGL2 or OES_vertex_array_object extension';
-
-// Return object with webgl2 flag and an extension
-function getExtensionData(gl, extension) {
-  return {
-    webgl2: isWebGL2(gl),
-    ext: gl.getExtension(extension)
-  };
-}
-
-// function mapExtensionConstant(gl, constant) {
-//   switch (constant) {
-//   case ext.FRAGMENT_SHADER_DERIVATIVE_HINT_OES: return GL.FRAGMENT_SHADER_DERIVATIVE_HINT;
-//   }
-// }
-
-export const WEBGL2_CONTEXT_POLYFILLS = {
-  // POLYFILL TABLE
-  [OES_vertex_array_object]: {
-    meta: {suffix: 'OES'},
-    // NEW METHODS
-    createVertexArray: () => {
-      assert(false, ERR_VAO_NOT_SUPPORTED);
-    },
-    deleteVertexArray: () => {},
-    bindVertexArray: () => {},
-    isVertexArray: () => false
-  },
-  [ANGLE_instanced_arrays]: {
-    meta: {
-      suffix: 'ANGLE'
-      // constants: {
-      //   VERTEX_ATTRIB_ARRAY_DIVISOR: 'VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE'
-      // }
-    },
-    vertexAttribDivisor(location, divisor) {
-      // Accept divisor 0 even if instancing is not supported (0 = no instancing)
-      assert(divisor === 0, 'WebGL instanced rendering not supported');
-    },
-    drawElementsInstanced: () => {},
-    drawArraysInstanced: () => {}
-  },
-  [WEBGL_draw_buffers]: {
-    meta: {
-      suffix: 'WEBGL'
-    },
-    drawBuffers: () => {
-      assert(false);
-    }
-  },
-  [EXT_disjoint_timer_query]: {
-    meta: {suffix: 'EXT'},
-    // WebGL1: Polyfills the WebGL2 Query API
-    createQuery: () => {
-      assert(false);
-    },
-    deleteQuery: () => {
-      assert(false);
-    },
-    beginQuery: () => {
-      assert(false);
-    },
-    endQuery: () => {},
-    getQuery(handle, pname) {
-      return this.getQueryObject(handle, pname);
-    },
-    // The WebGL1 extension uses getQueryObject rather then getQueryParameter
-    getQueryParameter(handle, pname) {
-      return this.getQueryObject(handle, pname);
-    },
-    getQueryObject: (handle: unknown, pname: unknown) => {}
-  }
-};
-
-export const WEBGL2_CONTEXT_OVERRIDES = {
-  // Ensure readBuffer is a no-op
-  readBuffer: (gl, originalFunc, attachment) => {
-    if (isWebGL2(gl)) {
-      originalFunc(attachment);
-    } else {
-      // assert(attachment !== GL_COLOR_ATTACHMENT0 && attachment !== GL_FRONT);
-    }
-  },
-  // Override for getVertexAttrib that returns sane values for non-WebGL1 constants
-  getVertexAttrib: (gl, originalFunc, location, pname) => {
-    // const gl = this; // eslint-disable-line
-    const {webgl2, ext} = getExtensionData(gl, ANGLE_instanced_arrays);
-
-    let result;
-    switch (pname) {
-      // WebGL1 attributes will never be integer
-      case GL.VERTEX_ATTRIB_ARRAY_INTEGER:
-        result = !webgl2 ? false : undefined;
-        break;
-      // if instancing is not available, return 0 meaning divisor has not been set
-      case GL.VERTEX_ATTRIB_ARRAY_DIVISOR:
-        result = !webgl2 && !ext ? 0 : undefined;
-        break;
-      default:
-    }
-
-    return result !== undefined ? result : originalFunc(location, pname);
-  },
-  // Handle transform feedback and uniform block queries in WebGL1
-  getProgramParameter: (gl, originalFunc, program, pname) => {
-    if (!isWebGL2(gl)) {
-      switch (pname) {
-        case GL.TRANSFORM_FEEDBACK_BUFFER_MODE:
-          return GL.SEPARATE_ATTRIBS;
-        case GL.TRANSFORM_FEEDBACK_VARYINGS:
-          return 0;
-        case GL.ACTIVE_UNIFORM_BLOCKS:
-          return 0;
-        default:
-      }
-    }
-    return originalFunc(program, pname);
-  },
-  getInternalformatParameter: (gl, originalFunc, target, format, pname) => {
-    if (!isWebGL2(gl)) {
-      switch (pname) {
-        case GL.SAMPLES:
-          return new Int32Array([0]);
-        default:
-      }
-    }
-    return gl.getInternalformatParameter(target, format, pname);
-  },
-  getTexParameter(gl, originalFunc, target, pname) {
-    switch (pname) {
-      case GL.TEXTURE_MAX_ANISOTROPY_EXT:
-        const contextState = getContextState(gl);
-        const {_extensions} = contextState;
-        const ext = _extensions[EXT_texture_filter_anisotropic];
-        pname = (ext && ext.TEXTURE_MAX_ANISOTROPY_EXT) || GL.TEXTURE_MAX_ANISOTROPY_EXT;
-        break;
-      default:
-    }
-    return originalFunc(target, pname);
-  },
-  getParameter: getParameterPolyfill,
-  hint(gl, originalFunc, pname, value) {
-    // TODO - handle GL.FRAGMENT_SHADER_DERIVATIVE_HINT:
-    // switch (pname) {
-    // case GL.FRAGMENT_SHADER_DERIVATIVE_HINT:
-    // }
-    return originalFunc(pname, value);
-  }
-};