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

package/dist/index.cjs

@@ -1213,7 +1213,10 @@ function getTextureFormatWebGL(format) {
   var _a;
   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 == null ? void 0 : formatData.dataFormat) || getWebGLPixelDataFormat(decoded.channels, decoded.integer, decoded.normalized, webglFormat),
@@ -1223,7 +1226,7 @@ function getTextureFormatWebGL(format) {
   };
 }
 function getDepthStencilAttachmentWebGL(format) {
-  const formatInfo = (0, import_core3.getTextureFormatInfo)(format);
+  const formatInfo = import_core3.textureFormatDecoder.getInfo(format);
   switch (formatInfo.attachment) {
     case "depth":
       return 36096;
@@ -1318,8 +1321,8 @@ var init_webgl_texture_table = __esm({
       "r16uint": { gl: 33332, rb: true },
       "r16sint": { gl: 33331, rb: true },
       "r16float": { gl: 33325, rb: true },
-      "r16unorm-webgl": { gl: 33322, rb: true },
-      "r16snorm-webgl": { gl: 36760 },
+      "r16unorm": { gl: 33322, rb: true },
+      "r16snorm": { gl: 36760 },
       // Packed 16-bit formats
       "rgba4unorm-webgl": { gl: 32854, rb: true },
       "rgb565unorm-webgl": { gl: 36194, rb: true },
@@ -1327,7 +1330,7 @@ var init_webgl_texture_table = __esm({
       // 24-bit formats
       "rgb8unorm-webgl": { gl: 32849 },
       "rgb8snorm-webgl": { gl: 36758 },
-      // 32-bit formats  
+      // 32-bit formats
       "rgba8unorm": { gl: 32856 },
       "rgba8unorm-srgb": { gl: 35907 },
       "rgba8snorm": { gl: 36759 },
@@ -1339,8 +1342,8 @@ var init_webgl_texture_table = __esm({
       "rg16uint": { gl: 33338 },
       "rg16sint": { gl: 33337 },
       "rg16float": { gl: 33327, rb: true },
-      "rg16unorm-webgl": { gl: 33324 },
-      "rg16snorm-webgl": { gl: 36761 },
+      "rg16unorm": { gl: 33324 },
+      "rg16snorm": { gl: 36761 },
       "r32uint": { gl: 33334, rb: true },
       "r32sint": { gl: 33333, rb: true },
       "r32float": { gl: 33326 },
@@ -1362,8 +1365,8 @@ var init_webgl_texture_table = __esm({
       "rgba16uint": { gl: 36214, rb: true },
       "rgba16sint": { gl: 36232, rb: true },
       "rgba16float": { gl: 34842 },
-      "rgba16unorm-webgl": { gl: 32859, rb: true },
-      "rgba16snorm-webgl": { gl: 36763 },
+      "rgba16unorm": { gl: 32859, rb: true },
+      "rgba16snorm": { gl: 36763 },
       // 96-bit formats (deprecated!)
       "rgb32float-webgl": { gl: 34837, x: EXT_color_buffer_float, dataFormat: 6407, types: [5126] },
       // 128-bit formats
@@ -1881,7 +1884,15 @@ var init_webgl_buffer = __esm({
           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;
@@ -1910,33 +1921,32 @@ var init_webgl_buffer = __esm({
         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;
         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);
@@ -2421,9 +2431,20 @@ function convertMinFilterMode(minFilter, mipmapFilter = "none") {
     case "none":
       return convertMaxFilterMode(minFilter);
     case "nearest":
-      return minFilter === "nearest" ? 9984 : 9986;
+      switch (minFilter) {
+        case "nearest":
+          return 9984;
+        case "linear":
+          return 9985;
+      }
+      break;
     case "linear":
-      return minFilter === "nearest" ? 9985 : 9987;
+      switch (minFilter) {
+        case "nearest":
+          return 9986;
+        case "linear":
+          return 9987;
+      }
   }
 }
 var import_constants12;
@@ -2656,10 +2677,10 @@ var init_webgl_texture = __esm({
         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]: options.bytesPerRow,
           [32878]: options.rowsPerImage
-        };
+        } : {};
         this.gl.bindTexture(glTarget, this.handle);
         withGLParameters(this.gl, glParameters, () => {
           switch (this.dimension) {
@@ -2733,7 +2754,7 @@ var init_webgl_texture = __esm({
        * 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);
@@ -3445,7 +3466,8 @@ var init_webgl_render_pipeline = __esm({
                 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();
         }
       }
       /**
@@ -3738,6 +3760,7 @@ var init_webgl_command_buffer = __esm({
     init_webgl_texture_table();
     WEBGLCommandBuffer = class extends import_core16.CommandBuffer {
       device;
+      handle = null;
       commands = [];
       constructor(device) {
         super(device, {});
@@ -3779,6 +3802,7 @@ var init_webgl_render_pass = __esm({
     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) {
@@ -4620,7 +4644,7 @@ function readPixelsToArray(source, options) {
   sourceFormat ||= (texture == null ? void 0 : texture.glFormat) || 6408;
   sourceType ||= (texture == null ? void 0 : texture.glType) || 5121;
   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, handle);
   gl.readBuffer(36064 + sourceAttachment);
@@ -4685,7 +4709,7 @@ function getPixelArray(pixelArray, glType, glFormat, width, height, depth) {
   }
   glType ||= 5121;
   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);
 }
@@ -4773,6 +4797,7 @@ var init_webgl_device = __esm({
       // 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;
@@ -4786,7 +4811,6 @@ var init_webgl_device = __esm({
       _resolveContextLost;
       /** WebGL2 context. */
       gl;
-      debug = false;
       /** Store constants */
       // @ts-ignore TODO fix
       _constants;
@@ -4798,16 +4822,27 @@ var init_webgl_device = __esm({
       //
       // 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) {
         var _a, _b;
         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 = (_b = (_a = canvasContextProps.canvas) == null ? void 0 : _a.gl) == null ? void 0 : _b.device;
         if (device) {
           throw new Error(`WebGL context already attached to device ${device.id}`);
@@ -4823,7 +4858,8 @@ var init_webgl_device = __esm({
         if (props.powerPreference !== void 0) {
           webglContextAttributes.powerPreference = props.powerPreference;
         }
-        const gl = createBrowserContext(this.canvasContext.canvas, {
+        const externalGLContext = this.props._handle;
+        const gl = externalGLContext || createBrowserContext(this.canvasContext.canvas, {
           onContextLost: (event) => {
             var _a2;
             return (_a2 = this._resolveContextLost) == null ? void 0 : _a2.call(this, {
@@ -4839,6 +4875,11 @@ var init_webgl_device = __esm({
         }
         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;
@@ -4868,15 +4909,27 @@ var init_webgl_device = __esm({
         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");
       }
@@ -5053,7 +5106,7 @@ var init_webgl_device = __esm({
        */
       _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;
       }
     };
@@ -5102,7 +5155,8 @@ var init_webgl_adapter = __esm({
       }
       /**
        * 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
        */
@@ -5117,30 +5171,36 @@ var init_webgl_adapter = __esm({
         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();