@luma.gl/webgl 8.6.0-alpha.1 → 8.6.0-alpha.5

package/src/features/check-glsl-extension.ts

@@ -1,34 +0,0 @@
-import isOldIE from './check-old-ie';
-import WEBGL_FEATURES from './webgl-features-table';
-import {assert} from '../utils';
-
-// Enables feature detection in IE11 due to a bug where gl.getExtension may return true
-// but fail to compile when the extension is enabled in the shader. Specifically,
-// the OES_standard_derivatives extension fails to compile in IE11 even though its included
-// in the list of supported extensions.
-const compiledGlslExtensions = {};
-
-// options allows user agent to be overridden for testing
-export default function canCompileGLGSExtension(gl, cap, options = {}) {
-  const feature = WEBGL_FEATURES[cap];
-  assert(feature, cap);
-
-  if (!isOldIE(options)) {
-    return true;
-  }
-
-  if (cap in compiledGlslExtensions) {
-    return compiledGlslExtensions[cap];
-  }
-
-  const extensionName = feature[0];
-  const source = `#extension GL_${extensionName} : enable\nvoid main(void) {}`;
-
-  const shader = gl.createShader(gl.VERTEX_SHADER);
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  const canCompile = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
-  gl.deleteShader(shader);
-  compiledGlslExtensions[cap] = canCompile;
-  return canCompile;
-}

package/src/features/features.ts

@@ -1,80 +0,0 @@
-// Feature detection for WebGL
-//
-// Provides a function that enables simple checking of which WebGL features are
-// available in an WebGL1 or WebGL2 environment.
-
-import WEBGL_FEATURES from './webgl-features-table';
-import {isWebGL2, log} from '@luma.gl/gltools';
-import {assert} from '../utils';
-import {getLumaContextData} from '../context/luma-context-data';
-
-const LOG_UNSUPPORTED_FEATURE = 2;
-
-// Check one feature
-export function hasFeature(gl, feature) {
-  return hasFeatures(gl, feature);
-}
-
-// Check one or more features
-export function hasFeatures(gl, features) {
-  features = Array.isArray(features) ? features : [features];
-  return features.every((feature) => {
-    return isFeatureSupported(gl, feature);
-  });
-}
-
-// Return a list of supported features
-export function getFeatures(gl) {
-  const lumaContextData = getLumaContextData(gl);
-  lumaContextData.caps = lumaContextData.caps || {};
-  for (const cap in WEBGL_FEATURES) {
-    if (lumaContextData.caps[cap] === undefined) {
-      lumaContextData.caps[cap] = isFeatureSupported(gl, cap);
-    }
-  }
-  return lumaContextData.caps;
-}
-
-// TODO - cache the value
-function isFeatureSupported(gl, cap) {
-  const lumaContextData = getLumaContextData(gl);
-  lumaContextData.caps = lumaContextData.caps || {};
-
-  if (lumaContextData.caps[cap] === undefined) {
-    lumaContextData.caps[cap] = queryFeature(gl, cap);
-  }
-
-  if (!lumaContextData.caps[cap]) {
-    log.log(LOG_UNSUPPORTED_FEATURE, `Feature: ${cap} not supported`)();
-  }
-
-  return lumaContextData.caps[cap];
-}
-
-function queryFeature(gl, cap) {
-  const feature = WEBGL_FEATURES[cap];
-  assert(feature, cap);
-
-  let isSupported;
-
-  // Get extension name from table
-  const featureDefinition = isWebGL2(gl) ? feature[1] || feature[0] : feature[0];
-
-  // Check if the value is dependent on checking one or more extensions
-  if (typeof featureDefinition === 'function') {
-    isSupported = featureDefinition(gl);
-  } else if (Array.isArray(featureDefinition)) {
-    isSupported = true;
-    for (const extension of featureDefinition) {
-      isSupported = isSupported && Boolean(gl.getExtension(extension));
-    }
-  } else if (typeof featureDefinition === 'string') {
-    isSupported = Boolean(gl.getExtension(featureDefinition));
-  } else if (typeof featureDefinition === 'boolean') {
-    isSupported = featureDefinition;
-  } else {
-    assert(false);
-  }
-
-  return isSupported;
-}

