@luma.gl/core 9.1.9 → 9.2.0-alpha.3

package/dist/gpu-type-utils/vertex-format-from-attribute.js

@@ -1,91 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-export function getDataTypeFromTypedArray(arrayOrType) {
-    const type = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
-    switch (type) {
-        case Float32Array:
-            return 'float32';
-        case Uint16Array:
-            return 'uint16';
-        case Uint32Array:
-            return 'uint32';
-        case Uint8Array:
-        case Uint8ClampedArray:
-            return 'uint8';
-        case Int8Array:
-            return 'sint8';
-        case Int16Array:
-            return 'sint16';
-        case Int32Array:
-            return 'sint32';
-        default:
-            // Failed to deduce data type from typed array
-            throw new Error(type.constructor.name);
-    }
-}
-export function getTypedArrayFromDataType(dataType) {
-    switch (dataType) {
-        case 'float32':
-            return Float32Array;
-        case 'uint32':
-            return Uint32Array;
-        case 'sint32':
-            return Int32Array;
-        case 'uint16':
-        case 'unorm16':
-            return Uint16Array;
-        case 'sint16':
-        case 'snorm16':
-            return Int16Array;
-        case 'uint8':
-        case 'unorm8':
-            return Uint8Array;
-        case 'sint8':
-        case 'snorm8':
-            return Int8Array;
-        default:
-            // Failed to deduce typed array from data type
-            throw new Error(dataType);
-    }
-}
-/** Get the vertex format for an attribute with TypedArray and size */
-export function getVertexFormatFromAttribute(typedArray, size, normalized) {
-    if (!size || size > 4) {
-        throw new Error(`size ${size}`);
-    }
-    const components = size;
-    let dataType = getDataTypeFromTypedArray(typedArray);
-    // TODO - Special cases for WebGL (not supported on WebGPU), overrides the check below
-    if (dataType === 'uint8' && normalized && components === 1) {
-        return 'unorm8-webgl';
-    }
-    if (dataType === 'uint8' && normalized && components === 3) {
-        return 'unorm8x3-webgl';
-    }
-    if (dataType === 'uint8' || dataType === 'sint8') {
-        if (components === 1 || components === 3) {
-            // WebGPU 8 bit formats must be aligned to 16 bit boundaries');
-            throw new Error(`size: ${size}`);
-        }
-        if (normalized) {
-            dataType = dataType.replace('int', 'norm');
-        }
-        return `${dataType}x${components}`;
-    }
-    if (dataType === 'uint16' || dataType === 'sint16') {
-        if (components === 1 || components === 3) {
-            // WebGPU 16 bit formats must be aligned to 32 bit boundaries
-            throw new Error(`size: ${size}`);
-        }
-        if (normalized) {
-            dataType = dataType.replace('int', 'norm');
-        }
-        return `${dataType}x${components}`;
-    }
-    if (components === 1) {
-        return dataType;
-    }
-    return `${dataType}x${components}`;
-}
-//# sourceMappingURL=vertex-format-from-attribute.js.map

