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

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export type { WebGLDeviceLimits } from "./adapter/device-helpers/webgl-device-limits.js";
+export { GL } from "./constants/webgl-constants.js";
+export type { GLTextureTarget, GLTextureCubeMapTarget, GLTexelDataFormat, GLPrimitiveTopology, GLPrimitive, GLDataType, GLPixelType, GLUniformType, GLSamplerType, GLFunction, GLBlendEquation, GLBlendFunction, GLStencilOp, GLSamplerParameters, GLValueParameters, GLPackParameters, GLUnpackParameters, GLFunctionParameters, GLParameters, GLLimits, GLExtensions, GLPolygonMode, GLProvokingVertex } from "./constants/webgl-types.js";
 export { webgl2Adapter } from "./adapter/webgl-adapter.js";
 export type { WebGLAdapter } from "./adapter/webgl-adapter.js";
 export { WebGLDevice } from "./adapter/webgl-device.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,YAAY,EAAC,iBAAiB,EAAC,wDAAqD;AAGpF,OAAO,EAAC,aAAa,EAAC,mCAAgC;AACtD,YAAY,EAAC,YAAY,EAAC,mCAAgC;AAG1D,OAAO,EAAC,WAAW,EAAC,kCAA+B;AACnD,OAAO,EAAC,kBAAkB,EAAC,0CAAuC;AAGlE,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAE/D,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,OAAO,EAAC,gBAAgB,EAAC,iDAA8C;AACvE,OAAO,EAAC,UAAU,EAAC,2CAAwC;AAE3D,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAE9E,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,OAAO,EAAC,eAAe,EAAC,iDAA8C;AAEtE,OAAO,EAAC,gBAAgB,EAAC,kDAA+C;AAGxE,OAAO,EAAC,sBAAsB,EAAC,wDAAqD;AAIpF,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,kDAA+C;AAGjG,OAAO,EAAC,uBAAuB,EAAC,yDAAsD;AACtF,OAAO,EAAC,iBAAiB,EAAC,uDAAoD;AAG9E,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,eAAe,EAChB,sDAAmD;AAEpD,OAAO,EAAC,gBAAgB,EAAC,mDAAgD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,YAAY,EAAC,iBAAiB,EAAC,wDAAqD;AACpF,OAAO,EAAC,EAAE,EAAC,uCAAoC;AAC/C,YAAY,EACV,eAAe,EACf,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,WAAW,EACX,UAAU,EACV,WAAW,EACX,aAAa,EACb,aAAa,EACb,UAAU,EACV,eAAe,EACf,eAAe,EACf,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,iBAAiB,EAClB,mCAAgC;AAGjC,OAAO,EAAC,aAAa,EAAC,mCAAgC;AACtD,YAAY,EAAC,YAAY,EAAC,mCAAgC;AAG1D,OAAO,EAAC,WAAW,EAAC,kCAA+B;AACnD,OAAO,EAAC,kBAAkB,EAAC,0CAAuC;AAGlE,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAE/D,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,OAAO,EAAC,gBAAgB,EAAC,iDAA8C;AACvE,OAAO,EAAC,UAAU,EAAC,2CAAwC;AAE3D,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAE9E,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,OAAO,EAAC,eAAe,EAAC,iDAA8C;AAEtE,OAAO,EAAC,gBAAgB,EAAC,kDAA+C;AAGxE,OAAO,EAAC,sBAAsB,EAAC,wDAAqD;AAIpF,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,kDAA+C;AAGjG,OAAO,EAAC,uBAAuB,EAAC,yDAAsD;AACtF,OAAO,EAAC,iBAAiB,EAAC,uDAAoD;AAG9E,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,eAAe,EAChB,sDAAmD;AAEpD,OAAO,EAAC,gBAAgB,EAAC,mDAAgD"}

package/dist/index.js

