@luma.gl/webgl 8.5.9 → 8.6.0-alpha.3

package/src/classes/texture.d.ts

@@ -1,80 +0,0 @@
-import Resource, {ResourceProps} from './resource';
-
-export type TextureProps = ResourceProps & {
-  data?: any;
-  width?: number; 
-  height?: number; 
-  depth?: number;
-
-  pixels?: any;
-  format?: number;
-  dataFormat?: number;
-  border?: number;
-  recreate?: boolean;
-  type?: number; 
-  compressed?: boolean; 
-  mipmaps?: boolean;
-
-  parameters?: object;
-  pixelStore?: object;
-  textureUnit?: number;
-}
-  
-export default class Texture extends Resource {
-  static isSupported(
-    gl: WebGLRenderingContext,
-    options?: {
-      format: any;
-      linearFiltering: any;
-    }
-  ): boolean;
-
-  readonly width: number;
-  readonly height: number;
-  readonly depth: number;
-  readonly target: any;
-
-  readonly MAX_ATTRIBUTES: number;
-
-  constructor(gl: WebGLRenderingContext, props: any);
-  toString(): string;
-  initialize(props?: {}): this | void;
-  resize(options: {height: any; width: any; mipmaps?: boolean}): this;
-  generateMipmap(params?: {}): this;
-  setImageData(options: any): this;
-
-  /**
-   * Redefines an area of an existing texture
-   * Note: does not allocate storage
-   */
-  setSubImageData(options: {
-    target?: any;
-    pixels?: any;
-    data?: any;
-    x?: number;
-    y?: number;
-    width?: any;
-    height?: any;
-    level?: number;
-    format?: any;
-    type?: any;
-    dataFormat?: any;
-    compressed?: boolean;
-    offset?: number;
-    border?: any;
-    parameters?: {};
-  }): void;
-
-  /**
-   * Defines a two-dimensional texture image or cube-map texture image with
-   * pixels from the current framebuffer (rather than from client memory).
-   * (gl.copyTexImage2D wrapper)
-   *
-   * Note that binding a texture into a Framebuffer's color buffer and
-   * rendering can be faster.
-   */
-  copyFramebuffer(opts?: {}): any;
-  getActiveUnit(): number;
-  bind(textureUnit?: any): any;
-  unbind(textureUnit?: any): any;
-}

package/src/classes/transform-feedback.d.ts

@@ -1,16 +0,0 @@
-import Resource, {ResourceProps} from './resource';
-
-export type TransformFeedbackProps = ResourceProps & {
-  [key: string]: any;
-};
-export default class TransformFeedback extends Resource {
-  static isSupported(gl: WebGLRenderingContext): boolean;
-
-  constructor(gl: WebGLRenderingContext, props?: TransformFeedbackProps);
-  initialize(props?: TransformFeedbackProps): this;
-  setProps(props: TransformFeedbackProps): void;
-  setBuffers(buffers?: {}): this;
-  setBuffer(locationOrName: any, bufferOrParams: any): this;
-  begin(primitiveMode?: any): this;
-  end(): this;
-}

package/src/classes/uniform-buffer-layout.d.ts

@@ -1,18 +0,0 @@
-/**
- * Std140 layout for uniforms
- */
-export default class UniformBufferLayout {
-  constructor(layout: any);
-  getBytes(): number;
-  getData(): any;
-  getSubData(
-    index: any
-  ): {
-    data: any;
-    offset: any;
-  };
-  setUniforms(values: any): this;
-  _setValue(key: any, value: any): void;
-  _addUniform(key: any, uniformType: any): void;
-  _alignTo(size: any, count: any): any;
-}

package/src/classes/uniforms.d.ts