package/dist/gpu-type-utils/vertex-format-from-attribute.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"vertex-format-from-attribute.js","sourceRoot":"","sources":["../../src/gpu-type-utils/vertex-format-from-attribute.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAUpC,MAAM,UAAU,yBAAyB,CACvC,WAA+C;IAE/C,MAAM,IAAI,GAAG,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC;IACrF,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,YAAY;YACf,OAAO,SAAS,CAAC;QACnB,KAAK,WAAW;YACd,OAAO,QAAQ,CAAC;QAClB,KAAK,WAAW;YACd,OAAO,QAAQ,CAAC;QAClB,KAAK,UAAU,CAAC;QAChB,KAAK,iBAAiB;YACpB,OAAO,OAAO,CAAC;QACjB,KAAK,SAAS;YACZ,OAAO,OAAO,CAAC;QACjB,KAAK,UAAU;YACb,OAAO,QAAQ,CAAC;QAClB,KAAK,UAAU;YACb,OAAO,QAAQ,CAAC;QAClB;YACE,8CAA8C;YAC9C,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;AACH,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,QAAiC;IAEjC,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,SAAS;YACZ,OAAO,YAAY,CAAC;QACtB,KAAK,QAAQ;YACX,OAAO,WAAW,CAAC;QACrB,KAAK,QAAQ;YACX,OAAO,UAAU,CAAC;QACpB,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS;YACZ,OAAO,WAAW,CAAC;QACrB,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS;YACZ,OAAO,UAAU,CAAC;QACpB,KAAK,OAAO,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,UAAU,CAAC;QACpB,KAAK,OAAO,CAAC;QACb,KAAK,QAAQ;YACX,OAAO,SAAS,CAAC;QACnB;YACE,8CAA8C;YAC9C,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;AACH,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,4BAA4B,CAC1C,UAAsB,EACtB,IAAY,EACZ,UAAoB;IAEpB,IAAI,CAAC,IAAI,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;IAClC,CAAC;IAED,MAAM,UAAU,GAAG,IAAqB,CAAC;IACzC,IAAI,QAAQ,GAA4B,yBAAyB,CAAC,UAAU,CAAC,CAAC;IAE9E,sFAAsF;IACtF,IAAI,QAAQ,KAAK,OAAO,IAAI,UAAU,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QAC3D,OAAO,cAAc,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,KAAK,OAAO,IAAI,UAAU,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QAC3D,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED,IAAI,QAAQ,KAAK,OAAO,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;QACjD,IAAI,UAAU,KAAK,CAAC,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;YACzC,+DAA+D;YAC/D,MAAM,IAAI,KAAK,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,UAAU,EAAE,CAAC;YACf,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAwB,CAAC;QACpE,CAAC;QACD,OAAO,GAAG,QAAQ,IAAI,UAAU,EAAE,CAAC;IACrC,CAAC;IACD,IAAI,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACnD,IAAI,UAAU,KAAK,CAAC,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;YACzC,6DAA6D;YAC7D,MAAM,IAAI,KAAK,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,UAAU,EAAE,CAAC;YACf,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAA0B,CAAC;QACtE,CAAC;QACD,OAAO,GAAG,QAAQ,IAAI,UAAU,EAAE,CAAC;IACrC,CAAC;IAED,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,OAAO,GAAG,QAAQ,IAAI,UAAU,EAAE,CAAC;AACrC,CAAC"}

package/dist/gpu-type-utils/vertex-formats.d.ts

@@ -1,14 +0,0 @@
-/** Basic data types signed and unsigned integers, and floats, of varying sizes */
-export type DataType = 'uint8' | 'sint8' | 'uint16' | 'sint16' | 'uint32' | 'sint32' | 'float16' | 'float32';
-/** Vertex and Pixel data types. Include normalized integers */
-export type NormalizedDataType = 'uint8' | 'sint8' | 'unorm8' | 'snorm8' | 'uint16' | 'sint16' | 'unorm16' | 'snorm16' | 'uint32' | 'sint32' | 'float32' | 'float16';
-/** Describes the type (without number of components) of a vertex format */
-export type VertexType = NormalizedDataType;
-/**
- * Describes the memory format of a buffer that will be supplied to vertex attributes
- * @note Must be compatible with the ShaderAttributeType of the shaders, see documentation.
- * @note This is a superset of WebGPU vertex formats to allow foe some flexibility for WebGL only applications
- * @todo Add device.isTextureFormatSupported() method?
- */
-export type VertexFormat = 'uint8x2' | 'uint8x4' | 'sint8x2' | 'sint8x4' | 'unorm8-webgl' | 'unorm8x2' | 'unorm8x3-webgl' | 'unorm8x4' | 'snorm8-webgl' | 'snorm8x2' | 'snorm8x3-webgl' | 'snorm8x4' | 'uint16x2' | 'uint16x4' | 'sint16x2' | 'sint16x4' | 'unorm16x2' | 'unorm16x4' | 'snorm16x2' | 'snorm16x4' | 'uint32' | 'uint32x2' | 'uint32x3' | 'uint32x4' | 'sint32' | 'sint32x2' | 'sint32x3' | 'sint32x4' | 'float16x2' | 'float16x4' | 'float32' | 'float32x2' | 'float32x3' | 'float32x4';
-//# sourceMappingURL=vertex-formats.d.ts.map

