@luma.gl/webgl 9.0.0-alpha.5 → 9.0.0-alpha.50

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';
@@ -47,7 +49,12 @@ export function getWebGLFeatures(gl: WebGLRenderingContext): Set<DeviceFeature>
 }
 
 function isFeatureSupported(gl: WebGLRenderingContext, feature: DeviceFeature): boolean {
-  const [webgl1Feature, webgl2Feature] = WEBGL_FEATURES[feature];;
+  const featureInfo = WEBGL_FEATURES[feature];
+  if (!featureInfo) {
+    return false;
+  }
+
+  const [webgl1Feature, webgl2Feature] = featureInfo || [];
 
   // Get extension name from table
   const featureDefinition = isWebGL2(gl) ? webgl2Feature : webgl1Feature;
@@ -100,6 +107,9 @@ export function canCompileGLSLExtension(gl: WebGLRenderingContext, extensionName
   const source = `#extension GL_${extensionName} : ${behavior}\nvoid main(void) {}`;
 
   const shader = gl.createShader(gl.VERTEX_SHADER);
+  if (!shader) {
+    throw new Error('shader');
+  }
   gl.shaderSource(shader, source);
   gl.compileShader(shader);
   const canCompile = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
@@ -116,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,11 +1,13 @@
 // 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 */
 export function getDeviceLimits(gl: WebGLRenderingContext): DeviceLimits {
-  const gl2: WebGL2RenderingContext = getWebGL2Context(gl);
+  const gl2: WebGL2RenderingContext | null = getWebGL2Context(gl);
   return {
     maxTextureDimension1D: 0, // WebGL does not support 1D textures
     maxTextureDimension2D: gl.getParameter(GL.MAX_TEXTURE_SIZE),

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

@@ -1,49 +1,84 @@
-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);
+
+  // 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
-    }
+    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): 'angle' | 'metal' | 'unknown' {
+  if ((/ANGLE/i.exec(vendor)) || (/ANGLE/i.exec(renderer))) {
+    return 'angle';
+  }
+  if ((/Metal/i.exec(vendor)) || (/Metal/i.exec(renderer))) {
+    return 'metal';
+  }
+  
   return 'unknown';
 }

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 {
@@ -25,8 +27,11 @@ const SAMPLER_TYPES: GLSamplerType[] = [
   GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
 ];
 
-// Composite types table 
-const COMPOSITE_GL_TYPES: Record<GLCompositeType, [GLType, number, string, UniformFormat, VertexFormat?]> = {
+// Composite types table
+const COMPOSITE_GL_TYPES: Record<
+  GLCompositeType,
+  [GLDataType, number, string, ShaderUniformType, VertexFormat?]
+> = {
   [GL.FLOAT]: [GL.FLOAT, 1, 'float', 'f32', 'float32'],
   [GL.FLOAT_VEC2]: [GL.FLOAT, 2, 'vec2', 'vec2<f32>', 'float32x2'],
   [GL.FLOAT_VEC3]: [GL.FLOAT, 3, 'vec3', 'vec3<f32>', 'float32x3'],
@@ -42,11 +47,12 @@ const COMPOSITE_GL_TYPES: Record<GLCompositeType, [GLType, number, string, Unifo
   [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
@@ -60,28 +66,40 @@ const COMPOSITE_GL_TYPES: Record<GLCompositeType, [GLType, number, string, Unifo
   [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) {
-    return null;
+    throw new Error('uniform');
   }
   const [glType, components, , format] = typeAndSize;
   return {format, components, glType};
 }
 
-export function decodeAttributeType(uniformType: GL): {format: VertexFormat, 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 decodeGLAttributeType(glAttributeType: GL): {
+  attributeType: ShaderAttributeType;
+  vertexFormat: VertexFormat;
+  components: number;
+  // glType: GLDataType;
+} {
+  const typeAndSize = COMPOSITE_GL_TYPES[glAttributeType];
   if (!typeAndSize) {
-    return null;
+    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;
   }
@@ -89,7 +107,7 @@ export function decomposeCompositeGLType(compositeGLType: GLCompositeType): {typ
   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:

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

@@ -0,0 +1,41 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+// Note: This was the only dependency that made @luma.gl/webgl depend on @luma.gl/shadertools
+// This file was coped from shadertools to avoid the dependency
+
+/** Information extracted from shader source code */
+export type ShaderInfo = {
+  name: string;
+  language: 'glsl' | 'wgsl';
+  version: number;
+};
+
+/** Extracts information from shader source code */
+export function getShaderInfo(source: string, defaultName?: string): ShaderInfo {
+  return {
+    name: getShaderName(source, defaultName),
+    language: 'glsl',
+    version: getShaderVersion(source)
+  };
+}
+
+/** Extracts GLSLIFY style naming of shaders: `#define SHADER_NAME ...` */
+function getShaderName(shader: string, defaultName: string = 'unnamed'): string {
+  const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
+  const match = SHADER_NAME_REGEXP.exec(shader);
+  return match ? match[1] : defaultName;
+}
+
+/** returns GLSL shader version of given shader string */
+function getShaderVersion(source: string): number {
+  let version = 100;
+  const words = source.match(/[^\s]+/g);
+  if (words && words.length >= 2 && words[0] === '#version') {
+    const v = parseInt(words[1], 10);
+    if (Number.isFinite(v)) {
+      version = v;
+    }
+  }
+  return version;
+}