@@ -1,63 +0,0 @@
-import {Matrix4} from '@math.gl/core';
-import Buffer from './buffer';
-import Framebuffer from './framebuffer';
-import Texture from './texture'
-
-
-interface NumberUniformDefinition {
-  type: 'number'
-  value: number
-  min: number
-  max: number
-}
-
-interface BooleanUniformDefinition {
-  type: 'boolean'
-  value: boolean
-}
-
-interface ArrayUniformDefinition {
-  type: 'array'
-  value: Array<any>
-}
-
-interface ObjectUniformDefinition {
-  type: 'object'
-  value: Object
-}
-
-type UniformDefinition = NumberUniformDefinition |
-  BooleanUniformDefinition |
-  ArrayUniformDefinition |
-  ObjectUniformDefinition
-
-// https://luma.gl/docs/developer-guide/shader-modules#getuniforms
-interface UniformsOptions {
-  [uniformName: string]: UniformDefinition
-}
-
-type Uniform = UniformDefinition |
-  Buffer | (() => Buffer) | Framebuffer |
-  Texture |
-  Matrix4 | // TODO: which other math.gl classes?
-  number | [number, number] | [number, number, number] | [number, number, number, number]
-
-interface Uniforms {
-  [uniformName: string]: Uniform
-}
-
-// Returns a Magic Uniform Setter
-export function getUniformSetter(gl: WebGLRenderingContext, location: number, info: object): any;
-
-export function parseUniformName(name: string): {name: string; isArray: boolean};
-
-/**
- * Basic checks of uniform values (with or without knowledge of program)
- * To facilitate early detection of e.g. undefined values in JavaScript
- */
-export function checkUniformValues(uniforms: object, source?: string, uniformMap?: object): boolean;
-
-/**
- * Creates a copy of the uniform
- */
-export function copyUniform(uniforms: object, key: string, value: any): void;

package/src/classes/vertex-array-object.d.ts

@@ -1,25 +0,0 @@
-import Resource, {ResourceProps} from './resource';
-
-export type VertexArrayObjectProps = ResourceProps & object;
-
-export default class VertexArrayObject extends Resource {
-  static isSupported(gl: WebGLRenderingContext, options?: VertexArrayObjectProps): boolean;
-  static getDefaultArray(gl: WebGLRenderingContext): any;
-  static getMaxAttributes(gl: WebGLRenderingContext): any;
-  static setConstant(gl: WebGLRenderingContext, location: any, array: any): void;
-
-  get MAX_ATTRIBUTES(): any;
-
-  constructor(gl: WebGLRenderingContext, opts?: VertexArrayObjectProps);
-  delete(): this;
-
-  initialize(props?: {}): this;
-  setProps(props: any): this;
-  setElementBuffer(elementBuffer?: any, opts?: {}): this;
-  setBuffer(location: any, buffer: any, accessor: any): this;
-  enable(location: any, enable?: boolean): this;
-  getConstantBuffer(elementCount: any, value: any): any;
-
-  // PRIVATE
-  // _normalizeConstantArrayValue(arrayValue);
-}

package/src/classes/vertex-array.d.ts

@@ -1,37 +0,0 @@
-import Program from './program'; 
-import ProgramConfiguration from './program-configuration';
-import VertexArrayObject from './vertex-array-object';
-import Accessor from './accessor';
-
-export type VertexArrayProps = {
-  program?: Program;
-  configuration?: ProgramConfiguration;
-  attributes?: any[];
-  elements?: any;
-  bindOnUse?: boolean;
-};
-
-export default class VertexArray {
-  readonly attributes: object;
-
-  constructor(gl: WebGLRenderingContext, opts?: {});
-  delete(): void;
-  initialize(props?: {}): this;
-  reset(): this;
-  setProps(props: any): this;
-  clearDrawParams(): void;
-  getDrawParams(): any;
-  setAttributes(attributes: any): this;
-  setElementBuffer(elementBuffer?: any, accessor?: {}): this;
-  setBuffer(locationOrName: any, buffer: any, appAccessor?: {}): this;
-  setConstant(locationOrName: any, arrayValue: any, appAccessor?: {}): this;
-  unbindBuffers(): this;
-  bindBuffers(): this;
-  bindForDraw(vertexCount: any, instanceCount: any, func: any): any;
-  setElements(elementBuffer?: any, accessor?: {}): this;
-
-  // FOR TESTING
-  readonly configuration: ProgramConfiguration | null;
-  readonly accessors: Accessor[];
-  readonly vertexArrayObject: VertexArrayObject;
-}