package/dist/gpu-type-utils/vertex-formats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vertex-formats.d.ts","sourceRoot":"","sources":["../../src/gpu-type-utils/vertex-formats.ts"],"names":[],"mappings":"AAIA,kFAAkF;AAClF,MAAM,MAAM,QAAQ,GAChB,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,SAAS,CAAC;AAEd,+DAA+D;AAC/D,MAAM,MAAM,kBAAkB,GAC1B,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,GAIR,SAAS,GACT,SAAS,CAAC;AAEd,2EAA2E;AAC3E,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAEpB,SAAS,GACT,SAAS,GACT,SAAS,GACT,SAAS,GACT,cAAc,GACd,UAAU,GACV,gBAAgB,GAChB,UAAU,GACV,cAAc,GACd,UAAU,GACV,gBAAgB,GAChB,UAAU,GAEV,UAAU,GACV,UAAU,GACV,UAAU,GACV,UAAU,GACV,WAAW,GACX,WAAW,GACX,WAAW,GACX,WAAW,GAEX,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,GAWV,WAAW,GACX,WAAW,GACX,SAAS,GACT,WAAW,GACX,WAAW,GACX,WAAW,CAAC"}

package/dist/gpu-type-utils/vertex-formats.js.map

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

package/dist/gpu-type-utils/wgsl-utils.d.ts

@@ -1,4 +0,0 @@
-import { ShaderAttributeType } from "./shader-types.js";
-/**  Predeclared aliases @see https://www.w3.org/TR/WGSL/#vector-types */
-export declare const WGSL_TYPE_ALIAS_MAP: Record<string, ShaderAttributeType>;
-//# sourceMappingURL=wgsl-utils.d.ts.map

package/dist/gpu-type-utils/wgsl-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wgsl-utils.d.ts","sourceRoot":"","sources":["../../src/gpu-type-utils/wgsl-utils.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,mBAAmB,EAAC,0BAAuB;AAEnD,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAcnE,CAAC"}

package/dist/gpu-type-utils/wgsl-utils.js

@@ -1,20 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-/**  Predeclared aliases @see https://www.w3.org/TR/WGSL/#vector-types */
-export const WGSL_TYPE_ALIAS_MAP = {
-    vec2i: 'vec2<i32>',
-    vec3i: 'vec3<i32>',
-    vec4i: 'vec4<i32>',
-    vec2u: 'vec2<u32>',
-    vec3u: 'vec3<u32>',
-    vec4u: 'vec4<u32>',
-    vec2f: 'vec2<f32>',
-    vec3f: 'vec3<f32>',
-    vec4f: 'vec4<f32>',
-    // Requires the f16 extension.
-    vec2h: 'vec2<f16>',
-    vec3h: 'vec3<f16>',
-    vec4h: 'vec4<f16>'
-};
-//# sourceMappingURL=wgsl-utils.js.map

package/dist/gpu-type-utils/wgsl-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wgsl-utils.js","sourceRoot":"","sources":["../../src/gpu-type-utils/wgsl-utils.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,yEAAyE;AACzE,MAAM,CAAC,MAAM,mBAAmB,GAAwC;IACtE,KAAK,EAAE,WAAW;IAClB,KAAK,EAAE,WAAW;IAClB,KAAK,EAAE,WAAW;IAClB,KAAK,EAAE,WAAW;IAClB,KAAK,EAAE,WAAW;IAClB,KAAK,EAAE,WAAW;IAClB,KAAK,EAAE,WAAW;IAClB,KAAK,EAAE,WAAW;IAClB,KAAK,EAAE,WAAW;IAClB,8BAA8B;IAC9B,KAAK,EAAE,WAAW;IAClB,KAAK,EAAE,WAAW;IAClB,KAAK,EAAE,WAAW;CACnB,CAAC"}

package/src/adapter-utils/buffer-layout-helper.ts