@@ -1,6 +1,7 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
+export { GL } from "./constants/webgl-constants.js";
 // WebGL adapter classes
 export { webgl2Adapter } from "./adapter/webgl-adapter.js";
 // WebGL Device classes

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAWpC,wBAAwB;AACxB,OAAO,EAAC,aAAa,EAAC,mCAAgC;AAGtD,uBAAuB;AACvB,OAAO,EAAC,WAAW,EAAC,kCAA+B;AACnD,OAAO,EAAC,kBAAkB,EAAC,0CAAuC;AAElE,yBAAyB;AACzB,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,mFAAmF;AACnF,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,OAAO,EAAC,gBAAgB,EAAC,iDAA8C;AACvE,OAAO,EAAC,UAAU,EAAC,2CAAwC;AAE3D,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,mFAAmF;AACnF,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,OAAO,EAAC,eAAe,EAAC,iDAA8C;AACtE,2EAA2E;AAC3E,OAAO,EAAC,gBAAgB,EAAC,kDAA+C;AAExE,wBAAwB;AACxB,OAAO,EAAC,sBAAsB,EAAC,wDAAqD;AAEpF,wBAAwB;AAExB,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,kDAA+C;AAEjG,yBAAyB;AACzB,OAAO,EAAC,uBAAuB,EAAC,yDAAsD;AACtF,OAAO,EAAC,iBAAiB,EAAC,uDAAoD;AAE9E,0BAA0B;AAC1B,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,eAAe,EAChB,sDAAmD;AAEpD,OAAO,EAAC,gBAAgB,EAAC,mDAAgD"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAUpC,OAAO,EAAC,EAAE,EAAC,uCAAoC;AA2B/C,wBAAwB;AACxB,OAAO,EAAC,aAAa,EAAC,mCAAgC;AAGtD,uBAAuB;AACvB,OAAO,EAAC,WAAW,EAAC,kCAA+B;AACnD,OAAO,EAAC,kBAAkB,EAAC,0CAAuC;AAElE,yBAAyB;AACzB,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,mFAAmF;AACnF,OAAO,EAAC,WAAW,EAAC,4CAAyC;AAC7D,OAAO,EAAC,YAAY,EAAC,6CAA0C;AAC/D,OAAO,EAAC,gBAAgB,EAAC,iDAA8C;AACvE,OAAO,EAAC,UAAU,EAAC,2CAAwC;AAE3D,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,mFAAmF;AACnF,OAAO,EAAC,mBAAmB,EAAC,qDAAkD;AAC9E,OAAO,EAAC,eAAe,EAAC,iDAA8C;AACtE,2EAA2E;AAC3E,OAAO,EAAC,gBAAgB,EAAC,kDAA+C;AAExE,wBAAwB;AACxB,OAAO,EAAC,sBAAsB,EAAC,wDAAqD;AAEpF,wBAAwB;AAExB,OAAO,EAAC,mBAAmB,EAAE,oBAAoB,EAAC,kDAA+C;AAEjG,yBAAyB;AACzB,OAAO,EAAC,uBAAuB,EAAC,yDAAsD;AACtF,OAAO,EAAC,iBAAiB,EAAC,uDAAoD;AAE9E,0BAA0B;AAC1B,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,eAAe,EAChB,sDAAmD;AAEpD,OAAO,EAAC,gBAAgB,EAAC,mDAAgD"}

package/dist/webgl-constants.d.ts

@@ -0,0 +1,2 @@
+export { GL } from "./constants/webgl-constants.js";
+//# sourceMappingURL=webgl-constants.d.ts.map

package/dist/webgl-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-constants.d.ts","sourceRoot":"","sources":["../src/webgl-constants.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,EAAE,EAAC,uCAAoC"}

package/dist/webgl-constants.js

@@ -0,0 +1,5 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export { GL } from "./constants/webgl-constants.js";
+//# sourceMappingURL=webgl-constants.js.map

package/dist/webgl-constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-constants.js","sourceRoot":"","sources":["../src/webgl-constants.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,OAAO,EAAC,EAAE,EAAC,uCAAoC"}

package/dist/webgl-types.d.ts

@@ -0,0 +1,2 @@
+export type { GLTextureTarget, GLTextureCubeMapTarget, GLTexelDataFormat, GLPrimitiveTopology, GLPrimitive, GLDataType, GLPixelType, GLUniformType, GLSamplerType, GLFunction, GLBlendEquation, GLBlendFunction, GLStencilOp, GLSamplerParameters, GLValueParameters, GLPackParameters, GLUnpackParameters, GLFunctionParameters, GLParameters, GLLimits, GLExtensions, GLPolygonMode, GLProvokingVertex } from "./constants/webgl-types.js";
+//# sourceMappingURL=webgl-types.d.ts.map

package/dist/webgl-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-types.d.ts","sourceRoot":"","sources":["../src/webgl-types.ts"],"names":[],"mappings":"AAIA,YAAY,EACV,eAAe,EACf,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,WAAW,EACX,UAAU,EACV,WAAW,EACX,aAAa,EACb,aAAa,EACb,UAAU,EACV,eAAe,EACf,eAAe,EACf,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,iBAAiB,EAClB,mCAAgC"}

package/dist/{types.js → webgl-types.js}

@@ -2,4 +2,4 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 export {};
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=webgl-types.js.map