package/src/features/index.ts

@@ -1,5 +0,0 @@
-export {getContextInfo, getGLContextInfo, getContextLimits} from './limits';
-export {FEATURES} from './webgl-features-table';
-export {hasFeature, hasFeatures, getFeatures} from './features';
-
-export {default as canCompileGLGSExtension} from './check-glsl-extension';

package/src/features/limits.ts

@@ -1,66 +0,0 @@
-import GL from '@luma.gl/constants';
-import {isWebGL2, getContextDebugInfo} from '@luma.gl/gltools';
-import WEBGL_LIMITS from './webgl-limits-table';
-import {getLumaContextData} from '../context/luma-context-data';
-
-export function getContextLimits(gl) {
-  const lumaContextData = getLumaContextData(gl);
-
-  if (!lumaContextData.limits) {
-    lumaContextData.limits = {};
-    lumaContextData.webgl1MinLimits = {};
-    lumaContextData.webgl2MinLimits = {};
-
-    const isWebgl2 = isWebGL2(gl);
-
-    // WEBGL limits
-    for (const parameter in WEBGL_LIMITS) {
-      const limit = WEBGL_LIMITS[parameter];
-
-      const webgl1MinLimit = limit.gl1;
-      const webgl2MinLimit = 'gl2' in limit ? limit.gl2 : limit.gl1;
-      const minLimit = isWebgl2 ? webgl2MinLimit : webgl1MinLimit;
-
-      // Check if we can query for this limit
-      const limitNotAvailable =
-        ('gl2' in limit && !isWebgl2) ||
-        // @ts-ignore
-        ('extension' in limit && !gl.getExtension(limit.extension));
-
-      const value = limitNotAvailable ? minLimit : gl.getParameter(parameter);
-      lumaContextData.limits[parameter] = value;
-      lumaContextData.webgl1MinLimits[parameter] = webgl1MinLimit;
-      lumaContextData.webgl2MinLimits[parameter] = webgl2MinLimit;
-    }
-  }
-
-  return lumaContextData.limits;
-}
-
-export function getGLContextInfo(gl) {
-  const lumaContextData = getLumaContextData(gl);
-
-  const info = getContextDebugInfo(gl);
-  if (!lumaContextData.info) {
-    lumaContextData.info = {
-      [GL.UNMASKED_VENDOR_WEBGL]: info.vendor,
-      [GL.UNMASKED_RENDERER_WEBGL]: info.renderer,
-      [GL.VENDOR]: info.vendorMasked,
-      [GL.RENDERER]: info.rendererMasked,
-      [GL.VERSION]: info.version,
-      [GL.SHADING_LANGUAGE_VERSION]: info.shadingLanguageVersion
-    };
-  }
-
-  return lumaContextData.info;
-}
-
-export function getContextInfo(gl) {
-  const lumaContextData = getLumaContextData(gl);
-  return Object.assign(getContextDebugInfo(gl), {
-    limits: getContextLimits(gl),
-    info: getGLContextInfo(gl),
-    webgl1MinLimits: lumaContextData.webgl1MinLimits,
-    webgl2MinLimits: lumaContextData.webgl2MinLimits
-  });
-}

package/src/features/webgl-features-table.ts