@@ -1,52 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {BufferLayout} from '../adapter/types/buffer-layout';
-import {log} from '../utils/log';
-
-/** BufferLayoutHelper is a helper class that should not be used directly by applications */
-export class BufferLayoutHelper {
-  bufferLayouts: BufferLayout[];
-
-  constructor(bufferLayouts: BufferLayout[]) {
-    this.bufferLayouts = bufferLayouts;
-  }
-
-  getBufferLayout(name: string): BufferLayout | null {
-    return this.bufferLayouts.find(layout => layout.name === name) || null;
-  }
-
-  /** Get attribute names from a BufferLayout */
-  getAttributeNamesForBuffer(bufferLayout: BufferLayout): string[] {
-    return bufferLayout.attributes
-      ? bufferLayout.attributes?.map(layout => layout.attribute)
-      : [bufferLayout.name];
-  }
-
-  mergeBufferLayouts(
-    bufferLayouts1: BufferLayout[],
-    bufferLayouts2: BufferLayout[]
-  ): BufferLayout[] {
-    const mergedLayouts = [...bufferLayouts1];
-    for (const attribute of bufferLayouts2) {
-      const index = mergedLayouts.findIndex(attribute2 => attribute2.name === attribute.name);
-      if (index < 0) {
-        mergedLayouts.push(attribute);
-      } else {
-        mergedLayouts[index] = attribute;
-      }
-    }
-    return mergedLayouts;
-  }
-
-  getBufferIndex(bufferName: string): number {
-    const bufferIndex = this.bufferLayouts.findIndex(layout => layout.name === bufferName);
-
-    if (bufferIndex === -1) {
-      log.warn(`BufferLayout: Missing buffer for "${bufferName}".`)();
-    }
-
-    return bufferIndex;
-  }
-}

package/src/adapter-utils/buffer-layout-order.ts

@@ -1,27 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {BufferLayout} from '../adapter/types/buffer-layout';
-import {ShaderLayout} from '../adapter/types/shader-layout';
-
-export function sortedBufferLayoutByShaderSourceLocations(
-  shaderLayout: ShaderLayout,
-  bufferLayout: BufferLayout[]
-): BufferLayout[] {
-  const shaderLayoutMap = Object.fromEntries(
-    shaderLayout.attributes.map(attr => [attr.name, attr.location])
-  );
-
-  const sortedLayout = bufferLayout.slice();
-  sortedLayout.sort((a, b) => {
-    const attributeNamesA = a.attributes ? a.attributes.map(attr => attr.attribute) : [a.name];
-    const attributeNamesB = b.attributes ? b.attributes.map(attr => attr.attribute) : [b.name];
-    const minLocationA = Math.min(...attributeNamesA.map(name => shaderLayoutMap[name]));
-    const minLocationB = Math.min(...attributeNamesB.map(name => shaderLayoutMap[name]));
-
-    return minLocationA - minLocationB;
-  });
-
-  return sortedLayout;
-}

package/src/gpu-type-utils/decode-attribute-type.ts

@@ -1,96 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {ShaderDataType, ShaderAttributeType} from './shader-types';
-import {VertexFormat, VertexType} from './vertex-formats';
-
-/** Information extracted from a ShaderAttributeInfo constant */
-export type ShaderAttributeTypeInfo = {
-  /** WGSL-style primitive data type, f32, i32, u32 */
-  dataType: ShaderDataType;
-  /** Whether this is a normalized integer (that must be used as float) */
-  components: 1 | 2 | 3 | 4;
-  /** Length in bytes of the data for one vertex */
-  byteLength?: number;
-  /** Whether this is for integer or float vert */
-  integer: boolean;
-  /** Whether this data type is signed */
-  signed: boolean;
-  /** The simplest vertex format that matches the shader attribute's data type */
-  defaultVertexFormat: VertexFormat;
-};
-
-/** Decodes a vertex type, returning byte length and flags (integer, signed, normalized) */
-export function decodeShaderAttributeType(
-  attributeType: ShaderAttributeType
-): ShaderAttributeTypeInfo {
-  const [dataType, components] = TYPE_INFO[attributeType];
-  const integer: boolean = dataType === 'i32' || dataType === 'u32';
-  const signed: boolean = dataType !== 'u32';
-
-  const byteLength = TYPE_SIZES[dataType] * components;
-  const defaultVertexFormat = getCompatibleVertexFormat(dataType, components);
-  return {
-    dataType,
-    components,
-    defaultVertexFormat,
-    byteLength,
-    integer,
-    signed
-  };
-}
-
-/** Get the "default" vertex format for a certain shader data type */
-function getCompatibleVertexFormat(
-  dataType: ShaderDataType,
-  components: 1 | 2 | 3 | 4
-): VertexFormat {
-  let vertexType: VertexType;
-  switch (dataType) {
-    case 'f32':
-      vertexType = 'float32';
-      break;
-    case 'i32':
-      vertexType = 'sint32';
-      break;
-    case 'u32':
-      vertexType = 'uint32';
-      break;
-    case 'f16':
-      return components <= 2 ? 'float16x2' : 'float16x4';
-  }
-  // TODO logic does not work for float16
-  if (components === 1) {
-    return vertexType;
-  }
-  return `${vertexType}x${components}`;
-}
-
-/** All valid shader attribute types. A table guarantees exhaustive list and fast execution */
-const TYPE_INFO: Record<ShaderAttributeType, [ShaderDataType, 1 | 2 | 3 | 4]> = {
-  f32: ['f32', 1],
-  'vec2<f32>': ['f32', 2],
-  'vec3<f32>': ['f32', 3],
-  'vec4<f32>': ['f32', 4],
-  f16: ['f16', 1],
-  'vec2<f16>': ['f16', 2],
-  'vec3<f16>': ['f16', 3],
-  'vec4<f16>': ['f16', 4],
-  i32: ['i32', 1],
-  'vec2<i32>': ['i32', 2],
-  'vec3<i32>': ['i32', 3],
-  'vec4<i32>': ['i32', 4],
-  u32: ['u32', 1],
-  'vec2<u32>': ['u32', 2],
-  'vec3<u32>': ['u32', 3],
-  'vec4<u32>': ['u32', 4]
-};
-
-const TYPE_SIZES: Record<ShaderDataType, number> = {
-  f32: 4,
-  f16: 2,
-  i32: 4,
-  u32: 4
-  // 'bool-webgl': 4,
-};