package/dist/webgl-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-types.js","sourceRoot":"","sources":["../src/webgl-types.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/webgl",
-  "version": "9.3.0-alpha.4",
+  "version": "9.3.0-alpha.8",
   "description": "WebGL2 adapter for the luma.gl core API",
   "type": "module",
   "license": "MIT",
@@ -25,6 +25,21 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
+    },
+    "./constants": {
+      "types": "./dist/constants/index.d.ts",
+      "import": "./dist/constants/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./webgl-constants": {
+      "types": "./dist/webgl-constants.d.ts",
+      "import": "./dist/webgl-constants.js",
+      "require": "./dist/index.cjs"
+    },
+    "./webgl-types": {
+      "types": "./dist/webgl-types.d.ts",
+      "import": "./dist/webgl-types.js",
+      "require": "./dist/index.cjs"
     }
   },
   "files": [
@@ -40,12 +55,11 @@
     "prepublishOnly": "npm run build-minified-bundle && npm run build-dev-bundle"
   },
   "peerDependencies": {
-    "@luma.gl/core": "9.2.0-alpha.6"
+    "@luma.gl/core": "9.3.0-alpha.6"
   },
   "dependencies": {
-    "@luma.gl/constants": "9.3.0-alpha.4",
     "@math.gl/types": "^4.1.0",
     "@probe.gl/env": "^4.1.1"
   },
-  "gitHead": "7486e7b0377fb6ab961b4499828681bede60f3b1"
+  "gitHead": "371f0979c1cd01563badc36118f314365a66e1a1"
 }

package/src/adapter/converters/device-parameters.ts

@@ -4,7 +4,7 @@
 
 import type {CompareFunction, StencilOperation, BlendOperation, BlendFactor} from '@luma.gl/core';
 import {Device, log, Parameters, PolygonMode, ProvokingVertex} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
+import {GL} from '@luma.gl/webgl/constants';
 import type {
   GLBlendEquation,
   GLBlendFunction,
@@ -13,7 +13,7 @@ import type {
   GLPolygonMode,
   GLProvokingVertex,
   GLStencilOp
-} from '@luma.gl/constants';
+} from '@luma.gl/webgl/constants';
 import {setGLParameters} from '../../context/parameters/unified-parameter-api';
 import {WebGLDevice} from '../webgl-device';
 
@@ -232,6 +232,10 @@ export function setDeviceParameters(device: Device, parameters: Parameters) {
     gl.depthFunc(convertCompareFunction('depthCompare', parameters.depthCompare));
   }
 
