@luma.gl/webgl 9.0.0-alpha.4 → 9.0.0-alpha.40

package/src/context/polyfill/get-parameter-polyfill.ts

@@ -1,5 +1,8 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 /* eslint-disable no-inline-comments, max-len, camelcase */
-import GL from '@luma.gl/constants';
+import {GL} from '@luma.gl/constants';
 import {isWebGL2} from '../context/webgl-checks';
 
 const OES_element_index = 'OES_element_index';
@@ -31,7 +34,7 @@ const WEBGL_PARAMETERS = {
   [GL.SAMPLES]: getWebGL2ValueOrZero,
 
   // WebGL2 extension context parameters
-  [GL_GPU_DISJOINT_EXT]: (gl, getParameter) => {
+  [GL_GPU_DISJOINT_EXT]: (gl: WebGLRenderingContext, getParameter) => {
     const ext = isWebGL2(gl)
       ? gl.getExtension(EXT_disjoint_timer_query_webgl2)
       : gl.getExtension(EXT_disjoint_timer_query);
@@ -39,18 +42,19 @@ const WEBGL_PARAMETERS = {
   },
 
   // Extension fixed values
-  [GL_UNMASKED_VENDOR_WEBGL]: (gl, getParameter) => {
+  [GL_UNMASKED_VENDOR_WEBGL]: (gl: WebGLRenderingContext, getParameter) => {
     const ext = gl.getExtension(WEBGL_debug_renderer_info);
     return getParameter((ext && ext.UNMASKED_VENDOR_WEBGL) || GL.VENDOR);
   },
 
-  [GL_UNMASKED_RENDERER_WEBGL]: (gl, getParameter) => {
+  [GL_UNMASKED_RENDERER_WEBGL]: (gl: WebGLRenderingContext, getParameter) => {
     const ext = gl.getExtension(WEBGL_debug_renderer_info);
     return getParameter((ext && ext.UNMASKED_RENDERER_WEBGL) || GL.RENDERER);
   },
 
   // Extension LIMITS
-  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl, getParameter) => {
+  [GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT]: (gl: WebGLRenderingContext, getParameter) => {
+    // @ts-ignore TODO - store these on the device instance instead...
     const ext = gl.luma?.extensions?.[EXT_texture_filter_anisotropic] ||
       gl.getExtension('EXT_texture_filter_anisotropic');
     return ext ? getParameter(ext.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 1.0;
@@ -60,7 +64,7 @@ const WEBGL_PARAMETERS = {
   [GL.MAX_3D_TEXTURE_SIZE]: getWebGL2ValueOrZero,
   [GL.MAX_ARRAY_TEXTURE_LAYERS]: getWebGL2ValueOrZero,
   [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: getWebGL2ValueOrZero,
-  [GL.MAX_COLOR_ATTACHMENTS]: (gl, getParameter) => {
+  [GL.MAX_COLOR_ATTACHMENTS]: (gl: WebGLRenderingContext, getParameter) => {
     if (!isWebGL2(gl)) {
       const ext = gl.getExtension(WEBGL_draw_buffers);
       return ext ? getParameter(ext.MAX_COLOR_ATTACHMENTS_WEBGL) : 0;
@@ -108,7 +112,7 @@ const WEBGL_PARAMETERS = {
 
 // A "replacement" gl.getParameter that accepts "enums" from extensions and WebGL2
 // and returns reasonably safe defaults
-export function getParameterPolyfill(gl, originalGetParameter, pname) {
+export function getParameterPolyfill(gl: WebGLRenderingContext, originalGetParameter, pname) {
   // Return mock limits (usually 0) for WebGL2 constants to ensure these
   // can be queries without error
   const limit = WEBGL_PARAMETERS[pname];

package/src/context/polyfill/polyfill-context.ts

@@ -1,3 +1,6 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 // WebGL1/WebGL2 extension polyfill support
 //
 // Provides a function that creates polyfills for WebGL2 functions based
@@ -7,17 +10,17 @@
 // This is intended to be a stand-alone file with minimal dependencies,
 // easy to reuse or repurpose in other projects.
 
-import {assert} from '@luma.gl/api';
+import {assert} from '@luma.gl/core';
 import {polyfillVertexArrayObject} from './polyfill-vertex-array-object';
 
 import {WEBGL2_CONTEXT_POLYFILLS, WEBGL2_CONTEXT_OVERRIDES} from './polyfill-table';
-import {getContextState} from '../context/context-state';
+import {getContextData} from './context-data';
 
 /**
  * Registers extensions, polyfills or mock functions for extensions in the polyfills list
  */
 export function polyfillContext(gl: WebGLRenderingContext): WebGL2RenderingContext {
-  const contextState = getContextState(gl);
+  const contextState = getContextData(gl);
 
   if (!contextState._polyfilled) {
     polyfillVertexArrayObject(gl);
@@ -32,19 +35,17 @@ export function polyfillContext(gl: WebGLRenderingContext): WebGL2RenderingConte
 }
 
 function initializeExtensions(gl: WebGLRenderingContext): void {
-  const contextState = getContextState(gl);
+  const contextState = getContextData(gl);
   // `getSupportedExtensions` can return null when context is lost.
   const EXTENSIONS = gl.getSupportedExtensions() || [];
   for (const extensionName of EXTENSIONS) {
     const extension = gl.getExtension(extensionName);
     contextState._extensions[extensionName] = extension;
-    // TODO - this looks like a mistake?
-    contextState[extensionName] = extension;
   }
 }
 
 function installPolyfills(gl: WebGLRenderingContext, polyfills): void {
-  const contextState = getContextState(gl);
+  const contextState = getContextData(gl);
   for (const extension of Object.getOwnPropertyNames(polyfills)) {
     if (extension !== 'overrides') {
       polyfillExtension(gl, {extension, target: contextState, target2: gl});
@@ -65,7 +66,7 @@ function polyfillExtension(gl: WebGLRenderingContext, {extension, target, target
   for (const key of Object.keys(defaults)) {
     const extKey = `${key}${suffix}`;
 
-    let polyfill = null;
+    let polyfill: Function | null = null;
     if (key === 'meta') {
       // ignore
     } else if (typeof gl[key] === 'function') {
@@ -86,7 +87,7 @@ function polyfillExtension(gl: WebGLRenderingContext, {extension, target, target
 }
 
 /** Install simple overrides (mostly get* functions) */
-function installOverrides(gl, {target, target2}) {
+function installOverrides(gl: WebGLRenderingContext, {target, target2}) {
   Object.keys(WEBGL2_CONTEXT_OVERRIDES).forEach((key) => {
     if (typeof WEBGL2_CONTEXT_OVERRIDES[key] === 'function') {
       // install an override, if no implementation was detected

package/src/context/polyfill/polyfill-table.ts

@@ -1,10 +1,14 @@
-import {assert} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import {assert} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
 import {isWebGL2} from '../context/webgl-checks';
 
 import {getParameterPolyfill} from './get-parameter-polyfill';
-import {getContextState} from '../context/context-state';
+import {getContextData} from './context-data';
 
+/* eslint-disable camelcase */
 const OES_vertex_array_object = 'OES_vertex_array_object';
 const ANGLE_instanced_arrays = 'ANGLE_instanced_arrays';
 const WEBGL_draw_buffers = 'WEBGL_draw_buffers';
@@ -14,14 +18,14 @@ const EXT_texture_filter_anisotropic = 'EXT_texture_filter_anisotropic';
 const ERR_VAO_NOT_SUPPORTED = 'VertexArray requires WebGL2 or OES_vertex_array_object extension';
 
 // Return object with webgl2 flag and an extension
-function getExtensionData(gl, extension) {
+function getExtensionData(gl: WebGLRenderingContext, extension: string) {
   return {
     webgl2: isWebGL2(gl),
     ext: gl.getExtension(extension)
   };
 }
 
-// function mapExtensionConstant(gl, constant) {
+// function mapExtensionConstant(gl: WebGLRenderingContext, constant) {
 //   switch (constant) {
 //   case ext.FRAGMENT_SHADER_DERIVATIVE_HINT_OES: return GL.FRAGMENT_SHADER_DERIVATIVE_HINT;
 //   }
@@ -46,7 +50,7 @@ export const WEBGL2_CONTEXT_POLYFILLS = {
       //   VERTEX_ATTRIB_ARRAY_DIVISOR: 'VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE'
       // }
     },
-    vertexAttribDivisor(location, divisor) {
+    vertexAttribDivisor(location: number, divisor: number) {
       // Accept divisor 0 even if instancing is not supported (0 = no instancing)
       assert(divisor === 0, 'WebGL instanced rendering not supported');
     },
@@ -74,20 +78,20 @@ export const WEBGL2_CONTEXT_POLYFILLS = {
       assert(false);
     },
     endQuery: () => {},
-    getQuery(handle, pname) {
+    getQuery(handle, pname: string) {
       return this.getQueryObject(handle, pname);
     },
     // The WebGL1 extension uses getQueryObject rather then getQueryParameter
-    getQueryParameter(handle, pname) {
+    getQueryParameter(handle, pname: string) {
       return this.getQueryObject(handle, pname);
     },
-    getQueryObject: () => {}
+    getQueryObject: (handle: unknown, pname: unknown) => {}
   }
 };
 
 export const WEBGL2_CONTEXT_OVERRIDES = {
   // Ensure readBuffer is a no-op
-  readBuffer: (gl, originalFunc, attachment) => {
+  readBuffer: (gl: WebGLRenderingContext, originalFunc, attachment) => {
     if (isWebGL2(gl)) {
       originalFunc(attachment);
     } else {
@@ -95,7 +99,7 @@ export const WEBGL2_CONTEXT_OVERRIDES = {
     }
   },
   // Override for getVertexAttrib that returns sane values for non-WebGL1 constants
-  getVertexAttrib: (gl, originalFunc, location, pname) => {
+  getVertexAttrib: (gl: WebGLRenderingContext, originalFunc, location, pname) => {
     // const gl = this; // eslint-disable-line
     const {webgl2, ext} = getExtensionData(gl, ANGLE_instanced_arrays);
 
@@ -115,7 +119,7 @@ export const WEBGL2_CONTEXT_OVERRIDES = {
     return result !== undefined ? result : originalFunc(location, pname);
   },
   // Handle transform feedback and uniform block queries in WebGL1
-  getProgramParameter: (gl, originalFunc, program, pname) => {
+  getProgramParameter: (gl: WebGLRenderingContext, originalFunc, program, pname) => {
     if (!isWebGL2(gl)) {
       switch (pname) {
         case GL.TRANSFORM_FEEDBACK_BUFFER_MODE:
@@ -129,7 +133,7 @@ export const WEBGL2_CONTEXT_OVERRIDES = {
     }
     return originalFunc(program, pname);
   },
-  getInternalformatParameter: (gl, originalFunc, target, format, pname) => {
+  getInternalformatParameter: (gl: WebGLRenderingContext, originalFunc, target, format, pname) => {
     if (!isWebGL2(gl)) {
       switch (pname) {
         case GL.SAMPLES:
@@ -137,13 +141,14 @@ export const WEBGL2_CONTEXT_OVERRIDES = {
         default:
       }
     }
-    return gl.getInternalformatParameter(target, format, pname);
+    const gl2 = gl as WebGL2RenderingContext;
+    return gl2.getInternalformatParameter(target, format, pname);
   },
   getTexParameter(gl, originalFunc, target, pname) {
     switch (pname) {
       case GL.TEXTURE_MAX_ANISOTROPY_EXT:
-        const contextState = getContextState(gl);
-        const {_extensions} = contextState;
+        const contextData = getContextData(gl);
+        const {_extensions} = contextData;
         const ext = _extensions[EXT_texture_filter_anisotropic];
         pname = (ext && ext.TEXTURE_MAX_ANISOTROPY_EXT) || GL.TEXTURE_MAX_ANISOTROPY_EXT;
         break;

package/src/context/polyfill/polyfill-vertex-array-object.ts

@@ -1,3 +1,6 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 /*
  ** Copyright (c) 2015 The Khronos Group Inc.
  **
@@ -25,6 +28,7 @@
 // the global class.
 
 // @ts-nocheck external code
+/* eslint-disable */ 
 
 const glErrorShadow = {};
 
@@ -103,6 +107,7 @@ WebGLVertexArrayObjectOES.VertexAttrib.prototype.recache = function recache() {
 };
 
 const OESVertexArrayObject = function OESVertexArrayObject(gl) {
+  // eslint-disable-next-line @typescript-eslint/no-this-alias
   const self = this;
   this.gl = gl;
 

package/src/context/state-tracker/deep-array-equal.ts

@@ -1,3 +1,5 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
 
 /** deeply compare two arrays */
 export function deepArrayEqual(x: any, y: any): boolean {

package/src/context/state-tracker/track-context-state.ts

@@ -1,8 +1,11 @@
+// luma.gl, MIT license
+// 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 {assert} from '@luma.gl/api';
+import {assert} from '@luma.gl/core';
 import {GL_PARAMETER_DEFAULTS, GL_HOOKED_SETTERS, NON_CACHE_PARAMETERS} from '../parameters/webgl-parameter-tables';
-import {setParameters, getParameters} from '../parameters/unified-parameter-api';
+import {setGLParameters, getGLParameters} from '../parameters/unified-parameter-api';
 import {deepArrayEqual} from './deep-array-equal';
 
 // HELPER CLASS - GLState
@@ -10,21 +13,21 @@ import {deepArrayEqual} from './deep-array-equal';
 /* eslint-disable no-shadow */
 class GLState {
   gl: WebGLRenderingContext;
-  program = null;
-  stateStack = [];
+  program: unknown = null;
+  stateStack: object[] = [];
   enable = true;
-  cache;
+  cache: Record<string, any>;
   log;
 
   constructor(
-    gl,
+    gl: WebGLRenderingContext,
     {
       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
     } = {}
   ) {
     this.gl = gl;
-    this.cache = copyState ? getParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
+    this.cache = copyState ? getGLParameters(gl) : Object.assign({}, GL_PARAMETER_DEFAULTS);
     this.log = log;
 
     this._updateCache = this._updateCache.bind(this);
@@ -39,7 +42,7 @@ class GLState {
     assert(this.stateStack.length > 0);
     // Use the saved values in the state stack to restore parameters
     const oldValues = this.stateStack[this.stateStack.length - 1];
-    setParameters(this.gl, oldValues);
+    setGLParameters(this.gl, oldValues);
     // Don't pop until we have reset parameters (to make sure other "stack frames" are not affected)
     this.stateStack.pop();
   }
@@ -50,11 +53,11 @@ class GLState {
    * @param values
    * @returns
    */
-  _updateCache(values) {
+  _updateCache(values: {[key: number | string]: any}) {
     let valueChanged = false;
     let oldValue; // = undefined
 
-    const oldValues = this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1];
+    const oldValues: {[key: number | string]: any} | null = this.stateStack.length > 0 ? this.stateStack[this.stateStack.length - 1] : null;
 
     for (const key in values) {
       assert(key !== undefined);
@@ -96,7 +99,7 @@ function getContextState(gl: WebGLRenderingContext): GLState {
  * gl.state.push() and gl.state.pop() will be available for saving,
  * temporarily modifying, and then restoring state.
  */
- export function trackContextState(
+export function trackContextState(
   gl: WebGLRenderingContext,
   options?: {
     enable?: boolean;
@@ -108,7 +111,6 @@ function getContextState(gl: WebGLRenderingContext): GLState {
   assert(copyState !== undefined);
   // @ts-expect-error
   if (!gl.state) {
-    const global_ = typeof global !== 'undefined' ? global : window;
     // @ts-ignore
     // const {polyfillContext} = global_;
     // if (polyfillContext) {
@@ -141,7 +143,7 @@ function getContextState(gl: WebGLRenderingContext): GLState {
 /**
  * Saves current WebGL context state onto an internal per-context stack
  */
- export function pushContextState(gl: WebGLRenderingContext): void {
+export function pushContextState(gl: WebGLRenderingContext): void {
   let glState = getContextState(gl);
   if (!glState) {
     trackContextState(gl, {copyState: false});
@@ -188,9 +190,9 @@ function installGetterOverride(gl: WebGLRenderingContext, functionName: string)
     // Optionally call the original function to do a "hard" query from the WebGLRenderingContext
     return glState.enable
       ? // Call the getter the params so that it can e.g. serve from a cache
-        glState.cache[pname]
+      glState.cache[pname]
       : // Optionally call the original function to do a "hard" query from the WebGLRenderingContext
-        originalGetterFunc(pname);
+      originalGetterFunc(pname);
   };
 
   // Set the name of this anonymous function to help in debugging and profiling
@@ -209,12 +211,13 @@ function installGetterOverride(gl: WebGLRenderingContext, functionName: string)
  * @param setter
  * @returns
  */
-function installSetterSpy(gl: WebGLRenderingContext, functionName, setter) {
+function installSetterSpy(gl: WebGLRenderingContext, functionName: string, setter: Function) {
   // Get the original function from the WebGLRenderingContext
   if (!gl[functionName]) {
     // This could happen if we try to intercept WebGL2 method on a WebGL1 context
     return;
   }
+
   const originalSetterFunc = gl[functionName].bind(gl);
 
   // Wrap it with a spy so that we can update our state cache when it gets called
@@ -222,6 +225,7 @@ function installSetterSpy(gl: WebGLRenderingContext, functionName, setter) {
     // Update the value
     // Call the setter with the state cache and the params so that it can store the parameters
     const glState = getContextState(gl);
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     const {valueChanged, oldValue} = setter(glState._updateCache, ...params);
 
     // Call the original WebGLRenderingContext func to make sure the context actually gets updated

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

@@ -1,4 +1,9 @@
-import {GLParameters, setParameters} from '../parameters/unified-parameter-api';
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {Device} from '@luma.gl/core';
+import {WebGLDevice} from '../../adapter/webgl-device';
+import {GLParameters, setGLParameters} from '../parameters/unified-parameter-api';
 import {pushContextState, popContextState} from './track-context-state';
 
 /**
@@ -9,16 +14,19 @@ import {pushContextState, popContextState} from './track-context-state';
  * - Restores parameters
  * - Returns the return value of the supplied function
  */
- export function withParameters(gl: WebGLRenderingContext, parameters: GLParameters & {nocatch?: boolean}, func: any): any {
+export function withGLParameters(device: Device | WebGLRenderingContext, parameters: GLParameters & {nocatch?: boolean}, func: any): any {
+  const webglDevice = WebGLDevice.attach(device);
+  const gl = webglDevice.gl;
+
   if (isObjectEmpty(parameters)) {
     // Avoid setting state if no parameters provided. Just call and return
-    return func(gl);
+    return func(device);
   }
 
   const {nocatch = true} = parameters;
 
   pushContextState(gl);
-  setParameters(gl, parameters);
+  setGLParameters(gl, parameters);
 
   // Setup is done, call the function
   let value;
@@ -43,6 +51,7 @@ import {pushContextState, popContextState} from './track-context-state';
 
 // Returns true if given object is empty, false otherwise.
 function isObjectEmpty(object) {
+  // @ts-ignore - dummy key variable
   for (const key in object) {
     return false;
   }

package/src/index.ts

@@ -1,38 +1,46 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 // luma.gl Base WebGL wrapper library
 // Provides simple class/function wrappers around the low level webgl objects
 // These classes are intentionally close to the WebGL API
 // but make it easier to use.
 // Higher level abstractions can be built on these classes
 
-// Initialize any global state
-import '@luma.gl/api';
-import './init'
+// Types
+export type {WebGLLimits} from './adapter/device-helpers/device-limits';
 
-export {default as WebGLDevice} from './adapter/webgl-device';
-export {default as WebGLCanvasContext} from './adapter/webgl-canvas-context';
+export {registerHeadlessGL} from './context/context/create-headless-context';
 
-// Legacy WebGL Classes - will be moved to gltools
-export {default as Accessor} from './classic/accessor';
-export type {ClassicBufferProps as BufferProps} from './classic/buffer';
-export {default as Buffer} from './classic/buffer';
-export {default as WEBGLResource, default as WebGLResource} from './adapter/objects/webgl-resource';
-export {default as WEBGLBuffer} from './adapter/resources/webgl-buffer';
-export {default as WEBGLTexture} from './adapter/resources/webgl-texture';
-// export {default as WEBGLExternalTexture} from './adapter/resources/webgl-external-texture';
-export {default as WEBGLShader} from './adapter/resources/webgl-shader';
-export {default as WEBGLSampler} from './adapter/resources/webgl-sampler';
-export {default as WEBGLFramebuffer} from './adapter/resources/webgl-framebuffer';
+// WebGL adapter classes
+export {WebGLDevice} from './adapter/webgl-device';
+export {WebGLCanvasContext} from './adapter/webgl-canvas-context';
 
-export {default as WEBGLRenderPipeline} from './adapter/resources/webgl-render-pipeline';
+// WebGL Resource classes
+export {WebGLResource, WebGLResource as WEBGLResource} from './adapter/objects/webgl-resource';
+export {WEBGLBuffer} from './adapter/resources/webgl-buffer';
+export {WEBGLTexture} from './adapter/resources/webgl-texture';
+// export {WEBGLExternalTexture} from './adapter/resources/webgl-external-texture';
+export {WEBGLShader} from './adapter/resources/webgl-shader';
+export {WEBGLSampler} from './adapter/resources/webgl-sampler';
+export {WEBGLFramebuffer} from './adapter/resources/webgl-framebuffer';
 
-// export {default as WEBGLComputePipeline} from './adapter/resources/webgl-compute-pipeline';
-export {default as WEBGLCommandEncoder} from './adapter/resources/webgl-command-encoder';
-export {default as WEBGLRenderPass} from './adapter/resources/webgl-render-pass';
-//export {default as WEBGLComputePass} from './adapter/resources/webgl-compute-pass';
+export {WEBGLRenderPipeline} from './adapter/resources/webgl-render-pipeline';
+// export {WEBGLComputePipeline} from './adapter/resources/webgl-compute-pipeline';
+export {WEBGLCommandEncoder} from './adapter/resources/webgl-command-encoder';
+export {WEBGLRenderPass} from './adapter/resources/webgl-render-pass';
+// export {WEBGLComputePass} from './adapter/resources/webgl-compute-pass';
+export {WEBGLVertexArray} from './adapter/resources/webgl-vertex-array';
 
+// non-api resources
 export type {RenderbufferProps} from './adapter/objects/webgl-renderbuffer';
-export {default as WEBGLRenderbuffer} from './adapter/objects/webgl-renderbuffer';
-export {default as WEBGLVertexArrayObject} from './adapter/objects/webgl-vertex-array-object';
+export {WEBGLRenderbuffer} from './adapter/objects/webgl-renderbuffer';
+
+// WebGL adapter classes (Legacy will likely be removed)
+export {Accessor} from './classic/accessor';
+export type {AccessorObject} from './types';
+export type {BufferWithAccessorProps} from './classic/buffer-with-accessor';
+export {BufferWithAccessor} from './classic/buffer-with-accessor';
 
 export {
   isWebGL,
@@ -42,34 +50,60 @@ export {
   assertWebGL2Context
 } from './context/context/webgl-checks';
 
-// Device ratio
-export {cssToDeviceRatio, cssToDevicePixels} from './context/context/device-pixels';
-
 // Unified parameter API
 
 export {setDeviceParameters, withDeviceParameters} from './adapter/converters/device-parameters';
 
-export type {GLParameters} from './types/webgl';
+export type {GLParameters} from '@luma.gl/constants';
 export {
-  getParameters,
-  setParameters,
-  resetParameters
+  getGLParameters,
+  setGLParameters,
+  resetGLParameters
 } from './context/parameters/unified-parameter-api';
 
+export {withGLParameters} from './context/state-tracker/with-parameters';
+
+// HELPERS - EXPERIMENTAL
+export {getShaderLayout} from './adapter/helpers/get-shader-layout';
 export {
-  withParameters
-} from './context/state-tracker/with-parameters';
+  convertGLToTextureFormat,
+  _checkFloat32ColorAttachment
+} from './adapter/converters/texture-formats';
+
+// TEST EXPORTS
+export {TEXTURE_FORMATS as _TEXTURE_FORMATS} from './adapter/converters/texture-formats';
 
+// DEPRECATED EXPORTS
+export {clear} from './classic/clear';
+export {readPixelsToBuffer, readPixelsToArray, copyToTexture} from './classic/copy-and-blit';
 // State tracking
 export {
   trackContextState,
   pushContextState,
   popContextState
 } from './context/state-tracker/track-context-state';
-
 // Polyfills (supports a subset of WebGL2 APIs on WebGL1 contexts)
 export {polyfillContext} from './context/polyfill/polyfill-context';
 
 // HELPERS - EXPERIMENTAL
-export {getShaderLayout, getProgramBindings} from './adapter/helpers/get-shader-layout';
-export {_checkFloat32ColorAttachment} from './adapter/converters/texture-formats';
+// export {getShaderLayout, getProgramBindings} from './adapter/helpers/get-shader-layout';
+// export {convertGLToTextureFormat, _checkFloat32ColorAttachment} from './adapter/converters/texture-formats';
+// export {TEXTURE_FORMATS as _TEXTURE_FORMATS} from './adapter/converters/texture-formats';
+
+// // WebGL Types - Experimental exports
+// export type {
+//   GLDrawMode,
+//   GLPrimitive,
+//   GLDataType,
+//   GLPixelType,
+//   GLUniformType,
+//   GLSamplerType,
+//   GLCompositeType,
+//   GLFunction,
+//   GLBlendEquation,
+//   GLBlendFunction,
+//   GLStencilOp,
+//   GLSamplerParameters,
+//   GLValueParameters,
+//   GLFunctionParameters
+// } from '@luma.gl/constants';

package/src/types.ts

@@ -1,3 +1,6 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 export type AccessorObject = {
   size?: number;
   index?: number;
@@ -5,4 +8,6 @@ export type AccessorObject = {
   divisor?: number;
   offset?: number;
   stride?: number;
+  normalized?: boolean;
+  integer?: boolean;
 };

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

@@ -1,16 +0,0 @@
-import GL from '@luma.gl/constants';
-export declare function isRenderbufferFormatSupported(gl: WebGLRenderingContext, format: GL): boolean;
-export declare function getRenderbufferFormatBytesPerPixel(format: GL): number;
-/**
- * @param bpp "bytes per pixel", used for memory usage calculations.
- * @param gl2 requires WebGL2
- * @param ext requires extension
- */
-declare type RenderbufferFormat = {
-    bpp: number;
-    gl2?: boolean;
-    ext?: string;
-};
-declare const RENDERBUFFER_FORMATS: Record<string, RenderbufferFormat>;
-export default RENDERBUFFER_FORMATS;
-//# sourceMappingURL=renderbuffer-formats.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"renderbuffer-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/renderbuffer-formats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAGpC,wBAAgB,6BAA6B,CAAC,EAAE,EAAE,qBAAqB,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,CAa5F;AAED,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,EAAE,GAAG,MAAM,CAErE;AAKD;;;;GAIG;AACH,aAAK,kBAAkB,GAAG;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,QAAA,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAqD5D,CAAC;AAEF,eAAe,oBAAoB,CAAC"}