package/src/gpu-type-utils/decode-data-type.ts

@@ -1,66 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {DataType, NormalizedDataType} from './vertex-formats';
-
-export type DecodedVertexType = {
-  /** WebGPU data type */
-  dataType: DataType;
-  /** Length in bytes of the data for one vertex */
-  byteLength: number;
-  /** Whether this is for integer or float vert */
-  integer: boolean;
-  /** Whether this data type is signed */
-  signed: boolean;
-  /** Whether this is a normalized integer (that must be used as float) */
-  normalized: boolean;
-};
-
-/** Decodes a vertex type, returning byte length and flags (integer, signed, normalized) */
-export function decodeVertexType(type: NormalizedDataType): DecodedVertexType {
-  const dataType = TYPE_MAP[type];
-  const bytes = getDataTypeBytes(dataType);
-  const normalized: boolean = type.includes('norm');
-  const integer: boolean = !normalized && !type.startsWith('float');
-  const signed: boolean = type.startsWith('s');
-  return {
-    dataType: TYPE_MAP[type],
-    byteLength: bytes,
-    integer,
-    signed,
-    normalized
-  };
-}
-
-function getDataTypeBytes(type: DataType): number {
-  const bytes = TYPE_SIZES[type];
-  // assert(bytes);
-  return bytes;
-}
-
-const TYPE_MAP: Record<NormalizedDataType, DataType> = {
-  uint8: 'uint8',
-  sint8: 'sint8',
-  unorm8: 'uint8',
-  snorm8: 'sint8',
-  uint16: 'uint16',
-  sint16: 'sint16',
-  unorm16: 'uint16',
-  snorm16: 'sint16',
-  float16: 'float16',
-  float32: 'float32',
-  uint32: 'uint32',
-  sint32: 'sint32'
-};
-
-const TYPE_SIZES: Record<DataType, number> = {
-  uint8: 1,
-  sint8: 1,
-  uint16: 2,
-  sint16: 2,
-  float16: 2,
-  float32: 4,
-  uint32: 4,
-  sint32: 4
-};

package/src/gpu-type-utils/decode-shader-types.ts

