@luma.gl/webgl 9.0.0-beta.4 → 9.0.0-beta.6

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

@@ -1,104 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-
-// 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/core';
-import {polyfillVertexArrayObject} from './polyfill-vertex-array-object';
-
-import {WEBGL2_CONTEXT_POLYFILLS, WEBGL2_CONTEXT_OVERRIDES} from './polyfill-table';
-import {getContextData} from './context-data';
-
-/**
- * Registers extensions, polyfills or mock functions for extensions in the polyfills list
- */
-export function polyfillContext(gl: WebGLRenderingContext): WebGL2RenderingContext {
-  const contextState = getContextData(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 = getContextData(gl);
-  // `getSupportedExtensions` can return null when context is lost.
-  const EXTENSIONS = gl.getSupportedExtensions() || [];
-  // Generates warnings in Chrome
-  const IGNORE_EXTENSIONS = ['WEBGL_polygon_mode'];
-  for (const extensionName of EXTENSIONS) {
-    if (!IGNORE_EXTENSIONS.includes(extensionName)) {
-      const extension = gl.getExtension(extensionName);
-      contextState._extensions[extensionName] = extension;
-    }
-  }
-}
-
-function installPolyfills(gl: WebGLRenderingContext, polyfills): void {
-  const contextState = getContextData(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: WebGLRenderingContext, {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,167 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-
-import {assert} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
-import {isWebGL2} from '../context/webgl-checks';
-
-import {getParameterPolyfill} from './get-parameter-polyfill';
-import {getContextData} from './context-data';
-
-/* eslint-disable camelcase */
-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: WebGLRenderingContext, extension: string) {
-  return {
-    webgl2: isWebGL2(gl),
-    ext: gl.getExtension(extension)
-  };
-}
-
-// function mapExtensionConstant(gl: WebGLRenderingContext, 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: number, divisor: number) {
-      // 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: string) {
-      return this.getQueryObject(handle, pname);
-    },
-    // The WebGL1 extension uses getQueryObject rather then getQueryParameter
-    getQueryParameter(handle, pname: string) {
-      return this.getQueryObject(handle, pname);
-    },
-    getQueryObject: (handle: unknown, pname: unknown) => {}
-  }
-};
-
-export const WEBGL2_CONTEXT_OVERRIDES = {
-  // Ensure readBuffer is a no-op
-  readBuffer: (gl: WebGLRenderingContext, 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: WebGLRenderingContext, 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: WebGLRenderingContext, 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: WebGLRenderingContext, originalFunc, target, format, pname) => {
-    if (!isWebGL2(gl)) {
-      switch (pname) {
-        case GL.SAMPLES:
-          return new Int32Array([0]);
-        default:
-      }
-    }
-    const gl2 = gl as WebGL2RenderingContext;
-    return gl2.getInternalformatParameter(target, format, pname);
-  },
-  getTexParameter(gl, originalFunc, target, pname) {
-    switch (pname) {
-      case GL.TEXTURE_MAX_ANISOTROPY_EXT:
-        const contextData = getContextData(gl);
-        const {_extensions} = contextData;
-        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);
-  }
-};

package/src/context/polyfill/polyfill-vertex-array-object.ts

