@luma.gl/webgl 9.3.0-alpha.6 → 9.3.0-alpha.8

package/src/adapter/resources/webgl-query-set.ts

@@ -1,6 +1,6 @@
 // WebGL2 QuerySet (also handles disjoint timer extensions)
 import {QuerySet, QuerySetProps} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
+import {GL} from '@luma.gl/webgl/constants';
 import {WebGLDevice} from '../webgl-device';
 
 type WebGLPendingQuery = {
@@ -8,6 +8,10 @@ type WebGLPendingQuery = {
   promise: Promise<bigint> | null;
   result: bigint | null;
   disjoint: boolean;
+  cancelled: boolean;
+  pollRequestId: number | null;
+  resolve: ((value: bigint) => void) | null;
+  reject: ((error: Error) => void) | null;
 };
 
 type WebGLTimestampPair = {
@@ -23,6 +27,7 @@ export class WEBGLQuerySet extends QuerySet {
   readonly handle: WebGLQuery | null;
 
   protected _timestampPairs: WebGLTimestampPair[] = [];
+  protected _pendingReads: Set<WebGLPendingQuery> = new Set();
   protected _occlusionQuery: WebGLPendingQuery | null = null;
   protected _occlusionActive = false;
 
@@ -67,17 +72,24 @@ export class WEBGLQuerySet extends QuerySet {
 
     for (const pair of this._timestampPairs) {
       if (pair.activeQuery) {
+        this._cancelPendingQuery(pair.activeQuery);
         this.device.gl.deleteQuery(pair.activeQuery.handle);
       }
       for (const query of pair.completedQueries) {
+        this._cancelPendingQuery(query);
         this.device.gl.deleteQuery(query.handle);
       }
     }
 
     if (this._occlusionQuery) {
+      this._cancelPendingQuery(this._occlusionQuery);
       this.device.gl.deleteQuery(this._occlusionQuery.handle);
     }
 
+    for (const query of Array.from(this._pendingReads)) {
+      this._cancelPendingQuery(query);
+    }
+
     this.destroyResource();
   }
 
@@ -162,7 +174,11 @@ export class WEBGLQuerySet extends QuerySet {
       handle: this.handle,
       promise: null,
       result: null,
-      disjoint: false
+      disjoint: false,
+      cancelled: false,
+      pollRequestId: null,
+      resolve: null,
+      reject: null
     };
     this._occlusionActive = true;
   }
@@ -198,7 +214,11 @@ export class WEBGLQuerySet extends QuerySet {
         handle,
         promise: null,
         result: null,
-        disjoint: false
+        disjoint: false,
+        cancelled: false,
+        pollRequestId: null,
+        resolve: null,
+        reject: null
       };
 
       this.device.gl.beginQuery(GL.TIME_ELAPSED_EXT, handle);
@@ -239,6 +259,11 @@ export class WEBGLQuerySet extends QuerySet {
   }
 
   protected _pollQueryAvailability(query: WebGLPendingQuery): boolean {
+    if (query.cancelled || this.destroyed) {
+      query.result = 0n;
+      return true;
+    }
+
     if (query.result !== null || query.disjoint) {
       return true;
     }
@@ -279,14 +304,32 @@ export class WEBGLQuerySet extends QuerySet {
       return query.promise;
     }
 
+    this._pendingReads.add(query);
     query.promise = new Promise((resolve, reject) => {
+      query.resolve = resolve;
+      query.reject = reject;
+
       const poll = () => {
+        query.pollRequestId = null;
+
+        if (query.cancelled || this.destroyed) {
+          this._pendingReads.delete(query);
+          query.promise = null;
+          query.resolve = null;
+          query.reject = null;
+          resolve(0n);
+          return;
+        }
+
         if (!this._pollQueryAvailability(query)) {
-          requestAnimationFrame(poll);
+          query.pollRequestId = this._requestAnimationFrame(poll);
           return;
         }
 
+        this._pendingReads.delete(query);
         query.promise = null;
+        query.resolve = null;
+        query.reject = null;
         if (query.disjoint) {
           reject(new Error('GPU timestamp query was invalidated by a disjoint event'));
         } else {
@@ -299,4 +342,28 @@ export class WEBGLQuerySet extends QuerySet {
 
     return query.promise;
   }
+
+  protected _cancelPendingQuery(query: WebGLPendingQuery): void {
+    this._pendingReads.delete(query);
+    query.cancelled = true;
+    if (query.pollRequestId !== null) {
+      this._cancelAnimationFrame(query.pollRequestId);
+      query.pollRequestId = null;
+    }
+    if (query.resolve) {
+      const resolve = query.resolve;
+      query.promise = null;
+      query.resolve = null;
+      query.reject = null;
+      resolve(0n);
+    }
+  }
+
+  protected _requestAnimationFrame(callback: FrameRequestCallback): number {
+    return requestAnimationFrame(callback);
+  }
+
+  protected _cancelAnimationFrame(requestId: number): void {
+    cancelAnimationFrame(requestId);
+  }
 }

package/src/adapter/resources/webgl-render-pass.ts

@@ -5,7 +5,7 @@
 import {NumericArray, NumberArray4} from '@math.gl/types';
 import {RenderPass, RenderPassProps, RenderPassParameters} from '@luma.gl/core';
 import {WebGLDevice} from '../webgl-device';
-import {GL, GLParameters} from '@luma.gl/constants';
+import {GL, GLParameters} from '@luma.gl/webgl/constants';
 import {withGLParameters} from '../../context/state-tracker/with-parameters';
 import {setGLParameters} from '../../context/parameters/unified-parameter-api';
 import {WEBGLQuerySet} from './webgl-query-set';
@@ -23,19 +23,21 @@ export class WEBGLRenderPass extends RenderPass {
   constructor(device: WebGLDevice, props: RenderPassProps) {
     super(device, props);
     this.device = device;
+    const webglFramebuffer = this.props.framebuffer as WEBGLFramebuffer | null;
+    const isDefaultFramebuffer = !webglFramebuffer || webglFramebuffer.handle === null;
 
-    if (!props?.framebuffer) {
-      // Default-framebuffer rendering bypasses CanvasContext.getCurrentFramebuffer(),
-      // so flush any deferred canvas resize before deriving viewport state.
+    if (isDefaultFramebuffer) {
+      // Treat an explicit wrapper around the default framebuffer the same as the
+      // implicit default path so draw buffer and viewport state stay valid.
       device.getDefaultCanvasContext()._resizeDrawingBufferIfNeeded();
     }
 
     // If no viewport is provided, apply reasonably defaults
     let viewport: NumberArray4 | undefined;
     if (!props?.parameters?.viewport) {
-      if (props?.framebuffer) {
+      if (!isDefaultFramebuffer) {
         // Set the viewport to the size of the framebuffer
-        const {width, height} = props.framebuffer;
+        const {width, height} = webglFramebuffer;
         viewport = [0, 0, width, height];
       } else {
         // Instead of using our own book-keeping, we can just read the values from the WebGL context
@@ -49,15 +51,13 @@ export class WEBGLRenderPass extends RenderPass {
     this.setParameters({viewport, ...this.props.parameters});
 
     // Specify mapping of draw buffer locations to color attachments
-    const webglFramebuffer = this.props.framebuffer as WEBGLFramebuffer;
     // Default framebuffers can only be set to GL.BACK or GL.NONE
-    if (this.props.framebuffer && webglFramebuffer?.handle) {
-      const drawBuffers = this.props.framebuffer.colorAttachments.map(
-        (_, i) => GL.COLOR_ATTACHMENT0 + i
-      );
+    if (!isDefaultFramebuffer) {
+      const drawBuffers = webglFramebuffer.colorAttachments.map((_, i) => GL.COLOR_ATTACHMENT0 + i);
       this.device.gl.drawBuffers(drawBuffers);
-    } else if (!this.props.framebuffer) {
-      // Default framebuffer only supports GL.BACK/GL.NONE draw buffers
+    } else {
+      // Default framebuffer only supports GL.BACK/GL.NONE draw buffers, even when
+      // passed through an explicit framebuffer wrapper.
       this.device.gl.drawBuffers([GL.BACK]);
     }
 

package/src/adapter/resources/webgl-render-pipeline.ts

@@ -8,13 +8,14 @@ import type {
   PrimitiveTopology,
   ShaderLayout,
   UniformValue,
-  Binding,
+  Bindings,
+  BindingsByGroup,
   RenderPass,
   VertexArray
 } from '@luma.gl/core';
-import {RenderPipeline, log} from '@luma.gl/core';
+import {RenderPipeline, flattenBindingsByGroup, log, normalizeBindingsByGroup} from '@luma.gl/core';
 // import {getAttributeInfosFromLayouts} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
+import {GL} from '@luma.gl/webgl/constants';
 
 import {withDeviceAndGLParameters} from '../converters/device-parameters';
 import {setUniform} from '../helpers/set-uniform';
@@ -45,7 +46,7 @@ export class WEBGLRenderPipeline extends RenderPipeline {
   introspectedLayout: ShaderLayout;
 
   /** Compatibility path for direct pipeline.setBindings() usage */
-  bindings: Record<string, Binding> = {};
+  bindings: Bindings = {};
   /** Compatibility path for direct pipeline.uniforms usage */
   uniforms: Record<string, UniformValue> = {};
   /** WebGL varyings */
@@ -73,7 +74,10 @@ export class WEBGLRenderPipeline extends RenderPipeline {
     this.introspectedLayout = webglSharedRenderPipeline.introspectedLayout;
     this.device._setWebGLDebugMetadata(this.handle, this, {spector: {id: this.props.id}});
 
-    // Merge provided layout with introspected layout
+    // WebGL only honors shaderLayout overrides for attributes that already exist in the
+    // linked program, and only the `type` / `stepMode` fields participate in the merge.
+    // Bindings and unknown attributes are ignored. If WebGL cache keys ever depend on
+    // `shaderLayout`, they need to match these merge semantics rather than the raw prop.
     this.shaderLayout = props.shaderLayout
       ? mergeShaderLayout(this.introspectedLayout, props.shaderLayout)
       : this.introspectedLayout;
@@ -93,11 +97,12 @@ export class WEBGLRenderPipeline extends RenderPipeline {
    * Compatibility shim for code paths that still set bindings on the pipeline.
    * Shared-model draws pass bindings per draw and do not rely on this state.
    */
-  setBindings(bindings: Record<string, Binding>, options?: {disableWarnings?: boolean}): void {
-    for (const [name, value] of Object.entries(bindings)) {
-      const binding =
-        this.shaderLayout.bindings.find(binding_ => binding_.name === name) ||
-        this.shaderLayout.bindings.find(binding_ => binding_.name === `${name}Uniforms`);
+  setBindings(bindings: Bindings | BindingsByGroup, options?: {disableWarnings?: boolean}): void {
+    const flatBindings = flattenBindingsByGroup(
+      normalizeBindingsByGroup(this.shaderLayout, bindings)
+    );
+    for (const [name, value] of Object.entries(flatBindings)) {
+      const binding = getShaderLayoutBindingByName(this.shaderLayout, name);
 
       if (!binding) {
         const validBindings = this.shaderLayout.bindings
@@ -161,10 +166,15 @@ export class WEBGLRenderPipeline extends RenderPipeline {
     firstInstance?: number;
     baseVertex?: number;
     transformFeedback?: WEBGLTransformFeedback;
-    bindings?: Record<string, Binding>;
+    bindings?: Bindings;
+    bindGroups?: BindingsByGroup;
+    _bindGroupCacheKeys?: Partial<Record<number, object>>;
     uniforms?: Record<string, UniformValue>;
   }): boolean {
     this._syncLinkStatus();
+    const drawBindings = options.bindGroups
+      ? flattenBindingsByGroup(options.bindGroups)
+      : options.bindings || this.bindings;
 
     const {
       renderPass,
@@ -180,7 +190,6 @@ export class WEBGLRenderPipeline extends RenderPipeline {
       // firstInstance,
       // baseVertex,
       transformFeedback,
-      bindings = this.bindings,
       uniforms = this.uniforms
     } = options;
 
@@ -199,7 +208,7 @@ export class WEBGLRenderPipeline extends RenderPipeline {
     // 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
-    if (!this._areTexturesRenderable(bindings)) {
+    if (!this._areTexturesRenderable(drawBindings)) {
       log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
       //  Note: false means that the app needs to redraw the pipeline again.
       return false;
@@ -222,7 +231,7 @@ export class WEBGLRenderPipeline extends RenderPipeline {
     }
 
     // We have to apply bindings before every draw call since other draw calls will overwrite
-    this._applyBindings(bindings, {disableWarnings: this.props.disableWarnings});
+    this._applyBindings(drawBindings, {disableWarnings: this.props.disableWarnings});
     this._applyUniforms(uniforms);
 
     const webglRenderPass = renderPass as WEBGLRenderPass;
@@ -266,11 +275,11 @@ export class WEBGLRenderPipeline extends RenderPipeline {
    * Update a texture if needed (e.g. from video)
    * Note: This is currently done before every draw call
    */
-  _areTexturesRenderable(bindings: Record<string, Binding>) {
+  _areTexturesRenderable(bindings: Bindings) {
     let texturesRenderable = true;
 
     for (const bindingInfo of this.shaderLayout.bindings) {
-      if (!bindings[bindingInfo.name] && !bindings[bindingInfo.name.replace(/Uniforms$/, '')]) {
+      if (!getBindingValueForLayoutBinding(bindings, bindingInfo.name)) {
         log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
         texturesRenderable = false;
       }
@@ -287,7 +296,7 @@ export class WEBGLRenderPipeline extends RenderPipeline {
   }
 
   /** Apply any bindings (before each draw call) */
-  _applyBindings(bindings: Record<string, Binding>, _options?: {disableWarnings?: boolean}) {
+  _applyBindings(bindings: Bindings, _options?: {disableWarnings?: boolean}) {
     this._syncLinkStatus();
 
     // If we are using async linking, we need to wait until linking completes
@@ -301,8 +310,7 @@ export class WEBGLRenderPipeline extends RenderPipeline {
     let textureUnit = 0;
     let uniformBufferIndex = 0;
     for (const binding of this.shaderLayout.bindings) {
-      // Accept both `xyz` and `xyzUniforms` as valid names for `xyzUniforms` uniform block
-      const value = bindings[binding.name] || bindings[binding.name.replace(/Uniforms$/, '')];
+      const value = getBindingValueForLayoutBinding(bindings, binding.name);
       if (!value) {
         throw new Error(`No value for binding ${binding.name} in ${this.id}`);
       }
@@ -318,15 +326,13 @@ export class WEBGLRenderPipeline extends RenderPipeline {
           if (value instanceof WEBGLBuffer) {
             gl.bindBufferBase(GL.UNIFORM_BUFFER, uniformBufferIndex, value.handle);
           } else {
+            const bufferBinding = value as {buffer: WEBGLBuffer; offset?: number; size?: number};
             gl.bindBufferRange(
               GL.UNIFORM_BUFFER,
               uniformBufferIndex,
-              // @ts-expect-error
-              value.buffer.handle,
-              // @ts-expect-error
-              value.offset || 0,
-              // @ts-expect-error
-              value.size || value.buffer.byteLength - value.offset
+              bufferBinding.buffer.handle,
+              bufferBinding.offset || 0,
+              bufferBinding.size || bufferBinding.buffer.byteLength - (bufferBinding.offset || 0)
             );
           }
           uniformBufferIndex += 1;
@@ -405,7 +411,8 @@ function mergeShaderLayout(baseLayout: ShaderLayout, overrideLayout: ShaderLayou
   // Deep clone the base layout
   const mergedLayout: ShaderLayout = {
     ...baseLayout,
-    attributes: baseLayout.attributes.map(attribute => ({...attribute}))
+    attributes: baseLayout.attributes.map(attribute => ({...attribute})),
+    bindings: baseLayout.bindings.map(binding => ({...binding}))
   };
   // Merge the attributes
   for (const attribute of overrideLayout?.attributes || []) {
@@ -417,5 +424,37 @@ function mergeShaderLayout(baseLayout: ShaderLayout, overrideLayout: ShaderLayou
       baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
     }
   }
+
+  for (const binding of overrideLayout?.bindings || []) {
+    const baseBinding = getShaderLayoutBindingByName(mergedLayout, binding.name);
+    if (!baseBinding) {
+      log.warn(`shader layout binding ${binding.name} not present in shader`);
+      continue;
+    }
+    Object.assign(baseBinding, binding);
+  }
   return mergedLayout;
 }
+
+function getShaderLayoutBindingByName(
+  shaderLayout: ShaderLayout,
+  bindingName: string
+): ShaderLayout['bindings'][number] | undefined {
+  return shaderLayout.bindings.find(
+    binding =>
+      binding.name === bindingName ||
+      binding.name === `${bindingName}Uniforms` ||
+      `${binding.name}Uniforms` === bindingName
+  );
+}
+
+function getBindingValueForLayoutBinding(
+  bindings: Bindings,
+  bindingName: string
+): Bindings[string] | undefined {
+  return (
+    bindings[bindingName] ||
+    bindings[`${bindingName}Uniforms`] ||
+    bindings[bindingName.replace(/Uniforms$/, '')]
+  );
+}

package/src/adapter/resources/webgl-sampler.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import {Sampler, SamplerProps} from '@luma.gl/core';
-import {GL, GLSamplerParameters} from '@luma.gl/constants';
+import {GL, GLSamplerParameters} from '@luma.gl/webgl/constants';
 import {convertSamplerParametersToWebGL} from '../converters/sampler-parameters';
 import type {WebGLDevice} from '../webgl-device';
 

package/src/adapter/resources/webgl-shader.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import {Shader, ShaderProps, CompilerMessage, log} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
+import {GL} from '@luma.gl/webgl/constants';
 import {parseShaderCompilerLog} from '../helpers/parse-shader-compiler-log';
 import {WebGLDevice} from '../webgl-device';
 
@@ -31,7 +31,13 @@ export class WEBGLShader extends Shader {
     // default framebuffer handle is null, so we can't set spector metadata...
     device._setWebGLDebugMetadata(this.handle, this, {spector: this.props});
 
-    this._compile(this.source);
+    const compilationStatus = this._compile(this.source);
+    if (compilationStatus && typeof compilationStatus.catch === 'function') {
+      compilationStatus.catch(() => {
+        // Ensure any async compile status errors are consumed.
+        this.compilationStatus = 'error';
+      });
+    }
   }
 
   override destroy(): void {
@@ -71,7 +77,7 @@ export class WEBGLShader extends Shader {
   // PRIVATE METHODS
 
   /** Compile a shader and get compilation status */
-  protected async _compile(source: string): Promise<void> {
+  protected _compile(source: string): void | Promise<void> {
     source = source.startsWith('#version ') ? source : `#version 300 es\n${source}`;
 
     const {gl} = this.device;
@@ -97,12 +103,13 @@ export class WEBGLShader extends Shader {
 
     // async case
     log.once(1, 'Shader compilation is asynchronous')();
-    await this._waitForCompilationComplete();
-    log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
-    this._getCompilationStatus();
+    return this._waitForCompilationComplete().then(() => {
+      log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
+      this._getCompilationStatus();
 
-    // The `Shader` base class will determine if debug window should be opened based on this.compilationStatus
-    this.debugShader();
+      // The `Shader` base class will determine if debug window should be opened based on this.compilationStatus
+      this.debugShader();
+    });
   }
 
   /** Use KHR_parallel_shader_compile extension if available */

package/src/adapter/resources/webgl-shared-render-pipeline.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GL} from '@luma.gl/constants';
+import {GL} from '@luma.gl/webgl/constants';
 import {
   SharedRenderPipeline,
   log,
@@ -48,6 +48,9 @@ export class WEBGLSharedRenderPipeline extends SharedRenderPipeline {
     }
 
     this._linkShaders();
+    // Introspection happens after linking to build wrapper-facing layout metadata.
+    // It is not a prerequisite for deciding whether a shared `WebGLProgram` can be
+    // reused; that decision must remain based on the shared-pipeline cache key alone.
     log.time(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
     this.introspectedLayout = getShaderLayoutFromGLSL(this.device.gl, this.handle);
     log.timeEnd(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();

package/src/adapter/resources/webgl-texture.ts

@@ -15,6 +15,7 @@ import {
   type TextureWriteOptions,
   type TextureFormat,
   Buffer,
+  getTypedArrayConstructor,
   Texture,
   log
 } from '@luma.gl/core';
@@ -27,7 +28,7 @@ import {
   GLTextureCubeMapTarget,
   GLTexelDataFormat,
   GLPixelType
-} from '@luma.gl/constants';
+} from '@luma.gl/webgl/constants';
 
 import {getTextureFormatWebGL} from '../converters/webgl-texture-table';
 import {convertSamplerParametersToWebGL} from '../converters/sampler-parameters';
@@ -38,7 +39,6 @@ import {WEBGLFramebuffer} from './webgl-framebuffer';
 import {WEBGLSampler} from './webgl-sampler';
 import {WEBGLTextureView} from './webgl-texture-view';
 import {convertGLDataTypeToDataType} from '../converters/shader-formats';
-import {getTypedArrayConstructor} from '@luma.gl/core';
 
 /**
  * WebGL... the texture API from hell... hopefully made simpler
@@ -219,23 +219,21 @@ export class WEBGLTexture extends Texture {
    * @note Only first-pass color readback is supported. Unsupported formats and aspects throw
    * before any WebGL calls are issued.
    */
-  readBuffer(options: TextureReadOptions = {}, buffer?: Buffer): Buffer {
+  readBuffer(options: TextureReadOptions & {byteOffset?: number} = {}, buffer?: Buffer): Buffer {
+    if (!buffer) {
+      throw new Error(`${this} readBuffer requires a destination buffer`);
+    }
     const normalizedOptions = this._getSupportedColorReadOptions(options);
+    const byteOffset = options.byteOffset ?? 0;
     const memoryLayout = this.computeMemoryLayout(normalizedOptions);
-    const readBuffer =
-      buffer ||
-      this.device.createBuffer({
-        byteLength: memoryLayout.byteLength,
-        usage: Buffer.COPY_DST | Buffer.MAP_READ
-      });
 
-    if (readBuffer.byteLength < memoryLayout.byteLength) {
+    if (buffer.byteLength < byteOffset + memoryLayout.byteLength) {
       throw new Error(
-        `${this} readBuffer target is too small (${readBuffer.byteLength} < ${memoryLayout.byteLength})`
+        `${this} readBuffer target is too small (${buffer.byteLength} < ${byteOffset + memoryLayout.byteLength})`
       );
     }
 
-    const webglBuffer = readBuffer as WEBGLBuffer;
+    const webglBuffer = buffer as WEBGLBuffer;
     this.gl.bindBuffer(GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
     try {
       this._readColorTextureLayers(normalizedOptions, memoryLayout, destinationByteOffset => {
@@ -246,21 +244,20 @@ export class WEBGLTexture extends Texture {
           normalizedOptions.height,
           this.glFormat,
           this.glType,
-          destinationByteOffset
+          byteOffset + destinationByteOffset
         );
       });
     } finally {
       this.gl.bindBuffer(GL.PIXEL_PACK_BUFFER, null);
     }
 
-    return readBuffer;
+    return buffer;
   }
 
   async readDataAsync(options: TextureReadOptions = {}): Promise<ArrayBuffer> {
-    const buffer = this.readBuffer(options);
-    const data = await buffer.readAsync();
-    buffer.destroy();
-    return data.buffer as ArrayBuffer;
+    throw new Error(
+      `${this} readDataAsync is deprecated; use readBuffer() with an explicit destination buffer or DynamicTexture.readAsync()`
+    );
   }
 
   writeBuffer(buffer: Buffer, options_: TextureWriteOptions = {}) {

package/src/adapter/resources/webgl-transform-feedback.ts

@@ -1,6 +1,6 @@
 import type {PrimitiveTopology, ShaderLayout, TransformFeedbackProps} from '@luma.gl/core';
 import {log, TransformFeedback, Buffer, BufferRange} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
+import {GL} from '@luma.gl/webgl/constants';
 import {WebGLDevice} from '../webgl-device';
 import {WEBGLBuffer} from '../../index';
 import {getGLPrimitive} from '../helpers/webgl-topology-utils';

package/src/adapter/resources/webgl-vertex-array.ts

@@ -5,7 +5,7 @@
 import type {TypedArray, NumericArray} from '@math.gl/types';
 import type {Device, Buffer, VertexArrayProps} from '@luma.gl/core';
 import {VertexArray, getScratchArray} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
+import {GL} from '@luma.gl/webgl/constants';
 import {getBrowser} from '@probe.gl/env';
 
 import {WebGLDevice} from '../webgl-device';

package/src/adapter/webgl-device.ts

@@ -36,7 +36,7 @@ import type {
   VertexFormat
 } from '@luma.gl/core';
 import {Device, CanvasContext, log} from '@luma.gl/core';
-import type {GLExtensions} from '@luma.gl/constants';
+import type {GLExtensions} from '@luma.gl/webgl/constants';
 import {WebGLStateTracker} from '../context/state-tracker/webgl-state-tracker';
 import {createBrowserContext} from '../context/helpers/create-browser-context';
 import {getWebGLContextData} from '../context/helpers/webgl-context-data';
@@ -369,13 +369,7 @@ export class WebGLDevice extends Device {
   submit(commandBuffer?: WEBGLCommandBuffer): void {
     let submittedCommandEncoder: WEBGLCommandEncoder | null = null;
     if (!commandBuffer) {
-      submittedCommandEncoder = this.commandEncoder;
-      commandBuffer = submittedCommandEncoder.finish();
-      this.commandEncoder.destroy();
-      this.commandEncoder = this.createCommandEncoder({
-        id: submittedCommandEncoder.props.id,
-        timeProfilingQuerySet: submittedCommandEncoder.getTimeProfilingQuerySet()
-      });
+      ({submittedCommandEncoder, commandBuffer} = this._finalizeDefaultCommandEncoderForSubmit());
     }
 
     try {
@@ -394,6 +388,20 @@ export class WebGLDevice extends Device {
     }
   }
 
+  private _finalizeDefaultCommandEncoderForSubmit(): {
+    submittedCommandEncoder: WEBGLCommandEncoder;
+    commandBuffer: WEBGLCommandBuffer;
+  } {
+    const submittedCommandEncoder = this.commandEncoder;
+    const commandBuffer = submittedCommandEncoder.finish();
+    this.commandEncoder.destroy();
+    this.commandEncoder = this.createCommandEncoder({
+      id: submittedCommandEncoder.props.id,
+      timeProfilingQuerySet: submittedCommandEncoder.getTimeProfilingQuerySet()
+    });
+    return {submittedCommandEncoder, commandBuffer};
+  }
+
   //
   // TEMPORARY HACKS - will be removed in v9.1
   //

package/src/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,EAAE,EAAC,6BAA0B;AAErC,YAAY,EACV,eAAe,EACf,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,WAAW,EACX,UAAU,EACV,WAAW,EACX,aAAa,EACb,aAAa,EACb,UAAU,EACV,eAAe,EACf,eAAe,EACf,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,iBAAiB,EAClB,yBAAsB"}

package/src/constants/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,OAAO,EAAC,EAAE,EAAC,6BAA0B"}

package/src/constants/index.ts

@@ -0,0 +1,31 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export {GL} from './webgl-constants';
+
+export type {
+  GLTextureTarget,
+  GLTextureCubeMapTarget,
+  GLTexelDataFormat,
+  GLPrimitiveTopology,
+  GLPrimitive,
+  GLDataType,
+  GLPixelType,
+  GLUniformType,
+  GLSamplerType,
+  GLFunction,
+  GLBlendEquation,
+  GLBlendFunction,
+  GLStencilOp,
+  GLSamplerParameters,
+  GLValueParameters,
+  GLPackParameters,
+  GLUnpackParameters,
+  GLFunctionParameters,
+  GLParameters,
+  GLLimits,
+  GLExtensions,
+  GLPolygonMode,
+  GLProvokingVertex
+} from './webgl-types';