@@ -1,104 +0,0 @@
-import Framebuffer from '../classes/framebuffer';
-import Texture2D from '../classes/texture-2d';
-// TODO - this should be the default export, test cases need updating
-export const FEATURES = {
-  WEBGL2: 'WEBGL2',
-
-  // API SUPPORT
-  VERTEX_ARRAY_OBJECT: 'VERTEX_ARRAY_OBJECT',
-  TIMER_QUERY: 'TIMER_QUERY',
-  INSTANCED_RENDERING: 'INSTANCED_RENDERING',
-  MULTIPLE_RENDER_TARGETS: 'MULTIPLE_RENDER_TARGETS',
-
-  // FEATURES
-  ELEMENT_INDEX_UINT32: 'ELEMENT_INDEX_UINT32',
-
-  // BLENDING
-  BLEND_EQUATION_MINMAX: 'BLEND_EQUATION_MINMAX',
-  FLOAT_BLEND: 'FLOAT_BLEND',
-
-  // TEXTURES: '// TEXTURES', RENDERBUFFERS
-  COLOR_ENCODING_SRGB: 'COLOR_ENCODING_SRGB',
-
-  // TEXTURES
-  TEXTURE_DEPTH: 'TEXTURE_DEPTH',
-  TEXTURE_FLOAT: 'TEXTURE_FLOAT',
-  TEXTURE_HALF_FLOAT: 'TEXTURE_HALF_FLOAT',
-
-  TEXTURE_FILTER_LINEAR_FLOAT: 'TEXTURE_FILTER_LINEAR_FLOAT',
-  TEXTURE_FILTER_LINEAR_HALF_FLOAT: 'TEXTURE_FILTER_LINEAR_HALF_FLOAT',
-  TEXTURE_FILTER_ANISOTROPIC: 'TEXTURE_FILTER_ANISOTROPIC',
-
-  // FRAMEBUFFERS: '// FRAMEBUFFERS', TEXTURES AND RENDERBUFFERS
-  COLOR_ATTACHMENT_RGBA32F: 'COLOR_ATTACHMENT_RGBA32F',
-  COLOR_ATTACHMENT_FLOAT: 'COLOR_ATTACHMENT_FLOAT',
-  COLOR_ATTACHMENT_HALF_FLOAT: 'COLOR_ATTACHMENT_HALF_FLOAT',
-
-  // GLSL extensions
-  GLSL_FRAG_DATA: 'GLSL_FRAG_DATA',
-  GLSL_FRAG_DEPTH: 'GLSL_FRAG_DEPTH',
-  GLSL_DERIVATIVES: 'GLSL_DERIVATIVES',
-  GLSL_TEXTURE_LOD: 'GLSL_TEXTURE_LOD'
-};
-
-// function to test if Float 32 bit format texture can be bound as color attachment
-function checkFloat32ColorAttachment(gl) {
-  const testTexture = new Texture2D(gl, {
-    format: gl.RGBA,
-    type: gl.FLOAT,
-    dataFormat: gl.RGBA
-  });
-  const testFb = new Framebuffer(gl, {
-    id: `test-framebuffer`,
-    check: false,
-    attachments: {
-      [gl.COLOR_ATTACHMENT0]: testTexture
-    }
-  });
-  const status = testFb.getStatus();
-  testTexture.delete();
-  testFb.delete();
-  return status === gl.FRAMEBUFFER_COMPLETE;
-}
-
-// Defines luma.gl "feature" names and semantics
-// Format: 'feature-name: [WebGL1 support, WebGL2 support] / [WebGL1 and WebGL2 support]', when support is 'string' it is the name of the extension
-export default {
-  [FEATURES.WEBGL2]: [false, true],
-
-  // API SUPPORT
-  [FEATURES.VERTEX_ARRAY_OBJECT]: ['OES_vertex_array_object', true],
-  [FEATURES.TIMER_QUERY]: ['EXT_disjoint_timer_query', 'EXT_disjoint_timer_query_webgl2'],
-  [FEATURES.INSTANCED_RENDERING]: ['ANGLE_instanced_arrays', true],
-  [FEATURES.MULTIPLE_RENDER_TARGETS]: ['WEBGL_draw_buffers', true],
-
-  // FEATURES
-  [FEATURES.ELEMENT_INDEX_UINT32]: ['OES_element_index_uint', true],
-
-  // BLENDING
-  [FEATURES.BLEND_EQUATION_MINMAX]: ['EXT_blend_minmax', true],
-  [FEATURES.FLOAT_BLEND]: ['EXT_float_blend'],
-
-  // TEXTURES, RENDERBUFFERS
-  [FEATURES.COLOR_ENCODING_SRGB]: ['EXT_sRGB', true],
-
-  // TEXTURES
-  [FEATURES.TEXTURE_DEPTH]: ['WEBGL_depth_texture', true],
-  [FEATURES.TEXTURE_FLOAT]: ['OES_texture_float', true],
-  [FEATURES.TEXTURE_HALF_FLOAT]: ['OES_texture_half_float', true],
-
-  [FEATURES.TEXTURE_FILTER_LINEAR_FLOAT]: ['OES_texture_float_linear'],
-  [FEATURES.TEXTURE_FILTER_LINEAR_HALF_FLOAT]: ['OES_texture_half_float_linear'],
-  [FEATURES.TEXTURE_FILTER_ANISOTROPIC]: ['EXT_texture_filter_anisotropic'],
-
-  // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS
-  [FEATURES.COLOR_ATTACHMENT_RGBA32F]: [checkFloat32ColorAttachment, 'EXT_color_buffer_float'],
-  [FEATURES.COLOR_ATTACHMENT_FLOAT]: [false, 'EXT_color_buffer_float'],
-  [FEATURES.COLOR_ATTACHMENT_HALF_FLOAT]: ['EXT_color_buffer_half_float'],
-
-  // GLSL extensions
-  [FEATURES.GLSL_FRAG_DATA]: ['WEBGL_draw_buffers', true],
-  [FEATURES.GLSL_FRAG_DEPTH]: ['EXT_frag_depth', true],
-  [FEATURES.GLSL_DERIVATIVES]: ['OES_standard_derivatives', true],
-  [FEATURES.GLSL_TEXTURE_LOD]: ['EXT_shader_texture_lod', true]
-};

