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

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

@@ -1,153 +0,0 @@
-// luma.gl, MIT license
-import type {DeviceLimits} from '@luma.gl/api';
-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 | null = getWebGL2Context(gl);
-  return {
-    maxTextureDimension1D: 0, // WebGL does not support 1D textures
-    maxTextureDimension2D: gl.getParameter(GL.MAX_TEXTURE_SIZE),
-    maxTextureDimension3D: gl2 ? gl2.getParameter(GL.MAX_3D_TEXTURE_SIZE) : 0,
-    maxTextureArrayLayers: gl2 ? gl2.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
-    maxBindGroups: 1, // TBD
-    maxDynamicUniformBuffersPerPipelineLayout: 0, // TBD
-    maxDynamicStorageBuffersPerPipelineLayout: 0, // TBD
-    maxSampledTexturesPerShaderStage: gl.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS), // TBD
-    maxSamplersPerShaderStage: gl.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
-    maxStorageBuffersPerShaderStage: 0, // TBD
-    maxStorageTexturesPerShaderStage: 0, // TBD
-    maxUniformBuffersPerShaderStage: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
-    maxUniformBufferBindingSize: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
-    maxStorageBufferBindingSize: 0,
-    minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
-    minStorageBufferOffsetAlignment: 0, // TBD
-    maxVertexBuffers: 0,
-    maxVertexAttributes: gl.getParameter(GL.MAX_VERTEX_ATTRIBS),
-    maxVertexBufferArrayStride: 2048, // TBD, this is just the default value from WebGPU
-    maxInterStageShaderComponents: gl2 ? gl2.getParameter(GL.MAX_VARYING_COMPONENTS) : 0,
-    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
-  }
-}
-
-/** WebGL context limits */
-export type WebGLLimits = {
-  [GL.ALIASED_LINE_WIDTH_RANGE]: [number, number];
-  [GL.ALIASED_POINT_SIZE_RANGE]: [number, number];
-  [GL.MAX_TEXTURE_SIZE]: number;
-  [GL.MAX_CUBE_MAP_TEXTURE_SIZE]: number;
-  [GL.MAX_TEXTURE_IMAGE_UNITS]: number;
-  [GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: number;
-  [GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: number;
-  [GL.MAX_RENDERBUFFER_SIZE]: number;
-  [GL.MAX_VARYING_VECTORS]: number;
-  [GL.MAX_VERTEX_ATTRIBS]: number;
-  [GL.MAX_VERTEX_UNIFORM_VECTORS]: number;
-  [GL.MAX_FRAGMENT_UNIFORM_VECTORS]: number;
-  [GL.MAX_VIEWPORT_DIMS]: [number, number];
-
-  // Extensions
-  [GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: number;
-
-  // WebGL2 Limits
-  [GL.MAX_3D_TEXTURE_SIZE]: number;
-  [GL.MAX_ARRAY_TEXTURE_LAYERS]: number;
-  [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: number;
-  [GL.MAX_COLOR_ATTACHMENTS]: number;
-  [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: number;
-  [GL.MAX_COMBINED_UNIFORM_BLOCKS]: number;
-  [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: number;
-  [GL.MAX_DRAW_BUFFERS]: number;
-  [GL.MAX_ELEMENT_INDEX]: number;
-  [GL.MAX_ELEMENTS_INDICES]: number;
-  [GL.MAX_ELEMENTS_VERTICES]: number;
-  [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: number;
-  [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: number;
-  [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: number;
-  [GL.MAX_SAMPLES]: number;
-  [GL.MAX_SERVER_WAIT_TIMEOUT]: number;
-  [GL.MAX_TEXTURE_LOD_BIAS]: number;
-  [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: number;
-  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: number;
-  [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: number;
-  [GL.MAX_UNIFORM_BLOCK_SIZE]: number;
-  [GL.MAX_UNIFORM_BUFFER_BINDINGS]: number;
-  [GL.MAX_VARYING_COMPONENTS]: number;
-  [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: number;
-  [GL.MAX_VERTEX_UNIFORM_BLOCKS]: number;
-  [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: number;
-  [GL.MIN_PROGRAM_TEXEL_OFFSET]: number;
-  [GL.MAX_PROGRAM_TEXEL_OFFSET]: number;
-  [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: number;
-};
-
-
-export function getWebGLLimits(gl: WebGLRenderingContext): WebGLLimits {
-  const gl2 = getWebGL2Context(gl);
-  function get<T = number>(pname: number): T {
-    return gl.getParameter(pname) as T;
-  }
-  function get2(pname: number, defaultValue?: number): number;
-  function get2<T>(pname: number, defaultValue: T): T;
-  function get2<T>(pname: number, defaultValue: T): T {
-    return gl2 ? gl2.getParameter(pname) as T : (defaultValue || 0) as T;
-  }
-  // function getMaxAnistropy() {
-  //   const extension = gl.getExtension('EXT_texture_filter_anisotropic');
-  // }
-  return {
-    [GL.ALIASED_LINE_WIDTH_RANGE]: get(GL.ALIASED_LINE_WIDTH_RANGE),
-    [GL.ALIASED_POINT_SIZE_RANGE]: get(GL.ALIASED_POINT_SIZE_RANGE),
-    [GL.MAX_TEXTURE_SIZE]: get(GL.MAX_TEXTURE_SIZE),
-    [GL.MAX_CUBE_MAP_TEXTURE_SIZE]: get(GL.MAX_CUBE_MAP_TEXTURE_SIZE), // GLint
-    [GL.MAX_TEXTURE_IMAGE_UNITS]: get(GL.MAX_TEXTURE_IMAGE_UNITS), // GLint
-    [GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS]: get(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS), // GLint
-    [GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS]: get(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS), // GLint
-    [GL.MAX_RENDERBUFFER_SIZE]: get(GL.MAX_RENDERBUFFER_SIZE), // GLint
-    [GL.MAX_VARYING_VECTORS]: get(GL.MAX_VARYING_VECTORS), // GLint
-    [GL.MAX_VERTEX_ATTRIBS]: get(GL.MAX_VERTEX_ATTRIBS), // GLint
-    [GL.MAX_VERTEX_UNIFORM_VECTORS]: get(GL.MAX_VERTEX_UNIFORM_VECTORS), // GLint
-    [GL.MAX_FRAGMENT_UNIFORM_VECTORS]: get(GL.MAX_FRAGMENT_UNIFORM_VECTORS), // GLint
-    [GL.MAX_VIEWPORT_DIMS]: get(GL.MAX_VIEWPORT_DIMS),
-
-    // Extensions
-    [GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT]: get(GL.MAX_TEXTURE_MAX_ANISOTROPY_EXT), // getMaxAnistropy(),
-
-    // WebGL2 Limits
-    [GL.MAX_3D_TEXTURE_SIZE]: get2(GL.MAX_3D_TEXTURE_SIZE), //  GLint
-    [GL.MAX_ARRAY_TEXTURE_LAYERS]: get2(GL.MAX_ARRAY_TEXTURE_LAYERS), // GLint
-    [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL), //  GLint64
-    [GL.MAX_COLOR_ATTACHMENTS]: get2(GL.MAX_COLOR_ATTACHMENTS), //  GLint
-    [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS), // GLint64
-    [GL.MAX_COMBINED_UNIFORM_BLOCKS]: get2(GL.MAX_COMBINED_UNIFORM_BLOCKS), //  GLint
-    [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS), // GLint64
-    [GL.MAX_DRAW_BUFFERS]: get2(GL.MAX_DRAW_BUFFERS), // GLint
-    [GL.MAX_ELEMENT_INDEX]: get2(GL.MAX_ELEMENT_INDEX), //  GLint64
-    [GL.MAX_ELEMENTS_INDICES]: get2(GL.MAX_ELEMENTS_INDICES), // GLint
-    [GL.MAX_ELEMENTS_VERTICES]: get2(GL.MAX_ELEMENTS_VERTICES), //  GLint
-    [GL.MAX_FRAGMENT_INPUT_COMPONENTS]: get2(GL.MAX_FRAGMENT_INPUT_COMPONENTS), //  GLint
-    [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(GL.MAX_FRAGMENT_UNIFORM_BLOCKS), //  GLint
-    [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(GL.MAX_FRAGMENT_UNIFORM_COMPONENTS), //  GLint
-    [GL.MAX_SAMPLES]: get2(GL.MAX_SAMPLES), //  GLint
-    [GL.MAX_SERVER_WAIT_TIMEOUT]: get2(GL.MAX_SERVER_WAIT_TIMEOUT), //  GLint64
-    [GL.MAX_TEXTURE_LOD_BIAS]: get2(GL.MAX_TEXTURE_LOD_BIAS), // GLfloat
-    [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS), //  GLint
-    [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS), //  GLint
-    [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS), // GLint
-    [GL.MAX_UNIFORM_BLOCK_SIZE]: get2(GL.MAX_UNIFORM_BLOCK_SIZE), // GLint64
-    [GL.MAX_UNIFORM_BUFFER_BINDINGS]: get2(GL.MAX_UNIFORM_BUFFER_BINDINGS), //  GLint
-    [GL.MAX_VARYING_COMPONENTS]: get2(GL.MAX_VARYING_COMPONENTS), // GLint
-    [GL.MAX_VERTEX_OUTPUT_COMPONENTS]: get2(GL.MAX_VERTEX_OUTPUT_COMPONENTS), // GLint
-    [GL.MAX_VERTEX_UNIFORM_BLOCKS]: get2(GL.MAX_VERTEX_UNIFORM_BLOCKS), //  GLint
-    [GL.MAX_VERTEX_UNIFORM_COMPONENTS]: get2(GL.MAX_VERTEX_UNIFORM_COMPONENTS), //  GLint
-    [GL.MIN_PROGRAM_TEXEL_OFFSET]: get2(GL.MIN_PROGRAM_TEXEL_OFFSET), // GLint
-    [GL.MAX_PROGRAM_TEXEL_OFFSET]: get2(GL.MAX_PROGRAM_TEXEL_OFFSET), // GLint
-    [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: get2(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) // GLint
-  };
-}

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

@@ -1,49 +0,0 @@
-import {DeviceInfo} from '@luma.gl/api';
-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 {
-  const vendorMasked = gl.getParameter(GL.VENDOR);
-  const rendererMasked = gl.getParameter(GL.RENDERER);
-  // Get unmasked strings if 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;
-  const gpu = identifyGPUVendor(vendor, renderer);
-  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
-    }
-  };
-}
-
-function identifyGPUVendor(vendor: string, renderer: string): 'nvidia' | 'intel' | 'apple' | 'amd' | 'unknown' {
-  if (vendor.match(/NVIDIA/i) || renderer.match(/NVIDIA/i)) {
-    return 'nvidia';
-  }
-  if (vendor.match(/INTEL/i) || renderer.match(/INTEL/i)) {
-    return 'intel';
-  }
-  if (vendor.match(/Apple/i) || renderer.match(/Apple/i)) {
-    return 'apple';
-  }
-  if (
-    vendor.match(/AMD/i) ||
-    renderer.match(/AMD/i) ||
-    vendor.match(/ATI/i) ||
-    renderer.match(/ATI/i)
-  ) {
-    return 'amd';
-  }
-  return 'unknown';
-}

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

@@ -1,11 +0,0 @@
-// opts allows user agent to be overridden for testing
-export function isOldIE(opts = {}) {
-  const navigator = typeof window !== 'undefined' ? window.navigator || {} : {};
-  // @ts-expect-error
-  const userAgent = opts.userAgent || navigator.userAgent || '';
-  // We only care about older versions of IE (IE 11 and below). Newer versions of IE (Edge)
-  // have much better web standards support.
-  const isMSIE = userAgent.indexOf('MSIE ') !== -1;
-  const isTrident = userAgent.indexOf('Trident/') !== -1;
-  return isMSIE || isTrident;
-}

package/src/adapter/helpers/attribute-utils.ts

@@ -1,61 +0,0 @@
-import GL from '@luma.gl/constants';
-import {GLDrawMode, GLPrimitive} from '../../types/webgl';
-
-// Counts the number of complete primitives given a number of vertices and a drawMode
-export function getPrimitiveDrawMode(drawMode: GLDrawMode): GLPrimitive {
-  switch (drawMode) {
-    case GL.POINTS:
-      return GL.POINTS;
-    case GL.LINES:
-      return GL.LINES;
-    case GL.LINE_STRIP:
-      return GL.LINES;
-    case GL.LINE_LOOP:
-      return GL.LINES;
-    case GL.TRIANGLES:
-      return GL.TRIANGLES;
-    case GL.TRIANGLE_STRIP:
-      return GL.TRIANGLES;
-    case GL.TRIANGLE_FAN:
-      return GL.TRIANGLES;
-    default:
-      throw new Error('drawMode');
-  }
-}
-
-// Counts the number of complete "primitives" given a number of vertices and a drawMode
-export function getPrimitiveCount(options: {drawMode: GLDrawMode, vertexCount: number}): number {
-  const {drawMode, vertexCount} = options;
-  switch (drawMode) {
-    case GL.POINTS:
-    case GL.LINE_LOOP:
-      return vertexCount;
-    case GL.LINES:
-      return vertexCount / 2;
-    case GL.LINE_STRIP:
-      return vertexCount - 1;
-    case GL.TRIANGLES:
-      return vertexCount / 3;
-    case GL.TRIANGLE_STRIP:
-    case GL.TRIANGLE_FAN:
-      return vertexCount - 2;
-    default:
-      throw new Error('drawMode');
-  }
-}
-
-// Counts the number of vertices after splitting the vertex stream into separate "primitives"
-export function getVertexCount(options: {drawMode: GLDrawMode, vertexCount: number}): number {
-  const {drawMode, vertexCount} = options;
-  const primitiveCount = getPrimitiveCount({drawMode, vertexCount});
-  switch (getPrimitiveDrawMode(drawMode)) {
-    case GL.POINTS:
-      return primitiveCount;
-    case GL.LINES:
-      return primitiveCount * 2;
-    case GL.TRIANGLES:
-      return primitiveCount * 3;
-    default:
-      throw new Error('drawMode');
-  }
-}

package/src/adapter/objects/webgl-vertex-array-object.ts

@@ -1,111 +0,0 @@
-import {assert, ResourceProps} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import {getBrowser} from '@probe.gl/env';
-
-import WebGLDevice from '../webgl-device';
-import WebGLResource from './webgl-resource';
-
-import Buffer from '../resources/webgl-buffer';
-
-const ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';
-
-/**
- * VertexArrayObject properties
- */
-export type VertexArrayObjectProps = ResourceProps & {
-};
-
-/** VertexArrayObject wrapper */
-export default class WEBGLVertexArrayObject extends WebGLResource<VertexArrayObjectProps> {
-  get [Symbol.toStringTag](): string {
-    return 'BaseVertexArrayObject';
-  }
-
-  constructor(device: WebGLDevice, props?: VertexArrayObjectProps) {
-    // @ts-expect-error
-    super(device, props, {});
-  }
-
-  _createHandle() {
-    return this.gl2.createVertexArray();
-  }
-
-  _deleteHandle(): void {
-    this.gl2.deleteVertexArray(this.handle);
-    // @ts-expect-error
-    return [this.elements];
-    // return [this.elements, ...this.buffers];
-  }
-
-  _bindHandle(handle: WEBGLVertexArrayObject): void {
-    this.gl2.bindVertexArray(handle);
-  }
-
-  // Set (bind) an elements buffer, for indexed rendering.
-  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
-  setElementBuffer(elementBuffer: Buffer | null = null, opts = {}) {
-    assert(!elementBuffer || elementBuffer.target === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
-
-    // The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject...
-    this.bind(() => {
-      this.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
-    });
-
-    return this;
-  }
-
-  /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
-  setBuffer(location: number, buffer: Buffer, accessor: any): this {
-    // Check target
-    if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {
-      return this.setElementBuffer(buffer, accessor);
-    }
-
-    const {size, type, stride, offset, normalized, integer, divisor} = accessor;
-
-    const {gl, gl2} = this;
-    location = Number(location);
-
-    this.bind(() => {
-      // A non-zero buffer object must be bound to the GL_ARRAY_BUFFER target
-      gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);
-
-      // WebGL2 supports *integer* data formats, i.e. GPU will see integer values
-      if (integer) {
-        this.device.assertWebGL2();
-        gl2.vertexAttribIPointer(location, size, type, stride, offset);
-      } else {
-        // Attaches ARRAY_BUFFER with specified buffer format to location
-        gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
-      }
-      gl.enableVertexAttribArray(location);
-      gl2.vertexAttribDivisor(location, divisor || 0);
-
-      // NOTE We don't unbind buffer here, typically another buffer will be bound just after
-    });
-
-    return this;
-  }
-
-  /**
-   * Enabling an attribute location makes it reference the currently bound buffer
-   *  Disabling an attribute location makes it reference the global constant value
-   * TODO - handle single values for size 1 attributes?
-   * TODO - convert classic arrays based on known type?
-   */
-  enable(location: number, enable = true): this {
-    // Attribute 0 cannot be disabled in most desktop OpenGL based browsers...
-    const canDisableAttributeZero = this.device.isWebGL2 || getBrowser() === 'Chrome';
-    const canDisableAttribute = canDisableAttributeZero || location !== 0;
-
-    if (enable || canDisableAttribute) {
-      location = Number(location);
-      this.bind(() =>
-        enable
-          ? this.gl.enableVertexAttribArray(location)
-          : this.gl.disableVertexAttribArray(location)
-      );
-    }
-    return this;
-  }
-}

package/src/bundle.ts

@@ -1,4 +0,0 @@
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.luma = globalThis.luma || {};
-module.exports = Object.assign(globalThis.luma, moduleExports);