@@ -1,365 +0,0 @@
-// luma.gl, MIT license
-// Copyright (c) vis.gl contributors
-
-/*
- ** 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.
- */
-
-// Modified to use ES6 and polyfill a provided context rather than
-// the global class.
-
-// @ts-nocheck external code
-/* eslint-disable */ 
-
-const glErrorShadow = {};
-
-function error(msg) {
-  if (globalThis.console && globalThis.console.error) {
-    globalThis.console.error(msg);
-  }
-}
-
-function log(msg) {
-  if (globalThis.console && globalThis.console.log) {
-    globalThis.console.log(msg);
-  }
-}
-
-function synthesizeGLError(err, opt_msg) {
-  glErrorShadow[err] = true;
-  if (opt_msg !== undefined) {
-    error(opt_msg);
-  }
-}
-
-function wrapGLError(gl) {
-  const f = gl.getError;
-  gl.getError = function getError() {
-    let err;
-    do {
-      err = f.apply(gl);
-      if (err !== gl.NO_ERROR) {
-        glErrorShadow[err] = true;
-      }
-    } while (err !== gl.NO_ERROR);
-
-    for (err in glErrorShadow) {
-      if (glErrorShadow[err]) {
-        delete glErrorShadow[err];
-        return parseInt(err, 10);
-      }
-    }
-
-    return gl.NO_ERROR;
-  };
-}
-
-const WebGLVertexArrayObjectOES = function WebGLVertexArrayObjectOES(ext) {
-  const gl = ext.gl;
-
-  this.ext = ext;
-  this.isAlive = true;
-  this.hasBeenBound = false;
-
-  this.elementArrayBuffer = null;
-  this.attribs = new Array(ext.maxVertexAttribs);
-  for (let n = 0; n < this.attribs.length; n++) {
-    const attrib = new WebGLVertexArrayObjectOES.VertexAttrib(gl);
-    this.attribs[n] = attrib;
-  }
-
-  this.maxAttrib = 0;
-};
-
-WebGLVertexArrayObjectOES.VertexAttrib = function VertexAttrib(gl) {
-  this.enabled = false;
-  this.buffer = null;
-  this.size = 4;
-  this.type = gl.FLOAT;
-  this.normalized = false;
-  this.stride = 16;
-  this.offset = 0;
-
-  this.cached = '';
-  this.recache();
-};
-WebGLVertexArrayObjectOES.VertexAttrib.prototype.recache = function recache() {
-  this.cached = [this.size, this.type, this.normalized, this.stride, this.offset].join(':');
-};
-
-const OESVertexArrayObject = function OESVertexArrayObject(gl) {
-  // eslint-disable-next-line @typescript-eslint/no-this-alias
-  const self = this;
-  this.gl = gl;
-
-  wrapGLError(gl);
-
-  const original = (this.original = {
-    getParameter: gl.getParameter,
-    enableVertexAttribArray: gl.enableVertexAttribArray,
-    disableVertexAttribArray: gl.disableVertexAttribArray,
-    bindBuffer: gl.bindBuffer,
-    getVertexAttrib: gl.getVertexAttrib,
-    vertexAttribPointer: gl.vertexAttribPointer
-  });
-
-  gl.getParameter = function getParameter(pname) {
-    if (pname === self.VERTEX_ARRAY_BINDING_OES) {
-      if (self.currentVertexArrayObject === self.defaultVertexArrayObject) {
-        return null;
-      }
-      return self.currentVertexArrayObject;
-    }
-    return original.getParameter.apply(this, arguments);
-  };
-
-  gl.enableVertexAttribArray = function enableVertexAttribArray(index) {
-    const vao = self.currentVertexArrayObject;
-    vao.maxAttrib = Math.max(vao.maxAttrib, index);
-    const attrib = vao.attribs[index];
-    attrib.enabled = true;
-    return original.enableVertexAttribArray.apply(this, arguments);
-  };
-  gl.disableVertexAttribArray = function disableVertexAttribArray(index) {
-    const vao = self.currentVertexArrayObject;
-    vao.maxAttrib = Math.max(vao.maxAttrib, index);
-    const attrib = vao.attribs[index];
-    attrib.enabled = false;
-    return original.disableVertexAttribArray.apply(this, arguments);
-  };
-
-  gl.bindBuffer = function bindBuffer(target, buffer) {
-    switch (target) {
-      case gl.ARRAY_BUFFER:
-        self.currentArrayBuffer = buffer;
-        break;
-      case gl.ELEMENT_ARRAY_BUFFER:
-        self.currentVertexArrayObject.elementArrayBuffer = buffer;
-        break;
-      default:
-    }
-    return original.bindBuffer.apply(this, arguments);
-  };
-
-  gl.getVertexAttrib = function getVertexAttrib(index, pname) {
-    const vao = self.currentVertexArrayObject;
-    const attrib = vao.attribs[index];
-    switch (pname) {
-      case gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
-        return attrib.buffer;
-      case gl.VERTEX_ATTRIB_ARRAY_ENABLED:
-        return attrib.enabled;
-      case gl.VERTEX_ATTRIB_ARRAY_SIZE:
-        return attrib.size;
-      case gl.VERTEX_ATTRIB_ARRAY_STRIDE:
-        return attrib.stride;
-      case gl.VERTEX_ATTRIB_ARRAY_TYPE:
-        return attrib.type;
-      case gl.VERTEX_ATTRIB_ARRAY_NORMALIZED:
-        return attrib.normalized;
-      default:
-        return original.getVertexAttrib.apply(this, arguments);
-    }
-  };
-
-  // eslint-disable-next-line max-params
-  gl.vertexAttribPointer = function vertexAttribPointer(
-    indx,
-    size,
-    type,
-    normalized,
-    stride,
-    offset
-  ) {
-    const vao = self.currentVertexArrayObject;
-    vao.maxAttrib = Math.max(vao.maxAttrib, indx);
-    const attrib = vao.attribs[indx];
-    attrib.buffer = self.currentArrayBuffer;
-    attrib.size = size;
-    attrib.type = type;
-    attrib.normalized = normalized;
-    attrib.stride = stride;
-    attrib.offset = offset;
-    attrib.recache();
-    return original.vertexAttribPointer.apply(this, arguments);
-  };
-
-  if (gl.instrumentExtension) {
-    gl.instrumentExtension(this, 'OES_vertex_array_object');
-  }
-
-  // undefined for headless gl
-  if (gl.canvas) {
-    gl.canvas.addEventListener(
-      'webglcontextrestored',
-      () => {
-        log('OESVertexArrayObject emulation library context restored');
-        self.reset_();
-      },
-      true
-    );
-  }
-
-  this.reset_();
-};
-
-OESVertexArrayObject.prototype.VERTEX_ARRAY_BINDING_OES = 0x85b5;
-
-OESVertexArrayObject.prototype.reset_ = function reset_() {
-  const contextWasLost = this.vertexArrayObjects !== undefined;
-  if (contextWasLost) {
-    for (let ii = 0; ii < this.vertexArrayObjects.length; ++ii) {
-      this.vertexArrayObjects.isAlive = false;
-    }
-  }
-  const gl = this.gl;
-  this.maxVertexAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
-
-  this.defaultVertexArrayObject = new WebGLVertexArrayObjectOES(this);
-  this.currentVertexArrayObject = null;
-  this.currentArrayBuffer = null;
-  this.vertexArrayObjects = [this.defaultVertexArrayObject];
-
-  this.bindVertexArrayOES(null);
-};
-
-OESVertexArrayObject.prototype.createVertexArrayOES = function createVertexArrayOES() {
-  const arrayObject = new WebGLVertexArrayObjectOES(this);
-  this.vertexArrayObjects.push(arrayObject);
-  return arrayObject;
-};
-
-OESVertexArrayObject.prototype.deleteVertexArrayOES = function deleteVertexArrayOES(arrayObject) {
-  arrayObject.isAlive = false;
-  this.vertexArrayObjects.splice(this.vertexArrayObjects.indexOf(arrayObject), 1);
-  if (this.currentVertexArrayObject === arrayObject) {
-    this.bindVertexArrayOES(null);
-  }
-};
-
-OESVertexArrayObject.prototype.isVertexArrayOES = function isVertexArrayOES(arrayObject) {
-  if (arrayObject && arrayObject instanceof WebGLVertexArrayObjectOES) {
-    if (arrayObject.hasBeenBound && arrayObject.ext === this) {
-      return true;
-    }
-  }
-  return false;
-};
-
-OESVertexArrayObject.prototype.bindVertexArrayOES = function bindVertexArrayOES(arrayObject) {
-  const gl = this.gl;
-  if (arrayObject && !arrayObject.isAlive) {
-    synthesizeGLError(
-      gl.INVALID_OPERATION,
-      'bindVertexArrayOES: attempt to bind deleted arrayObject'
-    );
-    return;
-  }
-  const original = this.original;
-
-  const oldVAO = this.currentVertexArrayObject;
-  this.currentVertexArrayObject = arrayObject || this.defaultVertexArrayObject;
-  this.currentVertexArrayObject.hasBeenBound = true;
-  const newVAO = this.currentVertexArrayObject;
-
-  if (oldVAO === newVAO) {
-    return;
-  }
-
-  if (!oldVAO || newVAO.elementArrayBuffer !== oldVAO.elementArrayBuffer) {
-    original.bindBuffer.call(gl, gl.ELEMENT_ARRAY_BUFFER, newVAO.elementArrayBuffer);
-  }
-
-  let currentBinding = this.currentArrayBuffer;
-  const maxAttrib = Math.max(oldVAO ? oldVAO.maxAttrib : 0, newVAO.maxAttrib);
-  for (let n = 0; n <= maxAttrib; n++) {
-    const attrib = newVAO.attribs[n];
-    const oldAttrib = oldVAO ? oldVAO.attribs[n] : null;
-
-    if (!oldVAO || attrib.enabled !== oldAttrib.enabled) {
-      if (attrib.enabled) {
-        original.enableVertexAttribArray.call(gl, n);
-      } else {
-        original.disableVertexAttribArray.call(gl, n);
-      }
-    }
-
-    if (attrib.enabled) {
-      let bufferChanged = false;
-      if (!oldVAO || attrib.buffer !== oldAttrib.buffer) {
-        if (currentBinding !== attrib.buffer) {
-          original.bindBuffer.call(gl, gl.ARRAY_BUFFER, attrib.buffer);
-          currentBinding = attrib.buffer;
-        }
-        bufferChanged = true;
-      }
-
-      if (bufferChanged || attrib.cached !== oldAttrib.cached) {
-        original.vertexAttribPointer.call(
-          gl,
-          n,
-          attrib.size,
-          attrib.type,
-          attrib.normalized,
-          attrib.stride,
-          attrib.offset
-        );
-      }
-    }
-  }
-
-  if (this.currentArrayBuffer !== currentBinding) {
-    original.bindBuffer.call(gl, gl.ARRAY_BUFFER, this.currentArrayBuffer);
-  }
-};
-
-export function polyfillVertexArrayObject(gl) {
-  if (typeof gl.createVertexArray === 'function') {
-    // VAOs directly supported on object (i.e. WebGL 2 context)
-    return;
-  }
-
-  const original_getSupportedExtensions = gl.getSupportedExtensions;
-  gl.getSupportedExtensions = function getSupportedExtensions() {
-    const list = original_getSupportedExtensions.call(this) || [];
-    if (list.indexOf('OES_vertex_array_object') < 0) {
-      list.push('OES_vertex_array_object');
-    }
-    return list;
-  };
-
-  const original_getExtension = gl.getExtension;
-  gl.getExtension = function getExtension(name) {
-    const ext = original_getExtension.call(this, name);
-    if (ext) {
-      return ext;
-    }
-    if (name !== 'OES_vertex_array_object') {
-      return null;
-    }
-
-    if (!gl.__OESVertexArrayObject) {
-      this.__OESVertexArrayObject = new OESVertexArrayObject(this);
-    }
-    return this.__OESVertexArrayObject;
-  };
-}