@luma.gl/webgl 9.1.0-alpha.2 → 9.1.0-beta.1

package/src/context/state-tracker/{track-context-state.ts → webgl-state-tracker.ts}

@@ -2,37 +2,43 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-// Support for listening to context state changes and intercepting state queries
-// NOTE: this system does not handle buffer bindings
+import {setGLParameters, getGLParameters} from '../parameters/unified-parameter-api';
+import {deepArrayEqual} from './deep-array-equal';
 import {
   GL_PARAMETER_DEFAULTS,
   GL_HOOKED_SETTERS,
   NON_CACHE_PARAMETERS
 } from '../parameters/webgl-parameter-tables';
-import {setGLParameters, getGLParameters} from '../parameters/unified-parameter-api';
-import {deepArrayEqual} from './deep-array-equal';
 
-// HELPER CLASS - GLState
+// HELPER CLASS - WebGLStateTracker
+
+/**
+ * Support for listening to context state changes and intercepting state queries
+ * NOTE: this system does not handle buffer bindings
+ */
+export class WebGLStateTracker {
+  static get(gl: WebGL2RenderingContext): WebGLStateTracker {
+    // @ts-expect-error
+    return gl.state as WebGLStateTracker;
+  }
 
-/* eslint-disable no-shadow */
-class GLState {
   gl: WebGL2RenderingContext;
   program: unknown = null;
   stateStack: object[] = [];
   enable = true;
-  cache: Record<string, any>;
+  cache: Record<string, any> = null!;
   log;
 
+  protected initialized = false;
+
   constructor(
     gl: WebGL2RenderingContext,
-    {
-      copyState = false, // Copy cache from params (slow) or initialize from WebGL defaults (fast)
-      log = () => {} // Logging function, called when gl parameter change calls are actually issued
-    } = {}
+    props?: {
+      log; // Logging function, called when gl parameter change calls are actually issued
+    }
   ) {
     this.gl = gl;
-    this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
-    this.log = log;
+    this.log = props?.log || (() => {});
 
     this._updateCache = this._updateCache.bind(this);
     Object.seal(this);
@@ -51,6 +57,38 @@ class GLState {
     this.stateStack.pop();
   }
 
+  /**
+   * Initialize WebGL state caching on a context
+   * can be called multiple times to enable/disable
+   *
+   * @note After calling this function, context state will be cached
+   * .push() and .pop() will be available for saving,
+   * temporarily modifying, and then restoring state.
+   */
+  trackState(gl: WebGL2RenderingContext, options?: {copyState?: boolean}): void {
+    this.cache = options.copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
+
+    if (this.initialized) {
+      throw new Error('WebGLStateTracker');
+    }
+    this.initialized = true;
+
+    // @ts-expect-error
+    this.gl.state = this;
+
+    installProgramSpy(gl);
+
+    // intercept all setter functions in the table
+    for (const key in GL_HOOKED_SETTERS) {
+      const setter = GL_HOOKED_SETTERS[key];
+      installSetterSpy(gl, key, setter);
+    }
+
+    // intercept all getter functions in the table
+    installGetterOverride(gl, 'getParameter');
+    installGetterOverride(gl, 'isEnabled');
+  }
+
   /**
   // interceptor for context set functions - update our cache and our stack
   // values (Object) - the key values for this setter
@@ -89,83 +127,6 @@ class GLState {
   }
 }
 
-function getContextState(gl: WebGL2RenderingContext): GLState {
-  // @ts-expect-error
-  return gl.state as GLState;
-}
-
-// PUBLIC API
-
-/**
- * Initialize WebGL state caching on a context
- * can be called multiple times to enable/disable
- *
- * @note After calling this function, context state will be cached
- * gl.state.push() and gl.state.pop() will be available for saving,
- * temporarily modifying, and then restoring state.
- */
-export function trackContextState(
-  gl: WebGL2RenderingContext,
-  options?: {
-    enable?: boolean;
-    copyState?: boolean;
-    log?: any;
-  }
-): WebGL2RenderingContext {
-  const {enable = true, copyState} = options || {};
-  // assert(copyState !== undefined);
-  // @ts-expect-error
-  if (!gl.state) {
-    // @ts-ignore
-    // const {polyfillContext} = global_;
-    // if (polyfillContext) {
-    //   polyfillContext(gl);
-    // }
-
-    // Create a state cache
-    // @ts-expect-error
-    gl.state = new GLState(gl, {copyState});
-
-    installProgramSpy(gl);
-
-    // intercept all setter functions in the table
-    for (const key in GL_HOOKED_SETTERS) {
-      const setter = GL_HOOKED_SETTERS[key];
-      installSetterSpy(gl, key, setter);
-    }
-
-    // intercept all getter functions in the table
-    installGetterOverride(gl, 'getParameter');
-    installGetterOverride(gl, 'isEnabled');
-  }
-
-  const glState = getContextState(gl);
-  glState.enable = enable;
-
-  return gl;
-}
-
-/**
- * Saves current WebGL context state onto an internal per-context stack
- */
-export function pushContextState(gl: WebGL2RenderingContext): void {
-  let glState = getContextState(gl);
-  if (!glState) {
-    trackContextState(gl, {copyState: false});
-    glState = getContextState(gl);
-  }
-  glState.push();
-}
-
-/**
- * Restores previously saved WebGL context state
- */
-export function popContextState(gl: WebGL2RenderingContext): void {
-  const glState = getContextState(gl);
-  // assert(glState);
-  glState.pop();
-}
-
 // HELPER FUNCTIONS - INSTALL GET/SET INTERCEPTORS (SPYS) ON THE CONTEXT
 
 /**
@@ -185,7 +146,7 @@ function installGetterOverride(gl: WebGL2RenderingContext, functionName: string)
       return originalGetterFunc(pname);
     }
 
-    const glState = getContextState(gl);
+    const glState = WebGLStateTracker.get(gl);
     if (!(pname in glState.cache)) {
       // WebGL limits are not prepopulated in the cache, call the original getter when first queried.
       glState.cache[pname] = originalGetterFunc(pname);
@@ -229,7 +190,7 @@ function installSetterSpy(gl: WebGL2RenderingContext, functionName: string, sett
   gl[functionName] = function set(...params) {
     // Update the value
     // Call the setter with the state cache and the params so that it can store the parameters
-    const glState = getContextState(gl);
+    const glState = WebGLStateTracker.get(gl);
     // eslint-disable-next-line @typescript-eslint/unbound-method
     const {valueChanged, oldValue} = setter(glState._updateCache, ...params);
 
@@ -257,7 +218,7 @@ function installProgramSpy(gl: WebGL2RenderingContext): void {
   const originalUseProgram = gl.useProgram.bind(gl);
 
   gl.useProgram = function useProgramLuma(handle) {
-    const glState = getContextState(gl);
+    const glState = WebGLStateTracker.get(gl);
     if (glState.program !== handle) {
       originalUseProgram(handle);
       glState.program = handle;

package/src/context/state-tracker/with-parameters.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import {GLParameters, setGLParameters} from '../parameters/unified-parameter-api';
-import {pushContextState, popContextState} from './track-context-state';
+import {WebGLStateTracker} from './webgl-state-tracker';
 
 /**
  * Execute a function with a set of temporary WebGL parameter overrides
@@ -25,7 +25,8 @@ export function withGLParameters(
 
   const {nocatch = true} = parameters;
 
-  pushContextState(gl);
+  const webglState = WebGLStateTracker.get(gl);
+  webglState.push();
   setGLParameters(gl, parameters);
 
   // Setup is done, call the function
@@ -34,13 +35,13 @@ export function withGLParameters(
   if (nocatch) {
     // Avoid try catch to minimize stack size impact for safe execution paths
     value = func(gl);
-    popContextState(gl);
+    webglState.pop();
   } else {
     // Wrap in a try-catch to ensure that parameters are restored on exceptions
     try {
       value = func(gl);
     } finally {
-      popContextState(gl);
+      webglState.pop();
     }
   }
 

package/src/{classic → deprecated}/accessor.ts

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Buffer} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
-import {getTypedArrayFromGLType} from './typed-array-utils';
+import {Buffer, log} from '@luma.gl/core';
+import {GL, GLDataType, GLPixelType} from '@luma.gl/constants';
+import {TypedArrayConstructor} from '@math.gl/types';
 
 /**
  * Attribute descriptor object
@@ -81,6 +81,7 @@ export class Accessor implements AccessorObject {
   }
 
   constructor(...accessors: AccessorObject[]) {
+    log.warn('Accessor will be removed in next minor release');
     accessors.forEach(accessor => this._assign(accessor)); // Merge in sequence
     Object.freeze(this);
   }
@@ -180,5 +181,45 @@ export class Accessor implements AccessorObject {
   }
 }
 
+/**
+ * Converts GL constant to corresponding TYPED ARRAY
+ * Used to auto deduce gl parameter types
+ * @deprecated Use getTypedArrayFromDataType
+ * @param glType
+ * @param param1
+ * @returns
+ */
+// eslint-disable-next-line complexity
+function getTypedArrayFromGLType(
+  glType: GLDataType | GLPixelType,
+  options?: {
+    clamped?: boolean;
+  }
+): TypedArrayConstructor {
+  const {clamped = true} = options || {};
+  // Sorted in some order of likelihood to reduce amount of comparisons
+  switch (glType) {
+    case GL.FLOAT:
+      return Float32Array;
+    case GL.UNSIGNED_SHORT:
+    case GL.UNSIGNED_SHORT_5_6_5:
+    case GL.UNSIGNED_SHORT_4_4_4_4:
+    case GL.UNSIGNED_SHORT_5_5_5_1:
+      return Uint16Array;
+    case GL.UNSIGNED_INT:
+      return Uint32Array;
+    case GL.UNSIGNED_BYTE:
+      return clamped ? Uint8ClampedArray : Uint8Array;
+    case GL.BYTE:
+      return Int8Array;
+    case GL.SHORT:
+      return Int16Array;
+    case GL.INT:
+      return Int32Array;
+    default:
+      throw new Error('Failed to deduce typed array type from GL constant');
+  }
+}
+
 // TEST EXPORTS
 export {DEFAULT_ACCESSOR_VALUES};

package/src/index.ts

@@ -12,6 +12,10 @@
 export type {WebGLDeviceLimits} from './adapter/device-helpers/webgl-device-limits';
 
 // WebGL adapter classes
+export {webgl2Adapter} from './adapter/webgl-adapter';
+export type {WebGLAdapter} from './adapter/webgl-adapter';
+
+// WebGL Device classes
 export {WebGLDevice} from './adapter/webgl-device';
 export {WebGLCanvasContext} from './adapter/webgl-canvas-context';
 
@@ -34,7 +38,7 @@ export {WEBGLVertexArray} from './adapter/resources/webgl-vertex-array';
 export {WEBGLTransformFeedback} from './adapter/resources/webgl-transform-feedback';
 
 // WebGL adapter classes
-export {Accessor} from './classic/accessor';
+export {Accessor} from './deprecated/accessor';
 export type {AccessorObject} from './types';
 
 // Unified parameter API
@@ -42,19 +46,10 @@ export type {AccessorObject} from './types';
 export {setDeviceParameters, withDeviceParameters} from './adapter/converters/device-parameters';
 
 // HELPERS - EXPERIMENTAL
-export {getShaderLayout} from './adapter/helpers/get-shader-layout';
-
-// TEST EXPORTS
-export {TEXTURE_FORMATS as _TEXTURE_FORMATS} from './adapter/converters/texture-formats';
+export {getShaderLayoutFromGLSL} from './adapter/helpers/get-shader-layout';
+export {WebGLStateTracker} from './context/state-tracker/webgl-state-tracker';
 
 // DEPRECATED TEST EXPORTS
-// State tracking
-export {
-  trackContextState,
-  pushContextState,
-  popContextState
-} from './context/state-tracker/track-context-state';
-
 export {
   resetGLParameters,
   setGLParameters,

package/src/utils/fill-array.ts

@@ -2,15 +2,15 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {NumberArray} from '@math.gl/types';
+import type {NumericArray} from '@math.gl/types';
 
 // Uses copyWithin to significantly speed up typed array value filling
 export function fillArray(options: {
-  target: NumberArray;
-  source: NumberArray;
+  target: NumericArray;
+  source: NumericArray;
   start?: number;
   count?: number;
-}): NumberArray {
+}): NumericArray {
   const {target, source, start = 0, count = 1} = options;
   const length = source.length;
   const total = count * length;

package/src/utils/split-uniforms-and-bindings.ts

@@ -5,7 +5,7 @@
 import type {UniformValue, Binding} from '@luma.gl/core';
 import {isNumericArray} from '@math.gl/types';
 
-export function isUniformValue(value: unknown): boolean {
+export function isUniformValue(value: unknown): value is UniformValue {
   return isNumericArray(value) !== null || typeof value === 'number' || typeof value === 'boolean';
 }
 
@@ -21,9 +21,9 @@ export function splitUniformsAndBindings(
   Object.keys(uniforms).forEach(name => {
     const uniform = uniforms[name];
     if (isUniformValue(uniform)) {
-      result.uniforms[name] = uniform as UniformValue;
+      result.uniforms[name] = uniform;
     } else {
-      result.bindings[name] = uniform as Binding;
+      result.bindings[name] = uniform;
     }
   });
 

package/src/utils/uid.ts

@@ -0,0 +1,16 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+const uidCounters: Record<string, number> = {};
+
+/**
+ * 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}`;
+}

package/dist/adapter/converters/texture-formats.d.ts

@@ -1,83 +0,0 @@
-import type { TextureFormat, DeviceFeature } from '@luma.gl/core';
-import { GL, GLPixelType, GLExtensions, GLTexelDataFormat } from '@luma.gl/constants';
-export declare const TEXTURE_FEATURES: Partial<Record<DeviceFeature, string[]>>;
-/** Return a list of texture feature strings (for Device.features). Mainly compressed texture support */
-export declare function isTextureFeature(feature: DeviceFeature): boolean;
-/** Checks a texture feature (for Device.features). Mainly compressed texture support */
-export declare function checkTextureFeature(gl: WebGL2RenderingContext, feature: DeviceFeature, extensions: GLExtensions): boolean;
-/** Map a format to webgl and constants */
-type Format = {
-    gl?: GL;
-    /** format requires WebGL2, when using a WebGL 1 context, color renderbuffer formats are limited */
-    gl2ext?: string;
-    /** (bytes per pixel), for memory usage calculations. */
-    b?: number;
-    /** channels */
-    c?: number;
-    bpp?: number;
-    /** packed */
-    p?: number;
-    /** compressed */
-    x?: string;
-    /** for compressed texture formats */
-    f?: DeviceFeature;
-    /** renderable if feature is present */
-    render?: DeviceFeature;
-    /** filterable if feature is present */
-    filter?: DeviceFeature;
-    /** If not supported on WebGPU */
-    wgpu?: false;
-    types?: GLPixelType[];
-    dataFormat?: GLTexelDataFormat;
-    /** Depth and stencil format attachment points. If set, needs to be a Renderbuffer unless depthTexture is set  */
-    attachment?: GL.DEPTH_ATTACHMENT | GL.STENCIL_ATTACHMENT | GL.DEPTH_STENCIL_ATTACHMENT;
-    /** if depthTexture is set this is a depth/stencil format that can be set to a texture  */
-    depthTexture?: boolean;
-    /** @deprecated can this format be used with renderbuffers */
-    rb?: boolean;
-};
-/**
- * Texture format data -
- * Exported but can change without notice
- */
-export declare const TEXTURE_FORMATS: Record<TextureFormat, Format>;
-/** Checks if a texture format is supported */
-export declare function isTextureFormatSupported(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
-export declare function isRenderbufferFormatSupported(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
-/** Checks if a texture format is supported */
-export declare function getTextureFormatSupport(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): {
-    supported: boolean;
-    filterable?: boolean;
-    renderable?: boolean;
-    blendable?: boolean;
-    storable?: boolean;
-};
-/** Checks whether linear filtering (interpolated sampling) is available for floating point textures */
-export declare function isTextureFormatFilterable(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
-export declare function isTextureFormatRenderable(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
-/** Get parameters necessary to work with format in WebGL: internalFormat, dataFormat, type, compressed, */
-export declare function getTextureFormatWebGL(format: TextureFormat): {
-    internalFormat: GL;
-    format: GLTexelDataFormat;
-    type: GLPixelType;
-    compressed: boolean;
-};
-export declare function getDepthStencilAttachmentWebGL(format: TextureFormat): GL.DEPTH_ATTACHMENT | GL.STENCIL_ATTACHMENT | GL.DEPTH_STENCIL_ATTACHMENT;
-/** TODO - VERY roundabout legacy way of calculating bytes per pixel */
-export declare function getTextureFormatBytesPerPixel(format: TextureFormat): number;
-export declare function getWebGLPixelDataFormat(dataFormat: string, integer: boolean, normalized: boolean, format: GL): GLTexelDataFormat;
-export {};
-/**
- * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
-export function convertGLToTextureFormat(format: GL | TextureFormat): TextureFormat {
-  if (typeof format === 'string') {
-    return format;
-  }
-  const entry = Object.entries(TEXTURE_FORMATS).find(([, entry]) => entry.gl === format);
-  if (!entry) {
-    throw new Error(`Unknown texture format ${format}`);
-  }
-  return entry[0] as TextureFormat;
-}
- */
-//# sourceMappingURL=texture-formats.d.ts.map

package/dist/adapter/converters/texture-formats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"texture-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/texture-formats.ts"],"names":[],"mappings":"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"}