@@ -1,49 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {ShaderUniformType, ShaderDataType} from './shader-types';
-
-const UNIFORM_FORMATS: Record<ShaderUniformType, {type: ShaderDataType; components: number}> = {
-  f32: {type: 'f32', components: 1},
-  i32: {type: 'i32', components: 1},
-  u32: {type: 'u32', components: 1},
-  // 'bool-webgl': {type: 'bool-webgl', components: 1},
-  'vec2<f32>': {type: 'f32', components: 2},
-  'vec3<f32>': {type: 'f32', components: 3},
-  'vec4<f32>': {type: 'f32', components: 4},
-  'vec2<i32>': {type: 'i32', components: 2},
-  'vec3<i32>': {type: 'i32', components: 3},
-  'vec4<i32>': {type: 'i32', components: 4},
-  'vec2<u32>': {type: 'u32', components: 2},
-  'vec3<u32>': {type: 'u32', components: 3},
-  'vec4<u32>': {type: 'u32', components: 4},
-  'mat2x2<f32>': {type: 'f32', components: 4},
-  'mat2x3<f32>': {type: 'f32', components: 6},
-  'mat2x4<f32>': {type: 'f32', components: 8},
-  'mat3x2<f32>': {type: 'f32', components: 6},
-  'mat3x3<f32>': {type: 'f32', components: 9},
-  'mat3x4<f32>': {type: 'f32', components: 12},
-  'mat4x2<f32>': {type: 'f32', components: 8},
-  'mat4x3<f32>': {type: 'f32', components: 12},
-  'mat4x4<f32>': {type: 'f32', components: 16}
-};
-
-/** Split a uniform type string into type and components */
-export function decodeShaderUniformType(format: ShaderUniformType): {
-  type: ShaderDataType;
-  components: number;
-} {
-  const decoded = UNIFORM_FORMATS[format];
-  return decoded;
-}
-
-/** Align offset to 1, 2 or 4 elements (4, 8 or 16 bytes) */
-export function alignTo(size: number, count: number): number {
-  // prettier-ignore
-  switch (count) {
-    case 1: return size; // Pad upwards to even multiple of 2
-    case 2: return size + (size % 2); // Pad upwards to even multiple of 2
-    default: return size + ((4 - (size % 4)) % 4); // Pad upwards to even multiple of 4
-  }
-}

package/src/gpu-type-utils/decode-vertex-format.ts

@@ -1,53 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {VertexFormat, VertexType} from './vertex-formats';
-import {decodeVertexType} from './decode-data-type';
-
-export type VertexFormatInfo = {
-  /** Length in bytes */
-  byteLength: number;
-  /** Type of each component */
-  type: VertexType;
-  /** Number of components per vertex / row */
-  components: 1 | 2 | 3 | 4;
-  /** Is this an integer format (normalized integer formats are not integer) */
-  integer: boolean;
-  /** Is this a signed format? */
-  signed: boolean;
-  /** Is this a normalized format? */
-  normalized: boolean;
-  /** Is this a webgl only format? */
-  webglOnly?: boolean;
-};
-
-/**
- * Decodes a vertex format, returning type, components, byte  length and flags (integer, signed, normalized)
- */
-export function decodeVertexFormat(format: VertexFormat): VertexFormatInfo {
-  // Strip the -webgl ending if present
-  let webglOnly: boolean | undefined;
-  if (format.endsWith('-webgl')) {
-    format.replace('-webgl', '');
-    webglOnly = true;
-  }
-  // split components from type
-  const [type_, count] = format.split('x');
-  const type = type_ as VertexType;
-  const components = (count ? parseInt(count) : 1) as 1 | 2 | 3 | 4;
-  // decode the type
-  const decodedType = decodeVertexType(type);
-  const result: VertexFormatInfo = {
-    type,
-    components,
-    byteLength: decodedType.byteLength * components,
-    integer: decodedType.integer,
-    signed: decodedType.signed,
-    normalized: decodedType.normalized
-  };
-  if (webglOnly) {
-    result.webglOnly = true;
-  }
-  return result;
-}

package/src/gpu-type-utils/shader-types.ts

