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

package/dist/dist.dev.js

@@ -48,10 +48,10 @@ var __exports__ = (() => {
     }
   });
 
-  // ../constants/src/webgl-constants.ts
+  // src/constants/webgl-constants.ts
   var GLEnum;
   var init_webgl_constants = __esm({
-    "../constants/src/webgl-constants.ts"() {
+    "src/constants/webgl-constants.ts"() {
       "use strict";
       GLEnum = /* @__PURE__ */ ((GLEnum2) => {
         GLEnum2[GLEnum2["DEPTH_BUFFER_BIT"] = 256] = "DEPTH_BUFFER_BIT";
@@ -705,9 +705,9 @@ var __exports__ = (() => {
     }
   });
 
-  // ../constants/src/index.ts
-  var init_src = __esm({
-    "../constants/src/index.ts"() {
+  // src/constants/index.ts
+  var init_constants = __esm({
+    "src/constants/index.ts"() {
       "use strict";
       init_webgl_constants();
     }
@@ -1111,7 +1111,7 @@ var __exports__ = (() => {
     "src/context/debug/webgl-developer-tools.ts"() {
       "use strict";
       import_core2 = __toESM(require_core(), 1);
-      init_src();
+      init_constants();
       init_dist();
       init_load_script();
       WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
@@ -2704,6 +2704,15 @@ var __exports__ = (() => {
           }
           gl.bindTexture(texture.glTarget, null);
         }
+        /** Default framebuffer resize is managed by canvas size and should be a no-op. */
+        resizeAttachments(width, height) {
+          if (this.handle === null) {
+            this.width = width;
+            this.height = height;
+            return;
+          }
+          super.resizeAttachments(width, height);
+        }
       };
     }
   });
@@ -3066,7 +3075,12 @@ var __exports__ = (() => {
               throw new Error(this.props.stage);
           }
           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(() => {
+              this.compilationStatus = "error";
+            });
+          }
         }
         destroy() {
           if (this.handle) {
@@ -3097,7 +3111,7 @@ var __exports__ = (() => {
         }
         // PRIVATE METHODS
         /** Compile a shader and get compilation status */
-        async _compile(source) {
+        _compile(source) {
           source = source.startsWith("#version ") ? source : `#version 300 es
 ${source}`;
           const { gl } = this.device;
@@ -3116,10 +3130,11 @@ ${source}`;
             return;
           }
           import_core10.log.once(1, "Shader compilation is asynchronous")();
-          await this._waitForCompilationComplete();
-          import_core10.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
-          this._getCompilationStatus();
-          this.debugShader();
+          return this._waitForCompilationComplete().then(() => {
+            import_core10.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
+            this._getCompilationStatus();
+            this.debugShader();
+          });
         }
         /** Use KHR_parallel_shader_compile extension if available */
         async _waitForCompilationComplete() {
@@ -3278,6 +3293,9 @@ ${source}`;
       parameters.depthCompare !== "always" ? gl.enable(2929 /* DEPTH_TEST */) : gl.disable(2929 /* DEPTH_TEST */);
       gl.depthFunc(convertCompareFunction("depthCompare", parameters.depthCompare));
     }
+    if (parameters.clearDepth !== void 0) {
+      gl.clearDepth(parameters.clearDepth);
+    }
     if (parameters.stencilWriteMask) {
       const mask = parameters.stencilWriteMask;
       gl.stencilMaskSeparate(1028 /* FRONT */, mask);
@@ -3687,7 +3705,7 @@ ${source}`;
   function getWebGLCubeFaceTarget(glTarget, dimension, level) {
     return dimension === "cube" ? 34069 /* TEXTURE_CUBE_MAP_POSITIVE_X */ + level : glTarget;
   }
-  var import_core14, import_core15, WEBGLTexture;
+  var import_core14, WEBGLTexture;
   var init_webgl_texture = __esm({
     "src/adapter/resources/webgl-texture.ts"() {
       "use strict";
@@ -3697,7 +3715,6 @@ ${source}`;
       init_with_parameters();
       init_webgl_texture_view();
       init_shader_formats();
-      import_core15 = __toESM(require_core(), 1);
       WEBGLTexture = class extends import_core14.Texture {
         // readonly MAX_ATTRIBUTES: number;
         device;
@@ -3829,18 +3846,18 @@ ${source}`;
          * before any WebGL calls are issued.
          */
         readBuffer(options = {}, 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: import_core14.Buffer.COPY_DST | import_core14.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;
+          const webglBuffer = buffer;
           this.gl.bindBuffer(35051 /* PIXEL_PACK_BUFFER */, webglBuffer.handle);
           try {
             this._readColorTextureLayers(normalizedOptions, memoryLayout, (destinationByteOffset) => {
@@ -3851,19 +3868,18 @@ ${source}`;
                 normalizedOptions.height,
                 this.glFormat,
                 this.glType,
-                destinationByteOffset
+                byteOffset + destinationByteOffset
               );
             });
           } finally {
             this.gl.bindBuffer(35051 /* PIXEL_PACK_BUFFER */, null);
           }
-          return readBuffer;
+          return buffer;
         }
         async readDataAsync(options = {}) {
-          const buffer = this.readBuffer(options);
-          const data = await buffer.readAsync();
-          buffer.destroy();
-          return data.buffer;
+          throw new Error(
+            `${this} readDataAsync is deprecated; use readBuffer() with an explicit destination buffer or DynamicTexture.readAsync()`
+          );
         }
         writeBuffer(buffer, options_ = {}) {
           const options = this._normalizeTextureWriteOptions(options_);
@@ -4018,7 +4034,7 @@ ${source}`;
           const options = this._getSupportedColorReadOptions(options_);
           const memoryLayout = this.computeMemoryLayout(options);
           const shaderType = convertGLDataTypeToDataType(this.glType);
-          const ArrayType = (0, import_core15.getTypedArrayConstructor)(shaderType);
+          const ArrayType = (0, import_core14.getTypedArrayConstructor)(shaderType);
           const targetArray = new ArrayType(memoryLayout.byteLength / ArrayType.BYTES_PER_ELEMENT);
           this._readColorTextureLayers(options, memoryLayout, (destinationByteOffset) => {
             const layerView = new ArrayType(
@@ -4332,24 +4348,41 @@ ${source}`;
   function mergeShaderLayout(baseLayout, overrideLayout) {
     const mergedLayout = {
       ...baseLayout,
-      attributes: baseLayout.attributes.map((attribute) => ({ ...attribute }))
+      attributes: baseLayout.attributes.map((attribute) => ({ ...attribute })),
+      bindings: baseLayout.bindings.map((binding) => ({ ...binding }))
     };
     for (const attribute of overrideLayout?.attributes || []) {
       const baseAttribute = mergedLayout.attributes.find((attr) => attr.name === attribute.name);
       if (!baseAttribute) {
-        import_core16.log.warn(`shader layout attribute ${attribute.name} not present in shader`);
+        import_core15.log.warn(`shader layout attribute ${attribute.name} not present in shader`);
       } else {
         baseAttribute.type = attribute.type || baseAttribute.type;
         baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
       }
     }
+    for (const binding of overrideLayout?.bindings || []) {
+      const baseBinding = getShaderLayoutBindingByName(mergedLayout, binding.name);
+      if (!baseBinding) {
+        import_core15.log.warn(`shader layout binding ${binding.name} not present in shader`);
+        continue;
+      }
+      Object.assign(baseBinding, binding);
+    }
     return mergedLayout;
   }
-  var import_core16, WEBGLRenderPipeline;
+  function getShaderLayoutBindingByName(shaderLayout, bindingName) {
+    return shaderLayout.bindings.find(
+      (binding) => binding.name === bindingName || binding.name === `${bindingName}Uniforms` || `${binding.name}Uniforms` === bindingName
+    );
+  }
+  function getBindingValueForLayoutBinding(bindings, bindingName) {
+    return bindings[bindingName] || bindings[`${bindingName}Uniforms`] || bindings[bindingName.replace(/Uniforms$/, "")];
+  }
+  var import_core15, WEBGLRenderPipeline;
   var init_webgl_render_pipeline = __esm({
     "src/adapter/resources/webgl-render-pipeline.ts"() {
       "use strict";
-      import_core16 = __toESM(require_core(), 1);
+      import_core15 = __toESM(require_core(), 1);
       init_device_parameters();
       init_set_uniform();
       init_webgl_buffer();
@@ -4357,7 +4390,7 @@ ${source}`;
       init_webgl_texture();
       init_webgl_texture_view();
       init_webgl_topology_utils();
-      WEBGLRenderPipeline = class extends import_core16.RenderPipeline {
+      WEBGLRenderPipeline = class extends import_core15.RenderPipeline {
         /** The WebGL device that created this render pipeline */
         device;
         /** Handle to underlying WebGL program */
@@ -4407,12 +4440,15 @@ ${source}`;
          * Shared-model draws pass bindings per draw and do not rely on this state.
          */
         setBindings(bindings, options) {
-          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`);
+          const flatBindings = (0, import_core15.flattenBindingsByGroup)(
+            (0, import_core15.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.map((binding_) => `"${binding_.name}"`).join(", ");
               if (!options?.disableWarnings) {
-                import_core16.log.warn(
+                import_core15.log.warn(
                   `No binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`,
                   value
                 )();
@@ -4420,7 +4456,7 @@ ${source}`;
               continue;
             }
             if (!value) {
-              import_core16.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
+              import_core15.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
             }
             switch (binding.type) {
               case "uniform":
@@ -4434,7 +4470,7 @@ ${source}`;
                 }
                 break;
               case "sampler":
-                import_core16.log.warn(`Ignoring sampler ${name}`)();
+                import_core15.log.warn(`Ignoring sampler ${name}`)();
                 break;
               default:
                 throw new Error(binding.type);
@@ -4448,6 +4484,7 @@ ${source}`;
          */
         draw(options) {
           this._syncLinkStatus();
+          const drawBindings = options.bindGroups ? (0, import_core15.flattenBindingsByGroup)(options.bindGroups) : options.bindings || this.bindings;
           const {
             renderPass,
             parameters = this.props.parameters,
@@ -4462,18 +4499,17 @@ ${source}`;
             // firstInstance,
             // baseVertex,
             transformFeedback,
-            bindings = this.bindings,
             uniforms = this.uniforms
           } = options;
           const glDrawMode = getGLDrawMode(topology);
           const isIndexed = Boolean(vertexArray.indexBuffer);
           const glIndexType = vertexArray.indexBuffer?.glIndexType;
           if (this.linkStatus !== "success") {
-            import_core16.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
+            import_core15.log.info(2, `RenderPipeline:${this.id}.draw() aborted - waiting for shader linking`)();
             return false;
           }
-          if (!this._areTexturesRenderable(bindings)) {
-            import_core16.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
+          if (!this._areTexturesRenderable(drawBindings)) {
+            import_core15.log.info(2, `RenderPipeline:${this.id}.draw() aborted - textures not yet loaded`)();
             return false;
           }
           this.device.gl.useProgram(this.handle);
@@ -4481,7 +4517,7 @@ ${source}`;
           if (transformFeedback) {
             transformFeedback.begin(this.props.topology);
           }
-          this._applyBindings(bindings, { disableWarnings: this.props.disableWarnings });
+          this._applyBindings(drawBindings, { disableWarnings: this.props.disableWarnings });
           this._applyUniforms(uniforms);
           const webglRenderPass = renderPass;
           withDeviceAndGLParameters(this.device, parameters, webglRenderPass.glParameters, () => {
@@ -4521,8 +4557,8 @@ ${source}`;
         _areTexturesRenderable(bindings) {
           let texturesRenderable = true;
           for (const bindingInfo of this.shaderLayout.bindings) {
-            if (!bindings[bindingInfo.name] && !bindings[bindingInfo.name.replace(/Uniforms$/, "")]) {
-              import_core16.log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
+            if (!getBindingValueForLayoutBinding(bindings, bindingInfo.name)) {
+              import_core15.log.warn(`Binding ${bindingInfo.name} not found in ${this.id}`)();
               texturesRenderable = false;
             }
           }
@@ -4539,7 +4575,7 @@ ${source}`;
           let textureUnit = 0;
           let uniformBufferIndex = 0;
           for (const binding of this.shaderLayout.bindings) {
-            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}`);
             }
@@ -4554,15 +4590,13 @@ ${source}`;
                 if (value instanceof WEBGLBuffer) {
                   gl.bindBufferBase(35345 /* UNIFORM_BUFFER */, uniformBufferIndex, value.handle);
                 } else {
+                  const bufferBinding = value;
                   gl.bindBufferRange(
                     35345 /* 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;
@@ -4577,7 +4611,7 @@ ${source}`;
                 } else if (value instanceof WEBGLTexture) {
                   texture = value;
                 } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTextureView) {
-                  import_core16.log.warn(
+                  import_core15.log.warn(
                     "Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead"
                   )();
                   texture = value.colorAttachments[0].texture;
@@ -4799,7 +4833,7 @@ ${source}`;
       }
       const { name, type: glUniformType, size } = activeInfo;
       const uniformType = convertGLUniformTypeToShaderVariableType(glUniformType);
-      const { type, components } = (0, import_core17.getVariableShaderTypeInfo)(uniformType);
+      const { type, components } = (0, import_core16.getVariableShaderTypeInfo)(uniformType);
       varyings.push({ location, name, type, size: size * components });
     }
     varyings.sort((a, b) => a.location - b.location);
@@ -4879,6 +4913,16 @@ ${source}`;
           });
         }
       }
+      const uniformInstancePrefixes = new Set(
+        blockInfo.uniforms.map((uniform) => uniform.name.split(".")[0]).filter((instanceName) => Boolean(instanceName))
+      );
+      const blockAlias = blockInfo.name.replace(/Uniforms$/, "");
+      if (uniformInstancePrefixes.size === 1 && !uniformInstancePrefixes.has(blockInfo.name) && !uniformInstancePrefixes.has(blockAlias)) {
+        const [instanceName] = uniformInstancePrefixes;
+        import_core16.log.warn(
+          `Uniform block "${blockInfo.name}" uses GLSL instance "${instanceName}". luma.gl binds uniform buffers by block name ("${blockInfo.name}") and alias ("${blockAlias}"). Prefer matching the instance name to one of those to avoid confusing silent mismatches.`
+        )();
+      }
       uniformBlocks.push(blockInfo);
     }
     uniformBlocks.sort((a, b) => a.location - b.location);
@@ -4894,7 +4938,7 @@ ${source}`;
     }
     const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
     const matches = UNIFORM_NAME_REGEXP.exec(name);
-    const uniformName = (0, import_core17.assertDefined)(matches?.[1], `Failed to parse GLSL uniform name ${name}`);
+    const uniformName = (0, import_core16.assertDefined)(matches?.[1], `Failed to parse GLSL uniform name ${name}`);
     return {
       name: uniformName,
       // TODO - is this a bug, shouldn't we return the value?
@@ -4902,25 +4946,25 @@ ${source}`;
       isArray: Boolean(matches?.[2])
     };
   }
-  var import_core17;
+  var import_core16;
   var init_get_shader_layout_from_glsl = __esm({
     "src/adapter/helpers/get-shader-layout-from-glsl.ts"() {
       "use strict";
-      import_core17 = __toESM(require_core(), 1);
+      import_core16 = __toESM(require_core(), 1);
       init_webgl_shadertypes();
     }
   });
 
   // src/adapter/resources/webgl-shared-render-pipeline.ts
-  var import_core18, LOG_PROGRAM_PERF_PRIORITY, WEBGLSharedRenderPipeline;
+  var import_core17, LOG_PROGRAM_PERF_PRIORITY, WEBGLSharedRenderPipeline;
   var init_webgl_shared_render_pipeline = __esm({
     "src/adapter/resources/webgl-shared-render-pipeline.ts"() {
       "use strict";
-      import_core18 = __toESM(require_core(), 1);
+      import_core17 = __toESM(require_core(), 1);
       init_get_shader_layout_from_glsl();
       init_webgl_shadertypes();
       LOG_PROGRAM_PERF_PRIORITY = 4;
-      WEBGLSharedRenderPipeline = class extends import_core18.SharedRenderPipeline {
+      WEBGLSharedRenderPipeline = class extends import_core17.SharedRenderPipeline {
         device;
         handle;
         vs;
@@ -4941,9 +4985,9 @@ ${source}`;
             );
           }
           this._linkShaders();
-          import_core18.log.time(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+          import_core17.log.time(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
           this.introspectedLayout = getShaderLayoutFromGLSL(this.device.gl, this.handle);
-          import_core18.log.timeEnd(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+          import_core17.log.timeEnd(3, `RenderPipeline ${this.id} - shaderLayout introspection`)();
         }
         destroy() {
           if (this.destroyed) {
@@ -4958,17 +5002,17 @@ ${source}`;
           const { gl } = this.device;
           gl.attachShader(this.handle, this.vs.handle);
           gl.attachShader(this.handle, this.fs.handle);
-          import_core18.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+          import_core17.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
           gl.linkProgram(this.handle);
-          import_core18.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+          import_core17.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
           if (!this.device.features.has("compilation-status-async-webgl")) {
             const status2 = this._getLinkStatus();
             this._reportLinkStatus(status2);
             return;
           }
-          import_core18.log.once(1, "RenderPipeline linking is asynchronous")();
+          import_core17.log.once(1, "RenderPipeline linking is asynchronous")();
           await this._waitForLinkComplete();
-          import_core18.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
+          import_core17.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
           const status = this._getLinkStatus();
           this._reportLinkStatus(status);
         }
@@ -5091,44 +5135,44 @@ ${source}`;
     device.gl.bindBuffer(36662 /* COPY_READ_BUFFER */, null);
     device.gl.bindBuffer(36663 /* COPY_WRITE_BUFFER */, null);
   }
-  function _copyBufferToTexture(device, options) {
-    throw new Error("Not implemented");
+  function _copyBufferToTexture(_device, _options) {
+    throw new Error("copyBufferToTexture is not supported in WebGL");
   }
   function _copyTextureToBuffer(device, options) {
     const {
-      /** Texture to copy to/from. */
       sourceTexture,
-      /**  Mip-map level of the texture to copy to/from. (Default 0) */
       mipLevel = 0,
-      /** Defines which aspects of the texture to copy to/from. */
       aspect = "all",
-      /** Width to copy */
       width = options.sourceTexture.width,
-      /** Height to copy */
       height = options.sourceTexture.height,
-      depthOrArrayLayers = 0,
-      /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
+      depthOrArrayLayers,
       origin = [0, 0, 0],
-      /** Destination buffer */
       destinationBuffer,
-      /** Offset, in bytes, from the beginning of the buffer to the start of the image data (default 0) */
       byteOffset = 0,
-      /**
-       * The stride, in bytes, between the beginning of each block row and the subsequent block row.
-       * Required if there are multiple block rows (i.e. the copy height or depth is more than one block).
-       */
       bytesPerRow,
-      /**
-       * Number of block rows per single image of the texture.
-       * rowsPerImage &times; bytesPerRow is the stride, in bytes, between the beginning of each image of data and the subsequent image.
-       * Required if there are multiple images (i.e. the copy depth is more than one).
-       */
       rowsPerImage
     } = options;
+    if (sourceTexture instanceof import_core18.Texture) {
+      sourceTexture.readBuffer(
+        {
+          x: origin[0] ?? 0,
+          y: origin[1] ?? 0,
+          z: origin[2] ?? 0,
+          width,
+          height,
+          depthOrArrayLayers,
+          mipLevel,
+          aspect,
+          byteOffset
+        },
+        destinationBuffer
+      );
+      return;
+    }
     if (aspect !== "all") {
       throw new Error("aspect not supported in WebGL");
     }
-    if (mipLevel !== 0 || depthOrArrayLayers !== 0 || bytesPerRow || rowsPerImage) {
+    if (mipLevel !== 0 || depthOrArrayLayers !== void 0 || bytesPerRow || rowsPerImage) {
       throw new Error("not implemented");
     }
     const { framebuffer, destroyFramebuffer } = getFramebuffer(sourceTexture);
@@ -5137,7 +5181,7 @@ ${source}`;
       const webglBuffer = destinationBuffer;
       const sourceWidth = width || framebuffer.width;
       const sourceHeight = height || framebuffer.height;
-      const colorAttachment0 = (0, import_core19.assertDefined)(framebuffer.colorAttachments[0]);
+      const colorAttachment0 = (0, import_core18.assertDefined)(framebuffer.colorAttachments[0]);
       const sourceParams = getTextureFormatWebGL(colorAttachment0.texture.props.format);
       const sourceFormat = sourceParams.format;
       const sourceType = sourceParams.type;
@@ -5245,7 +5289,7 @@ ${source}`;
     }
   }
   function getFramebuffer(source) {
-    if (source instanceof import_core19.Texture) {
+    if (source instanceof import_core18.Texture) {
       const { width, height, id } = source;
       const framebuffer = source.device.createFramebuffer({
         id: `framebuffer-for-${id}`,
@@ -5257,14 +5301,14 @@ ${source}`;
     }
     return { framebuffer: source, destroyFramebuffer: false };
   }
-  var import_core19, WEBGLCommandBuffer;
+  var import_core18, WEBGLCommandBuffer;
   var init_webgl_command_buffer = __esm({
     "src/adapter/resources/webgl-command-buffer.ts"() {
       "use strict";
-      import_core19 = __toESM(require_core(), 1);
-      init_webgl_texture();
+      import_core18 = __toESM(require_core(), 1);
       init_webgl_texture_table();
-      WEBGLCommandBuffer = class extends import_core19.CommandBuffer {
+      init_webgl_texture();
+      WEBGLCommandBuffer = class extends import_core18.CommandBuffer {
         device;
         handle = null;
         commands = [];
@@ -5297,15 +5341,15 @@ ${source}`;
   });
 
   // src/adapter/resources/webgl-render-pass.ts
-  var import_core20, COLOR_CHANNELS, WEBGLRenderPass;
+  var import_core19, COLOR_CHANNELS, WEBGLRenderPass;
   var init_webgl_render_pass = __esm({
     "src/adapter/resources/webgl-render-pass.ts"() {
       "use strict";
-      import_core20 = __toESM(require_core(), 1);
+      import_core19 = __toESM(require_core(), 1);
       init_with_parameters();
       init_unified_parameter_api();
       COLOR_CHANNELS = [1, 2, 4, 8];
-      WEBGLRenderPass = class extends import_core20.RenderPass {
+      WEBGLRenderPass = class extends import_core19.RenderPass {
         device;
         handle = null;
         /** Parameters that should be applied before each draw call */
@@ -5313,13 +5357,15 @@ ${source}`;
         constructor(device, props) {
           super(device, props);
           this.device = device;
-          if (!props?.framebuffer) {
+          const webglFramebuffer = this.props.framebuffer;
+          const isDefaultFramebuffer = !webglFramebuffer || webglFramebuffer.handle === null;
+          if (isDefaultFramebuffer) {
             device.getDefaultCanvasContext()._resizeDrawingBufferIfNeeded();
           }
           let viewport;
           if (!props?.parameters?.viewport) {
-            if (props?.framebuffer) {
-              const { width, height } = props.framebuffer;
+            if (!isDefaultFramebuffer) {
+              const { width, height } = webglFramebuffer;
               viewport = [0, 0, width, height];
             } else {
               const [width, height] = device.getDefaultCanvasContext().getDrawingBufferSize();
@@ -5328,13 +5374,10 @@ ${source}`;
           }
           this.device.pushState();
           this.setParameters({ viewport, ...this.props.parameters });
-          const webglFramebuffer = this.props.framebuffer;
-          if (this.props.framebuffer && webglFramebuffer?.handle) {
-            const drawBuffers = this.props.framebuffer.colorAttachments.map(
-              (_, i) => 36064 /* COLOR_ATTACHMENT0 */ + i
-            );
+          if (!isDefaultFramebuffer) {
+            const drawBuffers = webglFramebuffer.colorAttachments.map((_, i) => 36064 /* COLOR_ATTACHMENT0 */ + i);
             this.device.gl.drawBuffers(drawBuffers);
-          } else if (!this.props.framebuffer) {
+          } else {
             this.device.gl.drawBuffers([1029 /* BACK */]);
           }
           this.clear();
@@ -5494,14 +5537,14 @@ ${source}`;
   });
 
   // src/adapter/resources/webgl-command-encoder.ts
-  var import_core21, WEBGLCommandEncoder;
+  var import_core20, WEBGLCommandEncoder;
   var init_webgl_command_encoder = __esm({
     "src/adapter/resources/webgl-command-encoder.ts"() {
       "use strict";
-      import_core21 = __toESM(require_core(), 1);
+      import_core20 = __toESM(require_core(), 1);
       init_webgl_command_buffer();
       init_webgl_render_pass();
-      WEBGLCommandEncoder = class extends import_core21.CommandEncoder {
+      WEBGLCommandEncoder = class extends import_core20.CommandEncoder {
         device;
         handle = null;
         commandBuffer;
@@ -5550,7 +5593,8 @@ ${source}`;
         }
         insertDebugMarker(markerLabel) {
         }
-        resolveQuerySet(querySet, destination, options) {
+        resolveQuerySet(_querySet, _destination, _options) {
+          throw new Error("resolveQuerySet is not supported in WebGL");
         }
         writeTimestamp(querySet, queryIndex) {
           const webglQuerySet = querySet;
@@ -5604,15 +5648,15 @@ ${source}`;
     }
     return true;
   }
-  var import_core22, WEBGLVertexArray;
+  var import_core21, WEBGLVertexArray;
   var init_webgl_vertex_array = __esm({
     "src/adapter/resources/webgl-vertex-array.ts"() {
       "use strict";
-      import_core22 = __toESM(require_core(), 1);
+      import_core21 = __toESM(require_core(), 1);
       init_dist();
       init_webgl_vertex_formats();
       init_fill_array();
-      WEBGLVertexArray = class extends import_core22.VertexArray {
+      WEBGLVertexArray = class extends import_core21.VertexArray {
         get [Symbol.toStringTag]() {
           return "VertexArray";
         }
@@ -5780,7 +5824,7 @@ ${source}`;
           this.buffer = this.buffer || this.device.createBuffer({ byteLength });
           updateNeeded ||= !compareConstantArrayValues(constantValue, this.bufferValue);
           if (updateNeeded) {
-            const typedArray = (0, import_core22.getScratchArray)(value.constructor, length);
+            const typedArray = (0, import_core21.getScratchArray)(value.constructor, length);
             fillArray({ target: typedArray, source: constantValue, start: 0, count: length });
             this.buffer.write(typedArray);
             this.bufferValue = value;
@@ -5798,14 +5842,14 @@ ${source}`;
     }
     return /^\d+$/.test(value);
   }
-  var import_core23, WEBGLTransformFeedback;
+  var import_core22, WEBGLTransformFeedback;
   var init_webgl_transform_feedback = __esm({
     "src/adapter/resources/webgl-transform-feedback.ts"() {
       "use strict";
-      import_core23 = __toESM(require_core(), 1);
-      init_src2();
+      import_core22 = __toESM(require_core(), 1);
+      init_src();
       init_webgl_topology_utils();
-      WEBGLTransformFeedback = class extends import_core23.TransformFeedback {
+      WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
         device;
         gl;
         handle;
@@ -5868,7 +5912,7 @@ ${source}`;
           const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange);
           if (location < 0) {
             this.unusedBuffers[locationOrName] = buffer;
-            import_core23.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
+            import_core22.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
             return;
           }
           this.buffers[location] = { buffer, byteLength, byteOffset };
@@ -5951,15 +5995,16 @@ ${source}`;
   });
 
   // src/adapter/resources/webgl-query-set.ts
-  var import_core24, WEBGLQuerySet;
+  var import_core23, WEBGLQuerySet;
   var init_webgl_query_set = __esm({
     "src/adapter/resources/webgl-query-set.ts"() {
       "use strict";
-      import_core24 = __toESM(require_core(), 1);
-      WEBGLQuerySet = class extends import_core24.QuerySet {
+      import_core23 = __toESM(require_core(), 1);
+      WEBGLQuerySet = class extends import_core23.QuerySet {
         device;
         handle;
         _timestampPairs = [];
+        _pendingReads = /* @__PURE__ */ new Set();
         _occlusionQuery = null;
         _occlusionActive = false;
         get [Symbol.toStringTag]() {
@@ -5995,15 +6040,21 @@ ${source}`;
           }
           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();
         }
         isResultAvailable(queryIndex) {
@@ -6074,7 +6125,11 @@ ${source}`;
             handle: this.handle,
             promise: null,
             result: null,
-            disjoint: false
+            disjoint: false,
+            cancelled: false,
+            pollRequestId: null,
+            resolve: null,
+            reject: null
           };
           this._occlusionActive = true;
         }
@@ -6103,7 +6158,11 @@ ${source}`;
               handle,
               promise: null,
               result: null,
-              disjoint: false
+              disjoint: false,
+              cancelled: false,
+              pollRequestId: null,
+              resolve: null,
+              reject: null
             };
             this.device.gl.beginQuery(35007 /* TIME_ELAPSED_EXT */, handle);
             pair.activeQuery = query;
@@ -6135,6 +6194,10 @@ ${source}`;
           return this._pollQueryAvailability(pair.completedQueries[0]);
         }
         _pollQueryAvailability(query) {
+          if (query.cancelled || this.destroyed) {
+            query.result = 0n;
+            return true;
+          }
           if (query.result !== null || query.disjoint) {
             return true;
           }
@@ -6166,13 +6229,28 @@ ${source}`;
           if (query.promise) {
             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 {
@@ -6183,17 +6261,38 @@ ${source}`;
           });
           return query.promise;
         }
+        _cancelPendingQuery(query) {
+          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);
+          }
+        }
+        _requestAnimationFrame(callback) {
+          return requestAnimationFrame(callback);
+        }
+        _cancelAnimationFrame(requestId) {
+          cancelAnimationFrame(requestId);
+        }
       };
     }
   });
 
   // src/adapter/resources/webgl-fence.ts
-  var import_core25, WEBGLFence;
+  var import_core24, WEBGLFence;
   var init_webgl_fence = __esm({
     "src/adapter/resources/webgl-fence.ts"() {
       "use strict";
-      import_core25 = __toESM(require_core(), 1);
-      WEBGLFence = class extends import_core25.Fence {
+      import_core24 = __toESM(require_core(), 1);
+      WEBGLFence = class extends import_core24.Fence {
         device;
         gl;
         handle;
@@ -6313,7 +6412,7 @@ ${source}`;
     sourceFormat ||= texture?.glFormat || 6408 /* RGBA */;
     sourceType ||= texture?.glType || 5121 /* UNSIGNED_BYTE */;
     target2 = getPixelArray(target2, sourceType, sourceFormat, sourceWidth, sourceHeight, sourceDepth);
-    const signedType = (0, import_core26.getDataType)(target2);
+    const signedType = import_core25.dataTypeDecoder.getDataType(target2);
     sourceType = sourceType || convertDataTypeToGLDataType(signedType);
     const prevHandle = gl.bindFramebuffer(
       36160 /* FRAMEBUFFER */,
@@ -6365,7 +6464,7 @@ ${source}`;
     return webglBufferTarget;
   }
   function getFramebuffer2(source) {
-    if (!(source instanceof import_core26.Framebuffer)) {
+    if (!(source instanceof import_core25.Framebuffer)) {
       return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
     }
     return { framebuffer: source, deleteFramebuffer: false };
@@ -6387,15 +6486,15 @@ ${source}`;
     }
     glType ||= 5121 /* UNSIGNED_BYTE */;
     const shaderType = convertGLDataTypeToDataType(glType);
-    const ArrayType = (0, import_core26.getTypedArrayConstructor)(shaderType);
+    const ArrayType = import_core25.dataTypeDecoder.getTypedArrayConstructor(shaderType);
     const components = glFormatToComponents(glFormat);
     return new ArrayType(width * height * components);
   }
-  var import_core26;
+  var import_core25;
   var init_webgl_texture_utils = __esm({
     "src/adapter/helpers/webgl-texture-utils.ts"() {
       "use strict";
-      import_core26 = __toESM(require_core(), 1);
+      import_core25 = __toESM(require_core(), 1);
       init_webgl_shadertypes();
       init_format_utils();
       init_shader_formats();
@@ -6441,11 +6540,11 @@ ${source}`;
     }
     return true;
   }
-  var import_core27, WebGLDevice;
+  var import_core26, WebGLDevice;
   var init_webgl_device = __esm({
     "src/adapter/webgl-device.ts"() {
       "use strict";
-      import_core27 = __toESM(require_core(), 1);
+      import_core26 = __toESM(require_core(), 1);
       init_webgl_state_tracker();
       init_create_browser_context();
       init_webgl_context_data();
@@ -6474,7 +6573,7 @@ ${source}`;
       init_unified_parameter_api();
       init_with_parameters();
       init_webgl_extensions();
-      WebGLDevice = class extends import_core27.Device {
+      WebGLDevice = class extends import_core26.Device {
         static getDeviceFromContext(gl) {
           if (!gl) {
             return null;
@@ -6525,7 +6624,7 @@ ${source}`;
         }
         constructor(props) {
           super({ ...props, id: props.id || uid("webgl-device") });
-          const canvasContextProps = import_core27.Device._getCanvasContextProps(props);
+          const canvasContextProps = import_core26.Device._getCanvasContextProps(props);
           if (!canvasContextProps) {
             throw new Error("WebGLDevice requires props.createCanvasContext to be set");
           }
@@ -6567,7 +6666,7 @@ ${source}`;
           device = WebGLDevice.getDeviceFromContext(gl);
           if (device) {
             if (props._reuseDevices) {
-              import_core27.log.log(
+              import_core26.log.log(
                 1,
                 `Not creating a new Device, instead returning a reference to Device ${device.id} already attached to WebGL context`,
                 device
@@ -6591,15 +6690,15 @@ ${source}`;
             this.features.initializeFeatures();
           }
           const glState = new WebGLStateTracker(this.gl, {
-            log: (...args) => import_core27.log.log(1, ...args)()
+            log: (...args) => import_core26.log.log(1, ...args)()
           });
           glState.trackState(this.gl, { copyState: false });
           if (props.debug || props.debugWebGL) {
             this.gl = makeDebugContext(this.gl, { debugWebGL: true, traceWebGL: props.debugWebGL });
-            import_core27.log.warn("WebGL debug mode activated. Performance reduced.")();
+            import_core26.log.warn("WebGL debug mode activated. Performance reduced.")();
           }
           if (props.debugWebGL) {
-            import_core27.log.level = Math.max(import_core27.log.level, 1);
+            import_core26.log.level = Math.max(import_core26.log.level, 1);
           }
           this.commandEncoder = new WEBGLCommandEncoder(this, { id: `${this}-command-encoder` });
           this.canvasContext._startObservers();
@@ -6685,13 +6784,7 @@ ${source}`;
         submit(commandBuffer) {
           let submittedCommandEncoder = 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 {
             commandBuffer._executeCommands();
@@ -6705,6 +6798,16 @@ ${source}`;
             commandBuffer.destroy();
           }
         }
+        _finalizeDefaultCommandEncoderForSubmit() {
+          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
         //
@@ -6726,7 +6829,7 @@ ${source}`;
           return withGLParameters(this.gl, parameters, func);
         }
         resetWebGL() {
-          import_core27.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
+          import_core26.log.warn("WebGLDevice.resetWebGL is deprecated, use only for debugging")();
           resetGLParameters(this.gl);
         }
         _getDeviceSpecificTextureFormatCapabilities(capabilities) {
@@ -6798,7 +6901,7 @@ ${source}`;
           this._constants = this._constants || new Array(maxVertexAttributes).fill(null);
           const currentConstant = this._constants[location];
           if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
-            import_core27.log.info(
+            import_core26.log.info(
               1,
               `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`
             )();
@@ -6844,21 +6947,21 @@ ${source}`;
     }
     return Boolean(gl && typeof gl.createVertexArray === "function");
   }
-  var import_core28, LOG_LEVEL2, WebGLAdapter, webgl2Adapter;
+  var import_core27, LOG_LEVEL2, WebGLAdapter, webgl2Adapter;
   var init_webgl_adapter = __esm({
     "src/adapter/webgl-adapter.ts"() {
       "use strict";
-      import_core28 = __toESM(require_core(), 1);
+      import_core27 = __toESM(require_core(), 1);
       init_polyfill_webgl1_extensions();
       init_spector();
       init_webgl_developer_tools();
       LOG_LEVEL2 = 1;
-      WebGLAdapter = class extends import_core28.Adapter {
+      WebGLAdapter = class extends import_core27.Adapter {
         /** type of device's created by this adapter */
         type = "webgl";
         constructor() {
           super();
-          import_core28.Device.defaultProps = { ...import_core28.Device.defaultProps, ...DEFAULT_SPECTOR_PROPS };
+          import_core27.Device.defaultProps = { ...import_core27.Device.defaultProps, ...DEFAULT_SPECTOR_PROPS };
         }
         /** Force any created WebGL contexts to be WebGL2 contexts, polyfilled with WebGL1 extensions */
         enforceWebGL2(enable2) {
@@ -6873,7 +6976,7 @@ ${source}`;
             return true;
           }
           if (typeof WebGLRenderingContext !== "undefined" && handle instanceof WebGLRenderingContext) {
-            import_core28.log.warn("WebGL1 is not supported", handle)();
+            import_core27.log.warn("WebGL1 is not supported", handle)();
           }
           return false;
         }
@@ -6915,19 +7018,19 @@ ${source}`;
           const results = await Promise.allSettled(promises);
           for (const result of results) {
             if (result.status === "rejected") {
-              import_core28.log.error(`Failed to initialize debug libraries ${result.reason}`)();
+              import_core27.log.error(`Failed to initialize debug libraries ${result.reason}`)();
             }
           }
           try {
             const device = new WebGLDevice2(props);
-            import_core28.log.groupCollapsed(LOG_LEVEL2, `WebGLDevice ${device.id} created`)();
+            import_core27.log.groupCollapsed(LOG_LEVEL2, `WebGLDevice ${device.id} created`)();
             const message2 = `${device._reused ? "Reusing" : "Created"} device with WebGL2 ${device.props.debug ? "debug " : ""}context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
-            import_core28.log.probe(LOG_LEVEL2, message2)();
-            import_core28.log.table(LOG_LEVEL2, device.info)();
+            import_core27.log.probe(LOG_LEVEL2, message2)();
+            import_core27.log.table(LOG_LEVEL2, device.info)();
             return device;
           } finally {
-            import_core28.log.groupEnd(LOG_LEVEL2)();
-            import_core28.log.info(
+            import_core27.log.groupEnd(LOG_LEVEL2)();
+            import_core27.log.info(
               LOG_LEVEL2,
               `%cWebGL call tracing: luma.log.set('debug-webgl') `,
               "color: white; background: blue; padding: 2px 6px; border-radius: 3px;"
@@ -6940,9 +7043,10 @@ ${source}`;
   });
 
   // src/index.ts
-  var init_src2 = __esm({
+  var init_src = __esm({
     "src/index.ts"() {
       "use strict";
+      init_webgl_constants();
       init_webgl_adapter();
       init_webgl_device();
       init_webgl_canvas_context();
@@ -6968,6 +7072,7 @@ ${source}`;
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
+    GL: () => GLEnum,
     WEBGLBuffer: () => WEBGLBuffer,
     WEBGLCommandEncoder: () => WEBGLCommandEncoder,
     WEBGLFence: () => WEBGLFence,
@@ -6992,7 +7097,7 @@ ${source}`;
     withGLParameters: () => withGLParameters
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
-  init_src2();
+  init_src();
   return __toCommonJS(bundle_exports);
 })();
       return __exports__;