+  if (parameters.clearDepth !== undefined) {
+    gl.clearDepth(parameters.clearDepth);
+  }
+
   if (parameters.stencilWriteMask) {
     const mask = parameters.stencilWriteMask;
     gl.stencilMaskSeparate(GL.FRONT, mask);

package/src/adapter/converters/sampler-parameters.ts

@@ -4,7 +4,7 @@
 
 // SAMPLER FILTERS
 import {SamplerProps} from '@luma.gl/core';
-import {GL, GLSamplerParameters} from '@luma.gl/constants';
+import {GL, GLSamplerParameters} from '@luma.gl/webgl/constants';
 import {convertCompareFunction} from './device-parameters';
 
 /**

package/src/adapter/converters/shader-formats.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GL, GLDataType, GLPixelType} from '@luma.gl/constants';
+import {GL, GLDataType, GLPixelType} from '@luma.gl/webgl/constants';
 import {SignedDataType} from '@luma.gl/core';
 
 /** Get shadertypes data type from GL constants */
@@ -28,68 +28,3 @@ const GL_DATA_TYPE_MAP: Record<GLDataType | GLPixelType, SignedDataType> = {
   [GL.UNSIGNED_INT_24_8]: 'uint32',
   [GL.FLOAT_32_UNSIGNED_INT_24_8_REV]: 'uint32'
 };
-
-/** Get shader data type from GL constants *
-export function getPrimitiveTypeFromGL(type: GL): PrimitiveDataType {
-  switch (type) {
-    case GL.INT:
-      return 'i32';
-    case GL.UNSIGNED_INT:
-      return 'u32';
-    case GL.SHORT:
-      return 'i32';
-    case GL.UNSIGNED_SHORT:
-      return 'u32';
-    case GL.BYTE:
-      return 'i32';
-    case GL.UNSIGNED_BYTE:
-      return 'u32';
-    case GL.FLOAT:
-      return 'f32';
-    case GL.HALF_FLOAT:
-      return 'f16';
-    default:
-      throw new Error(String(type));
-  }
-}
-
-/** Get shader attribute type from GL constants *
-export function getShaderAttributeTypeFromGL(
-  type: GL,
-  components: 1 | 2 | 3 | 4
-): AttributeShaderType {
-  const dataType = getPrimitiveTypeFromGL(type);
-  switch (components) {
-    case 1:
-      return dataType;
-    case 2:
-      return `vec2<${dataType}>`;
-    case 3:
-      return `vec2<${dataType}>`;
-    case 4:
-      return `vec2<${dataType}>`;
-    default:
-      throw new Error(String(components));
-  }
-}
-*/
-
-/** GetGL constant from shader data type
-export function getGLFromShaderDataType(
-  type: PrimitiveDataType
-): GL.INT | GL.UNSIGNED_INT | GL.FLOAT | GL.HALF_FLOAT {
-  switch (type) {
-    // TODO
-    case 'i32':
-      return GL.INT;
-    case 'u32':
-      return GL.UNSIGNED_INT;
-    case 'f32':
-      return GL.FLOAT;
-    case 'f16':
-      return GL.HALF_FLOAT;
-    default:
-      throw new Error(String(type));
-  }
-}
-*/

package/src/adapter/converters/webgl-shadertypes.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import {VariableShaderType, SignedDataType, VertexFormat, NormalizedDataType} from '@luma.gl/core';
-import {GL, GLUniformType, GLSamplerType, GLDataType} from '@luma.gl/constants';
+import {GL, GLUniformType, GLSamplerType, GLDataType} from '@luma.gl/webgl/constants';
 
 export type TextureBindingInfo = {
   viewDimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
@@ -15,14 +15,6 @@ export function convertDataTypeToGLDataType(normalizedType: NormalizedDataType):
   return NORMALIZED_SHADER_TYPE_TO_WEBGL[normalizedType];
 }
 
-/** Converts to a luma shadertype to a GL data type (GL.BYTE, GL.FLOAT32 etc)  */
-export function convertShaderVariableTypeToGLDataType(
-  normalizedType: VariableShaderType
-): GLDataType {
-  // @ts-ignore TODO
-  return NORMALIZED_SHADER_TYPE_TO_WEBGL[normalizedType];
-}
-
 /** Convert a WebGL "compisite type (e.g. GL.VEC3) into the corresponding luma shader uniform type */
 export function convertGLUniformTypeToShaderVariableType(
   glUniformType: GLUniformType

package/src/adapter/converters/webgl-texture-table.ts

@@ -9,7 +9,7 @@ import type {
   DeviceTextureFormatCapabilities
 } from '@luma.gl/core';
 import {textureFormatDecoder} from '@luma.gl/core';
-import {GL, GLPixelType, GLExtensions, GLTexelDataFormat} from '@luma.gl/constants';
+import {GL, GLPixelType, GLExtensions, GLTexelDataFormat} from '@luma.gl/webgl/constants';
 import {getWebGLExtension} from '../../context/helpers/webgl-extensions';
 import {getGLFromVertexType} from './webgl-vertex-formats';
 
@@ -32,32 +32,44 @@ const X_ATC = 'WEBGL_compressed_texture_atc';
 const EXT_texture_norm16 = 'EXT_texture_norm16';
 const EXT_render_snorm = 'EXT_render_snorm';
 const EXT_color_buffer_float = 'EXT_color_buffer_float';
+const SNORM8_COLOR_RENDERABLE: DeviceFeature = 'snorm8-renderable-webgl';
+const NORM16_COLOR_RENDERABLE: DeviceFeature = 'norm16-renderable-webgl';
+const SNORM16_COLOR_RENDERABLE: DeviceFeature = 'snorm16-renderable-webgl';
+const FLOAT16_COLOR_RENDERABLE: DeviceFeature = 'float16-renderable-webgl';
+const FLOAT32_COLOR_RENDERABLE: DeviceFeature = 'float32-renderable-webgl';
+const RGB9E5UFLOAT_COLOR_RENDERABLE: DeviceFeature = 'rgb9e5ufloat-renderable-webgl';
+
+type TextureFeatureDefinition = {
+  extensions?: string[];
+  features?: DeviceFeature[];
+};
 
 // prettier-ignore
-export const TEXTURE_FEATURES: Partial<Record<DeviceFeature, string[]>> = {
-  'float32-renderable-webgl': ['EXT_color_buffer_float'],
-  'float16-renderable-webgl': ['EXT_color_buffer_half_float'],
-  '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],
+export const TEXTURE_FEATURES: Partial<Record<DeviceFeature, TextureFeatureDefinition>> = {
+  'float32-renderable-webgl': {extensions: [EXT_color_buffer_float]},
+  'float16-renderable-webgl': {extensions: ['EXT_color_buffer_half_float']},
+  'rgb9e5ufloat-renderable-webgl': {extensions: ['WEBGL_render_shared_exponent']},
+  'snorm8-renderable-webgl': {extensions: [EXT_render_snorm]},
+  'norm16-webgl': {extensions: [EXT_texture_norm16]},
+  'norm16-renderable-webgl': {features: ['norm16-webgl']},
+  'snorm16-renderable-webgl': {features: ['norm16-webgl'], extensions: [EXT_render_snorm]},
+
+  'float32-filterable': {extensions: ['OES_texture_float_linear']},
+  'float16-filterable-webgl': {extensions: ['OES_texture_half_float_linear']},
+  'texture-filterable-anisotropic-webgl': {extensions: ['EXT_texture_filter_anisotropic']},
+
+  'texture-blend-float-webgl': {extensions: ['EXT_float_blend']},
+
+  'texture-compression-bc': {extensions: [X_S3TC, X_S3TC_SRGB, X_RGTC, X_BPTC]},
   // 'texture-compression-bc3-srgb-webgl': [X_S3TC_SRGB],
   // 'texture-compression-bc3-webgl': [X_S3TC],
-  'texture-compression-bc5-webgl': [X_RGTC],
-  'texture-compression-bc7-webgl': [X_BPTC],
-  'texture-compression-etc2': [X_ETC2],
-  'texture-compression-astc': [X_ASTC],
-  'texture-compression-etc1-webgl': [X_ETC1],
-  'texture-compression-pvrtc-webgl': [X_PVRTC],
-  'texture-compression-atc-webgl': [X_ATC]
+  'texture-compression-bc5-webgl': {extensions: [X_RGTC]},
+  'texture-compression-bc7-webgl': {extensions: [X_BPTC]},
+  'texture-compression-etc2': {extensions: [X_ETC2]},
+  'texture-compression-astc': {extensions: [X_ASTC]},
+  'texture-compression-etc1-webgl': {extensions: [X_ETC1]},
+  'texture-compression-pvrtc-webgl': {extensions: [X_PVRTC]},
+  'texture-compression-atc-webgl': {extensions: [X_ATC]}
 };
 
 export function isTextureFeature(feature: DeviceFeature): boolean {
@@ -70,8 +82,36 @@ export function checkTextureFeature(
   feature: DeviceFeature,
   extensions: GLExtensions
 ): boolean {
-  const textureExtensions = TEXTURE_FEATURES[feature] || [];
-  return textureExtensions.every(extension => getWebGLExtension(gl, extension, extensions));
+  return hasTextureFeature(gl, feature, extensions, new Set<DeviceFeature>());
+}
+
+function hasTextureFeature(
+  gl: WebGL2RenderingContext,
+  feature: DeviceFeature,
+  extensions: GLExtensions,
+  seenFeatures: Set<DeviceFeature>
+): boolean {
+  const definition = TEXTURE_FEATURES[feature];
+  if (!definition) {
+    return false;
+  }
+
+  if (seenFeatures.has(feature)) {
+    return false;
+  }
+
+  seenFeatures.add(feature);
+  const hasDependentFeatures = (definition.features || []).every(dependentFeature =>
+    hasTextureFeature(gl, dependentFeature, extensions, seenFeatures)
+  );
+  seenFeatures.delete(feature);
+  if (!hasDependentFeatures) {
+    return false;
+  }
+
+  return (definition.extensions || []).every(extension =>
+    Boolean(getWebGLExtension(gl, extension, extensions))
+  );
 }
 
 // TEXTURE FORMATS
@@ -81,6 +121,8 @@ type WebGLFormatInfo = {
   gl?: GL;
   /** compressed */
   x?: string;
+  /** color-renderable capability gate. false means never color-renderable on WebGL. */
+  r?: DeviceFeature | false;
   types?: GLPixelType[];
   dataFormat?: GLTexelDataFormat;
   /** if depthTexture is set this is a depth/stencil format that can be set to a texture  */
@@ -99,21 +141,21 @@ type WebGLFormatInfo = {
 export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
   // 8-bit formats
   'r8unorm': {gl: GL.R8, rb: true},
-  'r8snorm': {gl: GL.R8_SNORM},
+  'r8snorm': {gl: GL.R8_SNORM, r: SNORM8_COLOR_RENDERABLE},
   'r8uint': {gl: GL.R8UI, rb: true},
   'r8sint': {gl: GL.R8I, rb: true},
 
   // 16-bit formats
   'rg8unorm': {gl: GL.RG8, rb: true},
-  'rg8snorm': {gl: GL.RG8_SNORM},
+  'rg8snorm': {gl: GL.RG8_SNORM, r: SNORM8_COLOR_RENDERABLE},
   'rg8uint': {gl: GL.RG8UI, rb: true},
   'rg8sint': {gl: GL.RG8I, rb: true},
 
   'r16uint': {gl: GL.R16UI, rb: true},
   'r16sint': {gl: GL.R16I, rb: true},
-  'r16float': {gl: GL.R16F, rb: true},
-  'r16unorm': {gl: GL.R16_EXT, rb: true},
-  'r16snorm': {gl: GL.R16_SNORM_EXT},
+  'r16float': {gl: GL.R16F, rb: true, r: FLOAT16_COLOR_RENDERABLE},
+  'r16unorm': {gl: GL.R16_EXT, rb: true, r: NORM16_COLOR_RENDERABLE},
+  'r16snorm': {gl: GL.R16_SNORM_EXT, r: SNORM16_COLOR_RENDERABLE},
 
   // Packed 16-bit formats
   'rgba4unorm-webgl': {gl: GL.RGBA4, rb: true},
@@ -127,7 +169,7 @@ export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
   // 32-bit formats
   'rgba8unorm': {gl: GL.RGBA8},
   'rgba8unorm-srgb': {gl: GL.SRGB8_ALPHA8},
-  'rgba8snorm': {gl: GL.RGBA8_SNORM},
+  'rgba8snorm': {gl: GL.RGBA8_SNORM, r: SNORM8_COLOR_RENDERABLE},
   'rgba8uint': {gl: GL.RGBA8UI},
   'rgba8sint': {gl: GL.RGBA8I},
   // reverse colors, webgpu only
@@ -136,41 +178,41 @@ export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
 
   'rg16uint': {gl: GL.RG16UI},
   'rg16sint': {gl: GL.RG16I},
-  'rg16float': {gl: GL.RG16F, rb: true},
-  'rg16unorm': {gl: GL.RG16_EXT},
-  'rg16snorm': {gl: GL.RG16_SNORM_EXT},
+  'rg16float': {gl: GL.RG16F, rb: true, r: FLOAT16_COLOR_RENDERABLE},
+  'rg16unorm': {gl: GL.RG16_EXT, r: NORM16_COLOR_RENDERABLE},
+  'rg16snorm': {gl: GL.RG16_SNORM_EXT, r: SNORM16_COLOR_RENDERABLE},
 
   'r32uint': {gl: GL.R32UI, rb: true},
   'r32sint': {gl: GL.R32I, rb: true},
-  'r32float': {gl: GL.R32F},
+  'r32float': {gl: GL.R32F, r: FLOAT32_COLOR_RENDERABLE},
 
   // Packed 32-bit formats
-  'rgb9e5ufloat': {gl: GL.RGB9_E5}, // , filter: true},
+  'rgb9e5ufloat': {gl: GL.RGB9_E5, r: RGB9E5UFLOAT_COLOR_RENDERABLE}, // , filter: true},
   'rg11b10ufloat': {gl: GL.R11F_G11F_B10F, rb: true},
   'rgb10a2unorm': {gl: GL.RGB10_A2, rb: true},
   'rgb10a2uint': {gl: GL.RGB10_A2UI, rb: true},
 
   // 48-bit formats
-  'rgb16unorm-webgl': {gl: GL.RGB16_EXT}, // rgb not renderable
-  'rgb16snorm-webgl': {gl: GL.RGB16_SNORM_EXT}, // rgb not renderable
+  'rgb16unorm-webgl': {gl: GL.RGB16_EXT, r: false}, // rgb not renderable
+  'rgb16snorm-webgl': {gl: GL.RGB16_SNORM_EXT, r: false}, // rgb not renderable
 
   // 64-bit formats
   'rg32uint': {gl: GL.RG32UI, rb: true},
   'rg32sint': {gl: GL.RG32I, rb: true},
-  'rg32float': {gl: GL.RG32F, rb: true},
+  'rg32float': {gl: GL.RG32F, rb: true, r: FLOAT32_COLOR_RENDERABLE},
   'rgba16uint': {gl: GL.RGBA16UI, rb: true},
   'rgba16sint': {gl: GL.RGBA16I, rb: true},
-  'rgba16float': {gl: GL.RGBA16F},
-  'rgba16unorm': {gl: GL.RGBA16_EXT, rb: true},
-  'rgba16snorm': {gl: GL.RGBA16_SNORM_EXT},
+  'rgba16float': {gl: GL.RGBA16F, r: FLOAT16_COLOR_RENDERABLE},
+  'rgba16unorm': {gl: GL.RGBA16_EXT, rb: true, r: NORM16_COLOR_RENDERABLE},
+  'rgba16snorm': {gl: GL.RGBA16_SNORM_EXT, r: SNORM16_COLOR_RENDERABLE},
 
   // 96-bit formats (deprecated!)
-  'rgb32float-webgl': {gl: GL.RGB32F, x: EXT_color_buffer_float, dataFormat: GL.RGB, types: [GL.FLOAT]},
+  'rgb32float-webgl': {gl: GL.RGB32F, x: EXT_color_buffer_float, r: FLOAT32_COLOR_RENDERABLE, dataFormat: GL.RGB, types: [GL.FLOAT]},
 
   // 128-bit formats
   'rgba32uint': {gl: GL.RGBA32UI, rb: true},
   'rgba32sint': {gl: GL.RGBA32I, rb: true},
-  'rgba32float': {gl: GL.RGBA32F, rb: true},
+  'rgba32float': {gl: GL.RGBA32F, rb: true, r: FLOAT32_COLOR_RENDERABLE},
 
   // Depth and stencil formats
   'stencil8': {gl: GL.STENCIL_INDEX8, rb: true}, // 8 stencil bits
@@ -237,8 +279,8 @@ export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
   'astc-8x6-unorm-srgb': {gl: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR},
   'astc-8x8-unorm': {gl: GL.COMPRESSED_RGBA_ASTC_8x8_KHR},
   'astc-8x8-unorm-srgb': {gl: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR},
-  'astc-10x5-unorm': {gl: GL.COMPRESSED_RGBA_ASTC_10x10_KHR},
-  'astc-10x5-unorm-srgb': {gl: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR},
+  'astc-10x5-unorm': {gl: GL.COMPRESSED_RGBA_ASTC_10x5_KHR},
+  'astc-10x5-unorm-srgb': {gl: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR},
   'astc-10x6-unorm': {gl: GL.COMPRESSED_RGBA_ASTC_10x6_KHR},
   'astc-10x6-unorm-srgb': {gl: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR},
   'astc-10x8-unorm': {gl: GL.COMPRESSED_RGBA_ASTC_10x8_KHR},
@@ -254,7 +296,7 @@ export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
 
   'pvrtc-rgb4unorm-webgl': {gl: GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG},
   'pvrtc-rgba4unorm-webgl': {gl: GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG},
-  'pvrtc-rbg2unorm-webgl': {gl: GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG},
+  'pvrtc-rgb2unorm-webgl': {gl: GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG},
   'pvrtc-rgba2unorm-webgl': {gl: GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG},
 
   // WEBGL_compressed_texture_etc1
@@ -270,26 +312,6 @@ export const WEBGL_TEXTURE_FORMATS: Record<TextureFormat, WebGLFormatInfo> = {
 
 // FUNCTIONS
 
-/** Checks if a texture format is supported */
-export function isWebGLTextureFormatCapabilitiesed(
-  gl: WebGL2RenderingContext,
-  format: TextureFormat,
-  extensions: GLExtensions
-): boolean {
-  const webglTextureInfo = WEBGL_TEXTURE_FORMATS[format];
-  // Check that we have a GL constant
-  if (!webglTextureInfo?.gl) {
-    return false;
-  }
-
-  // Check extensions
-  const extension = webglTextureInfo.x;
-  if (extension) {
-    return Boolean(getWebGLExtension(gl, extension, extensions));
-  }
-  return true;
-}
-
 /** Checks if a texture format is supported, renderable, filterable etc */
 export function getTextureFormatCapabilitiesWebGL(
   gl: WebGL2RenderingContext,
@@ -308,12 +330,29 @@ export function getTextureFormatCapabilitiesWebGL(
     supported = supported && Boolean(getWebGLExtension(gl, webglFormatInfo.x, extensions));
   }
 
+  // WebGL2 exposes STENCIL_INDEX8 for renderbuffers, but standalone stencil textures are not
+  // valid texture storage targets. Report them as unsupported texture formats to avoid invalid
+  // constructor paths and misleading capability checks.
+  if (formatSupport.format === 'stencil8') {
+    supported = false;
+  }
+
+  const renderFeatureSupported =
+    webglFormatInfo?.r === false
+      ? false
+      : webglFormatInfo?.r === undefined || checkTextureFeature(gl, webglFormatInfo.r, extensions);
+  const renderable =
+    supported &&
+    formatSupport.render &&
+    renderFeatureSupported &&
+    isColorRenderableTextureFormat(gl, formatSupport.format, extensions);
+
   return {
     format: formatSupport.format,
     // @ts-ignore
     create: supported && formatSupport.create,
     // @ts-ignore
-    render: supported && formatSupport.render,
+    render: renderable,
     // @ts-ignore
     filter: supported && formatSupport.filter,
     // @ts-ignore
@@ -323,6 +362,59 @@ export function getTextureFormatCapabilitiesWebGL(
   };
 }
 
+function isColorRenderableTextureFormat(
+  gl: WebGL2RenderingContext,
+  format: TextureFormat,
+  extensions: GLExtensions
+): boolean {
+  const webglFormatInfo = WEBGL_TEXTURE_FORMATS[format];
+  const internalFormat = webglFormatInfo?.gl;
+  if (internalFormat === undefined) {
+    return false;
+  }
+
+  if (webglFormatInfo?.x && !getWebGLExtension(gl, webglFormatInfo.x, extensions)) {
+    return false;
+  }
+
+  const previousTexture = gl.getParameter(GL.TEXTURE_BINDING_2D) as WebGLTexture | null;
+  const previousFramebuffer = gl.getParameter(GL.FRAMEBUFFER_BINDING) as WebGLFramebuffer | null;
+  const texture = gl.createTexture();
+  const framebuffer = gl.createFramebuffer();
+  if (!texture || !framebuffer) {
+    return false;
+  }
+
+  // Isolate the probe from any prior driver errors so the result reflects only this format.
+  const noError = Number(GL.NO_ERROR);
+  let error = Number(gl.getError());
+  while (error !== noError) {
+    error = gl.getError();
+  }
+
+  let renderable = false;
+  try {
+    gl.bindTexture(GL.TEXTURE_2D, texture);
+    gl.texStorage2D(GL.TEXTURE_2D, 1, internalFormat, 1, 1);
+    if (Number(gl.getError()) !== noError) {
+      return false;
+    }
+
+    gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer);
+    gl.framebufferTexture2D(GL.FRAMEBUFFER, GL.COLOR_ATTACHMENT0, GL.TEXTURE_2D, texture, 0);
+    renderable =
+      Number(gl.checkFramebufferStatus(GL.FRAMEBUFFER)) === Number(GL.FRAMEBUFFER_COMPLETE) &&
+      Number(gl.getError()) === noError;
+  } finally {
+    gl.bindFramebuffer(GL.FRAMEBUFFER, previousFramebuffer);
+    gl.deleteFramebuffer(framebuffer);
+    gl.bindTexture(GL.TEXTURE_2D, previousTexture);
+    gl.deleteTexture(texture);
+  }
+
+  return renderable;
+}
+
 /** Get parameters necessary to work with format in WebGL: internalFormat, dataFormat, type, compressed, */
 export function getTextureFormatWebGL(format: TextureFormat): {
   internalFormat: GL;

package/src/adapter/converters/webgl-vertex-formats.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {GL} from '@luma.gl/constants';
+import {GL} from '@luma.gl/webgl/constants';
 import {VertexFormat, NormalizedDataType} from '@luma.gl/core';
 
 type GLDataType =

package/src/adapter/device-helpers/webgl-device-features.ts

@@ -6,7 +6,7 @@
 // Provides a function that enables simple checking of which WebGL features are
 
 import {DeviceFeature, DeviceFeatures} from '@luma.gl/core';
-import {GLExtensions} from '@luma.gl/constants';
+import {GLExtensions} from '@luma.gl/webgl/constants';
 import {getWebGLExtension} from '../../context/helpers/webgl-extensions';
 import {
   isTextureFeature,
@@ -21,13 +21,12 @@ import {
 const WEBGL_FEATURES: Partial<Record<DeviceFeature, boolean | string>> = {
   // optional WebGPU features
   'depth-clip-control': 'EXT_depth_clamp', // TODO these seem subtly different
-  // 'timestamp-query' // GPUQueryType "timestamp-query"
+  'timestamp-query': 'EXT_disjoint_timer_query_webgl2',
   // "indirect-first-instance"
   // Textures are handled by getTextureFeatures()
   // 'depth32float-stencil8' // GPUTextureFormat 'depth32float-stencil8'
 
   // optional WebGL features
-  'timer-query-webgl': 'EXT_disjoint_timer_query_webgl2',
   'compilation-status-async-webgl': 'KHR_parallel_shader_compile',
   'polygon-mode-webgl': 'WEBGL_polygon_mode',
   'provoking-vertex-webgl': 'WEBGL_provoking_vertex',