@luma.gl/webgl 8.5.8 → 8.6.0-alpha.2

package/src/classes/shader.js

@@ -1,147 +0,0 @@
-import GL from '@luma.gl/constants';
-import {assertWebGLContext, log} from '@luma.gl/gltools';
-import {parseGLSLCompilerError, getShaderName} from '../glsl-utils';
-import {assert} from '../utils/assert';
-import {uid} from '../utils/utils';
-import Resource from './resource';
-
-const ERR_SOURCE = 'Shader: GLSL source code must be a JavaScript string';
-
-// For now this is an internal class
-export class Shader extends Resource {
-  static getTypeName(shaderType) {
-    switch (shaderType) {
-      case GL.VERTEX_SHADER:
-        return 'vertex-shader';
-      case GL.FRAGMENT_SHADER:
-        return 'fragment-shader';
-      default:
-        assert(false);
-        return 'unknown';
-    }
-  }
-
-  /* eslint-disable max-statements */
-  constructor(gl, props) {
-    assertWebGLContext(gl);
-
-    // Validate arguments
-    assert(typeof props.source === 'string', ERR_SOURCE);
-
-    // Deduce an id, from shader source, or supplied id, or shader type
-    const id =
-      getShaderName(props.source, null) ||
-      props.id ||
-      uid(`unnamed ${Shader.getTypeName(props.shaderType)}`);
-
-    super(gl, {id});
-
-    this.shaderType = props.shaderType;
-    this.source = props.source;
-
-    this.initialize(props);
-  }
-
-  initialize({source}) {
-    const shaderName = getShaderName(source, null);
-    if (shaderName) {
-      this.id = uid(shaderName);
-    }
-    this._compile(source);
-  }
-
-  // Accessors
-
-  getParameter(pname) {
-    return this.gl.getShaderParameter(this.handle, pname);
-  }
-
-  toString() {
-    return `${Shader.getTypeName(this.shaderType)}:${this.id}`;
-  }
-
-  getName() {
-    return getShaderName(this.source) || 'unnamed-shader';
-  }
-
-  getSource() {
-    return this.gl.getShaderSource(this.handle);
-  }
-
-  // Debug method - Returns translated source if available
-  getTranslatedSource() {
-    const extension = this.gl.getExtension('WEBGL_debug_shaders');
-    return extension
-      ? extension.getTranslatedShaderSource(this.handle)
-      : 'No translated source available. WEBGL_debug_shaders not implemented';
-  }
-
-  // PRIVATE METHODS
-  _compile(source = this.source) {
-    if (!source.startsWith('#version ')) {
-      source = `#version 100\n${source}`;
-    }
-    this.source = source;
-    this.gl.shaderSource(this.handle, this.source);
-    this.gl.compileShader(this.handle);
-
-    // TODO - For performance reasons, avoid checking shader compilation errors on production?
-    // TODO - Load log even when no error reported, to catch warnings?
-    // https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings
-    const compileStatus = this.getParameter(GL.COMPILE_STATUS);
-    if (!compileStatus) {
-      const infoLog = this.gl.getShaderInfoLog(this.handle);
-      const {shaderName, errors, warnings} = parseGLSLCompilerError(
-        infoLog,
-        this.source,
-        this.shaderType,
-        this.id
-      );
-      log.error(`GLSL compilation errors in ${shaderName}\n${errors}`)();
-      log.warn(`GLSL compilation warnings in ${shaderName}\n${warnings}`)();
-      throw new Error(`GLSL compilation errors in ${shaderName}`);
-    }
-  }
-
-  _deleteHandle() {
-    this.gl.deleteShader(this.handle);
-  }
-
-  _getOptsFromHandle() {
-    return {
-      type: this.getParameter(GL.SHADER_TYPE),
-      source: this.getSource()
-    };
-  }
-}
-
-export class VertexShader extends Shader {
-  constructor(gl, props) {
-    // Signature: new VertexShader(gl, source)
-    if (typeof props === 'string') {
-      props = {source: props};
-    }
-    super(gl, Object.assign({}, props, {shaderType: GL.VERTEX_SHADER}));
-  }
-
-  // PRIVATE METHODS
-  _createHandle() {
-    return this.gl.createShader(GL.VERTEX_SHADER);
-  }
-}
-
-export class FragmentShader extends Shader {
-  constructor(gl, props) {
-    // Signature: new FragmentShader(gl, source)
-    if (typeof props === 'string') {
-      props = {source: props};
-    }
-
-    super(gl, Object.assign({}, props, {shaderType: GL.FRAGMENT_SHADER}));
-  }
-
-  // PRIVATE METHODS
-  _createHandle() {
-    return this.gl.createShader(GL.FRAGMENT_SHADER);
-  }
-}

