@luma.gl/webgl 9.2.0-alpha.1 → 9.2.0-alpha.3

package/dist/dist.dev.js

@@ -2026,7 +2026,10 @@ var __exports__ = (() => {
   function getTextureFormatWebGL(format) {
     const formatData = WEBGL_TEXTURE_FORMATS[format];
     const webglFormat = convertTextureFormatToGL(format);
-    const decoded = (0, import_core3.getTextureFormatInfo)(format);
+    const decoded = import_core3.textureFormatDecoder.getInfo(format);
+    if (decoded.compressed) {
+      formatData.dataFormat = webglFormat;
+    }
     return {
       internalFormat: webglFormat,
       format: formatData?.dataFormat || getWebGLPixelDataFormat(decoded.channels, decoded.integer, decoded.normalized, webglFormat),
@@ -2036,7 +2039,7 @@ var __exports__ = (() => {
     };
   }
   function getDepthStencilAttachmentWebGL(format) {
-    const formatInfo = (0, import_core3.getTextureFormatInfo)(format);
+    const formatInfo = import_core3.textureFormatDecoder.getInfo(format);
     switch (formatInfo.attachment) {
       case "depth":
         return 36096 /* DEPTH_ATTACHMENT */;
@@ -2130,8 +2133,8 @@ var __exports__ = (() => {
         "r16uint": { gl: 33332 /* R16UI */, rb: true },
         "r16sint": { gl: 33331 /* R16I */, rb: true },
         "r16float": { gl: 33325 /* R16F */, rb: true },
-        "r16unorm-webgl": { gl: 33322 /* R16_EXT */, rb: true },
-        "r16snorm-webgl": { gl: 36760 /* R16_SNORM_EXT */ },
+        "r16unorm": { gl: 33322 /* R16_EXT */, rb: true },
+        "r16snorm": { gl: 36760 /* R16_SNORM_EXT */ },
         // Packed 16-bit formats
         "rgba4unorm-webgl": { gl: 32854 /* RGBA4 */, rb: true },
         "rgb565unorm-webgl": { gl: 36194 /* RGB565 */, rb: true },
@@ -2139,7 +2142,7 @@ var __exports__ = (() => {
         // 24-bit formats
         "rgb8unorm-webgl": { gl: 32849 /* RGB8 */ },
         "rgb8snorm-webgl": { gl: 36758 /* RGB8_SNORM */ },
-        // 32-bit formats  
+        // 32-bit formats
         "rgba8unorm": { gl: 32856 /* RGBA8 */ },
         "rgba8unorm-srgb": { gl: 35907 /* SRGB8_ALPHA8 */ },
         "rgba8snorm": { gl: 36759 /* RGBA8_SNORM */ },
@@ -2151,8 +2154,8 @@ var __exports__ = (() => {
         "rg16uint": { gl: 33338 /* RG16UI */ },
         "rg16sint": { gl: 33337 /* RG16I */ },
         "rg16float": { gl: 33327 /* RG16F */, rb: true },
-        "rg16unorm-webgl": { gl: 33324 /* RG16_EXT */ },
-        "rg16snorm-webgl": { gl: 36761 /* RG16_SNORM_EXT */ },
+        "rg16unorm": { gl: 33324 /* RG16_EXT */ },
+        "rg16snorm": { gl: 36761 /* RG16_SNORM_EXT */ },
         "r32uint": { gl: 33334 /* R32UI */, rb: true },
         "r32sint": { gl: 33333 /* R32I */, rb: true },
         "r32float": { gl: 33326 /* R32F */ },
@@ -2174,8 +2177,8 @@ var __exports__ = (() => {
         "rgba16uint": { gl: 36214 /* RGBA16UI */, rb: true },
         "rgba16sint": { gl: 36232 /* RGBA16I */, rb: true },
         "rgba16float": { gl: 34842 /* RGBA16F */ },
-        "rgba16unorm-webgl": { gl: 32859 /* RGBA16_EXT */, rb: true },
-        "rgba16snorm-webgl": { gl: 36763 /* RGBA16_SNORM_EXT */ },
+        "rgba16unorm": { gl: 32859 /* RGBA16_EXT */, rb: true },
+        "rgba16snorm": { gl: 36763 /* RGBA16_SNORM_EXT */ },
         // 96-bit formats (deprecated!)
         "rgb32float-webgl": { gl: 34837 /* RGB32F */, x: EXT_color_buffer_float, dataFormat: 6407 /* RGB */, types: [5126 /* FLOAT */] },
         // 128-bit formats
@@ -2694,7 +2697,15 @@ var __exports__ = (() => {
             this._initWithByteLength(props.byteLength || 0);
           }
         }
-        // PRIVATE METHODS
+        destroy() {
+          if (!this.destroyed && this.handle) {
+            this.removeStats();
+            this.trackDeallocatedMemory();
+            this.gl.deleteBuffer(this.handle);
+            this.destroyed = true;
+            this.handle = null;
+          }
+        }
         /** Allocate a new buffer and initialize to contents of typed array */
         _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) {
           const glTarget = this.glTarget;
@@ -2723,33 +2734,32 @@ var __exports__ = (() => {
           this.trackAllocatedMemory(byteLength);
           return this;
         }
-        destroy() {
-          if (!this.destroyed && this.handle) {
-            this.removeStats();
-            this.trackDeallocatedMemory();
-            this.gl.deleteBuffer(this.handle);
-            this.destroyed = true;
-            this.handle = null;
-          }
-        }
         write(data, byteOffset = 0) {
+          const dataView = ArrayBuffer.isView(data) ? data : new Uint8Array(data);
           const srcOffset = 0;
           const byteLength = void 0;
           const glTarget = 36663 /* COPY_WRITE_BUFFER */;
           this.gl.bindBuffer(glTarget, this.handle);
           if (srcOffset !== 0 || byteLength !== void 0) {
-            this.gl.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength);
+            this.gl.bufferSubData(glTarget, byteOffset, dataView, srcOffset, byteLength);
           } else {
-            this.gl.bufferSubData(glTarget, byteOffset, data);
+            this.gl.bufferSubData(glTarget, byteOffset, dataView);
           }
           this.gl.bindBuffer(glTarget, null);
           this._setDebugData(data, byteOffset, data.byteLength);
         }
-        /** Asynchronously read data from the buffer */
+        async mapAndWriteAsync(callback, byteOffset = 0, byteLength = this.byteLength - byteOffset) {
+          const arrayBuffer = new ArrayBuffer(byteLength);
+          await callback(arrayBuffer, "copied");
+          this.write(arrayBuffer, byteOffset);
+        }
         async readAsync(byteOffset = 0, byteLength) {
           return this.readSyncWebGL(byteOffset, byteLength);
         }
-        /** Synchronously read data from the buffer. WebGL only. */
+        async mapAndReadAsync(callback, byteOffset = 0, byteLength) {
+          const data = await this.readAsync(byteOffset, byteLength);
+          return await callback(data.buffer, "copied");
+        }
         readSyncWebGL(byteOffset = 0, byteLength) {
           byteLength = byteLength ?? this.byteLength - byteOffset;
           const data = new Uint8Array(byteLength);
@@ -3262,9 +3272,20 @@ ${source}`;
       case "none":
         return convertMaxFilterMode(minFilter);
       case "nearest":
-        return minFilter === "nearest" ? 9984 /* NEAREST_MIPMAP_NEAREST */ : 9986 /* NEAREST_MIPMAP_LINEAR */;
+        switch (minFilter) {
+          case "nearest":
+            return 9984 /* NEAREST_MIPMAP_NEAREST */;
+          case "linear":
+            return 9985 /* LINEAR_MIPMAP_NEAREST */;
+        }
+        break;
       case "linear":
-        return minFilter === "nearest" ? 9985 /* LINEAR_MIPMAP_NEAREST */ : 9987 /* LINEAR_MIPMAP_LINEAR */;
+        switch (minFilter) {
+          case "nearest":
+            return 9986 /* NEAREST_MIPMAP_LINEAR */;
+          case "linear":
+            return 9987 /* LINEAR_MIPMAP_LINEAR */;
+        }
     }
   }
   var init_sampler_parameters = __esm({
@@ -3493,10 +3514,10 @@ ${source}`;
           const { mipLevel = 0, byteOffset = 0, x = 0, y = 0, z = 0 } = options;
           const { glFormat, glType, compressed } = this;
           const glTarget = getWebGLCubeFaceTarget(this.glTarget, this.dimension, depth);
-          const glParameters = {
+          const glParameters = !this.compressed ? {
             [3314 /* UNPACK_ROW_LENGTH */]: options.bytesPerRow,
             [32878 /* UNPACK_IMAGE_HEIGHT */]: options.rowsPerImage
-          };
+          } : {};
           this.gl.bindTexture(glTarget, this.handle);
           withGLParameters(this.gl, glParameters, () => {
             switch (this.dimension) {
@@ -3570,7 +3591,7 @@ ${source}`;
          * Sets sampler parameters on texture
          */
         _setSamplerParameters(parameters) {
-          import_core13.log.log(1, `${this.id} sampler parameters`, this.device.getGLKeys(parameters))();
+          import_core13.log.log(2, `${this.id} sampler parameters`, this.device.getGLKeys(parameters))();
           this.gl.bindTexture(this.glTarget, this.handle);
           for (const [pname, pvalue] of Object.entries(parameters)) {
             const param = Number(pname);
@@ -4291,7 +4312,11 @@ ${source}`;
                   break;
               }
               const linkErrorLog = this.device.gl.getProgramInfoLog(this.handle);
-              this.device.reportError(new Error(`${errorType} during ${status}: ${linkErrorLog}`));
+              this.device.reportError(
+                new Error(`${errorType} during ${status}: ${linkErrorLog}`),
+                this
+              )();
+              this.device.debug();
           }
         }
         /**
@@ -4623,6 +4648,7 @@ ${source}`;
       init_webgl_texture_table();
       WEBGLCommandBuffer = class extends import_core16.CommandBuffer {
         device;
+        handle = null;
         commands = [];
         constructor(device) {
           super(device, {});
@@ -4663,6 +4689,7 @@ ${source}`;
       COLOR_CHANNELS = [1, 2, 4, 8];
       WEBGLRenderPass = class extends import_core17.RenderPass {
         device;
+        handle = null;
         /** Parameters that should be applied before each draw call */
         glParameters = {};
         constructor(device, props) {
@@ -5526,7 +5553,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_core22.getDataTypeFromTypedArray)(target2);
+    const signedType = (0, import_core22.getDataType)(target2);
     sourceType = sourceType || convertDataTypeToGLDataType(signedType);
     const prevHandle = gl.bindFramebuffer(
       36160 /* FRAMEBUFFER */,
@@ -5600,7 +5627,7 @@ ${source}`;
     }
     glType ||= 5121 /* UNSIGNED_BYTE */;
     const shaderType = convertGLDataTypeToDataType(glType);
-    const ArrayType = (0, import_core22.getTypedArrayFromDataType)(shaderType);
+    const ArrayType = (0, import_core22.getTypedArrayConstructor)(shaderType);
     const components = glFormatToComponents(glFormat);
     return new ArrayType(width * height * components);
   }
@@ -5687,6 +5714,7 @@ ${source}`;
         // Public `Device` API
         /** type of this device */
         type = "webgl";
+        // Use the ! assertion to handle the case where _reuseDevices causes the constructor to return early
         /** The underlying WebGL context */
         handle;
         features;
@@ -5700,7 +5728,6 @@ ${source}`;
         _resolveContextLost;
         /** WebGL2 context. */
         gl;
-        debug = false;
         /** Store constants */
         // @ts-ignore TODO fix
         _constants;
@@ -5712,15 +5739,26 @@ ${source}`;
         //
         // Public API
         //
+        get [Symbol.toStringTag]() {
+          return "WebGLDevice";
+        }
         toString() {
           return `${this[Symbol.toStringTag]}(${this.id})`;
         }
+        isVertexFormatSupported(format) {
+          switch (format) {
+            case "unorm8x4-bgra":
+              return false;
+            default:
+              return true;
+          }
+        }
         constructor(props) {
           super({ ...props, id: props.id || uid("webgl-device") });
-          if (!props.createCanvasContext) {
+          const canvasContextProps = import_core23.Device._getCanvasContextProps(props);
+          if (!canvasContextProps) {
             throw new Error("WebGLDevice requires props.createCanvasContext to be set");
           }
-          const canvasContextProps = props.createCanvasContext === true ? {} : props.createCanvasContext;
           let device = canvasContextProps.canvas?.gl?.device;
           if (device) {
             throw new Error(`WebGL context already attached to device ${device.id}`);
@@ -5736,7 +5774,8 @@ ${source}`;
           if (props.powerPreference !== void 0) {
             webglContextAttributes.powerPreference = props.powerPreference;
           }
-          const gl = createBrowserContext(
+          const externalGLContext = this.props._handle;
+          const gl = externalGLContext || createBrowserContext(
             this.canvasContext.canvas,
             {
               onContextLost: (event) => this._resolveContextLost?.({
@@ -5753,6 +5792,15 @@ ${source}`;
           }
           device = gl.device;
           if (device) {
+            if (props._reuseDevices) {
+              import_core23.log.log(
+                1,
+                `Not creating a new Device, instead returning a reference to Device ${device.id} already attached to WebGL context`,
+                device
+              )();
+              device._reused = true;
+              return device;
+            }
             throw new Error(`WebGL context already attached to device ${device.id}`);
           }
           this.handle = gl;
@@ -5786,15 +5834,27 @@ ${source}`;
           this.commandEncoder = new WEBGLCommandEncoder(this, { id: `${this}-command-encoder` });
         }
         /**
-         * Destroys the context
-         * @note Has no effect for WebGL browser contexts, there is no browser API for destroying contexts
+         * Destroys the device
+         *
+         * @note "Detaches" from the WebGL context unless _reuseDevices is true.
+         *
+         * @note The underlying WebGL context is not immediately destroyed,
+         * but may be destroyed later through normal JavaScript garbage collection.
+         * This is a fundamental limitation since WebGL does not offer any
+         * browser API for destroying WebGL contexts.
          */
         destroy() {
+          if (!this.props._reuseDevices && !this._reused) {
+            delete this.gl.device;
+          }
         }
         get isLost() {
           return this.gl.isContextLost();
         }
         // IMPLEMENTATION OF ABSTRACT DEVICE
+        getTextureByteAlignment() {
+          return 4;
+        }
         createCanvasContext(props) {
           throw new Error("WebGL only supports a single canvas");
         }
@@ -5973,7 +6033,7 @@ ${source}`;
          */
         _setWebGLDebugMetadata(handle, resource, options) {
           handle.luma = resource;
-          const spectorMetadata = { props: options.spector, id: options.spector.id };
+          const spectorMetadata = { props: options.spector, id: options.spector["id"] };
           handle.__SPECTOR_Metadata = spectorMetadata;
         }
       };
@@ -6022,7 +6082,8 @@ ${source}`;
         }
         /**
          * Get a device instance from a GL context
-         * Creates and instruments the device if not already created
+         * Creates a WebGLCanvasContext against the contexts canvas
+         * @note autoResize will be disabled, assuming that whoever created the external context will be handling resizes.
          * @param gl
          * @returns
          */
@@ -6037,30 +6098,36 @@ ${source}`;
           if (!isWebGL(gl)) {
             throw new Error("Invalid WebGL2RenderingContext");
           }
-          return new WebGLDevice2({ _handle: gl });
+          return new WebGLDevice2({
+            _handle: gl,
+            createCanvasContext: { canvas: gl.canvas, autoResize: false }
+          });
         }
         async create(props = {}) {
           const { WebGLDevice: WebGLDevice2 } = await Promise.resolve().then(() => (init_webgl_device(), webgl_device_exports));
           import_core24.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
-          const promises = [];
-          if (props.debugWebGL || props.debug) {
-            promises.push(loadWebGLDeveloperTools());
-          }
-          if (props.debugSpectorJS) {
-            promises.push(loadSpectorJS(props));
-          }
-          const results = await Promise.allSettled(promises);
-          for (const result of results) {
-            if (result.status === "rejected") {
-              import_core24.log.error(`Failed to initialize debug libraries ${result.reason}`)();
+          try {
+            const promises = [];
+            if (props.debugWebGL || props.debug) {
+              promises.push(loadWebGLDeveloperTools());
+            }
+            if (props.debugSpectorJS) {
+              promises.push(loadSpectorJS(props));
             }
+            const results = await Promise.allSettled(promises);
+            for (const result of results) {
+              if (result.status === "rejected") {
+                import_core24.log.error(`Failed to initialize debug libraries ${result.reason}`)();
+              }
+            }
+            const device = new WebGLDevice2(props);
+            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_core24.log.probe(LOG_LEVEL2, message2)();
+            import_core24.log.table(LOG_LEVEL2, device.info)();
+            return device;
+          } finally {
+            import_core24.log.groupEnd(LOG_LEVEL2)();
           }
-          const device = new WebGLDevice2(props);
-          const message2 = `Created ${device.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
-          import_core24.log.probe(LOG_LEVEL2, message2)();
-          import_core24.log.table(LOG_LEVEL2, device.info)();
-          import_core24.log.groupEnd(LOG_LEVEL2)();
-          return device;
         }
       };
       webgl2Adapter = new WebGLAdapter();