@@ -1,78 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/**
- * Primitive data types understood by shaders
- * @note These types describe the type used in shader calculations, but for attribute inputs these can be populated from a different in-memory type.
- * @note bindings (like textures, samplers, and uniform buffers) are considered "bindings", not types
- * @note `f16` requires the `f16` extension
- */
-export type ShaderDataType = 'u32' | 'i32' | 'f32' | 'f16';
-
-/**
- * Describes the type of an attribute as defined in the shader source code.
- * @note Buffers with various `VertexFormat`s can be supplied for each type, and the GPU will convert them at runtime,
- * but there are limitations, see documentation for details.
- */
-export type ShaderAttributeType =
-  | 'f32'
-  | 'vec2<f32>'
-  | 'vec3<f32>'
-  | 'vec4<f32>'
-  | 'i32'
-  | 'vec2<i32>'
-  | 'vec3<i32>'
-  | 'vec4<i32>'
-  | 'u32'
-  | 'vec2<u32>'
-  | 'vec3<u32>'
-  | 'vec4<u32>'
-  // requires `f16` extension
-  | 'f16'
-  | 'vec2<f16>'
-  | 'vec3<f16>'
-  | 'vec4<f16>';
-
-/**
- * Describes the type of a uniform as described in the shader source code.
- * Uniforms can be of a wider range of types than attributes.
- */
-export type ShaderUniformType =
-  | 'f32'
-  | 'i32'
-  | 'u32'
-  | 'vec2<f32>'
-  | 'vec3<f32>'
-  | 'vec4<f32>'
-  | 'vec2<i32>'
-  | 'vec3<i32>'
-  | 'vec4<i32>'
-  | 'vec2<u32>'
-  | 'vec3<u32>'
-  | 'vec4<u32>'
-  | 'mat2x2<f32>'
-  | 'mat2x3<f32>'
-  | 'mat2x4<f32>'
-  | 'mat3x2<f32>'
-  | 'mat3x3<f32>'
-  | 'mat3x4<f32>'
-  | 'mat4x2<f32>'
-  | 'mat4x3<f32>'
-  | 'mat4x4<f32>';
-
-/** Shorthand type aliases recognized by WGSL */
-export type ShaderTypeAlias =
-  | 'vec2i'
-  | 'vec3i'
-  | 'vec4i'
-  | 'vec2u'
-  | 'vec3u'
-  | 'vec4u'
-  | 'vec2f'
-  | 'vec3f'
-  | 'vec4f'
-  // Requires the f16 extension.
-  | 'vec2h'
-  | 'vec3h'
-  | 'vec4h';

package/src/gpu-type-utils/texture-features.ts

@@ -1,23 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/**
- * Texture feature checks
- * @note these must be a subset of DeviceFeatures.
- */
-export type TextureFeature =
-  | 'texture-compression-bc'
-  | 'texture-compression-astc'
-  | 'texture-compression-etc2'
-  | 'texture-compression-etc1-webgl'
-  | 'texture-compression-pvrtc-webgl'
-  | 'texture-compression-atc-webgl'
-  | 'float32-renderable-webgl'
-  | 'float16-renderable-webgl'
-  | 'rgb9e5ufloat-renderable-webgl'
-  | 'snorm8-renderable-webgl'
-  | 'norm16-renderable-webgl'
-  | 'snorm16-renderable-webgl'
-  | 'float32-filterable'
-  | 'float16-filterable-webgl';

package/src/gpu-type-utils/texture-format-capabilities.ts

@@ -1,53 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {TextureFormat} from './texture-formats';
-import type {TextureFeature} from './texture-features';
-import {decodeTextureFormat} from './decode-texture-format';
-
-import {getTextureFormatDefinition} from './texture-format-table';
-
-/**
- * Texture format capabilities.
- * @note Not directly usable. Can contain TextureFeature strings that need to be checked against a specific device.
- */
-export type TextureFormatCapabilities = {
-  format: TextureFormat;
-  /** Can the format be created */
-  create: TextureFeature | boolean;
-  /** If a feature string, the specified device feature determines if format is renderable. */
-  render: TextureFeature | boolean;
-  /** If a feature string, the specified device feature determines if format is filterable. */
-  filter: TextureFeature | boolean;
-  /** If a feature string, the specified device feature determines if format is blendable. */
-  blend: TextureFeature | boolean;
-  /** If a feature string, the specified device feature determines if format is storeable. */
-  store: TextureFeature | boolean;
-};
-
-export function getTextureFormatCapabilities(format: TextureFormat): TextureFormatCapabilities {
-  const info = getTextureFormatDefinition(format);
-
-  const formatCapabilities: Required<TextureFormatCapabilities> = {
-    format,
-    create: info.f ?? true,
-    render: info.render ?? true,
-    filter: info.filter ?? true,
-    blend: info.blend ?? true,
-    store: info.store ?? true
-  };
-
-  const formatInfo = decodeTextureFormat(format);
-  const isDepthStencil = format.startsWith('depth') || format.startsWith('stencil');
-  const isSigned = formatInfo?.signed;
-  const isInteger = formatInfo?.integer;
-  const isWebGLSpecific = formatInfo?.webgl;
-
-  // signed formats are not renderable
-  formatCapabilities.render &&= !isSigned;
-  // signed and integer formats are not filterable
-  formatCapabilities.filter &&= !isDepthStencil && !isSigned && !isInteger && !isWebGLSpecific;
-
-  return formatCapabilities;
-}