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

package/src/adapter/helpers/decode-webgl-types.ts

@@ -1,134 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// 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 {
-  return SAMPLER_TYPES.includes(type as GLSamplerType);
-}
-
-const SAMPLER_TYPES: GLSamplerType[] = [
-  GL.SAMPLER_2D,
-  GL.SAMPLER_CUBE,
-  GL.SAMPLER_3D,
-  GL.SAMPLER_2D_SHADOW,
-  GL.SAMPLER_2D_ARRAY,
-  GL.SAMPLER_2D_ARRAY_SHADOW,
-  GL.SAMPLER_CUBE_SHADOW,
-  GL.INT_SAMPLER_2D,
-  GL.INT_SAMPLER_3D,
-  GL.INT_SAMPLER_CUBE,
-  GL.INT_SAMPLER_2D_ARRAY,
-  GL.UNSIGNED_INT_SAMPLER_2D,
-  GL.UNSIGNED_INT_SAMPLER_3D,
-  GL.UNSIGNED_INT_SAMPLER_CUBE,
-  GL.UNSIGNED_INT_SAMPLER_2D_ARRAY
-];
-
-// 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'],
-  [GL.FLOAT_VEC4]: [GL.FLOAT, 4, 'vec4', 'vec4<f32>', 'float32x4'],
-
-  [GL.INT]: [GL.INT, 1, 'int', 'i32', 'sint32'],
-  [GL.INT_VEC2]: [GL.INT, 2, 'ivec2', 'vec2<i32>', 'sint32x2'],
-  [GL.INT_VEC3]: [GL.INT, 3, 'ivec3', 'vec3<i32>', 'sint32x3'],
-  [GL.INT_VEC4]: [GL.INT, 4, 'ivec4', 'vec4<i32>', 'sint32x4'],
-
-  [GL.UNSIGNED_INT]: [GL.UNSIGNED_INT, 1, 'uint', 'u32', 'uint32'],
-  [GL.UNSIGNED_INT_VEC2]: [GL.UNSIGNED_INT, 2, 'uvec2', 'vec2<u32>', 'uint32x2'],
-  [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', '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
-
-  [GL.FLOAT_MAT3x2]: [GL.FLOAT, 12, 'mat3x2', 'mat3x2<f32>'], // 6
-  [GL.FLOAT_MAT3]: [GL.FLOAT, 12, 'mat3', 'mat3x3<f32>'], // 9
-  [GL.FLOAT_MAT3x4]: [GL.FLOAT, 12, 'mat3x4', 'mat3x4<f32>'], // 12
-
-  [GL.FLOAT_MAT4x2]: [GL.FLOAT, 16, 'mat4x2', 'mat4x2<f32>'], // 8
-  [GL.FLOAT_MAT4x3]: [GL.FLOAT, 16, 'mat4x3', 'mat4x3<f32>'], // 12
-  [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 decodeGLUniformType(glUniformType: GL): {
-  format: ShaderUniformType;
-  components: number;
-  glType: GLDataType;
-} {
-  const typeAndSize = COMPOSITE_GL_TYPES[glUniformType];
-  if (!typeAndSize) {
-    throw new Error('uniform');
-  }
-  const [glType, components, , format] = typeAndSize;
-  return {format, components, glType};
-}
-
-/** 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) {
-    throw new Error('attribute');
-  }
-  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 decomposeCompositeGLDataType(
-  compositeGLDataType: GLCompositeType
-): {type: GLDataType; components: number} | null {
-  const typeAndSize = COMPOSITE_GL_TYPES[compositeGLDataType];
-  if (!typeAndSize) {
-    return null;
-  }
-  const [type, components] = typeAndSize;
-  return {type, components};
-}
-
-export function getCompositeGLDataType(
-  type: GL,
-  components
-): {glType: GLDataType; name: string} | null {
-  switch (type) {
-    case GL.BYTE:
-    case GL.UNSIGNED_BYTE:
-    case GL.SHORT:
-    case GL.UNSIGNED_SHORT:
-      type = GL.FLOAT;
-      break;
-    default:
-  }
-
-  for (const glType in COMPOSITE_GL_TYPES) {
-    const [compType, compComponents, name] = COMPOSITE_GL_TYPES[glType];
-    if (compType === type && compComponents === components) {
-      return {glType: Number(glType), name};
-    }
-  }
-  return null;
-}

package/src/adapter/helpers/typed-array-utils.ts

@@ -1,129 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {TypedArray, TypedArrayConstructor} from '@math.gl/types';
-import {GL, GLDataType, GLPixelType} from '@luma.gl/constants';
-
-const ERR_TYPE_DEDUCTION = 'Failed to deduce GL constant from typed array';
-
-/**
- * Converts TYPED ARRAYS to corresponding GL constant
- * Used to auto deduce gl parameter types
- * @deprecated Use getDataTypeFromTypedArray
- * @param arrayOrType
- * @returns
- */
-export function getGLTypeFromTypedArray(arrayOrType: TypedArray): GLDataType {
-  // If typed array, look up constructor
-  const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
-  switch (type) {
-    case Float32Array:
-      return GL.FLOAT;
-    case Uint16Array:
-      return GL.UNSIGNED_SHORT;
-    case Uint32Array:
-      return GL.UNSIGNED_INT;
-    case Uint8Array:
-      return GL.UNSIGNED_BYTE;
-    case Uint8ClampedArray:
-      return GL.UNSIGNED_BYTE;
-    case Int8Array:
-      return GL.BYTE;
-    case Int16Array:
-      return GL.SHORT;
-    case Int32Array:
-      return GL.INT;
-    default:
-      throw new Error(ERR_TYPE_DEDUCTION);
-  }
-}
-
-/**
- * Converts GL constant to corresponding TYPED ARRAY
- * Used to auto deduce gl parameter types
- * @deprecated Use getTypedArrayFromDataType
- * @param glType
- * @param param1
- * @returns
- */
-// eslint-disable-next-line complexity
-export function getTypedArrayFromGLType(
-  glType: GLDataType | GLPixelType,
-  options?: {
-    clamped?: boolean;
-  }
-): TypedArrayConstructor {
-  const {clamped = true} = options || {};
-  // Sorted in some order of likelihood to reduce amount of comparisons
-  switch (glType) {
-    case GL.FLOAT:
-      return Float32Array;
-    case GL.UNSIGNED_SHORT:
-    case GL.UNSIGNED_SHORT_5_6_5:
-    case GL.UNSIGNED_SHORT_4_4_4_4:
-    case GL.UNSIGNED_SHORT_5_5_5_1:
-      return Uint16Array;
-    case GL.UNSIGNED_INT:
-      return Uint32Array;
-    case GL.UNSIGNED_BYTE:
-      return clamped ? Uint8ClampedArray : Uint8Array;
-    case GL.BYTE:
-      return Int8Array;
-    case GL.SHORT:
-      return Int16Array;
-    case GL.INT:
-      return Int32Array;
-    default:
-      throw new Error('Failed to deduce typed array type from GL constant');
-  }
-}
-
-/**
- * Flip rows (can be used on arrays returned from `Framebuffer.readPixels`)
- * https: *stackoverflow.com/questions/41969562/
- * how-can-i-flip-the-result-of-webglrenderingcontext-readpixels
- * @param param0
- */
-export function flipRows(options: {
-  data: TypedArray;
-  width: number;
-  height: number;
-  bytesPerPixel?: number;
-  temp?: Uint8Array;
-}): void {
-  const {data, width, height, bytesPerPixel = 4, temp} = options;
-  const bytesPerRow = width * bytesPerPixel;
-
-  // make a temp buffer to hold one row
-  const tempBuffer = temp || new Uint8Array(bytesPerRow);
-  for (let y = 0; y < height / 2; ++y) {
-    const topOffset = y * bytesPerRow;
-    const bottomOffset = (height - y - 1) * bytesPerRow;
-    // make copy of a row on the top half
-    tempBuffer.set(data.subarray(topOffset, topOffset + bytesPerRow));
-    // copy a row from the bottom half to the top
-    data.copyWithin(topOffset, bottomOffset, bottomOffset + bytesPerRow);
-    // copy the copy of the top half row to the bottom half
-    data.set(tempBuffer, bottomOffset);
-  }
-}
-
-export function scalePixels(options: {data: TypedArray; width: number; height: number}): {
-  data: Uint8Array;
-  width: number;
-  height: number;
-} {
-  const {data, width, height} = options;
-  const newWidth = Math.round(width / 2);
-  const newHeight = Math.round(height / 2);
-  const newData = new Uint8Array(newWidth * newHeight * 4);
-  for (let y = 0; y < newHeight; y++) {
-    for (let x = 0; x < newWidth; x++) {
-      for (let c = 0; c < 4; c++) {
-        newData[(y * newWidth + x) * 4 + c] = data[(y * 2 * width + x * 2) * 4 + c];
-      }
-    }
-  }
-  return {data: newData, width: newWidth, height: newHeight};
-}

package/src/deprecated/accessor.ts

@@ -1,225 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {Buffer, log} from '@luma.gl/core';
-import {GL, GLDataType, GLPixelType} from '@luma.gl/constants';
-import {TypedArrayConstructor} from '@math.gl/types';
-
-/**
- * Attribute descriptor object
- * @deprecated Use ShaderLayout
- */
-export interface AccessorObject {
-  buffer?: Buffer;
-  // format: VertexFormat;
-  offset?: number;
-  // can now be described with single WebGPU-style `format` string
-
-  //
-  stride?: number;
-
-  /** @deprecated - Use accessor.stepMode */
-  divisor?: number;
-
-  /** @deprecated - Infer from format */
-  type?: number;
-  /** @deprecated - Infer from format */
-  size?: number;
-  /** @deprecated - Infer from format */
-  normalized?: boolean;
-  /** @deprecated - Infer from format */
-  integer?: boolean;
-
-  /** @deprecated */
-  index?: number;
-}
-
-const DEFAULT_ACCESSOR_VALUES = {
-  offset: 0,
-  stride: 0,
-  type: GL.FLOAT,
-  size: 1,
-  divisor: 0,
-  normalized: false,
-  integer: false
-};
-
-export class Accessor implements AccessorObject {
-  offset?: number;
-  stride?: number;
-  type?: number;
-  size?: number;
-  divisor?: number;
-  normalized?: boolean;
-  integer?: boolean;
-
-  buffer?: Buffer;
-  index?: number;
-
-  static getBytesPerElement(accessor: Accessor | AccessorObject): number {
-    // TODO: using `FLOAT` when type is not specified,
-    // ensure this assumption is valid or force API to specify type.
-    const ArrayType = getTypedArrayFromGLType(accessor.type || GL.FLOAT);
-    return ArrayType.BYTES_PER_ELEMENT;
-  }
-
-  static getBytesPerVertex(accessor: AccessorObject): number {
-    // assert(accessor.size);
-    // TODO: using `FLOAT` when type is not specified,
-    // ensure this assumption is valid or force API to specify type.
-    const ArrayType = getTypedArrayFromGLType(accessor.type || GL.FLOAT);
-    return ArrayType.BYTES_PER_ELEMENT * accessor.size;
-  }
-
-  // Combines (merges) a list of accessors. On top of default values
-  // Usually [programAccessor, bufferAccessor, appAccessor]
-  // All props will be set in the returned object.
-  // TODO check for conflicts between values in the supplied accessors
-  static resolve(...accessors: AccessorObject[]): Accessor {
-    return new Accessor(...[DEFAULT_ACCESSOR_VALUES, ...accessors]); // Default values
-  }
-
-  constructor(...accessors: AccessorObject[]) {
-    log.warn('Accessor will be removed in next minor release');
-    accessors.forEach(accessor => this._assign(accessor)); // Merge in sequence
-    Object.freeze(this);
-  }
-
-  toString(): string {
-    return JSON.stringify(this);
-  }
-
-  // ACCESSORS
-
-  // TODO - remove>
-  get BYTES_PER_ELEMENT(): number {
-    return Accessor.getBytesPerElement(this);
-  }
-
-  get BYTES_PER_VERTEX(): number {
-    return Accessor.getBytesPerVertex(this);
-  }
-
-  // PRIVATE
-
-  // eslint-disable-next-line complexity, max-statements
-  _assign(props: AccessorObject = {}): this {
-    if (props.type !== undefined) {
-      this.type = props.type;
-
-      // Auto-deduce integer type?
-      if ((props.type as GL) === GL.INT || (props.type as GL) === GL.UNSIGNED_INT) {
-        this.integer = true;
-      }
-    }
-    if (props.size !== undefined) {
-      this.size = props.size;
-    }
-    if (props.offset !== undefined) {
-      this.offset = props.offset;
-    }
-    if (props.stride !== undefined) {
-      this.stride = props.stride;
-    }
-    // @ts-expect-error
-    if (props.normalize !== undefined) {
-      // @ts-expect-error
-      this.normalized = props.normalize;
-    }
-    if (props.normalized !== undefined) {
-      this.normalized = props.normalized;
-    }
-    if (props.integer !== undefined) {
-      this.integer = props.integer;
-    }
-
-    // INSTANCE DIVISOR
-    if (props.divisor !== undefined) {
-      this.divisor = props.divisor;
-    }
-
-    // Buffer is optional
-    if (props.buffer !== undefined) {
-      this.buffer = props.buffer;
-    }
-
-    // The binding index (for binding e.g. Transform feedbacks and Uniform buffers)
-    // TODO - should this be part of accessor?
-    if (props.index !== undefined) {
-      if (typeof props.index === 'boolean') {
-        this.index = props.index ? 1 : 0;
-      } else {
-        this.index = props.index;
-      }
-    }
-
-    // DEPRECATED
-    // @ts-expect-error
-    if (props.instanced !== undefined) {
-      // @ts-expect-error
-      this.divisor = props.instanced ? 1 : 0;
-    }
-    // @ts-expect-error
-    if (props.isInstanced !== undefined) {
-      // @ts-expect-error
-      this.divisor = props.isInstanced ? 1 : 0;
-    }
-
-    if (this.offset === undefined) delete this.offset;
-    if (this.stride === undefined) delete this.stride;
-    if (this.type === undefined) delete this.type;
-    if (this.size === undefined) delete this.size;
-    if (this.divisor === undefined) delete this.divisor;
-    if (this.normalized === undefined) delete this.normalized;
-    if (this.integer === undefined) delete this.integer;
-
-    if (this.buffer === undefined) delete this.buffer;
-    if (this.index === undefined) delete this.index;
-
-    return this;
-  }
-}
-
-/**
- * Converts GL constant to corresponding TYPED ARRAY
- * Used to auto deduce gl parameter types
- * @deprecated Use getTypedArrayFromDataType
- * @param glType
- * @param param1
- * @returns
- */
-// eslint-disable-next-line complexity
-function getTypedArrayFromGLType(
-  glType: GLDataType | GLPixelType,
-  options?: {
-    clamped?: boolean;
-  }
-): TypedArrayConstructor {
-  const {clamped = true} = options || {};
-  // Sorted in some order of likelihood to reduce amount of comparisons
-  switch (glType) {
-    case GL.FLOAT:
-      return Float32Array;
-    case GL.UNSIGNED_SHORT:
-    case GL.UNSIGNED_SHORT_5_6_5:
-    case GL.UNSIGNED_SHORT_4_4_4_4:
-    case GL.UNSIGNED_SHORT_5_5_5_1:
-      return Uint16Array;
-    case GL.UNSIGNED_INT:
-      return Uint32Array;
-    case GL.UNSIGNED_BYTE:
-      return clamped ? Uint8ClampedArray : Uint8Array;
-    case GL.BYTE:
-      return Int8Array;
-    case GL.SHORT:
-      return Int16Array;
-    case GL.INT:
-      return Int32Array;
-    default:
-      throw new Error('Failed to deduce typed array type from GL constant');
-  }
-}
-
-// TEST EXPORTS
-export {DEFAULT_ACCESSOR_VALUES};

package/src/utils/split-uniforms-and-bindings.ts

@@ -1,31 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {UniformValue, Binding} from '@luma.gl/core';
-import {isNumericArray} from '@math.gl/types';
-
-export function isUniformValue(value: unknown): value is UniformValue {
-  return isNumericArray(value) !== null || typeof value === 'number' || typeof value === 'boolean';
-}
-
-type UniformsAndBindings = {
-  bindings: Record<string, Binding>;
-  uniforms: Record<string, UniformValue>;
-};
-
-export function splitUniformsAndBindings(
-  uniforms: Record<string, Binding | UniformValue>
-): UniformsAndBindings {
-  const result: UniformsAndBindings = {bindings: {}, uniforms: {}};
-  Object.keys(uniforms).forEach(name => {
-    const uniform = uniforms[name];
-    if (isUniformValue(uniform)) {
-      result.uniforms[name] = uniform;
-    } else {
-      result.bindings[name] = uniform;
-    }
-  });
-
-  return result;
-}