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

package/src/classes/framebuffer.d.ts

@@ -1,96 +0,0 @@
-import Resource, {ResourceProps} from './resource';
-
-export type FramebufferProps = ResourceProps & {
-  width?: number;
-  height?: number;
-  attachments?: any;
-  color?: boolean;
-  depth?: boolean;
-  stencil?: boolean;
-  check?: boolean;
-  readBuffer?: any;
-  drawBuffers?: any;
-}
-
-/**
- * Framebuffers hold a collection of Texture and Renderbuffer attachments.
- * Framebuffers allow rendering to non-Default Framebuffer locations
- * without disturbing the main screen.
-*/
-export default class Framebuffer extends Resource {
-  static readonly STATUS: number[];
-
-  readonly handle: WebGLFramebuffer;
-  readonly width: number;
-  readonly height: number;
-  readonly attachments: any[];
-
-  /**
-   * Support
-   * @param gl
-   * @param options.colorBufferFloat  Whether floating point textures can be rendered and read
-   * @param options.colorBufferHalfFloat Whether half float textures can be rendered and read
-   */
-  static isSupported(
-    gl: WebGLRenderingContext,
-    options?: {
-      colorBufferFloat: any;
-      colorBufferHalfFloat: any;
-    }
-  ): boolean;
-
-  /** returns the default Framebuffer */
-  static getDefaultFramebuffer(gl: WebGLRenderingContext): Framebuffer;
-
-  get MAX_COLOR_ATTACHMENTS(): any;
-  get MAX_DRAW_BUFFERS(): any;
-  get color(): any;
-  get texture(): any;
-  get depth(): any;
-  get stencil(): any;
-
-  constructor(gl: WebGLRenderingContext, props?: FramebufferProps);
-
-  initialize(options?: FramebufferProps): this;
-
-  // @ts-ignore
-  delete(): void;
-
-  resize(size?: {width: any; height: any}): this;
-
-  update(options?: {
-    attachments?: {};
-    readBuffer: any;
-    drawBuffers: any;
-    clearAttachments?: boolean;
-    resizeAttachments?: boolean;
-  }): this;
-
-  attach(
-    attachments: any,
-    options?: {
-      clearAttachments?: boolean;
-      resizeAttachments?: boolean;
-    }
-  ): this;
-
-  checkStatus(): this;
-  getStatus(): any;
-  clear(options?: {color?: any; depth?: any; stencil?: any; drawBuffers?: any[]}): this;
-  readPixels(opts?: {}): any;
-  readPixelsToBuffer(opts?: {}): any;
-  copyToDataUrl(opts?: {}): any;
-  copyToImage(opts?: {}): any;
-  copyToTexture(opts?: {}): any;
-  blit(opts?: {}): any;
-  invalidate(options: {attachments?: any[]; x?: number; y?: number; width: any; height: any}): this;
-  getAttachmentParameter(attachment: any, pname: any, keys: any): any;
-  getAttachmentParameters(attachment: any, keys: any, parameters?: any): {};
-  getParameters(keys?: boolean): {};
-  show(): this;
-  log(logLevel?: number, message?: string): this;
-  bind({target}?: {target?: any}): this;
-  unbind({target}?: {target?: any}): this;
-}
-
-export const FRAMEBUFFER_ATTACHMENT_PARAMETERS: any[];

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

@@ -1,15 +0,0 @@
-/**
- * is a mechanism for taking a program object and querying information 
- * about it, so as to be able to interface and interact with it. 
- * For example, if there is a uniform, you may need to query its 
- * location so that you can set its value.
- */
-export default class ProgramConfiguration {
-  constructor(program: any);
-  getAttributeInfo(locationOrName: any): any;
-  getAttributeLocation(locationOrName: any): any;
-  getAttributeAccessor(locationOrName: any): any;
-  getVaryingInfo(locationOrName: any): any;
-  getVaryingIndex(locationOrName: any): any;
-  getVaryingAccessor(locationOrName: any): any;
-}

package/src/classes/program.d.ts