package/src/classes/texture-2d.d.ts

@@ -1,11 +0,0 @@
-import Texture, {TextureProps} from './texture';
-
-export type Texture2DProps = TextureProps & {
-};
-
-export default class Texture2D extends Texture {
-  static isSupported(gl: WebGLRenderingContext, opts?: object): boolean;
-
-  constructor(gl: WebGLRenderingContext, props?: Texture2DProps);
-  constructor(gl: WebGLRenderingContext, props: Promise<Texture2DProps>);
-}

package/src/classes/texture-2d.js

@@ -1,30 +0,0 @@
-import GL from '@luma.gl/constants';
-import {assertWebGLContext} from '@luma.gl/gltools';
-import Texture from './texture';
-import {loadImage} from '../utils/load-file';
-
-export default class Texture2D extends Texture {
-  static isSupported(gl, opts) {
-    return Texture.isSupported(gl, opts);
-  }
-
-  constructor(gl, props = {}) {
-    assertWebGLContext(gl);
-
-    // Signature: new Texture2D(gl, url | Promise)
-    if (props instanceof Promise || typeof props === 'string') {
-      props = {data: props};
-    }
-
-    // Signature: new Texture2D(gl, {data: url})
-    if (typeof props.data === 'string') {
-      props = Object.assign({}, props, {data: loadImage(props.data)});
-    }
-
-    super(gl, Object.assign({}, props, {target: GL.TEXTURE_2D}));
-
-    this.initialize(props);
-
-    Object.seal(this);
-  }
-}

package/src/classes/texture-3d.d.ts

@@ -1,29 +0,0 @@
-import Texture, {TextureProps} from './texture';
-
-export type Texture3DProps = TextureProps & {
-};
-
-/**
- * Textures that have 3 dimensions: width, height, and depth. 
- * They are accessed by 3-dimensional texture coordinates.
- */
-export default class Texture3D extends Texture {
-  static isSupported(gl: WebGLRenderingContext): boolean;
-
-  constructor(gl: WebGL2RenderingContext, props: Texture3DProps);
-
-  /** Image 3D copies from Typed Array or WebGLBuffer */
-  setImageData(options: {
-    level?: number;
-    dataFormat?: any;
-    width: any;
-    height: any;
-    depth?: number;
-    border?: number;
-    format: any;
-    type?: any;
-    offset?: number;
-    data: any;
-    parameters?: {};
-  }): this;
-}

package/src/classes/texture-cube.d.ts

@@ -1,23 +0,0 @@
-import Texture, {TextureProps} from './texture';
-
-export type TextureCubeProps = TextureProps & {
-};
-
-export default class TextureCube extends Texture {
-  static readonly FACES: number[];
-
-  constructor(gl: WebGLRenderingContext, props?: TextureCubeProps);
-
-  initialize(props?: TextureCubeProps): void;
-  subImage(options: {face: any; data: any; x?: number; y?: number; mipmapLevel?: number}): any;
-  setCubeMapImageData(options: {
-    width: any;
-    height: any;
-    pixels: any;
-    data: any;
-    border?: number;
-    format?: any;
-    type?: any;
-  }): Promise<void>;
-  setImageDataForFace(options: any): this;
-}

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
-  });
-}