@luma.gl/webgl 9.0.0-alpha.9 → 9.0.0-beta.1

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

@@ -1,22 +1,83 @@
-import GL from '@luma.gl/constants';
-import {VertexFormat} from '@luma.gl/api';
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
 
-export function getVertexFormat(type: GL, components: number): VertexFormat {
-  const base = getDataFormat(type);
+import {GL} from '@luma.gl/constants';
+import {VertexFormat, VertexType} from '@luma.gl/core';
+
+type GLDataType = 
+  | GL.UNSIGNED_BYTE
+  | GL.BYTE
+  | GL.UNSIGNED_SHORT
+  | GL.SHORT
+  | GL.UNSIGNED_INT
+  | GL.INT
+  | GL.HALF_FLOAT
+  | GL.FLOAT;
+
+
+/** Get vertex format from GL constants */
+export function getVertexFormatFromGL(type: GLDataType, components: 1 | 2 | 3 | 4): VertexFormat {
+  const base = getVertexTypeFromGL(type);
+  // prettier-ignore
   switch (components) {
+    // @ts-expect-error TODO deal with lack of formats
     case 1: return base;
     case 2: return `${base}x2`;
+    // @ts-expect-error TODO deal with lack of formats
     case 3: return `${base}x3`;
     case 4: return `${base}x4`;
   }
+  // @ts-ignore unreachable
+  throw new Error(String(components));
 }
 
-function getDataFormat(type: GL): 'sint32' | 'uint32' | 'float32' {
+/** Get data type from GL constants */
+export function getVertexTypeFromGL(type: GLDataType, normalized = false): VertexType {
+  // prettier-ignore
   switch (type) {
-    // TODO
-    case GL.INT: return 'sint32';
-    case GL.UNSIGNED_INT: return 'uint32';
+    // WebGPU does not support normalized 32 bit integer attributes
+    case GL.INT: return normalized ? 'sint32' : 'sint32';
+    case GL.UNSIGNED_INT: return normalized ? 'uint32' : 'uint32';
+    case GL.SHORT: return normalized ? 'sint16' : 'unorm16';
+    case GL.UNSIGNED_SHORT: return normalized ? 'uint16' : 'unorm16';
+    case GL.BYTE: return normalized ? 'sint8' : 'snorm16';
+    case GL.UNSIGNED_BYTE: return normalized ? 'uint8' : 'unorm8';
     case GL.FLOAT: return 'float32';
-    default: throw new Error(String(type));
+    case GL.HALF_FLOAT: return 'float16';
   }
-}
+  // @ts-ignore unreachable
+  throw new Error(String(type));
+}
+
+export function getGLFromVertexType(
+  dataType: VertexType
+):
+  | GL.UNSIGNED_BYTE
+  | GL.BYTE
+  | GL.UNSIGNED_SHORT
+  | GL.SHORT
+  | GL.UNSIGNED_INT
+  | GL.INT
+  | GL.HALF_FLOAT
+  | GL.FLOAT {
+  // prettier-ignore
+  switch (dataType) {
+    case 'uint8': return GL.UNSIGNED_BYTE;
+    case 'sint8': return GL.BYTE;
+    case 'unorm8': return GL.UNSIGNED_BYTE;
+    case 'snorm8': return GL.BYTE;
+    case 'uint16': return GL.UNSIGNED_SHORT;
+    case 'sint16': return GL.SHORT;
+    case 'unorm16': return GL.UNSIGNED_SHORT;
+    case 'snorm16': return GL.SHORT;
+    case 'uint32': return GL.UNSIGNED_INT;
+    case 'sint32': return GL.INT;
+    // WebGPU does not support normalized 32 bit integer attributes
+    // case 'unorm32': return GL.UNSIGNED_INT;
+    // case 'snorm32': return GL.INT;
+    case 'float16': return GL.HALF_FLOAT;
+    case 'float32': return GL.FLOAT;
+  }
+  // @ts-ignore unreachable
+  throw new Error(String(dataType));
+}

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

@@ -1,9 +1,11 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 // Feature detection for WebGL
 // Provides a function that enables simple checking of which WebGL features are
 // available in an WebGL1 or WebGL2 environment.
 
-import {DeviceFeature} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+import {DeviceFeature} from '@luma.gl/core';
 import {isWebGL2} from '../../context/context/webgl-checks';
 import {isOldIE} from './is-old-ie';
 import {getTextureFeatures, _checkFloat32ColorAttachment} from '../converters/texture-formats';
@@ -124,6 +126,7 @@ const WEBGL_FEATURES: Partial<Record<DeviceFeature, [boolean | string, boolean |
   'webgl2': [false, true],
 
   'timer-query-webgl': ['EXT_disjoint_timer_query', 'EXT_disjoint_timer_query_webgl2'],
+  'transform-feedback-webgl2': [false, true],
 
   // WEBGL1 SUPPORT
   'vertex-array-object-webgl1': ['OES_vertex_array_object', true],

package/src/adapter/device-helpers/device-limits.ts

@@ -1,6 +1,8 @@
 // luma.gl, MIT license
-import type {DeviceLimits} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+// Copyright (c) vis.gl contributors
+
+import type {DeviceLimits} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
 import {getWebGL2Context} from '../../context/context/webgl-checks';
 
 /** Populate a WebGPU style device limits */

package/src/adapter/device-helpers/get-device-info.ts

@@ -1,49 +1,103 @@
-import {DeviceInfo} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import {DeviceInfo} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
 import {isWebGL2} from '../../context/context/webgl-checks';
 
 /** @returns strings identifying the GPU vendor and driver. */
 export function getDeviceInfo(gl: WebGLRenderingContext): DeviceInfo {
+  // "Masked" info is always available, but don't contain much useful information
   const vendorMasked = gl.getParameter(GL.VENDOR);
   const rendererMasked = gl.getParameter(GL.RENDERER);
-  // Get unmasked strings if available
+
+  // If we are lucky, unmasked info is available
   // https://www.khronos.org/registry/webgl/extensions/WEBGL_debug_renderer_info/
   const ext = gl.getExtension('WEBGL_debug_renderer_info');
   const vendorUnmasked = gl.getParameter(ext ? ext.UNMASKED_VENDOR_WEBGL : GL.VENDOR);
   const rendererUnmasked = gl.getParameter(ext ? ext.UNMASKED_RENDERER_WEBGL : GL.RENDERER);
   const vendor = vendorUnmasked || vendorMasked;
   const renderer = rendererUnmasked || rendererMasked;
+
+  // Driver version
+  const version = gl.getParameter(GL.VERSION) as string;
+
+  // "Sniff" the GPU type and backend from the info. This works best if unmasked info is available.
   const gpu = identifyGPUVendor(vendor, renderer);
+  const gpuBackend = identifyGPUBackend(vendor, renderer);
+  const gpuType = identifyGPUType(vendor, renderer);
+
+  // Determine GLSL version
+  // For now, skip parsing of the long version string, just use context type below to deduce version
+  // const version = gl.getParameter(GL.SHADING_LANGUAGE_VERSION) as string;
+  // const shadingLanguageVersion = parseGLSLVersion(version);
+  const shadingLanguage = 'glsl';
+  const shadingLanguageVersion = isWebGL2(gl) ? 300 : 100
+
   return {
     type: isWebGL2(gl) ? 'webgl2' : 'webgl',
     gpu,
-    vendor: vendorUnmasked || vendorMasked,
-    renderer: rendererUnmasked || rendererMasked,
-    version: gl.getParameter(GL.VERSION),
-    shadingLanguages: ['glsl'],
-    shadingLanguageVersions: {
-      'glsl': gl.getParameter(GL.SHADING_LANGUAGE_VERSION) as string
-    }
+    gpuType,
+    gpuBackend,
+    vendor,
+    renderer,
+    version,
+    shadingLanguage,
+    shadingLanguageVersion
   };
 }
 
-function identifyGPUVendor(vendor: string, renderer: string): 'nvidia' | 'intel' | 'apple' | 'amd' | 'unknown' {
-  if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) {
+/** "Sniff" the GPU type from the info. This works best if unmasked info is available. */
+function identifyGPUVendor(vendor: string, renderer: string): 'nvidia' | 'intel' | 'apple' | 'amd' | 'software' | 'unknown' {
+  if ((/NVIDIA/i.exec(vendor)) || (/NVIDIA/i.exec(renderer))) {
     return 'nvidia';
   }
-  if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) {
+  if ((/INTEL/i.exec(vendor)) || (/INTEL/i.exec(renderer))) {
     return 'intel';
   }
-  if (vendor.match(/Apple/i) || renderer.match(/Apple/i)) {
+  if ((/Apple/i.exec(vendor)) || (/Apple/i.exec(renderer))) {
     return 'apple';
   }
   if (
-    vendor.match(/AMD/i) ||
-    renderer.match(/AMD/i) ||
-    vendor.match(/ATI/i) ||
-    renderer.match(/ATI/i)
+    (/AMD/i.exec(vendor)) ||
+    (/AMD/i.exec(renderer)) ||
+    (/ATI/i.exec(vendor)) ||
+    (/ATI/i.exec(renderer))
   ) {
     return 'amd';
   }
+  if ((/SwiftShader/i.exec(vendor)) || (/SwiftShader/i.exec(renderer))) {
+    return 'software';
+  }
+  
+  return 'unknown';
+}
+
+/** "Sniff" the GPU backend from the info. This works best if unmasked info is available. */
+function identifyGPUBackend(vendor: string, renderer: string): 'opengl' | 'metal' | 'unknown' {
+  if ((/Metal/i.exec(vendor)) || (/Metal/i.exec(renderer))) {
+    return 'metal';
+  }
+  if ((/ANGLE/i.exec(vendor)) || (/ANGLE/i.exec(renderer))) {
+    return 'opengl';
+  }  
   return 'unknown';
 }
+
+function identifyGPUType(vendor: string, renderer: string): 'discrete' | 'integrated' | 'cpu' | 'unknown' {
+  if ((/SwiftShader/i.exec(vendor)) || (/SwiftShader/i.exec(renderer))) {
+    return 'cpu';
+  }
+
+  const gpuVendor = identifyGPUVendor(vendor, renderer);
+  switch (gpuVendor) {
+    case 'intel':
+      return 'integrated';
+    case 'software':
+      return 'cpu';
+    case 'unknown':
+      return 'unknown';
+    default:
+      return 'discrete';
+  }
+}

package/src/adapter/device-helpers/is-old-ie.ts

@@ -1,3 +1,6 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
 // opts allows user agent to be overridden for testing
 export function isOldIE(opts = {}) {
   const navigator = typeof window !== 'undefined' ? window.navigator || {} : {};

package/src/adapter/helpers/{uniforms.ts → decode-webgl-types.ts}

@@ -1,6 +1,8 @@
-import {UniformFormat, VertexFormat} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import {GLUniformType, GLSamplerType, GLCompositeType, GLType} from '../../types/webgl';
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import {ShaderUniformType, ShaderAttributeType, VertexFormat} from '@luma.gl/core';
+import {GL, GLUniformType, GLSamplerType, GLCompositeType, GLDataType} from '@luma.gl/constants';
 
 /** Check is uniform is of sampler type */
 export function isSamplerUniform(type: GLUniformType): boolean {
@@ -28,7 +30,7 @@ const SAMPLER_TYPES: GLSamplerType[] = [
 // Composite types table
 const COMPOSITE_GL_TYPES: Record<
   GLCompositeType,
-  [GLType, number, string, UniformFormat, VertexFormat?]
+  [GLDataType, number, string, ShaderUniformType, VertexFormat?]
 > = {
   [GL.FLOAT]: [GL.FLOAT, 1, 'float', 'f32', 'float32'],
   [GL.FLOAT_VEC2]: [GL.FLOAT, 2, 'vec2', 'vec2<f32>', 'float32x2'],
@@ -45,11 +47,12 @@ const COMPOSITE_GL_TYPES: Record<
   [GL.UNSIGNED_INT_VEC3]: [GL.UNSIGNED_INT, 3, 'uvec3', 'vec3<u32>', 'uint32x3'],
   [GL.UNSIGNED_INT_VEC4]: [GL.UNSIGNED_INT, 4, 'uvec4', 'vec4<u32>', 'uint32x4'],
 
-  [GL.BOOL]: [GL.FLOAT, 1, 'bool', 'f32', 'float32x2'],
-  [GL.BOOL_VEC2]: [GL.FLOAT, 2, 'bvec2', 'vec2<f32>'],
-  [GL.BOOL_VEC3]: [GL.FLOAT, 3, 'bvec3', 'vec3<f32>'],
-  [GL.BOOL_VEC4]: [GL.FLOAT, 4, 'bvec4', 'vec4<f32>'],
+  [GL.BOOL]: [GL.FLOAT, 1, 'bool', 'f32', 'float32'],
+  [GL.BOOL_VEC2]: [GL.FLOAT, 2, 'bvec2', 'vec2<f32>', 'float32x2'],
+  [GL.BOOL_VEC3]: [GL.FLOAT, 3, 'bvec3', 'vec3<f32>', 'float32x3'],
+  [GL.BOOL_VEC4]: [GL.FLOAT, 4, 'bvec4', 'vec4<f32>', 'float32x4'],
 
+  // TODO - are sizes/components below correct?
   [GL.FLOAT_MAT2]: [GL.FLOAT, 8, 'mat2', 'mat2x2<f32>'], // 4
   [GL.FLOAT_MAT2x3]: [GL.FLOAT, 8, 'mat2x3', 'mat2x3<f32>'], // 6
   [GL.FLOAT_MAT2x4]: [GL.FLOAT, 8, 'mat2x4', 'mat2x4<f32>'], // 8
@@ -63,11 +66,11 @@ const COMPOSITE_GL_TYPES: Record<
   [GL.FLOAT_MAT4]: [GL.FLOAT, 16, 'mat4', 'mat4x4<f32>'] // 16
 };
 
-/** Decomposes a composite type GL.VEC3 into a basic type (GL.FLOAT) and components (3) */
-export function decodeUniformType(
-  uniformType: GL
-): {format: UniformFormat; components: number; glType: GLType} {
-  const typeAndSize = COMPOSITE_GL_TYPES[uniformType];
+/** Decomposes a composite type (GL.VEC3) into a basic type (GL.FLOAT) and components (3) */
+export function decodeGLUniformType(
+  glUniformType: GL
+): {format: ShaderUniformType; components: number; glType: GLDataType} {
+  const typeAndSize = COMPOSITE_GL_TYPES[glUniformType];
   if (!typeAndSize) {
     throw new Error('uniform');
   }
@@ -75,24 +78,28 @@ export function decodeUniformType(
   return {format, components, glType};
 }
 
-export function decodeAttributeType(attributeType: GL): {
-  format: VertexFormat;
+/** Decomposes a composite type (GL.VEC3) into a basic type (GL.FLOAT) and components (3) */
+export function decodeGLAttributeType(glAttributeType: GL): {
+  attributeType: ShaderAttributeType;
+  vertexFormat: VertexFormat;
   components: number;
-  glType: GLType;
+  // glType: GLDataType;
 } {
-  const typeAndSize = COMPOSITE_GL_TYPES[attributeType];
+  const typeAndSize = COMPOSITE_GL_TYPES[glAttributeType];
   if (!typeAndSize) {
     throw new Error('attribute')
   }
-  const [glType, components, , , format] = typeAndSize;
-  return {format, components, glType};
+  const [, components, , shaderType, vertexFormat] = typeAndSize;
+  // TODO sanity - if (shaderType.startsWith('mat' ...))
+  const attributeType = shaderType as unknown as ShaderAttributeType
+  return {attributeType, vertexFormat, components}; // , glType};
 }
 
 /** Decomposes a composite type GL.VEC3 into a basic type (GL.FLOAT) and components (3) */
-export function decomposeCompositeGLType(
-  compositeGLType: GLCompositeType
-): {type: GLType; components: number} | null {
-  const typeAndSize = COMPOSITE_GL_TYPES[compositeGLType];
+export function decomposeCompositeGLDataType(
+  compositeGLDataType: GLCompositeType
+): {type: GLDataType; components: number} | null {
+  const typeAndSize = COMPOSITE_GL_TYPES[compositeGLDataType];
   if (!typeAndSize) {
     return null;
   }
@@ -100,7 +107,7 @@ export function decomposeCompositeGLType(
   return {type, components};
 }
 
-export function getCompositeGLType(type: GL, components): {glType: GLType; name: string} | null {
+export function getCompositeGLDataType(type: GL, components): {glType: GLDataType; name: string} | null {
   switch (type) {
     case GL.BYTE:
     case GL.UNSIGNED_BYTE: