@luma.gl/webgl 8.6.0-alpha.5 → 9.0.0-alpha.10

package/src/classes/program-configuration.ts

@@ -1,77 +0,0 @@
-// Contains metadata describing attribute configurations for a program's shaders
-// Much of this is automatically extracted from shaders after program linking
-// import Accessor from './accessor';
-import type Program from './program';
-import type {AttributeBinding, VaryingBinding} from '../helpers/program-bindings';
-import {getProgramBindings} from '../helpers/get-program-bindings';
-
-/**
- * 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 {
-  id: string;
-  attributeInfos: AttributeBinding[] = [];
-  attributeInfosByName: Record<string, AttributeBinding> = {};
-  // Locations may not be contiguous the case of matrix attributes
-  // so keep a separate location->attribute map.
-  attributeInfosByLocation: AttributeBinding[] = [];
-  varyingInfos: VaryingBinding[] = [];
-  varyingInfosByName: Record<string, VaryingBinding> = {};
-
-  constructor(program: Program) {
-    this.id = program.id;
-    Object.seal(this);
-
-    const bindings = getProgramBindings(program.gl2, program.handle);
-
-    this.attributeInfos = bindings.attributes;
-    for (const attributeInfo of bindings.attributes) {
-      this.attributeInfosByName[attributeInfo.name] = attributeInfo;
-      this.attributeInfosByLocation[attributeInfo.location] = attributeInfo;
-    }
-
-    for (const varyingInfo of bindings.varyings) {
-      this.varyingInfosByName[varyingInfo.name] = varyingInfo;
-    }
-  }
-
-  getAttributeInfo(locationOrName: number | string): AttributeBinding {
-    const location = Number(locationOrName);
-    if (Number.isFinite(location)) {
-      return this.attributeInfosByLocation[location];
-    }
-    return this.attributeInfosByName[locationOrName] || null;
-  }
-
-  // Resolves an attribute name or index to an index
-  getAttributeLocation(locationOrName: number | string): number {
-    const attributeInfo = this.getAttributeInfo(locationOrName);
-    return attributeInfo ? attributeInfo.location : -1;
-  }
-
-  getAttributeAccessor(locationOrName: number | string) {
-    const attributeInfo = this.getAttributeInfo(locationOrName);
-    return attributeInfo ? attributeInfo.accessor : null;
-  }
-
-  getVaryingInfo(locationOrName: number | string): VaryingBinding {
-    const location = Number(locationOrName);
-    if (Number.isFinite(location)) {
-      return this.varyingInfos[location];
-    }
-    return this.varyingInfosByName[locationOrName] || null;
-  }
-
-  getVaryingIndex(locationOrName: number | string): number {
-    const varying = this.getVaryingInfo(locationOrName);
-    return varying ? varying.location : -1;
-  }
-
-  getVaryingAccessor(locationOrName: number | string) {
-    const varying = this.getVaryingInfo(locationOrName);
-    return varying ? varying.accessor : null;
-  }
-}

package/src/classes/program.ts

@@ -1,431 +0,0 @@
-import {log, assert, uid, cast, Shader} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import WebGLDevice from '../adapter/webgl-device';
-import WebGLResource, {ResourceProps} from './webgl-resource';
-import Texture from './texture';
-import Framebuffer from './framebuffer';
-import {parseUniformName, getUniformSetter} from './uniforms';
-import {WEBGLShader} from '../adapter/webgl-shader';
-import ProgramConfiguration from './program-configuration';
-import {copyUniform, checkUniformValues} from './uniforms';
-
-import {isWebGL2, assertWebGL2Context} from '../context/context/webgl-checks';
-import {withParameters} from '../context/state-tracker/with-parameters';
-import {getKey} from '../webgl-utils/constants-to-keys';
-import {getPrimitiveDrawMode} from '../webgl-utils/attribute-utils';
-
-const LOG_PROGRAM_PERF_PRIORITY = 4;
-
-const GL_SEPARATE_ATTRIBS = 0x8c8d;
-
-export type ProgramProps = ResourceProps & {
-  hash?: string;
-  vs?: string | Shader;
-  fs?: string | Shader;
-  varyings?: string[];
-  bufferMode?: number;
-};
-
-export type ProgramDrawOptions = {
-  logPriority?: number;
-  drawMode?: number;
-  vertexCount: any;
-  offset?: number;
-  start?: number;
-  end?: number;
-  isIndexed?: boolean;
-  indexType?: any;
-  instanceCount?: number;
-  isInstanced?: boolean;
-  vertexArray?: any;
-  transformFeedback?: any; // TransformFeedback;
-  framebuffer?: Framebuffer;
-  parameters?: {};
-  uniforms?: Record<string, any>;
-  samplers?: any;
-};
-
-export default class Program extends WebGLResource<ProgramProps> {
-  configuration: ProgramConfiguration;
-  // Experimental flag to avoid deleting Program object while it is cached
-  hash: string; // Used by ProgramManager
-  vs: WEBGLShader;
-  fs: WEBGLShader;
-  uniforms: Record<string, any>;
-  varyings: Record<string, any>;
-  _textureUniforms: Record<string, any>;
-  _isCached: boolean = false;
-  _textureIndexCounter: number = 0;
-  _uniformCount: number = 0;
-  _uniformSetters: Record<string, Function>;
-
-  constructor(device: WebGLDevice | WebGLRenderingContext, props: ProgramProps = {}) {
-    super(WebGLDevice.attach(device), props, {} as any);
-    this.initialize(props);
-    Object.seal(this);
-    this._setId(props.id);
-  }
-
-  destroy(options = {}) {
-    if (this._isCached) {
-      // This object is cached, do not delete
-      return this;
-    }
-    return super.delete(options);
-  }
-
-  delete(options = {}) {
-    if (this._isCached) {
-      // This object is cached, do not delete
-      return this;
-    }
-    return super.delete(options);
-  }
-
-  initialize(props: ProgramProps = {}) {
-    const {hash, vs, fs, varyings, bufferMode = GL_SEPARATE_ATTRIBS} = props;
-
-    this.hash = hash || ''; // Used by ProgramManager
-
-    // Create shaders if needed
-    this.vs =
-      typeof vs === 'string'
-        ? this.device.createShader({id: `${props.id}-vs`, source: vs, stage: 'vertex'})
-        : cast<WEBGLShader>(vs);
-    this.fs =
-      typeof fs === 'string'
-        ? this.device.createShader({id: `${props.id}-fs`, source: fs, stage: 'fragment'})
-        : cast<WEBGLShader>(fs);
-    assert(this.vs.stage === 'vertex');
-    assert(this.fs.stage === 'fragment');
-
-    // uniforms
-    this.uniforms = {};
-    this._textureUniforms = {};
-
-    // Setup varyings if supplied
-    if (varyings && varyings.length > 0) {
-      assertWebGL2Context(this.gl);
-      this.varyings = varyings;
-      this.gl2.transformFeedbackVaryings(this.handle, varyings, bufferMode);
-    }
-
-    this._compileAndLink();
-    this._readUniformLocationsFromLinkedProgram();
-    this.configuration = new ProgramConfiguration(this);
-
-    return this.setProps(props);
-  }
-
-  setProps(props) {
-    if ('uniforms' in props) {
-      this.setUniforms(props.uniforms);
-    }
-    return this;
-  }
-
-  // A good thing about the WebGL API is that there are so many ways to draw things ;)
-  // This function unifies those ways into a single call using common parameters with sane defaults
-  draw(options: ProgramDrawOptions): boolean {
-    const {
-      logPriority, // Probe log priority, enables Model to do more integrated logging
-
-      drawMode = GL.TRIANGLES,
-      vertexCount,
-      offset = 0,
-      start,
-      end,
-      isIndexed = false,
-      indexType = GL.UNSIGNED_SHORT,
-      instanceCount = 0,
-      isInstanced = instanceCount > 0,
-
-      vertexArray = null,
-      transformFeedback,
-      framebuffer,
-
-      // Deprecated
-      uniforms,
-      samplers
-    } = options;
-
-    let {parameters = {}} = options;
-
-    if (uniforms || samplers) {
-      // DEPRECATED: v7.0 (deprecated earlier but warning not properly implemented)
-      log.deprecated('Program.draw({uniforms})', 'Program.setUniforms(uniforms)')();
-      this.setUniforms(uniforms || {});
-    }
-
-    if (log.priority >= logPriority) {
-      const fb = framebuffer ? framebuffer.id : 'default';
-      const message =
-        `mode=${getKey(this.gl, drawMode)} verts=${vertexCount} ` +
-        `instances=${instanceCount} indexType=${getKey(this.gl, indexType)} ` +
-        `isInstanced=${isInstanced} isIndexed=${isIndexed} ` +
-        `Framebuffer=${fb}`;
-      log.log(logPriority, message)();
-    }
-
-    // TODO - move vertex array binding and transform feedback binding to withParameters?
-    assert(vertexArray);
-
-    this.gl.useProgram(this.handle);
-
-    if (
-      // Note: async textures set as uniforms might still be loading.
-      // Now that all uniforms have been updated, check if any texture
-      // in the uniforms is not yet initialized, then we don't draw
-      !this._areTexturesRenderable() ||
-      // Avoid WebGL draw call when not rendering any data
-      vertexCount === 0 ||
-      (isInstanced && instanceCount === 0)
-    ) {
-      return false;
-    }
-
-    vertexArray.bindForDraw(vertexCount, instanceCount, () => {
-      if (framebuffer !== undefined) {
-        parameters = Object.assign({}, parameters, {framebuffer});
-      }
-
-      if (transformFeedback) {
-        const primitiveMode = getPrimitiveDrawMode(drawMode);
-        transformFeedback.begin(primitiveMode);
-      }
-
-      this._bindTextures();
-
-      withParameters(this.gl, parameters, () => {
-        // TODO - Use polyfilled WebGL2RenderingContext instead of ANGLE extension
-        if (isIndexed && isInstanced) {
-          this.gl2.drawElementsInstanced(drawMode, vertexCount, indexType, offset, instanceCount);
-        } else if (isIndexed && isWebGL2(this.gl) && !isNaN(start) && !isNaN(end)) {
-          this.gl2.drawRangeElements(drawMode, start, end, vertexCount, indexType, offset);
-        } else if (isIndexed) {
-          this.gl.drawElements(drawMode, vertexCount, indexType, offset);
-        } else if (isInstanced) {
-          this.gl2.drawArraysInstanced(drawMode, offset, vertexCount, instanceCount);
-        } else {
-          this.gl.drawArrays(drawMode, offset, vertexCount);
-        }
-      });
-
-      if (transformFeedback) {
-        transformFeedback.end();
-      }
-    });
-
-    return true;
-  }
-
-  setUniforms(uniforms = {}) {
-    if (log.priority >= 2) {
-      checkUniformValues(uniforms, this.id, this._uniformSetters);
-    }
-
-    this.gl.useProgram(this.handle);
-
-    for (const uniformName in uniforms) {
-      const uniform = uniforms[uniformName];
-      const uniformSetter = this._uniformSetters[uniformName];
-
-      if (uniformSetter) {
-        let value = uniform;
-        let textureUpdate = false;
-
-        if (value instanceof Framebuffer) {
-          value = value.texture;
-        }
-        if (value instanceof Texture) {
-          textureUpdate = this.uniforms[uniformName] !== uniform;
-
-          if (textureUpdate) {
-            // eslint-disable-next-line max-depth
-            // @ts-expect-error
-            if (uniformSetter.textureIndex === undefined) {
-              // @ts-expect-error
-              uniformSetter.textureIndex = this._textureIndexCounter++;
-            }
-
-            // Bind texture to index
-            const texture = value;
-            // @ts-expect-error
-            const {textureIndex} = uniformSetter;
-
-            texture.bind(textureIndex);
-            value = textureIndex;
-
-            this._textureUniforms[uniformName] = texture;
-          } else {
-            // @ts-expect-error
-            value = uniformSetter.textureIndex;
-          }
-        } else if (this._textureUniforms[uniformName]) {
-          delete this._textureUniforms[uniformName];
-        }
-
-        // NOTE(Tarek): uniformSetter returns whether
-        //   value had to be updated or not.
-        if (uniformSetter(value) || textureUpdate) {
-          copyUniform(this.uniforms, uniformName, uniform);
-        }
-      }
-    }
-
-    return this;
-  }
-
-  // PRIVATE METHODS
-
-  // Checks if all texture-values uniforms are renderable (i.e. loaded)
-  // Update a texture if needed (e.g. from video)
-  // Note: This is currently done before every draw call
-  _areTexturesRenderable() {
-    let texturesRenderable = true;
-
-    for (const uniformName in this._textureUniforms) {
-      const texture = this._textureUniforms[uniformName];
-      texture.update();
-      texturesRenderable = texturesRenderable && texture.loaded;
-    }
-
-    return texturesRenderable;
-  }
-
-  // Binds textures
-  // Note: This is currently done before every draw call
-  _bindTextures() {
-    for (const uniformName in this._textureUniforms) {
-      // @ts-expect-error
-      const textureIndex = this._uniformSetters[uniformName].textureIndex;
-      this._textureUniforms[uniformName].bind(textureIndex);
-    }
-  }
-
-  // RESOURCE METHODS
-
-  _createHandle() {
-    return this.gl.createProgram();
-  }
-
-  _deleteHandle() {
-    this.gl.deleteProgram(this.handle);
-  }
-
-  // Extract opts needed to initialize a `Program` from an independently created WebGLProgram handle
-  _getOptionsFromHandle(handle) {
-    const shaderHandles = this.gl.getAttachedShaders(handle);
-    const opts = {};
-    for (const shaderHandle of shaderHandles) {
-      const type = this.gl.getShaderParameter(this.handle, GL.SHADER_TYPE);
-      switch (type) {
-        case GL.VERTEX_SHADER:
-          // @ts-expect-error
-          opts.vs = new VertexShader({handle: shaderHandle});
-          break;
-        case GL.FRAGMENT_SHADER:
-          // @ts-expect-error
-          opts.fs = new FragmentShader({handle: shaderHandle});
-          break;
-        default:
-      }
-    }
-    return opts;
-  }
-
-  _getParameter(pname) {
-    return this.gl.getProgramParameter(this.handle, pname);
-  }
-
-  // If program is not named, name it after shader names
-  // TODO - this.id will already have been initialized
-  _setId(id) {
-    if (!id) {
-      const programName = this._getName();
-      this.id = uid(programName);
-    }
-  }
-
-  // Generate a default name for the program based on names of the shaders
-  _getName() {
-    // let programName = this.vs.getName() || this.fs.getName();
-    let programName = this.vs.id || this.fs.id;
-    programName = programName.replace(/shader/i, '');
-    programName = programName ? `${programName}-program` : 'program';
-    return programName;
-  }
-
-  _compileAndLink() {
-    const {gl} = this;
-    gl.attachShader(this.handle, this.vs.handle);
-    gl.attachShader(this.handle, this.fs.handle);
-    log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this._getName()}`)();
-    gl.linkProgram(this.handle);
-    log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this._getName()}`)();
-
-    // Avoid checking program linking error in production
-    // @ts-expect-error
-    if (gl.debug || log.level > 0) {
-      const linked = gl.getProgramParameter(this.handle, gl.LINK_STATUS);
-      if (!linked) {
-        throw new Error(`Error linking: ${gl.getProgramInfoLog(this.handle)}`);
-      }
-
-      gl.validateProgram(this.handle);
-      const validated = gl.getProgramParameter(this.handle, gl.VALIDATE_STATUS);
-      if (!validated) {
-        throw new Error(`Error validating: ${gl.getProgramInfoLog(this.handle)}`);
-      }
-    }
-  }
-
-  // query uniform locations and build name to setter map.
-  // TODO - This overlaps with ProgramConfiguration?
-  _readUniformLocationsFromLinkedProgram() {
-    const {gl} = this;
-    this._uniformSetters = {};
-    this._uniformCount = this._getParameter(GL.ACTIVE_UNIFORMS);
-    for (let i = 0; i < this._uniformCount; i++) {
-      const info = this.gl.getActiveUniform(this.handle, i);
-      const {name} = parseUniformName(info.name);
-      let location = gl.getUniformLocation(this.handle, name);
-      // @ts-expect-error
-      this._uniformSetters[name] = getUniformSetter(gl, location, info);
-      if (info.size > 1) {
-        for (let l = 0; l < info.size; l++) {
-          location = gl.getUniformLocation(this.handle, `${name}[${l}]`);
-          // @ts-expect-error
-          this._uniformSetters[`${name}[${l}]`] = getUniformSetter(gl, location, info);
-        }
-      }
-    }
-    this._textureIndexCounter = 0;
-  }
-
-  // TO BE REMOVED in v7?
-
-  // Rretrieves information about active uniforms identifed by their indices (`uniformIndices`)
-  // https://
-  // developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/getActiveUniforms
-  getActiveUniforms(uniformIndices, pname) {
-    return this.gl2.getActiveUniforms(this.handle, uniformIndices, pname);
-  }
-
-  // Retrieves the index of a uniform block
-  getUniformBlockIndex(blockName) {
-    return this.gl2.getUniformBlockIndex(this.handle, blockName);
-  }
-
-  // Retrieves information about an active uniform block (`blockIndex`)
-  // https://
-  // developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/getActiveUniformBlockParameter
-  getActiveUniformBlockParameter(blockIndex, pname) {
-    return this.gl2.getActiveUniformBlockParameter(this.handle, blockIndex, pname);
-  }
-
-  // Binds a uniform block (`blockIndex`) to a specific binding point (`blockBinding`)
-  uniformBlockBinding(blockIndex, blockBinding) {
-    this.gl2.uniformBlockBinding(this.handle, blockIndex, blockBinding);
-  }
-}

package/src/classes/query.ts

@@ -1,171 +0,0 @@
-// WebGL2 Query (also handles disjoint timer extensions)
-import {assert} from '@luma.gl/api';
-import WebGLDevice from '../adapter/webgl-device';
-import {isWebGL2} from '../context/context/webgl-checks';
-import WebGLResource, {ResourceProps} from './webgl-resource';
-
-const GL_QUERY_RESULT = 0x8866; // Returns a GLuint containing the query result.
-const GL_QUERY_RESULT_AVAILABLE = 0x8867; // whether query result is available.
-
-const GL_TIME_ELAPSED_EXT = 0x88bf; // Elapsed time (in nanoseconds).
-const GL_GPU_DISJOINT_EXT = 0x8fbb; // Whether GPU performed any disjoint operation.
-
-const GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8c88; // #primitives written to feedback buffers
-const GL_ANY_SAMPLES_PASSED = 0x8c2f; // Occlusion query (if drawing passed depth test)
-const GL_ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8d6a; // Occlusion query less accurate/faster version
-
-export type QueryProps = ResourceProps & {
-};
-
-/**
- * Asynchronous queries for different kinds of information
- */
-export default class Query extends WebGLResource<QueryProps> {
-  // Returns true if Query is supported by the WebGL implementation
-  // Can also check whether timestamp queries are available.
-  static isSupported(gl: WebGLRenderingContext, options: string[] = []): boolean {
-    const webgl2 = isWebGL2(gl);
-
-    // Initial value
-    const webglDevice = WebGLDevice.fromContext(gl);
-    const hasTimerQuery = webglDevice.features.has('webgl-timer-query');
-    let supported = webgl2 || hasTimerQuery;
-
-    for (const key of options) {
-      switch (key) {
-        case 'queries':
-          supported = supported && webgl2;
-          break;
-        case 'timers':
-          supported = supported && hasTimerQuery;
-          break;
-        default:
-          assert(false);
-      }
-    }
-
-    return supported;
-  }
-
-  target = null;
-  _queryPending = false;
-  _pollingPromise = null;
-
-  // Create a query class
-  constructor(gl: WebGLRenderingContext, opts: QueryProps = {}) {
-    super(WebGLDevice.attach(gl), opts, {} as any);
-    Object.seal(this);
-  }
-
-  // Shortcut for timer query (dependent on extension in both WebGL1 and 2)
-  // Measures GPU time delta between this call and a matching `end` call in the
-  // GPU instruction stream.
-  beginTimeElapsedQuery(): this {
-    return this.begin(GL_TIME_ELAPSED_EXT);
-  }
-
-  // Shortcut for occlusion queries
-  beginOcclusionQuery(options?: {conservative?: boolean}): this {
-    return this.begin(options?.conservative ? GL_ANY_SAMPLES_PASSED_CONSERVATIVE : GL_ANY_SAMPLES_PASSED);
-  }
-
-  // Shortcut for transformFeedbackQuery
-  beginTransformFeedbackQuery(): this {
-    return this.begin(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
-  }
-
-  // Due to OpenGL API limitations, after calling `begin()` on one Query
-  // instance, `end()` must be called on that same instance before
-  // calling `begin()` on another query. While there can be multiple
-  // outstanding queries representing disjoint `begin()`/`end()` intervals.
-  // It is not possible to interleave or overlap `begin` and `end` calls.
-  begin(target: number): this {
-    // Don't start a new query if one is already active.
-    if (this._queryPending) {
-      return this;
-    }
-
-    this.target = target;
-    this.gl2.beginQuery(this.target, this.handle);
-
-    return this;
-  }
-
-  // ends the current query
-  end(): this {
-    // Can't end a new query if the last one hasn't been resolved.
-    if (this._queryPending) {
-      return this;
-    }
-
-    if (this.target) {
-      this.gl2.endQuery(this.target);
-      this.target = null;
-      this._queryPending = true;
-    }
-    return this;
-  }
-
-  // Returns true if the query result is available
-  isResultAvailable(): boolean {
-    if (!this._queryPending) {
-      return false;
-    }
-
-    const resultAvailable = this.gl2.getQueryParameter(this.handle, GL_QUERY_RESULT_AVAILABLE);
-    if (resultAvailable) {
-      this._queryPending = false;
-    }
-    return resultAvailable;
-  }
-
-  // Timing query is disjoint, i.e. results are invalid
-  isTimerDisjoint(): boolean {
-    return this.gl2.getParameter(GL_GPU_DISJOINT_EXT);
-  }
-
-  // Returns query result.
-  getResult(): any {
-    return this.gl2.getQueryParameter(this.handle, GL_QUERY_RESULT);
-  }
-
-  // Returns the query result, converted to milliseconds to match JavaScript conventions.
-  getTimerMilliseconds() {
-    return this.getResult() / 1e6;
-  }
-
-  // Polls the query
-  createPoll(limit: number = Number.POSITIVE_INFINITY): Promise<any> {
-    if (this._pollingPromise) {
-      return this._pollingPromise;
-    }
-
-    let counter = 0;
-
-    this._pollingPromise = new Promise((resolve, reject) => {
-      const poll = () => {
-        if (this.isResultAvailable()) {
-          resolve(this.getResult());
-          this._pollingPromise = null;
-        } else if (counter++ > limit) {
-          reject('Timed out');
-          this._pollingPromise = null;
-        } else {
-          requestAnimationFrame(poll);
-        }
-      };
-
-      requestAnimationFrame(poll);
-    });
-
-    return this._pollingPromise;
-  }
-
-  _createHandle() {
-    return Query.isSupported(this.gl) ? this.gl2.createQuery() : null;
-  }
-
-  _deleteHandle() {
-    this.gl2.deleteQuery(this.handle);
-  }
-}