package/src/debug/debug-program-configuration.d.ts

@@ -1 +0,0 @@
-export function getDebugTableForProgramConfiguration(config: any): {};

package/src/debug/debug-uniforms.d.ts

@@ -1,11 +0,0 @@
-export function getDebugTableForUniforms(options?: {
-  header?: string;
-  program: any;
-  uniforms: any;
-  undefinedOnly?: boolean;
-}): {
-  table: {};
-  count: number;
-  unusedTable: {};
-  unusedCount: number;
-};

package/src/debug/debug-vertex-array.d.ts

@@ -1 +0,0 @@
-export function getDebugTableForVertexArray(options?: {vertexArray: any; header?: string}): {};

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

@@ -1,34 +0,0 @@
-import isOldIE from './check-old-ie';
-import WEBGL_FEATURES from './webgl-features-table';
-import {assert} from '../utils/assert';
-
-// 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.js

@@ -1,79 +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/assert';
-
-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) {
-  gl.luma = gl.luma || {};
-  gl.luma.caps = gl.luma.caps || {};
-  for (const cap in WEBGL_FEATURES) {
-    if (gl.luma.caps[cap] === undefined) {
-      gl.luma.caps[cap] = isFeatureSupported(gl, cap);
-    }
-  }
-  return gl.luma.caps;
-}
-
-// TODO - cache the value
-function isFeatureSupported(gl, cap) {
-  gl.luma = gl.luma || {};
-  gl.luma.caps = gl.luma.caps || {};
-
-  if (gl.luma.caps[cap] === undefined) {
-    gl.luma.caps[cap] = queryFeature(gl, cap);
-  }
-
-  if (!gl.luma.caps[cap]) {
-    log.log(LOG_UNSUPPORTED_FEATURE, `Feature: ${cap} not supported`)();
-  }
-
-  return gl.luma.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.js

@@ -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.js

@@ -1,65 +0,0 @@
-import GL from '@luma.gl/constants';
-
-import WEBGL_LIMITS from './webgl-limits-table';
-import {isWebGL2, getContextDebugInfo} from '@luma.gl/gltools';
-
-export function getContextLimits(gl) {
-  gl.luma = gl.luma || {};
-
-  if (!gl.luma.limits) {
-    gl.luma.limits = {};
-    gl.luma.webgl1MinLimits = {};
-    gl.luma.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);
-      gl.luma.limits[parameter] = value;
-      gl.luma.webgl1MinLimits[parameter] = webgl1MinLimit;
-      gl.luma.webgl2MinLimits[parameter] = webgl2MinLimit;
-    }
-  }
-
-  return gl.luma.limits;
-}
-
-export function getGLContextInfo(gl) {
-  gl.luma = gl.luma || {};
-
-  const info = getContextDebugInfo(gl);
-  if (!gl.luma.info) {
-    gl.luma.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 gl.luma.info;
-}
-
-export function getContextInfo(gl) {
-  return Object.assign(getContextDebugInfo(gl), {
-    limits: getContextLimits(gl),
-    info: getGLContextInfo(gl),
-    webgl1MinLimits: gl.luma.webgl1MinLimits,
-    webgl2MinLimits: gl.luma.webgl2MinLimits
-  });
-}

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

@@ -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.js

@@ -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/glsl-utils/format-glsl-error.d.ts

@@ -1,16 +0,0 @@
-export default function formatGLSLCompilerError(errLog: any, src: any, shaderType: any): string;
-
-/**
- * Parse a GLSL compiler error log into a string showing the source code around each error.
- * Based on https://github.com/wwwtyro/gl-format-compiler-error (public domain)
- */
-export function parseGLSLCompilerError(
-  errLog: any,
-  src: any,
-  shaderType: any,
-  shaderName: any
-): {
-  shaderName: string;
-  errors: string;
-  warnings: string;
-};