@luma.gl/webgl 9.0.17 → 9.1.0-alpha.10

package/dist/adapter/converters/device-parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"device-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/device-parameters.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAgD,MAAM,eAAe,CAAC;AAClG,OAAO,EAAC,MAAM,EAAsB,UAAU,EAA+B,MAAM,eAAe,CAAC;AAEnG,OAAO,KAAK,EAGV,UAAU,EACV,YAAY,EAIb,MAAM,oBAAoB,CAAC;AAO5B;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,OAAO,EACnD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAC1C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAeH;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,OAAO,EAC9C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,QAwMzE;AAyBD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,UAAU,CAW5F;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,eAAe,CAW9F"}
+{"version":3,"file":"device-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/device-parameters.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAgD,MAAM,eAAe,CAAC;AAClG,OAAO,EAAC,MAAM,EAAO,UAAU,EAA+B,MAAM,eAAe,CAAC;AAEpF,OAAO,KAAK,EAGV,UAAU,EACV,YAAY,EAIb,MAAM,oBAAoB,CAAC;AAM5B;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,OAAO,EACnD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAgBH;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,OAAO,EAC1C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAeH;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,OAAO,EAC9C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,CAAC,GAC3B,CAAC,CAeH;AAED,kCAAkC;AAClC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,QAgNzE;AAyBD,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,eAAe,GAAG,UAAU,CAW5F;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,eAAe,CAW9F"}

package/dist/adapter/converters/device-parameters.js

@@ -1,9 +1,8 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { log, isObjectEmpty } from '@luma.gl/core';
+import { log } from '@luma.gl/core';
 import { GL } from '@luma.gl/constants';
-import { pushContextState, popContextState } from "../../context/state-tracker/track-context-state.js";
 import { setGLParameters } from "../../context/parameters/unified-parameter-api.js";
 /* eslint-disable no-unused-expressions */ // For expression ? gl.enable() : gl.disable()
 /**
@@ -21,14 +20,14 @@ export function withDeviceAndGLParameters(device, parameters, glParameters, func
     }
     // Wrap in a try-catch to ensure that parameters are restored on exceptions
     const webglDevice = device;
-    pushContextState(webglDevice.gl);
+    webglDevice.pushState();
     try {
         setDeviceParameters(device, parameters);
         setGLParameters(webglDevice.gl, glParameters);
         return func(device);
     }
     finally {
-        popContextState(webglDevice.gl);
+        webglDevice.popState();
     }
 }
 /**
@@ -47,13 +46,13 @@ export function withGLParameters(device, parameters, func) {
     }
     // Wrap in a try-catch to ensure that parameters are restored on exceptions
     const webglDevice = device;
-    pushContextState(webglDevice.gl);
+    webglDevice.pushState();
     try {
         setGLParameters(webglDevice.gl, parameters);
         return func(device);
     }
     finally {
-        popContextState(webglDevice.gl);
+        webglDevice.popState();
     }
 }
 /**
@@ -69,16 +68,15 @@ export function withDeviceParameters(device, parameters, func) {
         // Avoid setting state if no parameters provided. Just call and return
         return func(device);
     }
-    // Wrap in a try-catch to ensure that parameters are restored on exceptions
-    // @ts-expect-error
-    pushContextState(device.gl);
+    // Wrap in a try-catch to ensure that parameters are restored on exceptions'
+    const webglDevice = device;
+    webglDevice.pushState();
     try {
         setDeviceParameters(device, parameters);
         return func(device);
     }
     finally {
-        // @ts-expect-error
-        popContextState(device.gl);
+        webglDevice.popState();
     }
 }
 /** Set WebGPU Style Parameters */