@@ -1,44 +0,0 @@
-import Resource, {ResourceProps} from './resource';
-import ProgramConfiguration from './program-configuration';
-
-export type ProgramProps = ResourceProps & {
-
-}
-
-/**
- * A Program holds fully processed executable code,
- * for one or more Shader stages. 
- */
-export default class Program extends Resource {
-
-  readonly handle: WebGLProgram;  
-  readonly configuration: ProgramConfiguration;
-
-  constructor(gl: WebGLRenderingContext, props?: {});
-  initialize(props?: {}): this;
-  delete(options?: {}): this;
-  setProps(props: any): this;
-  draw(options: {
-    logPriority?: any;
-    drawMode?: any;
-    vertexCount: any;
-    offset?: number;
-    start?: any;
-    end?: any;
-    isIndexed?: boolean;
-    indexType?: any;
-    instanceCount?: number;
-    isInstanced?: boolean;
-    vertexArray?: any;
-    transformFeedback?: any;
-    framebuffer?: any;
-    parameters?: {};
-    uniforms?: any;
-    samplers?: any;
-  }): boolean;
-  setUniforms(uniforms?: {}): this;
-  getActiveUniforms(uniformIndices: any, pname: any): any;
-  getUniformBlockIndex(blockName: any): any;
-  getActiveUniformBlockParameter(blockIndex: any, pname: any): any;
-  uniformBlockBinding(blockIndex: any, blockBinding: any): void;
-}

package/src/classes/query.d.ts

@@ -1,21 +0,0 @@
-import Resource from './resource';
-
-/**
- * Asynchronous queries for different kinds of information
- */
-export default class Query extends Resource {
-  readonly handle: WebGLQuery;
-
-  static isSupported(gl: WebGLRenderingContext, opts?: any[]): boolean;
-  constructor(gl: WebGLRenderingContext, opts?: {});
-  beginTimeElapsedQuery(): this;
-  beginOcclusionQuery({conservative}?: {conservative?: boolean}): this;
-  beginTransformFeedbackQuery(): this;
-  begin(target: any): this;
-  end(): this;
-  isResultAvailable(): any;
-  isTimerDisjoint(): any;
-  getResult(): any;
-  getTimerMilliseconds(): number;
-  createPoll(limit?: number): any;
-}

package/src/classes/renderbuffer.d.ts

@@ -1,34 +0,0 @@
-import Resource, {ResourceProps} from './resource';
-
-export type RenderbufferProps = ResourceProps & {
-  format: number;
-  width?: number;
-  height?: number;
-  samples?: number;
-};
-
-/**
- * Renderbuffers are GPU objects that contain images. 
- * In contrast to Textures they are optimized for use as render targets, with Framebuffers.
- * while Textures may not be, and are the logical choice when
- * you do not need to sample (i.e. in a post-pass shader) 
- * from the produced image. If you need to resample 
- * (such as when reading depth back in a second shader pass), 
- * use Textures instead. 
- * Renderbuffer objects also natively accommodate Multisampling (MSAA).
- */
-export default class Renderbuffer extends Resource {
-  static isSupported(gl: WebGLRenderingContext, options?: {format?: number}): boolean;
-  static getSamplesForFormat(gl: WebGLRenderingContext, options: {format: number}): number;
-
-  readonly width: number;
-  readonly height: number;
-  readonly format: number;
-
-  constructor(gl: WebGLRenderingContext, props: RenderbufferProps);
-
-  /** Creates and initializes a renderbuffer object's data store */
-  initialize(props: Renderbuffer): this;
-
-  resize(size: {width: number, height: number}): this;
-}

package/src/classes/renderbuffer.js

