@luma.gl/webgl 9.0.0-beta.5 → 9.0.0-beta.6

package/dist/index.cjs

@@ -56,8 +56,7 @@ __export(dist_exports, {
 module.exports = __toCommonJS(dist_exports);
 
 // dist/adapter/webgl-device.js
-var import_core26 = require("@luma.gl/core");
-var import_env3 = require("@probe.gl/env");
+var import_core29 = require("@luma.gl/core");
 
 // dist/context/state-tracker/track-context-state.js
 var import_core = require("@luma.gl/core");
@@ -122,14 +121,6 @@ var GL_PARAMETER_DEFAULTS = {
   [import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: import_constants.GL.KEEP,
   // Dynamic value: We use [0, 0, 1024, 1024] as default, but usually this is updated in each frame.
   [import_constants.GL.VIEWPORT]: [0, 0, 1024, 1024],
-  // WEBGL1 PIXEL PACK/UNPACK MODES
-  [import_constants.GL.PACK_ALIGNMENT]: 4,
-  [import_constants.GL.UNPACK_ALIGNMENT]: 4,
-  [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: false,
-  [import_constants.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,
-  [import_constants.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: import_constants.GL.BROWSER_DEFAULT_WEBGL,
-  // WEBGL2 / EXTENSIONS
-  // gl1: 'OES_standard_derivatives'
   [import_constants.GL.TRANSFORM_FEEDBACK_BINDING]: null,
   [import_constants.GL.COPY_READ_BUFFER_BINDING]: null,
   [import_constants.GL.COPY_WRITE_BUFFER_BINDING]: null,
@@ -138,6 +129,11 @@ var GL_PARAMETER_DEFAULTS = {
   [import_constants.GL.FRAGMENT_SHADER_DERIVATIVE_HINT]: import_constants.GL.DONT_CARE,
   [import_constants.GL.READ_FRAMEBUFFER_BINDING]: null,
   [import_constants.GL.RASTERIZER_DISCARD]: false,
+  [import_constants.GL.PACK_ALIGNMENT]: 4,
+  [import_constants.GL.UNPACK_ALIGNMENT]: 4,
+  [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: false,
+  [import_constants.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: false,
+  [import_constants.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: import_constants.GL.BROWSER_DEFAULT_WEBGL,
   [import_constants.GL.PACK_ROW_LENGTH]: 0,
   [import_constants.GL.PACK_SKIP_PIXELS]: 0,
   [import_constants.GL.PACK_SKIP_ROWS]: 0,
@@ -234,14 +230,29 @@ var GL_PARAMETER_SETTERS = {
   [import_constants.GL.STENCIL_BACK_PASS_DEPTH_FAIL]: "stencilOpBack",
   [import_constants.GL.STENCIL_BACK_PASS_DEPTH_PASS]: "stencilOpBack",
   [import_constants.GL.VIEWPORT]: (gl, value) => gl.viewport(...value),
-  // WEBGL1 PIXEL PACK/UNPACK MODES
+  // WEBGL2 EXTENSIONS
+  // EXT_depth_clamp https://registry.khronos.org/webgl/extensions/EXT_depth_clamp/
+  [import_constants.GL.DEPTH_CLAMP_EXT]: enable,
+  // WEBGL_provoking_vertex https://registry.khronos.org/webgl/extensions/WEBGL_provoking_vertex/
+  // [GL.PROVOKING_VERTEX_WEBL]: TODO - extension function needed
+  // WEBGL_polygon_mode https://registry.khronos.org/webgl/extensions/WEBGL_polygon_mode/
+  // POLYGON_MODE_WEBGL  TODO - extension function needed
+  [import_constants.GL.POLYGON_OFFSET_LINE_WEBGL]: enable,
+  // WEBGL_clip_cull_distance https://registry.khronos.org/webgl/extensions/WEBGL_clip_cull_distance/
+  [import_constants.GL.CLIP_DISTANCE0_WEBGL]: enable,
+  [import_constants.GL.CLIP_DISTANCE1_WEBGL]: enable,
+  [import_constants.GL.CLIP_DISTANCE2_WEBGL]: enable,
+  [import_constants.GL.CLIP_DISTANCE3_WEBGL]: enable,
+  [import_constants.GL.CLIP_DISTANCE4_WEBGL]: enable,
+  [import_constants.GL.CLIP_DISTANCE5_WEBGL]: enable,
+  [import_constants.GL.CLIP_DISTANCE6_WEBGL]: enable,
+  [import_constants.GL.CLIP_DISTANCE7_WEBGL]: enable,
+  // PIXEL PACK/UNPACK MODES
   [import_constants.GL.PACK_ALIGNMENT]: pixelStorei,
   [import_constants.GL.UNPACK_ALIGNMENT]: pixelStorei,
   [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: pixelStorei,
   [import_constants.GL.UNPACK_PREMULTIPLY_ALPHA_WEBGL]: pixelStorei,
   [import_constants.GL.UNPACK_COLORSPACE_CONVERSION_WEBGL]: pixelStorei,
-  // WEBGL2 PIXEL PACK/UNPACK MODES
-  // RASTERIZER_DISCARD ...
   [import_constants.GL.PACK_ROW_LENGTH]: pixelStorei,
   [import_constants.GL.PACK_SKIP_PIXELS]: pixelStorei,
   [import_constants.GL.PACK_SKIP_ROWS]: pixelStorei,
@@ -741,7 +752,7 @@ function installProgramSpy(gl) {
   };
 }
 
-// dist/context/context/create-browser-context.js
+// dist/context/helpers/create-browser-context.js
 var DEFAULT_CONTEXT_PROPS = {
   powerPreference: "high-performance",
   // After all, most apps are using WebGL for performance reasons
@@ -774,10 +785,21 @@ function createBrowserContext(canvas, props) {
 
 // dist/adapter/device-helpers/webgl-device-info.js
 var import_constants2 = require("@luma.gl/constants");
-function getDeviceInfo(gl) {
+
+// dist/context/helpers/webgl-extensions.js
+function getWebGLExtension(gl, name, extensions) {
+  if (extensions[name] === void 0) {
+    extensions[name] = gl.getExtension(name) || null;
+  }
+  return extensions[name];
+}
+
+// dist/adapter/device-helpers/webgl-device-info.js
+function getDeviceInfo(gl, extensions) {
   const vendorMasked = gl.getParameter(import_constants2.GL.VENDOR);
   const rendererMasked = gl.getParameter(import_constants2.GL.RENDERER);
-  const ext = gl.getExtension("WEBGL_debug_renderer_info");
+  getWebGLExtension(gl, "WEBGL_debug_renderer_info", extensions);
+  const ext = extensions.WEBGL_debug_renderer_info;
   const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : import_constants2.GL.VENDOR);
   const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : import_constants2.GL.RENDERER);
   const vendor = vendorUnmasked || vendorMasked;
@@ -844,6 +866,9 @@ function identifyGPUType(vendor, renderer) {
   }
 }
 
+// dist/adapter/device-helpers/webgl-device-features.js
+var import_core3 = require("@luma.gl/core");
+
 // dist/adapter/converters/texture-formats.js
 var import_core2 = require("@luma.gl/core");
 var import_constants4 = require("@luma.gl/constants");
@@ -887,6 +912,14 @@ var texture_compression_etc2 = "texture-compression-etc2";
 var texture_compression_etc1_webgl = "texture-compression-etc1-webgl";
 var texture_compression_pvrtc_webgl = "texture-compression-pvrtc-webgl";
 var texture_compression_atc_webgl = "texture-compression-atc-webgl";
+var float32_renderable = "float32-renderable-webgl";
+var float16_renderable = "float16-renderable-webgl";
+var rgb9e5ufloat_renderable = "rgb9e5ufloat_renderable-webgl";
+var snorm8_renderable = "snorm8-renderable-webgl";
+var norm16_renderable = "norm16-renderable-webgl";
+var snorm16_renderable = "snorm16-renderable-webgl";
+var float32_filterable = "float32-filterable";
+var float16_filterable = "float16-filterable-webgl";
 var X_S3TC = "WEBGL_compressed_texture_s3tc";
 var X_S3TC_SRGB = "WEBGL_compressed_texture_s3tc_srgb";
 var X_RGTC = "EXT_texture_compression_rgtc";
@@ -896,15 +929,18 @@ var X_ASTC = "WEBGL_compressed_texture_astc";
 var X_ETC1 = "WEBGL_compressed_texture_etc1";
 var X_PVRTC = "WEBGL_compressed_texture_pvrtc";
 var X_ATC = "WEBGL_compressed_texture_atc";
-var EXT_TEXTURE_NORM16 = "EXT_texture_norm16";
-var EXT_FLOAT_RENDER_WEBGL2 = "EXT_color_buffer_float";
-var TEXTURE_FEATURE_CHECKS = {
+var EXT_texture_norm16 = "EXT_texture_norm16";
+var EXT_render_snorm = "EXT_render_snorm";
+var EXT_color_buffer_float = "EXT_color_buffer_float";
+var TEXTURE_FEATURES = {
   "float32-renderable-webgl": ["EXT_color_buffer_float"],
-  // [false, 'EXT_color_buffer_float'],
   "float16-renderable-webgl": ["EXT_color_buffer_half_float"],
-  "norm16-renderable-webgl": [EXT_TEXTURE_NORM16],
-  "float32-filterable-linear-webgl": ["OES_texture_float_linear"],
-  "float16-filterable-linear-webgl": ["OES_texture_half_float_linear"],
+  "rgb9e5ufloat_renderable-webgl": ["WEBGL_render_shared_exponent"],
+  "snorm8-renderable-webgl": [EXT_render_snorm],
+  "norm16-renderable-webgl": [EXT_texture_norm16],
+  "snorm16-renderable-webgl": [EXT_texture_norm16, EXT_render_snorm],
+  "float32-filterable": ["OES_texture_float_linear"],
+  "float16-filterable-webgl": ["OES_texture_half_float_linear"],
   "texture-filterable-anisotropic-webgl": ["EXT_texture_filter_anisotropic"],
   "texture-blend-float-webgl": ["EXT_float_blend"],
   "texture-compression-bc": [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC],
@@ -918,13 +954,12 @@ var TEXTURE_FEATURE_CHECKS = {
   "texture-compression-pvrtc-webgl": [X_PVRTC],
   "texture-compression-atc-webgl": [X_ATC]
 };
-function checkTextureFeature(gl, feature) {
-  const extensions = TEXTURE_FEATURE_CHECKS[feature] || [];
-  return extensions.every((extension) => gl.getExtension(extension));
+function isTextureFeature(feature) {
+  return feature in TEXTURE_FEATURES;
 }
-function getTextureFeatures(gl) {
-  const textureFeatures = Object.keys(TEXTURE_FEATURE_CHECKS);
-  return textureFeatures.filter((feature) => checkTextureFeature(gl, feature));
+function checkTextureFeature(gl, feature, extensions) {
+  const textureExtensions = TEXTURE_FEATURES[feature] || [];
+  return textureExtensions.every((extension) => getWebGLExtension(gl, extension, extensions));
 }
 var TEXTURE_FORMATS = {
   // Unsized formats that leave the precision up to the driver.
@@ -950,19 +985,19 @@ var TEXTURE_FORMATS = {
   // 'rgba8unorm-srgb-unsized': {gl: GL.SRGB_ALPHA_EXT, b: 4, c: 2, bpp: 4, gl1Ext: SRGB},
   // 8-bit formats
   "r8unorm": { gl: import_constants4.GL.R8, b: 1, c: 1, renderbuffer: true },
-  "r8snorm": { gl: import_constants4.GL.R8_SNORM, b: 1, c: 1 },
+  "r8snorm": { gl: import_constants4.GL.R8_SNORM, b: 1, c: 1, render: snorm8_renderable },
   "r8uint": { gl: import_constants4.GL.R8UI, b: 1, c: 1, renderbuffer: true },
   "r8sint": { gl: import_constants4.GL.R8I, b: 1, c: 1, renderbuffer: true },
   // 16-bit formats
   "rg8unorm": { gl: import_constants4.GL.RG8, b: 2, c: 2, renderbuffer: true },
-  "rg8snorm": { gl: import_constants4.GL.RG8_SNORM, b: 2, c: 2 },
+  "rg8snorm": { gl: import_constants4.GL.RG8_SNORM, b: 2, c: 2, render: snorm8_renderable },
   "rg8uint": { gl: import_constants4.GL.RG8UI, b: 2, c: 2, renderbuffer: true },
   "rg8sint": { gl: import_constants4.GL.RG8I, b: 2, c: 2, renderbuffer: true },
   "r16uint": { gl: import_constants4.GL.R16UI, b: 2, c: 1, renderbuffer: true },
   "r16sint": { gl: import_constants4.GL.R16I, b: 2, c: 1, renderbuffer: true },
-  "r16float": { gl: import_constants4.GL.R16F, b: 2, c: 1, render: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl", renderbuffer: true },
-  "r16unorm-webgl": { gl: import_constants4.GL.R16_EXT, b: 2, c: 1, f: "norm16-renderable-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-  "r16snorm-webgl": { gl: import_constants4.GL.R16_SNORM_EXT, b: 2, c: 1, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
+  "r16float": { gl: import_constants4.GL.R16F, b: 2, c: 1, render: float16_renderable, filter: "float16-filterable-webgl", renderbuffer: true },
+  "r16unorm-webgl": { gl: import_constants4.GL.R16_EXT, b: 2, c: 1, f: norm16_renderable, renderbuffer: true },
+  "r16snorm-webgl": { gl: import_constants4.GL.R16_SNORM_EXT, b: 2, c: 1, f: snorm16_renderable },
   // Packed 16-bit formats
   "rgba4unorm-webgl": { gl: import_constants4.GL.RGBA4, b: 2, c: 4, wgpu: false, renderbuffer: true },
   "rgb565unorm-webgl": { gl: import_constants4.GL.RGB565, b: 2, c: 4, wgpu: false, renderbuffer: true },
@@ -973,7 +1008,7 @@ var TEXTURE_FORMATS = {
   // 32-bit formats  
   "rgba8unorm": { gl: import_constants4.GL.RGBA8, b: 4, c: 2, bpp: 4 },
   "rgba8unorm-srgb": { gl: import_constants4.GL.SRGB8_ALPHA8, b: 4, c: 4, bpp: 4 },
-  "rgba8snorm": { gl: import_constants4.GL.RGBA8_SNORM, b: 4, c: 4 },
+  "rgba8snorm": { gl: import_constants4.GL.RGBA8_SNORM, b: 4, c: 4, render: snorm8_renderable },
   "rgba8uint": { gl: import_constants4.GL.RGBA8UI, b: 4, c: 4, bpp: 4 },
   "rgba8sint": { gl: import_constants4.GL.RGBA8I, b: 4, c: 4, bpp: 4 },
   // reverse colors, webgpu only
@@ -982,42 +1017,45 @@ var TEXTURE_FORMATS = {
   "rg16uint": { gl: import_constants4.GL.RG16UI, b: 4, c: 1, bpp: 4 },
   "rg16sint": { gl: import_constants4.GL.RG16I, b: 4, c: 2, bpp: 4 },
   // When using a WebGL 2 context and the EXT_color_buffer_float WebGL2 extension
-  "rg16float": { gl: import_constants4.GL.RG16F, bpp: 4, b: 4, c: 2, render: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl", renderbuffer: true },
-  "rg16unorm-webgl": { gl: import_constants4.GL.RG16_EXT, b: 2, c: 2, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
-  "rg16snorm-webgl": { gl: import_constants4.GL.RG16_SNORM_EXT, b: 2, c: 2, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
+  "rg16float": { gl: import_constants4.GL.RG16F, bpp: 4, b: 4, c: 2, render: float16_renderable, filter: float16_filterable, renderbuffer: true },
+  "rg16unorm-webgl": { gl: import_constants4.GL.RG16_EXT, b: 2, c: 2, render: norm16_renderable },
+  "rg16snorm-webgl": { gl: import_constants4.GL.RG16_SNORM_EXT, b: 2, c: 2, render: snorm16_renderable },
   "r32uint": { gl: import_constants4.GL.R32UI, b: 4, c: 1, bpp: 4, renderbuffer: true },
   "r32sint": { gl: import_constants4.GL.R32I, b: 4, c: 1, bpp: 4, renderbuffer: true },
-  "r32float": { gl: import_constants4.GL.R32F, bpp: 4, b: 4, c: 1, render: "float32-renderable-webgl", filter: "float32-filterable-linear-webgl" },
+  "r32float": { gl: import_constants4.GL.R32F, bpp: 4, b: 4, c: 1, render: float32_renderable, filter: float32_filterable },
   // Packed 32-bit formats
-  "rgb9e5ufloat": { gl: import_constants4.GL.RGB9_E5, b: 4, c: 3, p: 1, render: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl" },
-  "rg11b10ufloat": { gl: import_constants4.GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: "float32-renderable-webgl", renderbuffer: true },
+  "rgb9e5ufloat": { gl: import_constants4.GL.RGB9_E5, b: 4, c: 3, p: 1, render: rgb9e5ufloat_renderable },
+  // , filter: true},
+  "rg11b10ufloat": { gl: import_constants4.GL.R11F_G11F_B10F, b: 4, c: 3, p: 1, render: float32_renderable, renderbuffer: true },
   "rgb10a2unorm": { gl: import_constants4.GL.RGB10_A2, b: 4, c: 4, p: 1, renderbuffer: true },
-  "rgb10a2unorm-webgl": { b: 4, c: 4, gl: import_constants4.GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
+  "rgb10a2uint-webgl": { b: 4, c: 4, gl: import_constants4.GL.RGB10_A2UI, p: 1, wgpu: false, bpp: 4, renderbuffer: true },
   // 48-bit formats
-  "rgb16unorm-webgl": { gl: import_constants4.GL.RGB16_EXT, b: 2, c: 3, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
-  "rgb16snorm-webgl": { gl: import_constants4.GL.RGB16_SNORM_EXT, b: 2, c: 3, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
+  "rgb16unorm-webgl": { gl: import_constants4.GL.RGB16_EXT, b: 2, c: 3, f: norm16_renderable },
+  // rgb not renderable
+  "rgb16snorm-webgl": { gl: import_constants4.GL.RGB16_SNORM_EXT, b: 2, c: 3, f: norm16_renderable },
+  // rgb not renderable
   // 64-bit formats
   "rg32uint": { gl: import_constants4.GL.RG32UI, b: 8, c: 2, renderbuffer: true },
   "rg32sint": { gl: import_constants4.GL.RG32I, b: 8, c: 2, renderbuffer: true },
-  "rg32float": { gl: import_constants4.GL.RG32F, b: 8, c: 2, render: "float32-renderable-webgl", filter: "float32-filterable-linear-webgl", renderbuffer: true },
+  "rg32float": { gl: import_constants4.GL.RG32F, b: 8, c: 2, render: float32_renderable, filter: float32_filterable, renderbuffer: true },
   "rgba16uint": { gl: import_constants4.GL.RGBA16UI, b: 8, c: 4, renderbuffer: true },
   "rgba16sint": { gl: import_constants4.GL.RGBA16I, b: 8, c: 4, renderbuffer: true },
-  "rgba16float": { gl: import_constants4.GL.RGBA16F, b: 8, c: 4, render: "float16-renderable-webgl", filter: "float16-filterable-linear-webgl" },
-  "rgba16unorm-webgl": { gl: import_constants4.GL.RGBA16_EXT, b: 2, c: 4, f: "norm16-renderable-webgl", renderbuffer: true, x: EXT_TEXTURE_NORM16 },
-  "rgba16snorm-webgl": { gl: import_constants4.GL.RGBA16_SNORM_EXT, b: 2, c: 4, f: "norm16-renderable-webgl", x: EXT_TEXTURE_NORM16 },
+  "rgba16float": { gl: import_constants4.GL.RGBA16F, b: 8, c: 4, render: float16_renderable, filter: float16_filterable },
+  "rgba16unorm-webgl": { gl: import_constants4.GL.RGBA16_EXT, b: 2, c: 4, render: norm16_renderable, renderbuffer: true },
+  "rgba16snorm-webgl": { gl: import_constants4.GL.RGBA16_SNORM_EXT, b: 2, c: 4, render: snorm16_renderable },
   // 96-bit formats (deprecated!)
   "rgb32float-webgl": {
     gl: import_constants4.GL.RGB32F,
-    render: "float32-renderable-webgl",
-    filter: "float32-filterable-linear-webgl",
-    gl2ext: EXT_FLOAT_RENDER_WEBGL2,
+    render: float32_renderable,
+    filter: float32_filterable,
+    gl2ext: EXT_color_buffer_float,
     dataFormat: import_constants4.GL.RGB,
     types: [import_constants4.GL.FLOAT]
   },
   // 128-bit formats
   "rgba32uint": { gl: import_constants4.GL.RGBA32UI, b: 16, c: 4, renderbuffer: true },
   "rgba32sint": { gl: import_constants4.GL.RGBA32I, b: 16, c: 4, renderbuffer: true },
-  "rgba32float": { gl: import_constants4.GL.RGBA32F, b: 16, c: 4, render: "float32-renderable-webgl", filter: "float32-filterable-linear-webgl", renderbuffer: true },
+  "rgba32float": { gl: import_constants4.GL.RGBA32F, b: 16, c: 4, render: float32_renderable, filter: float32_filterable, renderbuffer: true },
   // Depth and stencil formats
   "stencil8": { gl: import_constants4.GL.STENCIL_INDEX8, b: 1, c: 1, attachment: import_constants4.GL.STENCIL_ATTACHMENT, renderbuffer: true },
   // 8 stencil bits
@@ -1126,7 +1164,7 @@ var TYPE_SIZES = {
   [import_constants4.GL.BYTE]: 1,
   [import_constants4.GL.UNSIGNED_BYTE]: 1
 };
-function isTextureFormatSupported(gl, formatOrGL) {
+function isTextureFormatSupported(gl, formatOrGL, extensions) {
   const format = convertGLToTextureFormat(formatOrGL);
   const info = TEXTURE_FORMATS[format];
   if (!info) {
@@ -1137,13 +1175,13 @@ function isTextureFormatSupported(gl, formatOrGL) {
   }
   const extension = info.x || info.gl2ext;
   if (extension) {
-    return Boolean(gl.getExtension(extension));
+    return Boolean(getWebGLExtension(gl, extension, extensions));
   }
   return true;
 }
-function isRenderbufferFormatSupported(gl, format) {
+function isRenderbufferFormatSupported(gl, format, extensions) {
   var _a;
-  return isTextureFormatSupported(gl, format) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
+  return isTextureFormatSupported(gl, format, extensions) && ((_a = TEXTURE_FORMATS[format]) == null ? void 0 : _a.renderbuffer);
 }
 function convertGLToTextureFormat(format) {
   if (typeof format === "string") {
@@ -1163,9 +1201,9 @@ function convertTextureFormatToGL(format) {
   }
   return webglFormat;
 }
-function isTextureFormatFilterable(gl, formatOrGL) {
+function isTextureFormatFilterable(gl, formatOrGL, extensions) {
   const format = convertGLToTextureFormat(formatOrGL);
-  if (!isTextureFormatSupported(gl, format)) {
+  if (!isTextureFormatSupported(gl, format, extensions)) {
     return false;
   }
   try {
@@ -1177,16 +1215,16 @@ function isTextureFormatFilterable(gl, formatOrGL) {
     return false;
   }
   if (format.endsWith("32float")) {
-    return Boolean(gl.getExtension("OES_texture_float_linear"));
+    return Boolean(getWebGLExtension(gl, "OES_texture_float_linear, extensions", extensions));
   }
   if (format.endsWith("16float")) {
-    return Boolean(gl.getExtension("OES_texture_half_float_linear"));
+    return Boolean(getWebGLExtension(gl, "OES_texture_half_float_linear, extensions", extensions));
   }
   return true;
 }
-function isTextureFormatRenderable(gl, formatOrGL) {
+function isTextureFormatRenderable(gl, formatOrGL, extensions) {
   const format = convertGLToTextureFormat(formatOrGL);
-  if (!isTextureFormatSupported(gl, format)) {
+  if (!isTextureFormatSupported(gl, format, extensions)) {
     return false;
   }
   if (typeof format === "number") {
@@ -1240,187 +1278,188 @@ function getWebGLPixelDataFormat(dataFormat, integer, normalized, format) {
 }
 
 // dist/adapter/device-helpers/webgl-device-features.js
-function getDeviceFeatures(gl) {
-  const features = getWebGLFeatures(gl);
-  for (const textureFeature of getTextureFeatures(gl)) {
-    features.add(textureFeature);
-  }
-  return features;
-}
-function getWebGLFeatures(gl) {
-  gl.getExtension("EXT_color_buffer_float");
-  const features = /* @__PURE__ */ new Set();
-  for (const feature of Object.keys(WEBGL_FEATURES)) {
-    if (isFeatureSupported(gl, feature)) {
-      features.add(feature);
-    }
-  }
-  return features;
-}
-function isFeatureSupported(gl, feature) {
-  const featureInfo = WEBGL_FEATURES[feature];
-  return typeof featureInfo === "string" ? Boolean(gl.getExtension(featureInfo)) : Boolean(featureInfo);
-}
 var WEBGL_FEATURES = {
-  webgl: true,
-  glsl: true,
-  "uniforms-webgl": true,
-  "transform-feedback-webgl": true,
-  "constant-attributes-webgl": true,
+  // optional WebGPU features
+  "depth-clip-control": "EXT_depth_clamp",
+  // TODO these seem subtly different
+  // '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",
-  "shader-status-async-webgl": "KHR_parallel_shader_compile"
+  "compilation-status-async-webgl": "KHR_parallel_shader_compile",
+  "polygon-mode-webgl": "WEBGL_polygon_mode",
+  "provoking-vertex-webgl": "WEBGL_provoking_vertex",
+  "shader-clip-cull-distance-webgl": "WEBGL_clip_cull_distance",
+  "shader-noperspective-interpolation-webgl": "NV_shader_noperspective_interpolation",
+  "shader-conservative-depth-webgl": "EXT_conservative_depth"
   // Textures are handled by getTextureFeatures()
 };
+var WebGLDeviceFeatures = class extends import_core3.DeviceFeatures {
+  gl;
+  extensions;
+  testedFeatures = /* @__PURE__ */ new Set();
+  constructor(gl, extensions) {
+    super();
+    this.gl = gl;
+    this.extensions = extensions;
+    getWebGLExtension(gl, "EXT_color_buffer_float", extensions);
+  }
+  *[Symbol.iterator]() {
+    for (const feature of Object.keys(WEBGL_FEATURES)) {
+      if (this.has(feature)) {
+        yield feature;
+      }
+    }
+    for (const feature of Object.keys(TEXTURE_FEATURES)) {
+      if (this.has(feature)) {
+        yield feature;
+      }
+    }
+    return [];
+  }
+  has(feature) {
+    if (!this.testedFeatures.has(feature)) {
+      this.testedFeatures.add(feature);
+      if (isTextureFeature(feature) && checkTextureFeature(this.gl, feature, this.extensions)) {
+        this.features.add(feature);
+      }
+      if (this.getWebGLFeature(feature)) {
+        this.features.add(feature);
+      }
+    }
+    return this.features.has(feature);
+  }
+  /** Extract all WebGL features */
+  getWebGLFeature(feature) {
+    const featureInfo = WEBGL_FEATURES[feature];
+    const isSupported = typeof featureInfo === "string" ? Boolean(getWebGLExtension(this.gl, featureInfo, this.extensions)) : Boolean(featureInfo);
+    return isSupported;
+  }
+};
 
 // dist/adapter/device-helpers/webgl-device-limits.js
+var import_core4 = require("@luma.gl/core");
 var import_constants5 = require("@luma.gl/constants");
-function getDeviceLimits(gl) {
-  return {
-    maxTextureDimension1D: 0,
-    // WebGL does not support 1D textures
-    maxTextureDimension2D: gl.getParameter(import_constants5.GL.MAX_TEXTURE_SIZE),
-    maxTextureDimension3D: gl.getParameter(import_constants5.GL.MAX_3D_TEXTURE_SIZE),
-    maxTextureArrayLayers: gl.getParameter(import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS),
-    maxBindGroups: 1,
-    // TBD - if we emulate bind groups we could support any number...
-    maxDynamicUniformBuffersPerPipelineLayout: 0,
-    // TBD
-    maxDynamicStorageBuffersPerPipelineLayout: 0,
-    // TBD
-    maxSampledTexturesPerShaderStage: gl.getParameter(import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
-    // TBD
-    maxSamplersPerShaderStage: gl.getParameter(import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
-    maxStorageBuffersPerShaderStage: 0,
-    // TBD
-    maxStorageTexturesPerShaderStage: 0,
-    // TBD
-    maxUniformBuffersPerShaderStage: gl.getParameter(import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS),
-    maxUniformBufferBindingSize: gl.getParameter(import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE),
-    maxStorageBufferBindingSize: 0,
-    minUniformBufferOffsetAlignment: gl.getParameter(import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT),
-    minStorageBufferOffsetAlignment: 0,
-    // TBD
-    maxVertexBuffers: 0,
-    maxVertexAttributes: gl.getParameter(import_constants5.GL.MAX_VERTEX_ATTRIBS),
-    maxVertexBufferArrayStride: 2048,
-    // TBD, this is just the default value from WebGPU
-    maxInterStageShaderComponents: gl.getParameter(import_constants5.GL.MAX_VARYING_COMPONENTS),
-    maxComputeWorkgroupStorageSize: 0,
-    // WebGL does not support compute shaders
-    maxComputeInvocationsPerWorkgroup: 0,
-    // WebGL does not support compute shaders
-    maxComputeWorkgroupSizeX: 0,
-    // WebGL does not support compute shaders
-    maxComputeWorkgroupSizeY: 0,
-    // WebGL does not support compute shaders
-    maxComputeWorkgroupSizeZ: 0,
-    // WebGL does not support compute shaders
-    maxComputeWorkgroupsPerDimension: 0
-    // WebGL does not support compute shaders
-  };
-}
-function getWebGLLimits(gl) {
-  function get(pname) {
-    return gl.getParameter(pname);
+var WebGLDeviceLimits = class extends import_core4.DeviceLimits {
+  get maxTextureDimension1D() {
+    return 0;
   }
-  function get2(pname, defaultValue) {
-    return gl.getParameter(pname) || defaultValue;
+  // WebGL does not support 1D textures
+  get maxTextureDimension2D() {
+    return this.getParameter(import_constants5.GL.MAX_TEXTURE_SIZE);
   }
-  return {
-    [import_constants5.GL.ALIASED_LINE_WIDTH_RANGE]: get(import_constants5.GL.ALIASED_LINE_WIDTH_RANGE),
-    [import_constants5.GL.ALIASED_POINT_SIZE_RANGE]: get(import_constants5.GL.ALIASED_POINT_SIZE_RANGE),
-    [import_constants5.GL.MAX_TEXTURE_SIZE]: get(import_constants5.GL.MAX_TEXTURE_SIZE),
-    [import_constants5.GL.MAX_CUBE_MAP_TEXTURE_SIZE]: get(import_constants5.GL.MAX_CUBE_MAP_TEXTURE_SIZE),
-    // GLint
-    [import_constants5.GL.MAX_TEXTURE_IMAGE_UNITS]: get(import_constants5.GL.MAX_TEXTURE_IMAGE_UNITS),
-    // GLint
-    [import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
-    // GLint
-    [import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
-    // GLint
-    [import_constants5.GL.MAX_RENDERBUFFER_SIZE]: get(import_constants5.GL.MAX_RENDERBUFFER_SIZE),
-    // GLint
-    [import_constants5.GL.MAX_VARYING_VECTORS]: get(import_constants5.GL.MAX_VARYING_VECTORS),
-    // GLint
-    [import_constants5.GL.MAX_VERTEX_ATTRIBS]: get(import_constants5.GL.MAX_VERTEX_ATTRIBS),
-    // GLint
-    [import_constants5.GL.MAX_VERTEX_UNIFORM_VECTORS]: get(import_constants5.GL.MAX_VERTEX_UNIFORM_VECTORS),
-    // GLint
-    [import_constants5.GL.MAX_FRAGMENT_UNIFORM_VECTORS]: get(import_constants5.GL.MAX_FRAGMENT_UNIFORM_VECTORS),
-    // GLint
-    [import_constants5.GL.MAX_VIEWPORT_DIMS]: get(import_constants5.GL.MAX_VIEWPORT_DIMS),
-    // Extensions
-    [import_constants5.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: get(import_constants5.GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT),
-    // getMaxAnistropy(),
-    // WebGL2 Limits
-    [import_constants5.GL.MAX_3D_TEXTURE_SIZE]: get2(import_constants5.GL.MAX_3D_TEXTURE_SIZE),
-    //  GLint
-    [import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS]: get2(import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS),
-    // GLint
-    // [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL), //  GLint64
-    [import_constants5.GL.MAX_COLOR_ATTACHMENTS]: get2(import_constants5.GL.MAX_COLOR_ATTACHMENTS),
-    //  GLint
-    [import_constants5.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS),
-    // GLint64
-    [import_constants5.GL.MAX_COMBINED_UNIFORM_BLOCKS]: get2(import_constants5.GL.MAX_COMBINED_UNIFORM_BLOCKS),
-    //  GLint
-    [import_constants5.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS),
-    // GLint64
-    [import_constants5.GL.MAX_DRAW_BUFFERS]: get2(import_constants5.GL.MAX_DRAW_BUFFERS),
-    // GLint
-    [import_constants5.GL.MAX_ELEMENT_INDEX]: get2(import_constants5.GL.MAX_ELEMENT_INDEX),
-    //  GLint64
-    [import_constants5.GL.MAX_ELEMENTS_INDICES]: get2(import_constants5.GL.MAX_ELEMENTS_INDICES),
-    // GLint
-    [import_constants5.GL.MAX_ELEMENTS_VERTICES]: get2(import_constants5.GL.MAX_ELEMENTS_VERTICES),
-    //  GLint
-    [import_constants5.GL.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(import_constants5.GL.MAX_FRAGMENT_INPUT_COMPONENTS),
-    //  GLint
-    [import_constants5.GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(import_constants5.GL.MAX_FRAGMENT_UNIFORM_BLOCKS),
-    //  GLint
-    [import_constants5.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_FRAGMENT_UNIFORM_COMPONENTS),
-    //  GLint
-    [import_constants5.GL.MAX_SAMPLES]: get2(import_constants5.GL.MAX_SAMPLES),
-    //  GLint
-    // [GL.MAX_SERVER_WAIT_TIMEOUT]: get2(GL.MAX_SERVER_WAIT_TIMEOUT), //  GLint64
-    [import_constants5.GL.MAX_TEXTURE_LOD_BIAS]: get2(import_constants5.GL.MAX_TEXTURE_LOD_BIAS),
-    // GLfloat
-    [import_constants5.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(import_constants5.GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS),
-    //  GLint
-    [import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS),
-    //  GLint
-    [import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(import_constants5.GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS),
-    // GLint
-    [import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE]: get2(import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE),
-    // GLint64
-    [import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS]: get2(import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS),
-    //  GLint
-    [import_constants5.GL.MAX_VARYING_COMPONENTS]: get2(import_constants5.GL.MAX_VARYING_COMPONENTS),
-    // GLint
-    [import_constants5.GL.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(import_constants5.GL.MAX_VERTEX_OUTPUT_COMPONENTS),
-    // GLint
-    [import_constants5.GL.MAX_VERTEX_UNIFORM_BLOCKS]: get2(import_constants5.GL.MAX_VERTEX_UNIFORM_BLOCKS),
-    //  GLint
-    [import_constants5.GL.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(import_constants5.GL.MAX_VERTEX_UNIFORM_COMPONENTS),
-    //  GLint
-    [import_constants5.GL.MIN_PROGRAM_TEXEL_OFFSET]: get2(import_constants5.GL.MIN_PROGRAM_TEXEL_OFFSET),
-    // GLint
-    [import_constants5.GL.MAX_PROGRAM_TEXEL_OFFSET]: get2(import_constants5.GL.MAX_PROGRAM_TEXEL_OFFSET),
-    // GLint
-    [import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT)
-    // GLint
-  };
-}
+  get maxTextureDimension3D() {
+    return this.getParameter(import_constants5.GL.MAX_3D_TEXTURE_SIZE);
+  }
+  get maxTextureArrayLayers() {
+    return this.getParameter(import_constants5.GL.MAX_ARRAY_TEXTURE_LAYERS);
+  }
+  get maxBindGroups() {
+    return 0;
+  }
+  get maxDynamicUniformBuffersPerPipelineLayout() {
+    return 0;
+  }
+  // TBD
+  get maxDynamicStorageBuffersPerPipelineLayout() {
+    return 0;
+  }
+  // TBD
+  get maxSampledTexturesPerShaderStage() {
+    return this.getParameter(import_constants5.GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS);
+  }
+  // ) TBD
+  get maxSamplersPerShaderStage() {
+    return this.getParameter(import_constants5.GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+  }
+  get maxStorageBuffersPerShaderStage() {
+    return 0;
+  }
+  // TBD
+  get maxStorageTexturesPerShaderStage() {
+    return 0;
+  }
+  // TBD
+  get maxUniformBuffersPerShaderStage() {
+    return this.getParameter(import_constants5.GL.MAX_UNIFORM_BUFFER_BINDINGS);
+  }
+  get maxUniformBufferBindingSize() {
+    return this.getParameter(import_constants5.GL.MAX_UNIFORM_BLOCK_SIZE);
+  }
+  get maxStorageBufferBindingSize() {
+    return 0;
+  }
+  get minUniformBufferOffsetAlignment() {
+    return this.getParameter(import_constants5.GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT);
+  }
+  get minStorageBufferOffsetAlignment() {
+    return 0;
+  }
+  get maxVertexBuffers() {
+    return 16;
+  }
+  // WebGL 2 supports 16 buffers, see https://github.com/gpuweb/gpuweb/issues/4284
+  get maxVertexAttributes() {
+    return this.getParameter(import_constants5.GL.MAX_VERTEX_ATTRIBS);
+  }
+  get maxVertexBufferArrayStride() {
+    return 2048;
+  }
+  // TBD, this is just the default value from WebGPU
+  get maxInterStageShaderComponents() {
+    return this.getParameter(import_constants5.GL.MAX_VARYING_COMPONENTS);
+  }
+  get maxComputeWorkgroupStorageSize() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeInvocationsPerWorkgroup() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeX() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeY() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupSizeZ() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  get maxComputeWorkgroupsPerDimension() {
+    return 0;
+  }
+  // WebGL does not support compute shaders
+  // PRIVATE
+  gl;
+  limits = {};
+  constructor(gl) {
+    super();
+    this.gl = gl;
+  }
+  getParameter(parameter) {
+    if (this.limits[parameter] === void 0) {
+      this.limits[parameter] = this.gl.getParameter(parameter);
+    }
+    return this.limits[parameter];
+  }
+};
 
 // dist/adapter/webgl-canvas-context.js
-var import_core11 = require("@luma.gl/core");
+var import_core13 = require("@luma.gl/core");
 
 // dist/adapter/resources/webgl-framebuffer.js
-var import_core10 = require("@luma.gl/core");
+var import_core12 = require("@luma.gl/core");
 var import_constants12 = require("@luma.gl/constants");
 
 // dist/adapter/resources/webgl-texture.js
-var import_core6 = require("@luma.gl/core");
+var import_core9 = require("@luma.gl/core");
 var import_constants10 = require("@luma.gl/constants");
 
 // dist/context/state-tracker/with-parameters.js
@@ -1457,10 +1496,10 @@ function isObjectEmpty2(object) {
 var import_constants7 = require("@luma.gl/constants");
 
 // dist/adapter/converters/device-parameters.js
-var import_core3 = require("@luma.gl/core");
+var import_core5 = require("@luma.gl/core");
 var import_constants6 = require("@luma.gl/constants");
 function withDeviceAndGLParameters(device, parameters, glParameters, func) {
-  if ((0, import_core3.isObjectEmpty)(parameters)) {
+  if ((0, import_core5.isObjectEmpty)(parameters)) {
     return func(device);
   }
   pushContextState(device.gl);
@@ -1473,7 +1512,7 @@ function withDeviceAndGLParameters(device, parameters, glParameters, func) {
   }
 }
 function withDeviceParameters(device, parameters, func) {
-  if ((0, import_core3.isObjectEmpty)(parameters)) {
+  if ((0, import_core5.isObjectEmpty)(parameters)) {
     return func(device);
   }
   pushContextState(device.gl);
@@ -1508,9 +1547,66 @@ function setDeviceParameters(device, parameters) {
       cw: import_constants6.GL.CW
     }));
   }
+  if (parameters.unclippedDepth) {
+    if (device.features.has("depth-clip-control")) {
+      gl.enable(import_constants6.GL.DEPTH_CLAMP_EXT);
+    }
+  }
   if (parameters.depthBias !== void 0) {
     gl.polygonOffset(parameters.depthBias, parameters.depthBiasSlopeScale || 0);
   }
+  if (device.features.has("provoking-vertex-webgl")) {
+    const extensions = webglDevice.getExtension("WEBGL_provoking_vertex");
+    const ext = extensions.WEBGL_provoking_vertex;
+    if (parameters.provokingVertex) {
+      const vertex = map("provokingVertex", parameters.provokingVertex, {
+        first: import_constants6.GL.FIRST_VERTEX_CONVENTION_WEBGL,
+        last: import_constants6.GL.LAST_VERTEX_CONVENTION_WEBGL
+      });
+      ext == null ? void 0 : ext.provokingVertexWEBGL(vertex);
+    }
+  }
+  if (device.features.has("polygon-mode-webgl")) {
+    const extensions = webglDevice.getExtension("WEBGL_polygon_mode");
+    const ext = extensions.WEBGL_polygon_mode;
+    if (parameters.polygonMode) {
+      const mode = map("polygonMode", parameters.provokingVertex, {
+        fill: import_constants6.GL.FILL_WEBGL,
+        lint: import_constants6.GL.LINE_WEBGL
+      });
+      ext == null ? void 0 : ext.polygonModeWEBGL(import_constants6.GL.FRONT, mode);
+      ext == null ? void 0 : ext.polygonModeWEBGL(import_constants6.GL.BACK, mode);
+    }
+    if (parameters.polygonOffsetLine) {
+      gl.enable(import_constants6.GL.POLYGON_OFFSET_LINE_WEBGL);
+    }
+  }
+  if (device.features.has("shader-clip-cull-distance-webgl")) {
+    if (parameters.clipDistance0) {
+      gl.enable(import_constants6.GL.CLIP_DISTANCE0_WEBGL);
+    }
+    if (parameters.clipDistance1) {
+      gl.enable(import_constants6.GL.CLIP_DISTANCE1_WEBGL);
+    }
+    if (parameters.clipDistance2) {
+      gl.enable(import_constants6.GL.CLIP_DISTANCE2_WEBGL);
+    }
+    if (parameters.clipDistance3) {
+      gl.enable(import_constants6.GL.CLIP_DISTANCE3_WEBGL);
+    }
+    if (parameters.clipDistance4) {
+      gl.enable(import_constants6.GL.CLIP_DISTANCE4_WEBGL);
+    }
+    if (parameters.clipDistance5) {
+      gl.enable(import_constants6.GL.CLIP_DISTANCE5_WEBGL);
+    }
+    if (parameters.clipDistance6) {
+      gl.enable(import_constants6.GL.CLIP_DISTANCE6_WEBGL);
+    }
+    if (parameters.clipDistance7) {
+      gl.enable(import_constants6.GL.CLIP_DISTANCE7_WEBGL);
+    }
+  }
   if (parameters.depthWriteEnabled !== void 0) {
     gl.depthMask(mapBoolean("depthWriteEnabled", parameters.depthWriteEnabled));
   }
@@ -1524,7 +1620,7 @@ function setDeviceParameters(device, parameters) {
     gl.stencilMaskSeparate(import_constants6.GL.BACK, mask);
   }
   if (parameters.stencilReadMask) {
-    import_core3.log.warn("stencilReadMask not supported under WebGL");
+    import_core5.log.warn("stencilReadMask not supported under WebGL");
   }
   if (parameters.stencilCompare) {
     const mask = parameters.stencilReadMask || 4294967295;
@@ -1578,17 +1674,17 @@ function convertStencilOperation(parameter, value) {
 }
 function convertBlendOperationToEquation(parameter, value) {
   return map(parameter, value, {
-    "add": import_constants6.GL.FUNC_ADD,
-    "subtract": import_constants6.GL.FUNC_SUBTRACT,
+    add: import_constants6.GL.FUNC_ADD,
+    subtract: import_constants6.GL.FUNC_SUBTRACT,
     "reverse-subtract": import_constants6.GL.FUNC_REVERSE_SUBTRACT,
-    "min": import_constants6.GL.MIN,
-    "max": import_constants6.GL.MAX
+    min: import_constants6.GL.MIN,
+    max: import_constants6.GL.MAX
   });
 }
 function convertBlendFactorToFunction(parameter, value) {
   return map(parameter, value, {
-    "one": import_constants6.GL.ONE,
-    "zero": import_constants6.GL.ZERO,
+    one: import_constants6.GL.ONE,
+    zero: import_constants6.GL.ZERO,
     "src-color": import_constants6.GL.SRC_COLOR,
     "one-minus-src-color": import_constants6.GL.ONE_MINUS_SRC_COLOR,
     "dst-color": import_constants6.GL.DST_COLOR,
@@ -1678,9 +1774,9 @@ function convertMinFilterMode(minFilter, mipmapFilter) {
 }
 
 // dist/adapter/resources/webgl-buffer.js
-var import_core4 = require("@luma.gl/core");
+var import_core6 = require("@luma.gl/core");
 var import_constants8 = require("@luma.gl/constants");
-var WEBGLBuffer = class extends import_core4.Buffer {
+var WEBGLBuffer = class extends import_core6.Buffer {
   device;
   gl;
   handle;
@@ -1725,7 +1821,7 @@ var WEBGLBuffer = class extends import_core4.Buffer {
   }
   // Allocate a GPU buffer of specified size.
   _initWithByteLength(byteLength) {
-    (0, import_core4.assert)(byteLength >= 0);
+    (0, import_core6.assert)(byteLength >= 0);
     let data = byteLength;
     if (byteLength === 0) {
       data = new Float32Array(0);
@@ -1779,34 +1875,34 @@ var WEBGLBuffer = class extends import_core4.Buffer {
   }
 };
 function getWebGLTarget(usage) {
-  if (usage & import_core4.Buffer.INDEX) {
+  if (usage & import_core6.Buffer.INDEX) {
     return import_constants8.GL.ELEMENT_ARRAY_BUFFER;
   }
-  if (usage & import_core4.Buffer.VERTEX) {
+  if (usage & import_core6.Buffer.VERTEX) {
     return import_constants8.GL.ARRAY_BUFFER;
   }
-  if (usage & import_core4.Buffer.UNIFORM) {
+  if (usage & import_core6.Buffer.UNIFORM) {
     return import_constants8.GL.UNIFORM_BUFFER;
   }
   return import_constants8.GL.ARRAY_BUFFER;
 }
 function getWebGLUsage(usage) {
-  if (usage & import_core4.Buffer.INDEX) {
+  if (usage & import_core6.Buffer.INDEX) {
     return import_constants8.GL.STATIC_DRAW;
   }
-  if (usage & import_core4.Buffer.VERTEX) {
+  if (usage & import_core6.Buffer.VERTEX) {
     return import_constants8.GL.STATIC_DRAW;
   }
-  if (usage & import_core4.Buffer.UNIFORM) {
+  if (usage & import_core6.Buffer.UNIFORM) {
     return import_constants8.GL.DYNAMIC_DRAW;
   }
   return import_constants8.GL.STATIC_DRAW;
 }
 
 // dist/adapter/resources/webgl-sampler.js
-var import_core5 = require("@luma.gl/core");
+var import_core7 = require("@luma.gl/core");
 var import_constants9 = require("@luma.gl/constants");
-var WEBGLSampler = class extends import_core5.Sampler {
+var WEBGLSampler = class extends import_core7.Sampler {
   device;
   handle;
   parameters;
@@ -1843,6 +1939,22 @@ var WEBGLSampler = class extends import_core5.Sampler {
   }
 };
 
+// dist/adapter/resources/webgl-texture-view.js
+var import_core8 = require("@luma.gl/core");
+var WEBGLTextureView = class extends import_core8.TextureView {
+  device;
+  gl;
+  handle;
+  texture;
+  constructor(device, props) {
+    super(device, { ...import_core8.Texture.defaultProps, ...props });
+    this.device = device;
+    this.gl = this.device.gl;
+    this.handle = null;
+    this.texture = props.texture;
+  }
+};
+
 // dist/adapter/resources/webgl-texture.js
 var DEFAULT_WEBGL_TEXTURE_PROPS = {
   // deprecated
@@ -1854,13 +1966,14 @@ var DEFAULT_WEBGL_TEXTURE_PROPS = {
   textureUnit: void 0,
   target: void 0
 };
-var _WEBGLTexture = class extends import_core6.Texture {
+var _WEBGLTexture = class extends import_core9.Texture {
   MAX_ATTRIBUTES;
   device;
   gl;
   handle;
-  /** Sampler object (currently unused) */
+  // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */
   sampler = void 0;
+  view = void 0;
   // data;
   glFormat = void 0;
   type = void 0;
@@ -1895,7 +2008,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
     this.target = getWebGLTextureTarget(this.props);
     this.loaded = false;
     if (typeof ((_a = this.props) == null ? void 0 : _a.data) === "string") {
-      Object.assign(this.props, { data: (0, import_core6.loadImage)(this.props.data) });
+      Object.assign(this.props, { data: (0, import_core9.loadImage)(this.props.data) });
     }
     this.initialize(this.props);
     Object.seal(this);
@@ -1972,6 +2085,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
     });
     this.setSampler(props.sampler);
     this._setSamplerParameters(parameters);
+    this.view = new WEBGLTextureView(this.device, { ...this.props, texture: this });
     if (mipmaps) {
       this.generateMipmap();
     }
@@ -2133,7 +2247,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
           }
           break;
         default:
-          (0, import_core6.assert)(false, "Unknown image data type");
+          (0, import_core9.assert)(false, "Unknown image data type");
       }
     });
     if (data && data.byteLength) {
@@ -2160,7 +2274,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
       width,
       height
     }));
-    (0, import_core6.assert)(this.depth === 1, "texSubImage not supported for 3D textures");
+    (0, import_core9.assert)(this.depth === 1, "texSubImage not supported for 3D textures");
     if (!data) {
       data = pixels;
     }
@@ -2200,7 +2314,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
    * rendering can be faster.
    */
   copyFramebuffer(opts = {}) {
-    import_core6.log.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")();
+    import_core9.log.error("Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})")();
     return null;
   }
   getActiveUnit() {
@@ -2272,9 +2386,9 @@ var _WEBGLTexture = class extends import_core6.Texture {
     } else {
       size = { width, height };
     }
-    (0, import_core6.assert)(size, "Could not deduced texture size");
-    (0, import_core6.assert)(width === void 0 || size.width === width, "Deduced texture width does not match supplied width");
-    (0, import_core6.assert)(height === void 0 || size.height === height, "Deduced texture height does not match supplied height");
+    (0, import_core9.assert)(size, "Could not deduced texture size");
+    (0, import_core9.assert)(width === void 0 || size.width === width, "Deduced texture width does not match supplied width");
+    (0, import_core9.assert)(height === void 0 || size.height === height, "Deduced texture height does not match supplied height");
     return size;
   }
   // CUBE MAP METHODS
@@ -2290,7 +2404,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
     this.bind();
     _WEBGLTexture.FACES.forEach((face, index) => {
       if (resolvedFaces[index].length > 1 && this.props.mipmaps !== false) {
-        import_core6.log.warn(`${this.id} has mipmap and multiple LODs.`)();
+        import_core9.log.warn(`${this.id} has mipmap and multiple LODs.`)();
       }
       resolvedFaces[index].forEach((image, lodLevel) => {
         if (width && height) {
@@ -2383,7 +2497,7 @@ var _WEBGLTexture = class extends import_core6.Texture {
    * Sets sampler parameters on texture
    */
   _setSamplerParameters(parameters) {
-    if ((0, import_core6.isObjectEmpty)(parameters)) {
+    if ((0, import_core9.isObjectEmpty)(parameters)) {
       return;
     }
     logParameters(parameters);
@@ -2432,35 +2546,17 @@ function getWebGLTextureTarget(props) {
   }
 }
 function logParameters(parameters) {
-  import_core6.log.log(1, "texture sampler parameters", parameters)();
+  import_core9.log.log(1, "texture sampler parameters", parameters)();
 }
 
 // dist/adapter/objects/webgl-renderbuffer.js
-var import_core9 = require("@luma.gl/core");
+var import_core11 = require("@luma.gl/core");
 var import_constants11 = require("@luma.gl/constants");
 
 // dist/adapter/objects/webgl-resource.js
-var import_core8 = require("@luma.gl/core");
-
-// dist/adapter/objects/constants-to-keys.js
-var import_core7 = require("@luma.gl/core");
-function getKeyValue(gl, name) {
-  if (typeof name !== "string") {
-    return name;
-  }
-  const number = Number(name);
-  if (!isNaN(number)) {
-    return number;
-  }
-  name = name.replace(/^.*\./, "");
-  const value = gl[name];
-  (0, import_core7.assert)(value !== void 0, `Accessing undefined constant GL.${name}`);
-  return value;
-}
-
-// dist/adapter/objects/webgl-resource.js
+var import_core10 = require("@luma.gl/core");
 var ERR_RESOURCE_METHOD_UNDEFINED = "Resource subclass must define virtual methods";
-var WebGLResource = class extends import_core8.Resource {
+var WebGLResource = class extends import_core10.Resource {
   device;
   gl;
   gl2;
@@ -2475,7 +2571,7 @@ var WebGLResource = class extends import_core8.Resource {
     const { id } = props || {};
     this.gl = gl;
     this.gl2 = gl;
-    this.id = id || (0, import_core8.uid)(this.constructor.name);
+    this.id = id || (0, import_core10.uid)(this.constructor.name);
     this._handle = props == null ? void 0 : props.handle;
     if (this._handle === void 0) {
       this._handle = this._createHandle();
@@ -2519,85 +2615,9 @@ var WebGLResource = class extends import_core8.Resource {
   unbind() {
     this.bind(null);
   }
-  /**
-   * Query a Resource parameter
-   *
-   * @param name
-   * @return param
-   */
-  getParameter(pname, props = {}) {
-    pname = getKeyValue(this.gl, pname);
-    (0, import_core8.assert)(pname);
-    const parameters = this.constructor.PARAMETERS || {};
-    const parameter = parameters[pname];
-    if (parameter) {
-      const parameterAvailable = !("extension" in parameter) || this.gl.getExtension(parameter.extension);
-      if (!parameterAvailable) {
-        return parameter.webgl2;
-      }
-    }
-    return this._getParameter(pname, props);
-  }
-  // Many resources support a getParameter call -
-  // getParameters will get all parameters - slow but useful for debugging
-  // eslint-disable-next-line complexity
-  getParameters(options = {}) {
-    const { parameters, keys } = options;
-    const PARAMETERS = this.constructor.PARAMETERS || {};
-    const values = {};
-    const parameterKeys = parameters || Object.keys(PARAMETERS);
-    for (const pname of parameterKeys) {
-      const parameter = PARAMETERS[pname];
-      const parameterAvailable = parameter && (!("extension" in parameter) || this.gl.getExtension(parameter.extension));
-      if (parameterAvailable) {
-        const key = keys ? this.device.getGLKey(pname) : pname;
-        values[key] = this.getParameter(pname, options);
-        if (keys && parameter.type === "GLenum") {
-          values[key] = this.device.getGLKey(values[key]);
-        }
-      }
-    }
-    return values;
-  }
-  /**
-   * Update a Resource setting
-   *
-   * @todo - cache parameter to avoid issuing WebGL calls?
-   *
-   * @param pname - parameter (GL constant, value or key)
-   * @param value {GLint|GLfloat|GLenum}
-   * @return returns self to enable chaining
-   */
-  setParameter(pname, value) {
-    pname = getKeyValue(this.gl, pname);
-    (0, import_core8.assert)(pname);
-    const parameters = this.constructor.PARAMETERS || {};
-    const parameter = parameters[pname];
-    if (parameter) {
-      const parameterAvailable = !("extension" in parameter) || this.gl.getExtension(parameter.extension);
-      if (!parameterAvailable) {
-        throw new Error("Parameter not available on this platform");
-      }
-      if (parameter.type === "GLenum") {
-        value = getKeyValue(value);
-      }
-    }
-    this._setParameter(pname, value);
-    return this;
-  }
-  /*
-   * Batch update resource parameters
-   * Assumes the subclass supports a setParameter call
-   */
-  setParameters(parameters) {
-    for (const pname in parameters) {
-      this.setParameter(pname, parameters[pname]);
-    }
-    return this;
-  }
   // Install stubs for removed methods
   stubRemovedMethods(className, version, methodNames) {
-    return (0, import_core8.stubRemovedMethods)(this, className, version, methodNames);
+    return (0, import_core10.stubRemovedMethods)(this, className, version, methodNames);
   }
   // PUBLIC VIRTUAL METHODS
   initialize(props) {
@@ -2646,7 +2666,7 @@ var _WEBGLRenderbuffer = class extends WebGLResource {
   /** WebGL format constant */
   glFormat;
   static isTextureFormatSupported(device, format) {
-    return isRenderbufferFormatSupported(device.gl, format);
+    return isRenderbufferFormatSupported(device.gl, format, device._extensions);
   }
   constructor(device, props) {
     if (typeof props.format === "number") {
@@ -2666,7 +2686,7 @@ var _WEBGLRenderbuffer = class extends WebGLResource {
   /** Creates and initializes a renderbuffer object's data store */
   _initialize(props) {
     const { format, width, height, samples } = props;
-    (0, import_core9.assert)(format, "Needs format");
+    (0, import_core11.assert)(format, "Needs format");
     this.trackDeallocatedMemory();
     this.gl.bindRenderbuffer(import_constants11.GL.RENDERBUFFER, this.handle);
     if (samples !== 0) {
@@ -2702,7 +2722,7 @@ __publicField(WEBGLRenderbuffer, "defaultProps", {
 });
 
 // dist/adapter/resources/webgl-framebuffer.js
-var WEBGLFramebuffer = class extends import_core10.Framebuffer {
+var WEBGLFramebuffer = class extends import_core12.Framebuffer {
   device;
   gl;
   handle;
@@ -2727,13 +2747,16 @@ var WEBGLFramebuffer = class extends import_core10.Framebuffer {
         }
       }
       if (this.depthStencilAttachment) {
-        this._attachOne(getDepthStencilAttachmentWebGL(this.depthStencilAttachment.format), this.depthStencilAttachment);
+        this._attachOne(getDepthStencilAttachmentWebGL(this.depthStencilAttachment.props.format), this.depthStencilAttachment);
+      }
+      if (props.check !== false) {
+        const status = this.gl.checkFramebufferStatus(import_constants12.GL.FRAMEBUFFER);
+        if (status !== import_constants12.GL.FRAMEBUFFER_COMPLETE) {
+          throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
+        }
       }
       this.gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, null);
     }
-    if (props.check !== false) {
-      this._checkStatus();
-    }
   }
   /** destroys any auto created resources etc. */
   destroy() {
@@ -2743,16 +2766,6 @@ var WEBGLFramebuffer = class extends import_core10.Framebuffer {
     }
   }
   // PRIVATE
-  /** Check the status */
-  _checkStatus() {
-    const { gl } = this;
-    const prevHandle = gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, this.handle);
-    const status = gl.checkFramebufferStatus(import_constants12.GL.FRAMEBUFFER);
-    gl.bindFramebuffer(import_constants12.GL.FRAMEBUFFER, prevHandle || null);
-    if (status !== gl.FRAMEBUFFER_COMPLETE) {
-      throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);
-    }
-  }
   /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */
   createDepthStencilTexture(format) {
     return new WEBGLRenderbuffer(this.device, {
@@ -2781,10 +2794,10 @@ var WEBGLFramebuffer = class extends import_core10.Framebuffer {
       height = this.gl.drawingBufferHeight;
     }
     for (const colorAttachment of this.colorAttachments) {
-      colorAttachment.resize({ width, height });
+      colorAttachment.texture.resize({ width, height });
     }
     if (this.depthStencilAttachment) {
-      this.depthStencilAttachment.resize({ width, height });
+      this.depthStencilAttachment.texture.resize({ width, height });
     }
     return this;
   }
@@ -2800,6 +2813,10 @@ var WEBGLFramebuffer = class extends import_core10.Framebuffer {
     } else if (attachment instanceof WEBGLTexture) {
       this._attachTexture(attachmentPoint, attachment, 0, 0);
       return attachment;
+    } else if (attachment instanceof WEBGLTextureView) {
+      const textureView = attachment;
+      this._attachTexture(attachmentPoint, textureView.texture, textureView.props.baseMipLevel, textureView.props.baseArrayLayer);
+      return attachment.texture;
     }
     throw new Error("attach");
   }
@@ -2828,7 +2845,7 @@ var WEBGLFramebuffer = class extends import_core10.Framebuffer {
         gl.framebufferTexture2D(import_constants12.GL.FRAMEBUFFER, attachment, import_constants12.GL.TEXTURE_2D, texture.handle, level);
         break;
       default:
-        (0, import_core10.assert)(false, "Illegal texture type");
+        (0, import_core12.assert)(false, "Illegal texture type");
     }
     gl.bindTexture(texture.target, null);
   }
@@ -2856,7 +2873,7 @@ function _getFrameBufferStatus(status) {
 }
 
 // dist/adapter/webgl-canvas-context.js
-var WebGLCanvasContext = class extends import_core11.CanvasContext {
+var WebGLCanvasContext = class extends import_core13.CanvasContext {
   device;
   presentationSize;
   _framebuffer = null;
@@ -2907,9 +2924,9 @@ var WebGLCanvasContext = class extends import_core11.CanvasContext {
 };
 
 // dist/context/debug/spector.js
-var import_core12 = require("@luma.gl/core");
+var import_core14 = require("@luma.gl/core");
 var DEFAULT_SPECTOR_PROPS = {
-  spector: import_core12.log.get("spector") || import_core12.log.get("inspect")
+  spector: import_core14.log.get("spector") || import_core14.log.get("inspect")
 };
 var SPECTOR_CDN_URL = "https://spectorcdn.babylonjs.com/spector.bundle.js";
 var LOG_LEVEL = 1;
@@ -2918,9 +2935,9 @@ var initialized = false;
 async function loadSpectorJS(props) {
   if (!globalThis.SPECTOR) {
     try {
-      await (0, import_core12.loadScript)(SPECTOR_CDN_URL);
+      await (0, import_core14.loadScript)(SPECTOR_CDN_URL);
     } catch (error) {
-      import_core12.log.warn(String(error));
+      import_core14.log.warn(String(error));
     }
   }
 }
@@ -2930,7 +2947,7 @@ function initializeSpectorJS(props) {
     return null;
   }
   if (!spector && globalThis.SPECTOR) {
-    import_core12.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
+    import_core14.log.probe(LOG_LEVEL, "SPECTOR found and initialized")();
     spector = new globalThis.SPECTOR.Spector();
     if (globalThis.luma) {
       globalThis.luma.spector = spector;
@@ -2942,9 +2959,9 @@ function initializeSpectorJS(props) {
   if (!initialized) {
     initialized = true;
     spector.spyCanvases();
-    spector == null ? void 0 : spector.onCaptureStarted.add((capture) => import_core12.log.info("Spector capture started:", capture)());
+    spector == null ? void 0 : spector.onCaptureStarted.add((capture) => import_core14.log.info("Spector capture started:", capture)());
     spector == null ? void 0 : spector.onCapture.add((capture) => {
-      import_core12.log.info("Spector capture complete:", capture)();
+      import_core14.log.info("Spector capture complete:", capture)();
       spector == null ? void 0 : spector.getResultUI();
       spector == null ? void 0 : spector.resultView.display();
       spector == null ? void 0 : spector.resultView.addCapture(capture);
@@ -2956,7 +2973,7 @@ function initializeSpectorJS(props) {
     }
     spector == null ? void 0 : spector.startCapture(props == null ? void 0 : props.canvas, 500);
     new Promise((resolve) => setTimeout(resolve, 2e3)).then((_) => {
-      import_core12.log.info("Spector capture stopped after 2 seconds")();
+      import_core14.log.info("Spector capture stopped after 2 seconds")();
       spector == null ? void 0 : spector.stopCapture();
     });
   }
@@ -2964,11 +2981,11 @@ function initializeSpectorJS(props) {
 }
 
 // dist/context/debug/webgl-developer-tools.js
-var import_core13 = require("@luma.gl/core");
+var import_core15 = require("@luma.gl/core");
 var import_constants13 = require("@luma.gl/constants");
 var import_env = require("@probe.gl/env");
 var WEBGL_DEBUG_CDN_URL = "https://unpkg.com/webgl-debug@2.0.1/index.js";
-function getContextData(gl) {
+function getWebGLContextData(gl) {
   gl.luma = gl.luma || {};
   return gl.luma;
 }
@@ -2976,7 +2993,7 @@ async function loadWebGLDeveloperTools() {
   if ((0, import_env.isBrowser)() && !globalThis.WebGLDebugUtils) {
     globalThis.global = globalThis.global || globalThis;
     globalThis.global.module = {};
-    await (0, import_core13.loadScript)(WEBGL_DEBUG_CDN_URL);
+    await (0, import_core15.loadScript)(WEBGL_DEBUG_CDN_URL);
   }
 }
 function makeDebugContext(gl, props = {}) {
@@ -2986,15 +3003,15 @@ function makeDebugContext(gl, props = {}) {
   return props.debug ? getDebugContext(gl, props) : getRealContext(gl);
 }
 function getRealContext(gl) {
-  const data = getContextData(gl);
+  const data = getWebGLContextData(gl);
   return data.realContext ? data.realContext : gl;
 }
 function getDebugContext(gl, props) {
   if (!globalThis.WebGLDebugUtils) {
-    import_core13.log.warn("webgl-debug not loaded")();
+    import_core15.log.warn("webgl-debug not loaded")();
     return gl;
   }
-  const data = getContextData(gl);
+  const data = getWebGLContextData(gl);
   if (data.debugContext) {
     return data.debugContext;
   }
@@ -3026,7 +3043,7 @@ function onGLError(props, err, functionName, args) {
   const errorMessage = globalThis.WebGLDebugUtils.glEnumToString(err);
   const functionArgs = globalThis.WebGLDebugUtils.glFunctionArgsToString(functionName, args);
   const message2 = `${errorMessage} in gl.${functionName}(${functionArgs})`;
-  import_core13.log.error(message2)();
+  import_core15.log.error(message2)();
   debugger;
   if (props.throwOnError) {
     throw new Error(message2);
@@ -3034,9 +3051,9 @@ function onGLError(props, err, functionName, args) {
 }
 function onValidateGLFunc(props, functionName, functionArgs) {
   let functionString = "";
-  if (import_core13.log.level >= 1) {
+  if (import_core15.log.level >= 1) {
     functionString = getFunctionString(functionName, functionArgs);
-    import_core13.log.log(1, functionString)();
+    import_core15.log.log(1, functionString)();
   }
   if (props.break && props.break.length > 0) {
     functionString = functionString || getFunctionString(functionName, functionArgs);
@@ -3051,7 +3068,7 @@ function onValidateGLFunc(props, functionName, functionArgs) {
       if (props.throwOnError) {
         throw new Error(`Undefined argument: ${functionString}`);
       } else {
-        import_core13.log.error(`Undefined argument: ${functionString}`)();
+        import_core15.log.error(`Undefined argument: ${functionString}`)();
         debugger;
       }
     }
@@ -3059,7 +3076,7 @@ function onValidateGLFunc(props, functionName, functionArgs) {
 }
 
 // dist/adapter/resources/webgl-shader.js
-var import_core14 = require("@luma.gl/core");
+var import_core16 = require("@luma.gl/core");
 var import_constants14 = require("@luma.gl/constants");
 
 // dist/adapter/helpers/parse-shader-compiler-log.js
@@ -3107,7 +3124,7 @@ function getMessageType(messageType) {
 }
 
 // dist/adapter/resources/webgl-shader.js
-var WEBGLShader = class extends import_core14.Shader {
+var WEBGLShader = class extends import_core16.Shader {
   device;
   handle;
   constructor(device, props) {
@@ -3140,6 +3157,11 @@ var WEBGLShader = class extends import_core14.Shader {
     const log9 = this.device.gl.getShaderInfoLog(this.handle);
     return parseShaderCompilerLog(log9);
   }
+  getTranslatedSource() {
+    const extensions = this.device.getExtension("WEBGL_debug_shaders");
+    const ext = extensions.WEBGL_debug_shaders;
+    return ext == null ? void 0 : ext.getTranslatedShaderSource(this.handle);
+  }
   // PRIVATE METHODS
   /** Compile a shader and get compilation status */
   async _compile(source) {
@@ -3149,11 +3171,11 @@ ${source2}`;
     const { gl } = this.device;
     gl.shaderSource(this.handle, source);
     gl.compileShader(this.handle);
-    if (import_core14.log.level === 0) {
+    if (import_core16.log.level === 0) {
       this.compilationStatus = "pending";
       return;
     }
-    if (!this.device.features.has("shader-status-async-webgl")) {
+    if (!this.device.features.has("compilation-status-async-webgl")) {
       this._getCompilationStatus();
       if (this.compilationStatus === "error") {
         throw new Error(`GLSL compilation errors in ${this.props.stage} shader ${this.props.id}`);
@@ -3161,9 +3183,9 @@ ${source2}`;
       this.debugShader();
       return;
     }
-    import_core14.log.once(1, "Shader compilation is asynchronous")();
+    import_core16.log.once(1, "Shader compilation is asynchronous")();
     await this._waitForCompilationComplete();
-    import_core14.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
+    import_core16.log.info(2, `Shader ${this.id} - async compilation complete: ${this.compilationStatus}`)();
     this._getCompilationStatus();
     this.debugShader();
   }
@@ -3171,13 +3193,13 @@ ${source2}`;
   async _waitForCompilationComplete() {
     const waitMs = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
     const DELAY_MS = 10;
-    if (!this.device.features.has("shader-status-async-webgl")) {
+    if (!this.device.features.has("compilation-status-async-webgl")) {
       await waitMs(DELAY_MS);
       return;
     }
     const { gl } = this.device;
     for (; ; ) {
-      const complete = gl.getShaderParameter(this.handle, import_constants14.GL.COMPLETION_STATUS);
+      const complete = gl.getShaderParameter(this.handle, import_constants14.GL.COMPLETION_STATUS_KHR);
       if (complete) {
         return;
       }
@@ -3188,20 +3210,20 @@ ${source2}`;
    * Get the shader compilation status
    * TODO - Load log even when no error reported, to catch warnings?
    * https://gamedev.stackexchange.com/questions/30429/how-to-detect-glsl-warnings
-  */
+   */
   _getCompilationStatus() {
     this.compilationStatus = this.device.gl.getShaderParameter(this.handle, import_constants14.GL.COMPILE_STATUS) ? "success" : "error";
   }
 };
 
 // dist/adapter/resources/webgl-render-pass.js
-var import_core15 = require("@luma.gl/core");
+var import_core17 = require("@luma.gl/core");
 var import_constants15 = require("@luma.gl/constants");
 var GL_DEPTH_BUFFER_BIT = 256;
 var GL_STENCIL_BUFFER_BIT = 1024;
 var GL_COLOR_BUFFER_BIT = 16384;
 var GL_COLOR = 6144;
-var WEBGLRenderPass = class extends import_core15.RenderPass {
+var WEBGLRenderPass = class extends import_core17.RenderPass {
   device;
   /** Parameters that should be applied before each draw call */
   glParameters;
@@ -3224,7 +3246,6 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
   }
   insertDebugMarker(markerLabel) {
   }
-  // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
   // beginOcclusionQuery(queryIndex: number): void;
   // endOcclusionQuery(): void;
   // executeBundles(bundles: Iterable<GPURenderBundle>): void;
@@ -3263,7 +3284,15 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
     this.glParameters = glParameters;
     setGLParameters(this.device, glParameters);
   }
-  // Internal
+  beginOcclusionQuery(queryIndex) {
+    const webglQuerySet = this.props.occlusionQuerySet;
+    webglQuerySet == null ? void 0 : webglQuerySet.beginOcclusionQuery();
+  }
+  endOcclusionQuery() {
+    const webglQuerySet = this.props.occlusionQuerySet;
+    webglQuerySet == null ? void 0 : webglQuerySet.endOcclusionQuery();
+  }
+  // PRIVATE
   /**
    * Optionally clears depth, color and stencil buffers based on parameters
    */
@@ -3310,15 +3339,15 @@ var WEBGLRenderPass = class extends import_core15.RenderPass {
 };
 
 // dist/adapter/resources/webgl-render-pipeline.js
-var import_core17 = require("@luma.gl/core");
-var import_core18 = require("@luma.gl/core");
+var import_core19 = require("@luma.gl/core");
+var import_core20 = require("@luma.gl/core");
 var import_constants22 = require("@luma.gl/constants");
 
 // dist/adapter/helpers/get-shader-layout.js
 var import_constants19 = require("@luma.gl/constants");
 
 // dist/classic/accessor.js
-var import_core16 = require("@luma.gl/core");
+var import_core18 = require("@luma.gl/core");
 var import_constants17 = require("@luma.gl/constants");
 
 // dist/classic/typed-array-utils.js
@@ -3403,7 +3432,7 @@ var Accessor = class {
     return ArrayType.BYTES_PER_ELEMENT;
   }
   static getBytesPerVertex(accessor) {
-    (0, import_core16.assert)(accessor.size);
+    (0, import_core18.assert)(accessor.size);
     const ArrayType = getTypedArrayFromGLType(accessor.type || import_constants17.GL.FLOAT);
     return ArrayType.BYTES_PER_ELEMENT * accessor.size;
   }
@@ -3432,7 +3461,7 @@ var Accessor = class {
   // PRIVATE
   // eslint-disable-next-line complexity, max-statements
   _assign(props = {}) {
-    props = (0, import_core16.checkProps)("Accessor", props, PROP_CHECKS);
+    props = (0, import_core18.checkProps)("Accessor", props, PROP_CHECKS);
     if (props.type !== void 0) {
       this.type = props.type;
       if (props.type === import_constants17.GL.INT || props.type === import_constants17.GL.UNSIGNED_INT) {
@@ -3922,7 +3951,7 @@ function getGLPrimitive(topology) {
 
 // dist/adapter/resources/webgl-render-pipeline.js
 var LOG_PROGRAM_PERF_PRIORITY = 4;
-var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
+var WEBGLRenderPipeline = class extends import_core19.RenderPipeline {
   /** The WebGL device that created this render pipeline */
   device;
   /** Handle to underlying WebGL program */
@@ -3947,20 +3976,22 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
     this.device = device;
     this.handle = this.props.handle || this.device.gl.createProgram();
     this.device.setSpectorMetadata(this.handle, { id: this.props.id });
-    this.vs = (0, import_core17.cast)(props.vs);
-    this.fs = (0, import_core17.cast)(props.fs);
+    this.vs = (0, import_core19.cast)(props.vs);
+    this.fs = (0, import_core19.cast)(props.fs);
     const { varyings, bufferMode = import_constants22.GL.SEPARATE_ATTRIBS } = props;
     if (varyings && varyings.length > 0) {
       this.varyings = varyings;
       this.device.gl.transformFeedbackVaryings(this.handle, varyings, bufferMode);
     }
     this._linkShaders();
+    import_core19.log.time(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
     this.introspectedLayout = getShaderLayout(this.device.gl, this.handle);
-    this.shaderLayout = (0, import_core18.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
+    import_core19.log.timeEnd(0, `RenderPipeline ${this.id} - shaderLayout introspection`)();
+    this.shaderLayout = (0, import_core20.mergeShaderLayout)(this.introspectedLayout, props.shaderLayout);
     switch (this.props.topology) {
       case "triangle-fan-webgl":
       case "line-loop-webgl":
-        import_core17.log.warn(`Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`);
+        import_core19.log.warn(`Primitive topology ${this.props.topology} is deprecated and will be removed in v9.1`);
         break;
       default:
     }
@@ -3980,11 +4011,11 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
       const binding = this.shaderLayout.bindings.find((binding2) => binding2.name === name) || this.shaderLayout.bindings.find((binding2) => binding2.name === `${name}Uniforms`);
       if (!binding) {
         const validBindings = this.shaderLayout.bindings.map((binding2) => `"${binding2.name}"`).join(", ");
-        import_core17.log.warn(`Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`)();
+        import_core19.log.warn(`Unknown binding "${name}" in render pipeline "${this.id}", expected one of ${validBindings}`)();
         continue;
       }
       if (!value) {
-        import_core17.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
+        import_core19.log.warn(`Unsetting binding "${name}" in render pipeline "${this.id}"`)();
       }
       switch (binding.type) {
         case "uniform":
@@ -3993,12 +4024,12 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
           }
           break;
         case "texture":
-          if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+          if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
             throw new Error("texture value");
           }
           break;
         case "sampler":
-          import_core17.log.warn(`Ignoring sampler ${name}`)();
+          import_core19.log.warn(`Ignoring sampler ${name}`)();
           break;
         default:
           throw new Error(binding.type);
@@ -4006,14 +4037,6 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
       this.bindings[name] = value;
     }
   }
-  /** This function is @deprecated, use uniform buffers */
-  setUniforms(uniforms) {
-    const { bindings } = (0, import_core17.splitUniformsAndBindings)(uniforms);
-    Object.keys(bindings).forEach((name) => {
-      import_core17.log.warn(`Unsupported value "${JSON.stringify(bindings[name])}" used in setUniforms() for key ${name}. Use setBindings() instead?`)();
-    });
-    Object.assign(this.uniforms, uniforms);
-  }
   /** @todo needed for portable model
    * @note The WebGL API is offers many ways to draw things
    * This function unifies those ways into a single call using common parameters with sane defaults
@@ -4074,6 +4097,14 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
     vertexArray.unbindAfterRender(renderPass);
     return true;
   }
+  // DEPRECATED METHODS
+  setUniformsWebGL(uniforms) {
+    const { bindings } = (0, import_core19.splitUniformsAndBindings)(uniforms);
+    Object.keys(bindings).forEach((name) => {
+      import_core19.log.warn(`Unsupported value "${JSON.stringify(bindings[name])}" used in setUniforms() for key ${name}. Use setBindings() instead?`)();
+    });
+    Object.assign(this.uniforms, uniforms);
+  }
   // PRIVATE METHODS
   // setAttributes(attributes: Record<string, Buffer>): void {}
   // setBindings(bindings: Record<string, Binding>): void {}
@@ -4081,19 +4112,19 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
     const { gl } = this.device;
     gl.attachShader(this.handle, this.vs.handle);
     gl.attachShader(this.handle, this.fs.handle);
-    import_core17.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    import_core19.log.time(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
     gl.linkProgram(this.handle);
-    import_core17.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
-    if (import_core17.log.level === 0) {
+    import_core19.log.timeEnd(LOG_PROGRAM_PERF_PRIORITY, `linkProgram for ${this.id}`)();
+    if (import_core19.log.level === 0) {
     }
-    if (!this.device.features.has("shader-status-async-webgl")) {
+    if (!this.device.features.has("compilation-status-async-webgl")) {
       const status2 = this._getLinkStatus();
       this._reportLinkStatus(status2);
       return;
     }
-    import_core17.log.once(1, "RenderPipeline linking is asynchronous")();
+    import_core19.log.once(1, "RenderPipeline linking is asynchronous")();
     await this._waitForLinkComplete();
-    import_core17.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
+    import_core19.log.info(2, `RenderPipeline ${this.id} - async linking complete: ${this.linkStatus}`)();
     const status = this._getLinkStatus();
     this._reportLinkStatus(status);
   }
@@ -4140,13 +4171,13 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
   async _waitForLinkComplete() {
     const waitMs = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));
     const DELAY_MS = 10;
-    if (!this.device.features.has("shader-status-async-webgl")) {
+    if (!this.device.features.has("compilation-status-async-webgl")) {
       await waitMs(DELAY_MS);
       return;
     }
     const { gl } = this.device;
     for (; ; ) {
-      const complete = gl.getProgramParameter(this.handle, import_constants22.GL.COMPLETION_STATUS);
+      const complete = gl.getProgramParameter(this.handle, import_constants22.GL.COMPLETION_STATUS_KHR);
       if (complete) {
         return;
       }
@@ -4207,14 +4238,16 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
           uniformBufferIndex += 1;
           break;
         case "texture":
-          if (!(value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
+          if (!(value instanceof WEBGLTextureView || value instanceof WEBGLTexture || value instanceof WEBGLFramebuffer)) {
             throw new Error("texture");
           }
           let texture;
-          if (value instanceof WEBGLTexture) {
+          if (value instanceof WEBGLTextureView) {
+            texture = value.texture;
+          } else if (value instanceof WEBGLTexture) {
             texture = value;
           } else if (value instanceof WEBGLFramebuffer && value.colorAttachments[0] instanceof WEBGLTexture) {
-            import_core17.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
+            import_core19.log.warn("Passing framebuffer in texture binding may be deprecated. Use fbo.colorAttachments[0] instead")();
             texture = value.colorAttachments[0];
           } else {
             throw new Error("No texture");
@@ -4247,15 +4280,15 @@ var WEBGLRenderPipeline = class extends import_core17.RenderPipeline {
 };
 
 // dist/adapter/resources/webgl-command-encoder.js
-var import_core20 = require("@luma.gl/core");
+var import_core22 = require("@luma.gl/core");
 
 // dist/adapter/resources/webgl-command-buffer.js
-var import_core19 = require("@luma.gl/core");
+var import_core21 = require("@luma.gl/core");
 var import_constants23 = require("@luma.gl/constants");
 function cast2(value) {
   return value;
 }
-var WEBGLCommandBuffer = class extends import_core19.CommandBuffer {
+var WEBGLCommandBuffer = class extends import_core21.CommandBuffer {
   device;
   commands = [];
   constructor(device) {
@@ -4335,7 +4368,7 @@ function _copyTextureToBuffer(device, options) {
     const webglBuffer = destination;
     const sourceWidth = width || framebuffer.width;
     const sourceHeight = height || framebuffer.height;
-    const sourceParams = getWebGLTextureParameters(framebuffer.texture.format);
+    const sourceParams = getWebGLTextureParameters(framebuffer.texture.props.format);
     const sourceFormat = sourceParams.dataFormat;
     const sourceType = sourceParams.type;
     device.gl.bindBuffer(import_constants23.GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
@@ -4413,7 +4446,7 @@ function _copyTextureToTexture(device, options) {
   return texture;
 }
 function getFramebuffer(source) {
-  if (source instanceof import_core19.Texture) {
+  if (source instanceof import_core21.Texture) {
     const { width, height, id } = source;
     const framebuffer = source.device.createFramebuffer({
       id: `framebuffer-for-${id}`,
@@ -4427,7 +4460,7 @@ function getFramebuffer(source) {
 }
 
 // dist/adapter/resources/webgl-command-encoder.js
-var WEBGLCommandEncoder = class extends import_core20.CommandEncoder {
+var WEBGLCommandEncoder = class extends import_core22.CommandEncoder {
   device;
   commandBuffer;
   constructor(device, props) {
@@ -4461,13 +4494,15 @@ var WEBGLCommandEncoder = class extends import_core20.CommandEncoder {
   }
   insertDebugMarker(markerLabel) {
   }
+  resolveQuerySet(querySet, destination, options) {
+  }
 };
 
 // dist/adapter/resources/webgl-vertex-array.js
-var import_core21 = require("@luma.gl/core");
+var import_core23 = require("@luma.gl/core");
 var import_constants24 = require("@luma.gl/constants");
 var import_env2 = require("@probe.gl/env");
-var WEBGLVertexArray = class extends import_core21.VertexArray {
+var WEBGLVertexArray = class extends import_core23.VertexArray {
   get [Symbol.toStringTag]() {
     return "VertexArray";
   }
@@ -4531,7 +4566,7 @@ var WEBGLVertexArray = class extends import_core21.VertexArray {
     this.attributes[location] = buffer;
   }
   /** Set a location in vertex attributes array to a constant value, disables the location */
-  setConstant(location, value) {
+  setConstantWebGL(location, value) {
     this._enable(location, false);
     this.attributes[location] = value;
   }
@@ -4559,7 +4594,7 @@ var WEBGLVertexArray = class extends import_core21.VertexArray {
     for (let location = 0; location < this.maxVertexAttributes; ++location) {
       const constant = this.attributes[location];
       if (ArrayBuffer.isView(constant)) {
-        this.device.setConstantAttribute(location, constant);
+        this.device.setConstantAttributeWebGL(location, constant);
       }
     }
   }
@@ -4637,8 +4672,8 @@ var WEBGLVertexArray = class extends import_core21.VertexArray {
     this.buffer = this.buffer || this.device.createBuffer({ byteLength });
     updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
     if (updateNeeded) {
-      const typedArray = (0, import_core21.getScratchArray)(value.constructor, length);
-      (0, import_core21.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
+      const typedArray = (0, import_core23.getScratchArray)(value.constructor, length);
+      (0, import_core23.fillArray)({ target: typedArray, source: constantValue, start: 0, count: length });
       this.buffer.write(typedArray);
       this.bufferValue = value;
     }
@@ -4664,9 +4699,9 @@ function compareConstantArrayValues(v1, v2) {
 }
 
 // dist/adapter/resources/webgl-transform-feedback.js
-var import_core22 = require("@luma.gl/core");
+var import_core24 = require("@luma.gl/core");
 var import_constants25 = require("@luma.gl/constants");
-var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
+var WEBGLTransformFeedback = class extends import_core24.TransformFeedback {
   device;
   gl;
   handle;
@@ -4729,7 +4764,7 @@ var WEBGLTransformFeedback = class extends import_core22.TransformFeedback {
     const { buffer, byteLength, byteOffset } = this._getBufferRange(bufferOrRange);
     if (location < 0) {
       this.unusedBuffers[locationOrName] = buffer;
-      import_core22.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
+      import_core24.log.warn(`${this.id} unusedBuffers varying buffer ${locationOrName}`)();
       return;
     }
     this.buffers[location] = { buffer, byteLength, byteOffset };
@@ -4815,57 +4850,187 @@ function isIndex(value) {
   return /^\d+$/.test(value);
 }
 
+// dist/adapter/resources/webgl-query-set.js
+var import_core25 = require("@luma.gl/core");
+var import_constants26 = require("@luma.gl/constants");
+var WEBGLQuerySet = class extends import_core25.QuerySet {
+  device;
+  handle;
+  target = null;
+  _queryPending = false;
+  _pollingPromise = null;
+  get [Symbol.toStringTag]() {
+    return "Query";
+  }
+  // Create a query class
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+    if (props.count > 1) {
+      throw new Error("WebGL QuerySet can only have one value");
+    }
+    this.handle = this.device.gl.createQuery();
+    Object.seal(this);
+  }
+  destroy() {
+    this.device.gl.deleteQuery(this.handle);
+  }
+  // FOR RENDER PASS AND COMMAND ENCODER
+  /**
+   * Shortcut for timer query (dependent on extension in both WebGL1 and 2)
+   * Measures GPU time delta between this call and a matching `end` call in the
+   * GPU instruction stream.
+   */
+  beginTimestampQuery() {
+    return this._begin(import_constants26.GL.TIME_ELAPSED_EXT);
+  }
+  endTimestampQuery() {
+    this._end();
+  }
+  // Shortcut for occlusion queries
+  beginOcclusionQuery(options) {
+    return this._begin((options == null ? void 0 : options.conservative) ? import_constants26.GL.ANY_SAMPLES_PASSED_CONSERVATIVE : import_constants26.GL.ANY_SAMPLES_PASSED);
+  }
+  endOcclusionQuery() {
+    this._end();
+  }
+  // Shortcut for transformFeedbackQuery
+  beginTransformFeedbackQuery() {
+    return this._begin(import_constants26.GL.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
+  }
+  endTransformFeedbackQuery() {
+    this._end();
+  }
+  async resolveQuery() {
+    const value = await this.pollQuery();
+    return [value];
+  }
+  // PRIVATE METHODS
+  /**
+   * Due to OpenGL API limitations, after calling `begin()` on one Query
+   * instance, `end()` must be called on that same instance before
+   * calling `begin()` on another query. While there can be multiple
+   * outstanding queries representing disjoint `begin()`/`end()` intervals.
+   * It is not possible to interleave or overlap `begin` and `end` calls.
+   */
+  _begin(target) {
+    if (this._queryPending) {
+      return;
+    }
+    this.target = target;
+    this.device.gl.beginQuery(this.target, this.handle);
+    return;
+  }
+  // ends the current query
+  _end() {
+    if (this._queryPending) {
+      return;
+    }
+    if (this.target) {
+      this.device.gl.endQuery(this.target);
+      this.target = null;
+      this._queryPending = true;
+    }
+    return;
+  }
+  // Returns true if the query result is available
+  isResultAvailable() {
+    if (!this._queryPending) {
+      return false;
+    }
+    const resultAvailable = this.device.gl.getQueryParameter(this.handle, import_constants26.GL.QUERY_RESULT_AVAILABLE);
+    if (resultAvailable) {
+      this._queryPending = false;
+    }
+    return resultAvailable;
+  }
+  // Timing query is disjoint, i.e. results are invalid
+  isTimerDisjoint() {
+    return this.device.gl.getParameter(import_constants26.GL.GPU_DISJOINT_EXT);
+  }
+  // Returns query result.
+  getResult() {
+    return this.device.gl.getQueryParameter(this.handle, import_constants26.GL.QUERY_RESULT);
+  }
+  // Returns the query result, converted to milliseconds to match JavaScript conventions.
+  getTimerMilliseconds() {
+    return this.getResult() / 1e6;
+  }
+  // Polls the query
+  pollQuery(limit = Number.POSITIVE_INFINITY) {
+    if (this._pollingPromise) {
+      return this._pollingPromise;
+    }
+    let counter = 0;
+    this._pollingPromise = new Promise((resolve, reject) => {
+      const poll = () => {
+        if (this.isResultAvailable()) {
+          resolve(this.getResult());
+          this._pollingPromise = null;
+        } else if (counter++ > limit) {
+          reject("Timed out");
+          this._pollingPromise = null;
+        } else {
+          requestAnimationFrame(poll);
+        }
+      };
+      requestAnimationFrame(poll);
+    });
+    return this._pollingPromise;
+  }
+};
+
 // dist/classic/copy-and-blit.js
-var import_core24 = require("@luma.gl/core");
-var import_constants27 = require("@luma.gl/constants");
+var import_core27 = require("@luma.gl/core");
+var import_constants28 = require("@luma.gl/constants");
 
 // dist/classic/format-utils.js
-var import_core23 = require("@luma.gl/core");
-var import_constants26 = require("@luma.gl/constants");
+var import_core26 = require("@luma.gl/core");
+var import_constants27 = require("@luma.gl/constants");
 function glFormatToComponents(format) {
   switch (format) {
-    case import_constants26.GL.ALPHA:
-    case import_constants26.GL.R32F:
-    case import_constants26.GL.RED:
+    case import_constants27.GL.ALPHA:
+    case import_constants27.GL.R32F:
+    case import_constants27.GL.RED:
       return 1;
-    case import_constants26.GL.RG32F:
-    case import_constants26.GL.RG:
+    case import_constants27.GL.RG32F:
+    case import_constants27.GL.RG:
       return 2;
-    case import_constants26.GL.RGB:
-    case import_constants26.GL.RGB32F:
+    case import_constants27.GL.RGB:
+    case import_constants27.GL.RGB32F:
       return 3;
-    case import_constants26.GL.RGBA:
-    case import_constants26.GL.RGBA32F:
+    case import_constants27.GL.RGBA:
+    case import_constants27.GL.RGBA32F:
       return 4;
     default:
-      (0, import_core23.assert)(false);
+      (0, import_core26.assert)(false);
       return 0;
   }
 }
 function glTypeToBytes(type) {
   switch (type) {
-    case import_constants26.GL.UNSIGNED_BYTE:
+    case import_constants27.GL.UNSIGNED_BYTE:
       return 1;
-    case import_constants26.GL.UNSIGNED_SHORT_5_6_5:
-    case import_constants26.GL.UNSIGNED_SHORT_4_4_4_4:
-    case import_constants26.GL.UNSIGNED_SHORT_5_5_5_1:
+    case import_constants27.GL.UNSIGNED_SHORT_5_6_5:
+    case import_constants27.GL.UNSIGNED_SHORT_4_4_4_4:
+    case import_constants27.GL.UNSIGNED_SHORT_5_5_5_1:
       return 2;
-    case import_constants26.GL.FLOAT:
+    case import_constants27.GL.FLOAT:
       return 4;
     default:
-      (0, import_core23.assert)(false);
+      (0, import_core26.assert)(false);
       return 0;
   }
 }
 
 // dist/classic/copy-and-blit.js
 function readPixelsToArray(source, options) {
-  var _a;
+  var _a, _b;
   const {
     sourceX = 0,
     sourceY = 0,
-    sourceFormat = import_constants27.GL.RGBA,
-    sourceAttachment = import_constants27.GL.COLOR_ATTACHMENT0
+    sourceFormat = import_constants28.GL.RGBA,
+    sourceAttachment = import_constants28.GL.COLOR_ATTACHMENT0
     // TODO - support gl.readBuffer
   } = options || {};
   let {
@@ -4876,31 +5041,31 @@ function readPixelsToArray(source, options) {
     sourceType
   } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-  (0, import_core24.assert)(framebuffer);
+  (0, import_core27.assert)(framebuffer);
   const { gl, handle } = framebuffer;
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
-  const attachment = sourceAttachment - import_constants27.GL.COLOR_ATTACHMENT0;
-  sourceType = sourceType || ((_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.type) || import_constants27.GL.UNSIGNED_BYTE;
+  const attachment = sourceAttachment - import_constants28.GL.COLOR_ATTACHMENT0;
+  sourceType = sourceType || ((_b = (_a = framebuffer.colorAttachments[attachment]) == null ? void 0 : _a.texture) == null ? void 0 : _b.type) || import_constants28.GL.UNSIGNED_BYTE;
   target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
   sourceType = sourceType || getGLTypeFromTypedArray(target);
-  const prevHandle = gl.bindFramebuffer(import_constants27.GL.FRAMEBUFFER, handle);
+  const prevHandle = gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, handle);
   gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-  gl.bindFramebuffer(import_constants27.GL.FRAMEBUFFER, prevHandle || null);
+  gl.bindFramebuffer(import_constants28.GL.FRAMEBUFFER, prevHandle || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
   return target;
 }
 function readPixelsToBuffer(source, options) {
-  const { target, sourceX = 0, sourceY = 0, sourceFormat = import_constants27.GL.RGBA, targetByteOffset = 0 } = options || {};
+  const { target, sourceX = 0, sourceY = 0, sourceFormat = import_constants28.GL.RGBA, targetByteOffset = 0 } = options || {};
   let { sourceWidth, sourceHeight, sourceType } = options || {};
   const { framebuffer, deleteFramebuffer } = getFramebuffer2(source);
-  (0, import_core24.assert)(framebuffer);
+  (0, import_core27.assert)(framebuffer);
   sourceWidth = sourceWidth || framebuffer.width;
   sourceHeight = sourceHeight || framebuffer.height;
   const webglFramebuffer = framebuffer;
-  sourceType = sourceType || import_constants27.GL.UNSIGNED_BYTE;
+  sourceType = sourceType || import_constants28.GL.UNSIGNED_BYTE;
   let webglBufferTarget = target;
   if (!webglBufferTarget) {
     const components = glFormatToComponents(sourceFormat);
@@ -4924,7 +5089,7 @@ function readPixelsToBuffer(source, options) {
   return webglBufferTarget;
 }
 function getFramebuffer2(source) {
-  if (!(source instanceof import_core24.Framebuffer)) {
+  if (!(source instanceof import_core27.Framebuffer)) {
     return { framebuffer: toFramebuffer(source), deleteFramebuffer: true };
   }
   return { framebuffer: source, deleteFramebuffer: false };
@@ -4944,14 +5109,14 @@ function getPixelArray(pixelArray, type, format, width, height) {
   if (pixelArray) {
     return pixelArray;
   }
-  type = type || import_constants27.GL.UNSIGNED_BYTE;
+  type = type || import_constants28.GL.UNSIGNED_BYTE;
   const ArrayType = getTypedArrayFromGLType(type, { clamped: false });
   const components = glFormatToComponents(format);
   return new ArrayType(width * height * components);
 }
 
 // dist/classic/clear.js
-var import_core25 = require("@luma.gl/core");
+var import_core28 = require("@luma.gl/core");
 var GL_DEPTH_BUFFER_BIT2 = 256;
 var GL_STENCIL_BUFFER_BIT2 = 1024;
 var GL_COLOR_BUFFER_BIT2 = 16384;
@@ -4981,7 +5146,7 @@ function clear(device, options) {
       parameters.clearStencil = depth;
     }
   }
-  (0, import_core25.assert)(clearFlags !== 0, ERR_ARGUMENTS);
+  (0, import_core28.assert)(clearFlags !== 0, ERR_ARGUMENTS);
   withGLParameters(device, parameters, () => {
     const gl = device.gl;
     gl.clear(clearFlags);
@@ -4990,25 +5155,18 @@ function clear(device, options) {
 
 // dist/adapter/webgl-device.js
 var LOG_LEVEL2 = 1;
-var _WebGLDevice = class extends import_core26.Device {
+var _WebGLDevice = class extends import_core29.Device {
   static isSupported() {
     return typeof WebGL2RenderingContext !== "undefined";
   }
+  /** The underlying WebGL context */
+  handle;
+  features;
+  limits;
   info;
   canvasContext;
-  handle;
-  get features() {
-    this._features = this._features || getDeviceFeatures(this.gl);
-    return this._features;
-  }
-  get limits() {
-    this._limits = this._limits || getDeviceLimits(this.gl);
-    return this._limits;
-  }
   lost;
   _resolveContextLost;
-  _features;
-  _limits;
   //
   // Static methods, expected to be present by `luma.createDevice()`
   //
@@ -5022,7 +5180,7 @@ var _WebGLDevice = class extends import_core26.Device {
     if (gl instanceof _WebGLDevice) {
       return gl;
     }
-    if ((gl == null ? void 0 : gl.device) instanceof import_core26.Device) {
+    if ((gl == null ? void 0 : gl.device) instanceof import_core29.Device) {
       return gl.device;
     }
     if (!isWebGL(gl)) {
@@ -5031,26 +5189,28 @@ var _WebGLDevice = class extends import_core26.Device {
     return new _WebGLDevice({ gl });
   }
   static async create(props = {}) {
-    import_core26.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
-    if (typeof props.canvas === "string") {
-      await import_core26.CanvasContext.pageLoaded;
+    var _a;
+    import_core29.log.groupCollapsed(LOG_LEVEL2, "WebGLDevice created")();
+    const promises = [];
+    if (props.debug) {
+      promises.push(loadWebGLDeveloperTools());
     }
-    if (import_core26.log.get("debug") || props.debug) {
-      await loadWebGLDeveloperTools();
+    if (props.spector) {
+      promises.push(loadSpectorJS());
     }
-    const { spector: spector2 } = props;
-    if (import_core26.log.get("spector") || spector2) {
-      await loadSpectorJS();
+    if (typeof props.canvas === "string") {
+      promises.push(import_core29.CanvasContext.pageLoaded);
     }
-    import_core26.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
-    if (props.gl && props.gl.device) {
+    await Promise.all(promises);
+    import_core29.log.probe(LOG_LEVEL2 + 1, "DOM is loaded")();
+    if ((_a = props.gl) == null ? void 0 : _a.device) {
       return _WebGLDevice.attach(props.gl);
     }
     const device = new _WebGLDevice(props);
     const message2 = `Created ${device.info.type}${device.debug ? " debug" : ""} context: ${device.info.vendor}, ${device.info.renderer} for canvas: ${device.canvasContext.id}`;
-    import_core26.log.probe(LOG_LEVEL2, message2)();
-    import_core26.log.table(LOG_LEVEL2, device.info)();
-    import_core26.log.groupEnd(LOG_LEVEL2)();
+    import_core29.log.probe(LOG_LEVEL2, message2)();
+    import_core29.log.table(LOG_LEVEL2, device.info)();
+    import_core29.log.groupEnd(LOG_LEVEL2)();
     return device;
   }
   //
@@ -5058,54 +5218,57 @@ var _WebGLDevice = class extends import_core26.Device {
   //
   constructor(props) {
     var _a, _b;
-    super({ ...props, id: props.id || (0, import_core26.uid)("webgl-device") });
+    super({ ...props, id: props.id || (0, import_core29.uid)("webgl-device") });
     const device = (_a = props.gl) == null ? void 0 : _a.device;
     if (device) {
       throw new Error(`WebGL context already attached to device ${device.id}`);
     }
-    const canvas = props.canvas || ((_b = props.gl) == null ? void 0 : _b.canvas);
+    const canvas = ((_b = props.gl) == null ? void 0 : _b.canvas) || props.canvas;
     this.canvasContext = new WebGLCanvasContext(this, { ...props, canvas });
     this.lost = new Promise((resolve) => {
       this._resolveContextLost = resolve;
     });
-    const onContextLost = (event) => {
-      var _a2;
-      return (_a2 = this._resolveContextLost) == null ? void 0 : _a2.call(this, {
-        reason: "destroyed",
-        message: "Computer entered sleep mode, or too many apps or browser tabs are using the GPU."
-      });
-    };
     let gl = props.gl || null;
-    gl = gl || ((0, import_env3.isBrowser)() ? createBrowserContext(this.canvasContext.canvas, { ...props, onContextLost }) : null);
+    gl ||= createBrowserContext(this.canvasContext.canvas, {
+      ...props,
+      onContextLost: (event) => {
+        var _a2;
+        return (_a2 = this._resolveContextLost) == null ? void 0 : _a2.call(this, {
+          reason: "destroyed",
+          message: "Entered sleep mode, or too many apps or browser tabs are using the GPU."
+        });
+      }
+    });
     if (!gl) {
       throw new Error("WebGL context creation failed");
     }
     this.handle = gl;
-    this.gl = this.handle;
-    this.canvasContext.resize();
-    this.info = getDeviceInfo(this.gl);
+    this.gl = gl;
     this.gl.device = this;
-    this.gl._version = this.isWebGL2 ? 2 : 1;
+    this.gl._version = 2;
+    this.info = getDeviceInfo(this.gl, this._extensions);
+    this.features = new WebGLDeviceFeatures(this.gl, this._extensions);
+    this.limits = new WebGLDeviceLimits(this.gl);
+    this.canvasContext.resize();
     const { enable: enable2 = true, copyState = false } = props;
     trackContextState(this.gl, {
       enable: enable2,
       copyState,
-      log: (...args) => import_core26.log.log(1, ...args)()
+      log: (...args) => import_core29.log.log(1, ...args)()
     });
-    if ((0, import_env3.isBrowser)() && props.debug) {
+    if (props.debug) {
       this.gl = makeDebugContext(this.gl, { ...props, throwOnError: true });
       this.debug = true;
-      import_core26.log.level = Math.max(import_core26.log.level, 1);
-      import_core26.log.warn("WebGL debug mode activated. Performance reduced.")();
+      import_core29.log.level = Math.max(import_core29.log.level, 1);
+      import_core29.log.warn("WebGL debug mode activated. Performance reduced.")();
     }
-    if ((0, import_env3.isBrowser)() && props.spector) {
-      const canvas2 = this.handle.canvas || props.canvas;
-      this.spector = initializeSpectorJS({ ...this.props, canvas: canvas2 });
+    if (props.spector) {
+      this.spectorJS = initializeSpectorJS({ ...this.props, canvas: this.handle.canvas });
     }
   }
   /**
    * Destroys the context
-   * @note Has no effect for browser contexts, there is no browser API for destroying contexts
+   * @note Has no effect for WebGL browser contexts, there is no browser API for destroying contexts
    */
   destroy() {
   }
@@ -5116,13 +5279,13 @@ var _WebGLDevice = class extends import_core26.Device {
     return [this.gl.drawingBufferWidth, this.gl.drawingBufferHeight];
   }
   isTextureFormatSupported(format) {
-    return isTextureFormatSupported(this.gl, format);
+    return isTextureFormatSupported(this.gl, format, this._extensions);
   }
   isTextureFormatFilterable(format) {
-    return isTextureFormatFilterable(this.gl, format);
+    return isTextureFormatFilterable(this.gl, format, this._extensions);
   }
   isTextureFormatRenderable(format) {
-    return isTextureFormatRenderable(this.gl, format);
+    return isTextureFormatRenderable(this.gl, format, this._extensions);
   }
   // IMPLEMENTATION OF ABSTRACT DEVICE
   createCanvasContext(props) {
@@ -5147,12 +5310,18 @@ var _WebGLDevice = class extends import_core26.Device {
   createFramebuffer(props) {
     return new WEBGLFramebuffer(this, props);
   }
-  createRenderPipeline(props) {
-    return new WEBGLRenderPipeline(this, props);
-  }
   createVertexArray(props) {
     return new WEBGLVertexArray(this, props);
   }
+  createTransformFeedback(props) {
+    return new WEBGLTransformFeedback(this, props);
+  }
+  createQuerySet(props) {
+    return new WEBGLQuerySet(this, props);
+  }
+  createRenderPipeline(props) {
+    return new WEBGLRenderPipeline(this, props);
+  }
   beginRenderPass(props) {
     return new WEBGLRenderPass(this, props);
   }
@@ -5162,9 +5331,6 @@ var _WebGLDevice = class extends import_core26.Device {
   beginComputePass(props) {
     throw new Error("ComputePass not supported in WebGL");
   }
-  createTransformFeedback(props) {
-    return new WEBGLTransformFeedback(this, props);
-  }
   renderPass = null;
   getDefaultRenderPass() {
     this.renderPass = this.renderPass || this.beginRenderPass({
@@ -5187,7 +5353,7 @@ var _WebGLDevice = class extends import_core26.Device {
   }
   //
   // TEMPORARY HACKS - will be removed in v9.1
-  // 
+  //
   /** @deprecated - should use command encoder */
   readPixelsToArrayWebGL(source, options) {
     return readPixelsToArray(source, options);
@@ -5220,13 +5386,7 @@ var _WebGLDevice = class extends import_core26.Device {
   _extensions = {};
   _polyfilled = false;
   /** Instance of Spector.js (if initialized) */
-  spector;
-  _webglLimits;
-  /** Return WebGL specific limits */
-  get webglLimits() {
-    this._webglLimits = this._webglLimits || getWebGLLimits(this.gl);
-    return this._webglLimits;
-  }
+  spectorJS;
   /**
    * Triggers device (or WebGL context) loss.
    * @note primarily intended for testing how application reacts to device loss
@@ -5234,7 +5394,8 @@ var _WebGLDevice = class extends import_core26.Device {
   loseDevice() {
     var _a;
     let deviceLossTriggered = false;
-    const ext = this.gl.getExtension("WEBGL_lose_context");
+    const extensions = this.getExtension("WEBGL_lose_context");
+    const ext = extensions.WEBGL_lose_context;
     if (ext) {
       deviceLossTriggered = true;
       ext.loseContext();
@@ -5283,11 +5444,12 @@ var _WebGLDevice = class extends import_core26.Device {
    * so they need to be updated before every render
    * @todo - remember/cache values to avoid setting them unnecessarily?
    */
-  setConstantAttribute(location, constant) {
-    this._constants = this._constants || new Array(this.limits.maxVertexAttributes).fill(null);
+  setConstantAttributeWebGL(location, constant) {
+    const maxVertexAttributes = this.limits.maxVertexAttributes;
+    this._constants = this._constants || new Array(maxVertexAttributes).fill(null);
     const currentConstant = this._constants[location];
     if (currentConstant && compareConstantArrayValues2(currentConstant, constant)) {
-      import_core26.log.info(1, `setConstantAttribute(${location}) could have been skipped, value unchanged`)();
+      import_core29.log.info(1, `setConstantAttributeWebGL(${location}) could have been skipped, value unchanged`)();
     }
     this._constants[location] = constant;
     switch (constant.constructor) {
@@ -5301,9 +5463,14 @@ var _WebGLDevice = class extends import_core26.Device {
         setConstantUintArray(this, location, constant);
         break;
       default:
-        (0, import_core26.assert)(false);
+        (0, import_core29.assert)(false);
     }
   }
+  /** Ensure extensions are only requested once */
+  getExtension(name) {
+    getWebGLExtension(this.gl, name, this._extensions);
+    return this._extensions;
+  }
 };
 var WebGLDevice = _WebGLDevice;
 //
@@ -5331,7 +5498,7 @@ function setConstantFloatArray(device, location, array) {
       device.gl.vertexAttrib4fv(location, array);
       break;
     default:
-      (0, import_core26.assert)(false);
+      (0, import_core29.assert)(false);
   }
 }
 function setConstantIntArray(device, location, array) {