@@ -218,8 +216,17 @@ export function setDeviceParameters(device, parameters) {
     //   // handled by stencilPassOperation
     // },
     // COLOR STATE
+    switch (parameters.blend) {
+        case true:
+            gl.enable(3042);
+            break;
+        case false:
+            gl.disable(3042);
+            break;
+        default:
+        // leave WebGL blend state unchanged if `parameters.blend` is not set
+    }
     if (parameters.blendColorOperation || parameters.blendAlphaOperation) {
-        gl.enable(3042);
         const colorEquation = convertBlendOperationToEquation('blendColorOperation', parameters.blendColorOperation || 'add');
         const alphaEquation = convertBlendOperationToEquation('blendAlphaOperation', parameters.blendAlphaOperation || 'add');
         gl.blendEquationSeparate(colorEquation, alphaEquation);
@@ -328,3 +335,14 @@ function map(parameter, value, valueMap) {
 function mapBoolean(parameter, value) {
     return value;
 }
+/** Returns true if given object is empty, false otherwise. */
+function isObjectEmpty(obj) {
+    let isEmpty = true;
+    // @ts-ignore key is unused
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (const key in obj) {
+        isEmpty = false;
+        break;
+    }
+    return isEmpty;
+}

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

@@ -1,5 +1,5 @@
 import type { TextureFormat, DeviceFeature } from '@luma.gl/core';
-import { GL, GLExtensions } from '@luma.gl/constants';
+import { GL, GLPixelType, GLExtensions, GLTexelDataFormat } from '@luma.gl/constants';
 export declare const TEXTURE_FEATURES: Partial<Record<DeviceFeature, string[]>>;
 /** Return a list of texture feature strings (for Device.features). Mainly compressed texture support */
 export declare function isTextureFeature(feature: DeviceFeature): boolean;
@@ -27,8 +27,8 @@ type Format = {
     filter?: DeviceFeature;
     /** If not supported on WebGPU */
     wgpu?: false;
-    types?: number[];
-    dataFormat?: GL;
+    types?: GLPixelType[];
+    dataFormat?: GLTexelDataFormat;
     /** Depth and stencil format attachment points. If set, needs to be a Renderbuffer unless depthTexture is set  */
     attachment?: GL.DEPTH_ATTACHMENT | GL.STENCIL_ATTACHMENT | GL.DEPTH_STENCIL_ATTACHMENT;
     /** if depthTexture is set this is a depth/stencil format that can be set to a texture  */
@@ -44,14 +44,6 @@ export declare const TEXTURE_FORMATS: Record<TextureFormat, Format>;
 /** Checks if a texture format is supported */
 export declare function isTextureFormatSupported(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
 export declare function isRenderbufferFormatSupported(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
-/**
- * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
- */
-export declare function convertGLToTextureFormat(format: GL | TextureFormat): TextureFormat;
-/**
- * Map WebGPU style texture format strings to GL constants
- */
-export declare function convertTextureFormatToGL(format: TextureFormat): GL | undefined;
 /** Checks if a texture format is supported */
 export declare function getTextureFormatSupport(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): {
     supported: boolean;
@@ -64,14 +56,28 @@ export declare function getTextureFormatSupport(gl: WebGL2RenderingContext, form
 export declare function isTextureFormatFilterable(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
 export declare function isTextureFormatRenderable(gl: WebGL2RenderingContext, format: TextureFormat, extensions: GLExtensions): boolean;
 /** Get parameters necessary to work with format in WebGL: internalFormat, dataFormat, type, compressed, */
-export declare function getWebGLTextureParameters(format: TextureFormat): {
-    format: GL;
-    dataFormat: GL;
-    type: number;
-    compressed: any;
+export declare function getTextureFormatWebGL(format: TextureFormat): {
+    internalFormat: GL;
+    format: GLTexelDataFormat;
+    type: GLPixelType;
+    compressed: boolean;
 };
 export declare function getDepthStencilAttachmentWebGL(format: TextureFormat): GL.DEPTH_ATTACHMENT | GL.STENCIL_ATTACHMENT | GL.DEPTH_STENCIL_ATTACHMENT;
 /** TODO - VERY roundabout legacy way of calculating bytes per pixel */
 export declare function getTextureFormatBytesPerPixel(format: TextureFormat): number;
+export declare function getWebGLPixelDataFormat(channels: 'r' | 'rg' | 'rgb' | 'rgba' | 'bgra', integer: boolean, normalized: boolean, format: GL): GLTexelDataFormat;
 export {};
+/**
+ * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
+export function convertGLToTextureFormat(format: GL | TextureFormat): TextureFormat {
+  if (typeof format === 'string') {
+    return format;
+  }
+  const entry = Object.entries(TEXTURE_FORMATS).find(([, entry]) => entry.gl === format);
+  if (!entry) {
+    throw new Error(`Unknown texture format ${format}`);
+  }
+  return entry[0] as TextureFormat;
+}
+ */
 //# sourceMappingURL=texture-formats.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"texture-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/texture-formats.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"texture-formats.d.ts","sourceRoot":"","sources":["../../../src/adapter/converters/texture-formats.ts"],"names":[],"mappings":"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"}

package/dist/adapter/converters/texture-formats.js

@@ -82,14 +82,6 @@ export function checkTextureFeature(gl, feature, extensions) {
  */
 // prettier-ignore
 export const TEXTURE_FORMATS = {
-    // Unsized formats that leave the precision up to the driver. TODO - Fix bpp constants
-    'rgb8unorm-unsized': { gl: 6407, b: 4, c: 2, bpp: 4,
-        dataFormat: 6407, types: [5121, 33635] },
-    'rgba8unorm-unsized': { gl: 6408, b: 4, c: 2, bpp: 4,
-        dataFormat: 6408, types: [5121, 32819, 32820] },
-    // 'r8unorm-unsized': {gl: GL.LUMINANCE, b: 4, c: 2, bpp: 4},
-    // 'rgb8unorm-srgb-unsized': {gl: GL.SRGB_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
-    // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
     // 8-bit formats
     'r8unorm': { gl: 33321, b: 1, c: 1, rb: true },
     'r8snorm': { gl: 36756, b: 1, c: 1, render: snorm8_renderable },
@@ -123,7 +115,6 @@ export const TEXTURE_FORMATS = {
     'bgra8unorm-srgb': { b: 4, c: 4 },
     'rg16uint': { gl: 33338, b: 4, c: 1, bpp: 4 },
     'rg16sint': { gl: 33337, b: 4, c: 2, bpp: 4 },
-    // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
     'rg16float': { gl: 33327, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, rb: true },
     'rg16unorm-webgl': { gl: 33324, b: 2, c: 2, render: norm16_renderable },
     'rg16snorm-webgl': { gl: 36761, b: 2, c: 2, render: snorm16_renderable },
@@ -165,9 +156,6 @@ export const TEXTURE_FORMATS = {
     // The depth component of the "depth24plus" and "depth24plus-stencil8" formats may be implemented as either a 24-bit depth value or a "depth32float" value.
     'depth24plus-stencil8': { gl: 35056, b: 4, c: 2, p: 1, attachment: 33306, rb: true, depthTexture: true,
         dataFormat: 34041, types: [34042] },
-    // "depth24unorm-stencil8" feature
-    'depth24unorm-stencil8': { gl: 35056, b: 4, c: 2, p: 1, attachment: 33306,
-        dataFormat: 34041, types: [34042], rb: true },
     // "depth32float-stencil8" feature - TODO below is render buffer only?
     'depth32float-stencil8': { gl: 36013, b: 5, c: 2, p: 1, attachment: 33306,
         dataFormat: 34041, types: [36269], rb: true },
@@ -371,6 +359,10 @@ export function isTextureFormatSupported(gl, format, extensions) {
     if (info.gl === undefined) {
         return false;
     }
+    const feature = info.f;
+    if (feature) {
+        return checkTextureFeature(gl, feature, extensions);
+    }
     // Check extensions
     const extension = info.x || info.gl2ext;
     if (extension) {
@@ -380,31 +372,7 @@ export function isTextureFormatSupported(gl, format, extensions) {
 }
 export function isRenderbufferFormatSupported(gl, format, extensions) {
     // Note: Order is important since the function call initializes extensions.
-    return isTextureFormatSupported(gl, format, extensions) && TEXTURE_FORMATS[format]?.rb;
-}
-/**
- * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
- */
-export function convertGLToTextureFormat(format) {
-    if (typeof format === 'string') {
-        return format;
-    }
-    const entry = Object.entries(TEXTURE_FORMATS).find(([, entry]) => entry.gl === format);
-    if (!entry) {
-        throw new Error(`Unknown texture format ${format}`);
-    }
-    return entry[0];
-}
-/**
- * Map WebGPU style texture format strings to GL constants
- */
-export function convertTextureFormatToGL(format) {
-    const formatInfo = TEXTURE_FORMATS[format];
-    const webglFormat = formatInfo?.gl;
-    if (webglFormat === undefined) {
-        throw new Error(`Unsupported texture format ${format}`);
-    }
-    return webglFormat;
+    return isTextureFormatSupported(gl, format, extensions) && Boolean(TEXTURE_FORMATS[format]?.rb);
 }
 /** Checks if a texture format is supported */
 export function getTextureFormatSupport(gl, format, extensions) {
@@ -470,20 +438,19 @@ export function isTextureFormatRenderable(gl, format, extensions) {
     return true;
 }
 /** Get parameters necessary to work with format in WebGL: internalFormat, dataFormat, type, compressed, */
-export function getWebGLTextureParameters(format) {
+export function getTextureFormatWebGL(format) {
     const formatData = TEXTURE_FORMATS[format];
     const webglFormat = convertTextureFormatToGL(format);
     const decoded = decodeTextureFormat(format);
     return {
-        format: webglFormat,
-        dataFormat: formatData?.dataFormat ||
-            getWebGLPixelDataFormat(decoded.format, decoded.integer, decoded.normalized, webglFormat),
+        internalFormat: webglFormat,
+        format: formatData?.dataFormat ||
+            getWebGLPixelDataFormat(decoded.channels, decoded.integer, decoded.normalized, webglFormat),
         // depth formats don't have a type
         type: decoded.dataType
             ? getGLFromVertexType(decoded.dataType)
             : formatData?.types?.[0] || 5121,
-        // @ts-expect-error
-        compressed: decoded.compressed
+        compressed: decoded.compressed || false
     };
 }
 export function getDepthStencilAttachmentWebGL(format) {
@@ -496,24 +463,49 @@ export function getDepthStencilAttachmentWebGL(format) {
 /** TODO - VERY roundabout legacy way of calculating bytes per pixel */
 export function getTextureFormatBytesPerPixel(format) {
     // TODO remove webgl1 support
-    const params = getWebGLTextureParameters(format);
+    const params = getTextureFormatWebGL(format);
     // NOTE(Tarek): Default to RGBA bytes
-    const channels = DATA_FORMAT_CHANNELS[params.dataFormat] || 4;
+    const channels = DATA_FORMAT_CHANNELS[params.format] || 4;
     const channelSize = TYPE_SIZES[params.type] || 1;
     return channels * channelSize;
 }
 // DATA TYPE HELPERS
-function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
+export function getWebGLPixelDataFormat(channels, integer, normalized, format) {
     // WebGL1 formats use same internalFormat
     if (format === 6408 || format === 6407) {
         return format;
     }
     // prettier-ignore
-    switch (dataFormat) {
+    switch (channels) {
         case 'r': return integer && !normalized ? 36244 : 6403;
         case 'rg': return integer && !normalized ? 33320 : 33319;
         case 'rgb': return integer && !normalized ? 36248 : 6407;
         case 'rgba': return integer && !normalized ? 36249 : 6408;
+        case 'bgra': throw new Error('bgra pixels not supported by WebGL');
         default: return 6408;
     }
 }
+/**
+ * Map WebGPU style texture format strings to GL constants
+ */
+function convertTextureFormatToGL(format) {
+    const formatInfo = TEXTURE_FORMATS[format];
+    const webglFormat = formatInfo?.gl;
+    if (webglFormat === undefined) {
+        throw new Error(`Unsupported texture format ${format}`);
+    }
+    return webglFormat;
+}
+/**
+ * Map WebGL texture formats (GL constants) to WebGPU-style TextureFormat strings
+export function convertGLToTextureFormat(format: GL | TextureFormat): TextureFormat {
+  if (typeof format === 'string') {
+    return format;
+  }
+  const entry = Object.entries(TEXTURE_FORMATS).find(([, entry]) => entry.gl === format);
+  if (!entry) {
+    throw new Error(`Unknown texture format ${format}`);
+  }
+  return entry[0] as TextureFormat;
+}
+ */

package/dist/adapter/device-helpers/webgl-device-features.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgl-device-features.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/webgl-device-features.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AA8BhD;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,SAAS,CAAC,EAAE,EAAE,sBAAsB,CAAC;IACrC,SAAS,CAAC,UAAU,EAAE,YAAY,CAAC;IACnC,SAAS,CAAC,cAAc,qBAA4B;gBAGlD,EAAE,EAAE,sBAAsB,EAC1B,UAAU,EAAE,YAAY,EACxB,gBAAgB,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAU1D,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAU5C,GAAG,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAuB7C,kBAAkB;IAWlB,WAAW;IAIX,iCAAiC;IACjC,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;CAU3D"}
+{"version":3,"file":"webgl-device-features.d.ts","sourceRoot":"","sources":["../../../src/adapter/device-helpers/webgl-device-features.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AA6BhD;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,SAAS,CAAC,EAAE,EAAE,sBAAsB,CAAC;IACrC,SAAS,CAAC,UAAU,EAAE,YAAY,CAAC;IACnC,SAAS,CAAC,cAAc,qBAA4B;gBAGlD,EAAE,EAAE,sBAAsB,EAC1B,UAAU,EAAE,YAAY,EACxB,gBAAgB,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IAU1D,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,aAAa,CAAC;IAU5C,GAAG,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAuB7C,kBAAkB;IAWlB,WAAW,IACoE,aAAa,EAAE;IAG9F,iCAAiC;IACjC,SAAS,CAAC,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;CAU3D"}

package/dist/adapter/device-helpers/webgl-device-features.js

@@ -17,7 +17,6 @@ const WEBGL_FEATURES = {
     // 'timestamp-query' // GPUQueryType "timestamp-query"
     // "indirect-first-instance"
     // Textures are handled by getTextureFeatures()
-    // 'depth24unorm-stencil8' // GPUTextureFormat 'depth24unorm-stencil8'
     // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8'
     // optional WebGL features
     'timer-query-webgl': 'EXT_disjoint_timer_query_webgl2',
@@ -57,7 +56,7 @@ export class WebGLDeviceFeatures extends DeviceFeatures {
         return [];
     }
     has(feature) {
-        if (this.disabledFeatures[feature]) {
+        if (this.disabledFeatures?.[feature]) {
             return false;
         }
         // We have already tested this feature

package/dist/adapter/device-helpers/webgl-device-limits.js

@@ -42,6 +42,6 @@ export class WebGLDeviceLimits extends DeviceLimits {
         if (this.limits[parameter] === undefined) {
             this.limits[parameter] = this.gl.getParameter(parameter);
         }
-        return this.limits[parameter];
+        return this.limits[parameter] || 0;
     }
 }

package/dist/adapter/helpers/webgl-texture-utils.d.ts

@@ -0,0 +1,300 @@
+import type { ExternalImage } from '@luma.gl/core';
+import { GL, GLTextureTarget, GLTexelDataFormat, GLPixelType } from '@luma.gl/constants';
+import { TypedArray } from '@math.gl/types';
+export type WebGLSetTextureOptions = {
+    dimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+    height: number;
+    width: number;
+    depth?: number;
+    level?: number;
+    glTarget: GLTextureTarget;
+    glInternalFormat: GL;
+    glFormat: GLTexelDataFormat;
+    glType: GLPixelType;
+    compressed?: boolean;
+    byteOffset?: number;
+    byteLength?: number;
+};
+/**
+ * @param {*} pixels, data -
+ *  null - create empty texture of specified format
+ *  Typed array - init from image data in typed array
+ *  Buffer|WebGLBuffer - (WEBGL2) init from image data in WebGLBuffer
+ *  HTMLImageElement|Image - Inits with content of image. Auto width/height
+ *  HTMLCanvasElement - Inits with contents of canvas. Auto width/height
+ *  HTMLVideoElement - Creates video texture. Auto width/height
+ *
+ * @param  x - xOffset from where texture to be updated
+ * @param  y - yOffset from where texture to be updated
+ * @param  width - width of the sub image to be updated
+ * @param  height - height of the sub image to be updated
+ * @param  level - mip level to be updated
+ * @param {GLenum} format - internal format of image data.
+ * @param {GLenum} type
+ *  - format of array (autodetect from type) or
+ *  - (WEBGL2) format of buffer or ArrayBufferView
+ * @param {GLenum} dataFormat - format of image data.
+ * @param {Number} offset - (WEBGL2) offset from start of buffer
+ * @parameters - temporary settings to be applied, can be used to supply pixel store settings.
+ */
+export type WebGLCopyTextureOptions = {
+    dimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+    level?: number;
+    height: number;
+    width: number;
+    depth?: number;
+    x?: number;
+    y?: number;
+    z?: number;
+    glTarget: GLTextureTarget;
+    glInternalFormat: GL;
+    glFormat: GL;
+    glType: GL;
+    compressed?: boolean;
+    byteOffset?: number;
+    byteLength?: number;
+};
+/**
+ * Initializes a texture memory space
+ * Clear all the textures and mip levels of a two-dimensional or array texture at the same time.
+ * On some implementations faster than repeatedly setting levels
+ *
+ * @note From WebGL 2 spec section 3.7.6:
+ * @see https://registry.khronos.org/webgl/specs/latest/2.0/
+ * - The image contents are set as if a buffer of sufficient size initialized to 0 would be passed to each level's texImage2D/3D
+ * - texStorage2D should be considered a preferred alternative to texImage2D. It may have lower memory costs than texImage2D in some implementations.
+ * - Once texStorage*D has been called, the texture is immutable and can only be updated with texSubImage*(), not texImage()
+ */
+export declare function initializeTextureStorage(gl: WebGL2RenderingContext, levels: number, options: WebGLSetTextureOptions): void;
+/**
+ * Copy a region of compressed data from a GPU memory buffer into this texture.
+ */
+export declare function copyCPUImageToMipLevel(gl: WebGL2RenderingContext, image: ExternalImage, options: WebGLCopyTextureOptions): void;
+/**
+ * Copy a region of data from a CPU memory buffer into this texture.
+ */
+export declare function copyCPUDataToMipLevel(gl: WebGL2RenderingContext, typedArray: TypedArray, options: WebGLCopyTextureOptions): void;
+/**
+ * Copy a region of compressed data from a GPU memory buffer into this texture.
+ */
+export declare function copyGPUBufferToMipLevel(gl: WebGL2RenderingContext, webglBuffer: WebGLBuffer, byteLength: number, options: WebGLCopyTextureOptions): void;
+/** Convert a WebGPU style texture constant to a WebGL style texture constant */
+export declare function getWebGLTextureTarget(dimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d'): GLTextureTarget;
+/**
+ * Clear a texture mip level.
+ * Wrapper for the messy WebGL texture API
+ *
+export function clearMipLevel(gl: WebGL2RenderingContext, options: WebGLSetTextureOptions): void {
+  const {dimension, width, height, depth = 0, level = 0} = options;
+  const {glInternalFormat, glFormat, glType, compressed} = options;
+  const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
+
+  switch (dimension) {
+    case '2d-array':
+    case '3d':
+      if (compressed) {
+        // prettier-ignore
+        gl.compressedTexImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, null);
+      } else {
+        // prettier-ignore
+        gl.texImage3D( glTarget, level, glInternalFormat, width, height, depth, BORDER, glFormat, glType, null);
+      }
+      break;
+
+    case '2d':
+    case 'cube':
+      if (compressed) {
+        // prettier-ignore
+        gl.compressedTexImage2D(glTarget, level, glInternalFormat, width, height, BORDER, null);
+      } else {
+        // prettier-ignore
+        gl.texImage2D(glTarget, level, glInternalFormat, width, height, BORDER, glFormat, glType, null);
+      }
+      break;
+
+    default:
+      throw new Error(dimension);
+  }
+}
+
+/**
+ * Set a texture mip level to the contents of an external image.
+ * Wrapper for the messy WebGL texture API
+ * @note Corresponds to WebGPU device.queue.copyExternalImageToTexture()
+ *
+export function setMipLevelFromExternalImage(
+  gl: WebGL2RenderingContext,
+  image: ExternalImage,
+  options: WebGLSetTextureOptions
+): void {
+  const {dimension, width, height, depth = 0, level = 0} = options;
+  const {glInternalFormat, glType} = options;
+
+  const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
+
+  // TODO - we can't change texture width (due to WebGPU limitations) -
+  // and the width/heigh of an external image is implicit, so why do we need to extract it?
+  // So what width height do we supply? The image size or the texture size?
+  // const {width, height} = Texture.getExternalImageSize(image);
+
+  switch (dimension) {
+    case '2d-array':
+    case '3d':
+      // prettier-ignore
+      gl.texImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, glInternalFormat, glType, image);
+      break;
+
+    case '2d':
+    case 'cube':
+      // prettier-ignore
+      gl.texImage2D(glTarget, level, glInternalFormat, width, height, BORDER, glInternalFormat, glType, image);
+      break;
+
+    default:
+      throw new Error(dimension);
+  }
+}
+
+/**
+ * Set a texture mip level from CPU memory
+ * Wrapper for the messy WebGL texture API
+ * @note Not available (directly) in WebGPU
+ *
+export function setMipLevelFromTypedArray(
+  gl: WebGL2RenderingContext,
+  data: TypedArray,
+  parameters: {},
+  options: {
+    dimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+    height: number;
+    width: number;
+    depth?: number;
+    level?: number;
+    offset?: number;
+    glTarget: GLTextureTarget;
+    glInternalFormat: GL;
+    glFormat: GL;
+    glType: GL;
+    compressed?: boolean;
+  }
+): void {
+  const {dimension, width, height, depth = 0, level = 0, offset = 0} = options;
+  const {glInternalFormat, glFormat, glType, compressed} = options;
+
+  const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
+
+  withGLParameters(gl, parameters, () => {
+    switch (dimension) {
+      case '2d-array':
+      case '3d':
+        if (compressed) {
+          // prettier-ignore
+          gl.compressedTexImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, data);
+        } else {
+          // prettier-ignore
+          gl.texImage3D( glTarget, level, glInternalFormat, width, height, depth, BORDER, glFormat, glType, data);
+        }
+        break;
+
+      case '2d':
+        if (compressed) {
+          // prettier-ignore
+          gl.compressedTexImage2D(glTarget, level, glInternalFormat, width, height, BORDER, data);
+        } else {
+          // prettier-ignore
+          gl.texImage2D( glTarget, level, glInternalFormat, width, height, BORDER, glFormat, glType, data, offset);
+        }
+        break;
+
+      default:
+        throw new Error(dimension);
+    }
+  });
+}
+
+/**
+   * Set a texture level from CPU memory
+   * @note Not available (directly) in WebGPU
+  _setMipLevelFromTypedArray(
+    depth: number,
+    level: number,
+    data: TextureLevelData,
+    offset = 0,
+    parameters
+  ): void {
+    withGLParameters(this.gl, parameters, () => {
+      switch (this.props.dimension) {
+        case '2d-array':
+        case '3d':
+          if (this.compressed) {
+            // prettier-ignore
+            this.device.gl.compressedTexImage3D(this.glTarget, level, this.glInternalFormat, data.width, data.height, depth, BORDER, data.data);
+          } else {
+            // prettier-ignore
+            this.gl.texImage3D( this.glTarget, level, this.glInternalFormat, this.width, this.height, depth, BORDER, this.glFormat, this.glType, data.data);
+          }
+          break;
+
+        case '2d':
+          if (this.compressed) {
+            // prettier-ignore
+            this.device.gl.compressedTexImage2D(this.glTarget, level, this.glInternalFormat, data.width, data.height, BORDER, data.data);
+          } else {
+            // prettier-ignore
+            this.device.gl.texImage2D( this.glTarget, level, this.glInternalFormat, this.width, this.height, BORDER, this.glFormat, this.glType, data.data, offset);
+          }
+          break;
+
+        default:
+          throw new Error(this.props.dimension);
+      }
+    });
+  }
+
+ * Set a texture level from a GPU buffer
+ *
+export function setMipLevelFromGPUBuffer(
+  gl: WebGL2RenderingContext,
+  buffer: Buffer,
+  options: WebGLSetTextureOptions
+): void {
+  const {dimension, width, height, depth = 0, level = 0, byteOffset = 0} = options;
+  const {glInternalFormat, glFormat, glType, compressed} = options;
+  const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
+
+  const webglBuffer = buffer as WEBGLBuffer;
+  const imageSize = buffer.byteLength;
+
+  // In WebGL the source buffer is not a parameter. Instead it needs to be bound to a special bind point
+  gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, webglBuffer.handle);
+
+  switch (dimension) {
+    case '2d-array':
+    case '3d':
+      if (compressed) {
+        // prettier-ignore
+        gl.compressedTexImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, imageSize, byteOffset);
+      } else {
+        // prettier-ignore
+        gl.texImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, glFormat, glType, byteOffset);
+      }
+      break;
+
+    case '2d':
+      if (compressed) {
+        // prettier-ignore
+        gl.compressedTexImage2D(glTarget, level, glInternalFormat, width, height, BORDER, imageSize, byteOffset);
+      } else {
+        // prettier-ignore
+        gl.texImage2D(glTarget, level, glInternalFormat, width, height, BORDER, glFormat, glType, byteOffset);
+      }
+      break;
+
+    default:
+      throw new Error(dimension);
+  }
+
+  gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
+}
+*/
+//# sourceMappingURL=webgl-texture-utils.d.ts.map