@@ -1,105 +0,0 @@
-/* eslint-disable no-inline-comments */
-import GL from '@luma.gl/constants';
-import Resource from './resource';
-import RENDERBUFFER_FORMATS from './renderbuffer-formats';
-import {isWebGL2} from '@luma.gl/gltools';
-import {assert} from '../utils/assert';
-
-function isFormatSupported(gl, format, formats) {
-  const info = formats[format];
-  if (!info) {
-    return false;
-  }
-  const value = isWebGL2(gl) ? info.gl2 || info.gl1 : info.gl1;
-  if (typeof value === 'string') {
-    return gl.getExtension(value);
-  }
-  return value;
-}
-
-export default class Renderbuffer extends Resource {
-  static isSupported(gl, {format} = {format: null}) {
-    return !format || isFormatSupported(gl, format, RENDERBUFFER_FORMATS);
-  }
-
-  static getSamplesForFormat(gl, {format}) {
-    // Polyfilled to return [0] under WebGL1
-    return gl.getInternalformatParameter(GL.RENDERBUFFER, format, GL.SAMPLES);
-  }
-
-  constructor(gl, opts = {}) {
-    super(gl, opts);
-
-    // @ts-ignore
-    this.initialize(opts);
-
-    Object.seal(this);
-  }
-
-  // Creates and initializes a renderbuffer object's data store
-  initialize({format, width = 1, height = 1, samples = 0}) {
-    assert(format, 'Needs format');
-
-    this._trackDeallocatedMemory();
-
-    this.gl.bindRenderbuffer(GL.RENDERBUFFER, this.handle);
-
-    if (samples !== 0 && isWebGL2(this.gl)) {
-      // @ts-ignore
-      this.gl.renderbufferStorageMultisample(GL.RENDERBUFFER, samples, format, width, height);
-    } else {
-      this.gl.renderbufferStorage(GL.RENDERBUFFER, format, width, height);
-    }
-
-    // this.gl.bindRenderbuffer(GL.RENDERBUFFER, null);
-
-    this.format = format;
-    this.width = width;
-    this.height = height;
-    this.samples = samples;
-
-    this._trackAllocatedMemory(
-      this.width * this.height * (this.samples || 1) * RENDERBUFFER_FORMATS[this.format].bpp
-    );
-
-    return this;
-  }
-
-  resize({width, height}) {
-    // Don't resize if width/height haven't changed
-    if (width !== this.width || height !== this.height) {
-      return this.initialize({width, height, format: this.format, samples: this.samples});
-    }
-    return this;
-  }
-
-  // PRIVATE METHODS
-  _createHandle() {
-    return this.gl.createRenderbuffer();
-  }
-
-  _deleteHandle() {
-    this.gl.deleteRenderbuffer(this.handle);
-    this._trackDeallocatedMemory();
-  }
-
-  _bindHandle(handle) {
-    this.gl.bindRenderbuffer(GL.RENDERBUFFER, handle);
-  }
-
-  _syncHandle(handle) {
-    this.format = this.getParameter(GL.RENDERBUFFER_INTERNAL_FORMAT);
-    this.width = this.getParameter(GL.RENDERBUFFER_WIDTH);
-    this.height = this.getParameter(GL.RENDERBUFFER_HEIGHT);
-    this.samples = this.getParameter(GL.RENDERBUFFER_SAMPLES);
-  }
-
-  // @param {Boolean} opt.autobind=true - method call will bind/unbind object
-  // @returns {GLenum|GLint} - depends on pname
-  _getParameter(pname) {
-    this.gl.bindRenderbuffer(GL.RENDERBUFFER, this.handle);
-    const value = this.gl.getRenderbufferParameter(GL.RENDERBUFFER, pname);
-    // this.gl.bindRenderbuffer(GL.RENDERBUFFER, null);
-    return value;
-  }
-}

package/src/classes/resource.d.ts

@@ -1,47 +0,0 @@
-export type ResourceProps = {
-  id?: string;
-  handle?: any
-}
-
-/**
- * Base class for WebGL object wrappers
- */
-export default class Resource {
-  readonly id: string;
-  readonly gl: WebGLRenderingContext;
-  readonly gl2: WebGL2RenderingContext;
-  readonly _handle: any;
-
-  readonly handle: any;
-
-  constructor(gl: WebGLRenderingContext, props?: ResourceProps);
-  toString(): string;
-  delete({ deleteChildren }?: { deleteChildren?: boolean }): this;
-  bind(funcOrHandle?: any): any;
-  unbind(): void;
-
-  /**
-   * Query a Resource parameter
-   *
-   * @param {GLenum} pname
-   * @return {GLint|GLfloat|GLenum} param
-   */
-  getParameter(pname: any, opts?: {}): any;
-  getParameters(opts?: {}): {};
-  /**
-   * Update a Resource setting
-   *
-   * @todo - cache parameter to avoid issuing WebGL calls?
-   *
-   * @param {GLenum} pname - parameter (GL constant, value or key)
-   * @param {GLint|GLfloat|GLenum} value
-   * @return {Resource} returns self to enable chaining
-   */
-  setParameter(pname: any, value: any): this;
-  setParameters(parameters: any): this;
-  stubRemovedMethods(className: any, version: any, methodNames: any): void;
-  initialize(opts: any): void;
-
-  _trackAllocatedMemory(bytes: number, name?: string): void;
-  _trackDeallocatedMemory(name?: string): void;
-}

package/src/classes/shader.d.ts

@@ -1,29 +0,0 @@
-import Resource, {ResourceProps} from './resource';
-
-export type ShaderProps = ResourceProps & {
-  source: string;
-  shaderType?: string;
-};
-
-/**
- * Encapsulates the compiled or linked Shaders that execute portions of the WebGL Pipeline
- */
-export class Shader extends Resource {
-  static getTypeName(shaderType: any): 'vertex-shader' | 'fragment-shader' | 'unknown';
-
-  constructor(gl: WebGLRenderingContext, props: ShaderProps);
-  initialize(options: ShaderProps): this;
-  getParameter(pname: any): any;
-  toString(): string;
-  getName(): string;
-  getSource(): string;
-  getTranslatedSource(): string;
-}
-
-export class VertexShader extends Shader {
-  constructor(gl: WebGLRenderingContext, props: any);
-}
-
-export class FragmentShader extends Shader {
-  constructor(gl: WebGLRenderingContext, props: any);
-}

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