package/src/features/webgl-limits-table.ts

@@ -1,51 +0,0 @@
-import GL from '@luma.gl/constants';
-
-export default {
-  [GL.ALIASED_LINE_WIDTH_RANGE]: {gl1: new Float32Array([1, 1])},
-  [GL.ALIASED_POINT_SIZE_RANGE]: {gl1: new Float32Array([1, 1])},
-  [GL.MAX_TEXTURE_SIZE]: {gl1: 64, gl2: 2048}, // GLint
-  [GL.MAX_CUBE_MAP_TEXTURE_SIZE]: {gl1: 16}, // GLint
-  [GL.MAX_TEXTURE_IMAGE_UNITS]: {gl1: 8}, // GLint
-  [GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: {gl1: 8}, // GLint
-  [GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: {gl1: 0}, // GLint
-  [GL.MAX_RENDERBUFFER_SIZE]: {gl1: 1}, // GLint
-  [GL.MAX_VARYING_VECTORS]: {gl1: 8}, // GLint
-  [GL.MAX_VERTEX_ATTRIBS]: {gl1: 8}, // GLint
-  [GL.MAX_VERTEX_UNIFORM_VECTORS]: {gl1: 128}, // GLint
-  [GL.MAX_FRAGMENT_UNIFORM_VECTORS]: {gl1: 16}, // GLint
-  [GL.MAX_VIEWPORT_DIMS]: {gl1: new Int32Array([0, 0])},
-
-  // Extensions
-  // [GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: {gl1: 1.0, extension: 'EXT_texture_filter_anisotropic'},
-
-  // WebGL2 Limits
-  [GL.MAX_3D_TEXTURE_SIZE]: {gl1: 0, gl2: 256}, //  GLint
-  [GL.MAX_ARRAY_TEXTURE_LAYERS]: {gl1: 0, gl2: 256}, // GLint
-  [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: {gl1: 0, gl2: 0}, //  GLint64
-  [GL.MAX_COLOR_ATTACHMENTS]: {gl1: 0, gl2: 4}, //  GLint
-  [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: {gl1: 0, gl2: 0}, // GLint64
-  [GL.MAX_COMBINED_UNIFORM_BLOCKS]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: {gl1: 0, gl2: 0}, // GLint64
-  [GL.MAX_DRAW_BUFFERS]: {gl1: 0, gl2: 4}, // GLint
-  [GL.MAX_ELEMENT_INDEX]: {gl1: 0, gl2: 0}, //  GLint64
-  [GL.MAX_ELEMENTS_INDICES]: {gl1: 0, gl2: 0}, // GLint
-  [GL.MAX_ELEMENTS_VERTICES]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MAX_SAMPLES]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MAX_SERVER_WAIT_TIMEOUT]: {gl1: 0, gl2: 0}, //  GLint64
-  [GL.MAX_TEXTURE_LOD_BIAS]: {gl1: 0, gl2: 0}, // GLfloat
-  [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: {gl1: 0, gl2: 0}, // GLint
-  [GL.MAX_UNIFORM_BLOCK_SIZE]: {gl1: 0, gl2: 0}, // GLint64
-  [GL.MAX_UNIFORM_BUFFER_BINDINGS]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MAX_VARYING_COMPONENTS]: {gl1: 0, gl2: 0}, // GLint
-  [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: {gl1: 0, gl2: 0}, // GLint
-  [GL.MAX_VERTEX_UNIFORM_BLOCKS]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: {gl1: 0, gl2: 0}, //  GLint
-  [GL.MIN_PROGRAM_TEXEL_OFFSET]: {gl1: 0, gl2: -8, negative: true}, // GLint
-  [GL.MAX_PROGRAM_TEXEL_OFFSET]: {gl1: 0, gl2: 7}, // GLint
-  [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: {gl1: 0, gl2: 0} // GLint
-};

package/src/utils/array-utils-flat.ts

@@ -1,56 +0,0 @@
-let arrayBuffer = null;
-
-export function getScratchArrayBuffer(byteLength) {
-  if (!arrayBuffer || arrayBuffer.byteLength < byteLength) {
-    arrayBuffer = new ArrayBuffer(byteLength);
-  }
-  return arrayBuffer;
-}
-
-export function getScratchArray(Type, length) {
-  const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);
-  return new Type(scratchArrayBuffer, 0, length); // arrayBuffer, byteOffset, length (in elements)
-}
-
-// Uses copyWithin to significantly speed up typed array value filling
-export function fillArray({target, source, start = 0, count = 1}) {
-  const length = source.length;
-  const total = count * length;
-  let copied = 0;
-  for (let i = start; copied < length; copied++) {
-    target[i++] = source[copied];
-  }
-
-  while (copied < total) {
-    // If we have copied less than half, copy everything we got
-    // else copy remaining in one operation
-    if (copied < total - copied) {
-      target.copyWithin(start + copied, start, start + copied);
-      copied *= 2;
-    } else {
-      target.copyWithin(start + copied, start, start + total - copied);
-      copied = total;
-    }
-  }
-
-  return target;
-}
-
-/*
-
-// Creates a new Uint8Array based on two different ArrayBuffers
-// @private
-// @param {ArrayBuffers} buffer1 The first buffer.
-// @param {ArrayBuffers} buffer2 The second buffer.
-// @return {ArrayBuffers} The new ArrayBuffer created out of the two.
-//
-export function copyArrayBuffer(
-  targetBuffer, sourceBuffer, byteOffset, byteLength = sourceBuffer.byteLength
-) {
-  const targetArray = new Uint8Array(targetBuffer, byteOffset, byteLength);
-  const sourceArray = new Uint8Array(sourceBuffer);
-  targetArray.set(sourceArray);
-  return targetBuffer;
-}
-
-*/

package/src/utils/assert.ts

@@ -1,7 +0,0 @@
-// Recommendation is to ignore message but current test suite checks agains the
-// message so keep it for now.
-export default function assert(condition, message?: string): void {
-  if (!condition) {
-    throw new Error(message || 'luma.gl: assertion failed.');
-  }
-}

package/src/utils/check-props.ts

@@ -1,68 +0,0 @@
-/* Use as
-import {checkProps} from '../util/check-props;'
-
-const PROP_CHECKS = {
-  // Removed props no longer supported, print error and link to upgrade guide
-  removedProps: {
-  },
-  // Deprecated props
-  deprecatedProps: {
-    offset: 'accessor',
-    stride: 'accessor',
-    type: 'accessor',
-    size: 'accessor',
-    divisor: 'accessor',
-    normalized: 'accessor',
-    integer: 'accessor'
-  },
-  // Deprecated props that can be autosubstituted, print warning and return updated props object
-  replacedProps: {
-    bytes: 'byteLength'
-  }
-}
-
-class Buffer {
-  setProps(props) {
-    checkProps('Buffer', props, PROP_CHECKS);
-  }
-}
-*/
-import {log} from '@luma.gl/gltools';
-
-export function checkProps(className, props, propChecks) {
-  const {removedProps = {}, deprecatedProps = {}, replacedProps = {}} = propChecks;
-
-  // removedProps: Removed props no longer supported
-  // print error and link to upgrade guide
-  for (const propName in removedProps) {
-    if (propName in props) {
-      const replacementProp = removedProps[propName];
-      const replacement = replacementProp ? `${className}.${removedProps[propName]}` : 'N/A';
-      log.removed(`${className}.${propName}`, replacement)();
-    }
-  }
-
-  // deprecatedProps: Deprecated props that can not be autosubstituted
-  // print warning and rely on caller to substitute
-  for (const propName in deprecatedProps) {
-    if (propName in props) {
-      const replacementProp = deprecatedProps[propName];
-      log.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)();
-    }
-  }
-
-  // replacedProps: Deprecated props that can be autosubstituted
-  // print warning and return updated props object
-  let newProps = null;
-  for (const propName in replacedProps) {
-    if (propName in props) {
-      const replacementProp = replacedProps[propName];
-      log.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)();
-      newProps = newProps || Object.assign({}, props);
-      newProps[replacementProp] = props[propName];
-      delete newProps[propName];
-    }
-  }
-
-  return newProps || props;
-}

package/src/utils/format-value.ts

@@ -1,37 +0,0 @@
-// TODO / DEPRECATED - delete when confident that probe.gl logging implements all opts
-/* eslint-disable no-console */
-function formatArrayValue(v, opts) {
-  const {maxElts = 16, size = 1} = opts;
-  let string = '[';
-  for (let i = 0; i < v.length && i < maxElts; ++i) {
-    if (i > 0) {
-      string += `,${i % size === 0 ? ' ' : ''}`;
-    }
-    string += formatValue(v[i], opts);
-  }
-  const terminator = v.length > maxElts ? '...' : ']';
-  return `${string}${terminator}`;
-}
-
-export function formatValue(v, opts?: {isInteger?: boolean, size?: number}) {
-  const EPSILON = 1e-16;
-  const {isInteger = false} = opts || {};
-  if (Array.isArray(v) || ArrayBuffer.isView(v)) {
-    return formatArrayValue(v, opts);
-  }
-  if (!Number.isFinite(v)) {
-    return String(v);
-  }
-  if (Math.abs(v) < EPSILON) {
-    return isInteger ? '0' : '0.';
-  }
-  if (isInteger) {
-    return v.toFixed(0);
-  }
-  if (Math.abs(v) > 100 && Math.abs(v) < 10000) {
-    return v.toFixed(0);
-  }
-  const string = v.toPrecision(2);
-  const decimal = string.indexOf('.0');
-  return decimal === string.length - 2 ? string.slice(0, -1) : string;
-}

package/src/utils/index.ts

@@ -1,6 +0,0 @@
-export {default as assert} from './assert';
-export {default as isOldIE} from './is-old-ie';
-export {uid, isPowerOfTwo, isObjectEmpty} from './utils';
-export {formatValue} from './format-value';
-export {stubRemovedMethods} from './stub-methods';
-export {checkProps} from './check-props';

package/src/utils/is-old-ie.ts

@@ -1,6 +0,0 @@
-import {getBrowser} from 'probe.gl/env';
-
-// opts allows user agent to be overridden for testing
-export default function isOldIE(opts: {userAgent?}): boolean {
-  return getBrowser(opts.userAgent) === 'IE';
-}

package/src/utils/load-file.ts

@@ -1,40 +0,0 @@
-import {assert} from '../utils';
-
-let pathPrefix = '';
-
-/*
- * Set a relative path prefix
- */
-export function setPathPrefix(prefix) {
-  pathPrefix = prefix;
-}
-
-// Reads raw file data from:
-export function loadFile(url, options = {}) {
-  assert(typeof url === 'string');
-  url = pathPrefix + url;
-  // @ts-expect-error
-  const dataType = options.dataType || 'text';
-  return fetch(url, options).then((res) => res[dataType]());
-}
-
-/*
- * Loads images asynchronously
- * image.crossOrigin can be set via opts.crossOrigin, default to 'anonymous'
- * returns a promise tracking the load
- */
-export function loadImage(url, opts) {
-  assert(typeof url === 'string');
-  url = pathPrefix + url;
-  return new Promise((resolve, reject) => {
-    try {
-      const image = new Image();
-      image.onload = () => resolve(image);
-      image.onerror = () => reject(new Error(`Could not load image ${url}.`));
-      image.crossOrigin = (opts && opts.crossOrigin) || 'anonymous';
-      image.src = url;
-    } catch (error) {
-      reject(error);
-    }
-  });
-}

package/src/utils/stub-methods.ts

@@ -1,20 +0,0 @@
-import {log} from '@luma.gl/gltools';
-
-// Install stubs for removed methods
-export function stubRemovedMethods(instance, className, version, methodNames) {
-  const upgradeMessage = `See luma.gl ${version} Upgrade Guide at \
-https://luma.gl/docs/upgrade-guide`;
-
-  const prototype = Object.getPrototypeOf(instance);
-
-  methodNames.forEach((methodName) => {
-    if (prototype.methodName) {
-      return;
-    }
-
-    prototype[methodName] = () => {
-      log.removed(`Calling removed method ${className}.${methodName}: `, upgradeMessage)();
-      throw new Error(methodName);
-    };
-  });
-}

package/src/utils/utils.ts

@@ -1,35 +0,0 @@
-import assert from './assert';
-
-const uidCounters = {};
-
-/**
- * Returns a UID.
- * @param id= - Identifier base name
- * @return uid
- **/
-export function uid(id: string = 'id'): string {
-  uidCounters[id] = uidCounters[id] || 1;
-  const count = uidCounters[id]++;
-  return `${id}-${count}`;
-}
-
-/**
- * Verifies if a given number is power of two or not.
- * @param n - The number to check.
- * @return  Returns true if the given number is power of 2, false otherwise.
- **/
-export function isPowerOfTwo(n: number): boolean {
-  return n && (n & (n - 1)) === 0;
-}
-
-/** Returns true if given object is empty, false otherwise. */
-export function isObjectEmpty(obj: object): boolean {
-  let isEmpty = true;
-  /* eslint-disable no-unused-vars  */
-  for (const key in obj) {
-    isEmpty = false;
-    break;
-  }
-  /* eslint-enable no-unused-vars  */
-  return isEmpty;
-}

package/src/webgl-utils/texture-utils.d.ts

@@ -1,11 +0,0 @@
-import Texture2D from '../classes/texture-2d';
-import TextureCube from '../classes/texture-cube';
-import Texture3D from '../classes/texture-3d';
-import Texture from '../classes/texture';
-import Framebuffer, {FramebufferProps} from '../classes/framebuffer';
-
-type TextureType = Texture2D | TextureCube | Texture3D;
-
-export function cloneTextureFrom<T extends TextureType>(refTexture: T, overrides?: any): T;
-
-export function toFramebuffer(texture: Texture, opts?: FramebufferProps): Framebuffer;

package/src/webgl-utils/typed-array-utils.d.ts

@@ -1,36 +0,0 @@
-type TypedArrayConstructor =
-  | Float32ArrayConstructor
-  | Uint16ArrayConstructor
-  | Uint32ArrayConstructor
-  | Uint8ArrayConstructor
-  | Uint8ClampedArrayConstructor
-  | Int8ArrayConstructor
-  | Int16ArrayConstructor
-  | Int32ArrayConstructor;
-
-export function getGLTypeFromTypedArray(arrayOrType: any): any;
-
-export function getTypedArrayFromGLType(
-  glType: any,
-  options?: {
-    clamped?: boolean;
-  }
-): TypedArrayConstructor;
-
-export function flipRows(options: {
-  data: any;
-  width: any;
-  height: any;
-  bytesPerPixel?: number;
-  temp?: any;
-}): void;
-
-export function scalePixels(options: {
-  data: any;
-  width: any;
-  height: any;
-}): {
-  data: Uint8Array;
-  width: number;
-  height: number;
-};