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

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

@@ -1,42 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {TextureFormat} from './texture-formats';
-import {VertexType} from './vertex-formats';
-
-/** Information about the structure of a texture format */
-export type TextureFormatInfo = {
-  /** The format that is described */
-  format: TextureFormat;
-  /** Color or depth stencil attachment formats */
-  attachment?: 'color' | 'depth' | 'stencil' | 'depth-stencil';
-  /** String describing which channels this texture has */
-  channels: 'r' | 'rg' | 'rgb' | 'rgba' | 'bgra';
-  /** Number of components (corresponds to channels string) */
-  components: 1 | 2 | 3 | 4;
-  /** What is the data type of each component */
-  dataType?: VertexType;
-  /** If this is a packed data type */
-  packed?: boolean;
-  /** Number of bytes per pixel */
-  bytesPerPixel?: number;
-  /** Number of bits per channel (may be unreliable for packed formats) */
-  bitsPerChannel: [number, number, number, number];
-  /** SRGB texture format? */
-  srgb?: boolean;
-  /** WebGL specific texture format? */
-  webgl?: boolean;
-  /** Is this an integer or floating point format? */
-  integer: boolean;
-  /** Is this a signed or unsigned format? */
-  signed: boolean;
-  /** Is this a normalized integer format? */
-  normalized: boolean;
-  /** Is this a compressed texture format */
-  compressed?: boolean;
-  /** Compressed formats only: Block size for ASTC formats (texture width must be a multiple of this value) */
-  blockWidth?: number;
-  /** Compressed formats only: Block size for ASTC formats (texture height must be a multiple of this value) */
-  blockHeight?: number;
-};

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

@@ -1,161 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/** Texture formats */
-export type TextureFormat = ColorTextureFormat | DepthStencilTextureFormat;
-
-/** Depth and stencil texture formats */
-export type DepthStencilTextureFormat =
-  | 'stencil8'
-  | 'depth16unorm'
-  | 'depth24plus'
-  | 'depth24plus-stencil8'
-  | 'depth32float'
-  // device.features.has('depth32float-stencil8')
-  | 'depth32float-stencil8';
-
-/** Texture formats for color attachments */
-export type ColorTextureFormat =
-  | WebGPUColorTextureFormat
-  | WebGL2ColorTextureFormat
-  | CompressedTextureFormat;
-
-export type WebGPUColorTextureFormat =
-  // 8-bit formats
-  | 'r8unorm'
-  | 'r8snorm'
-  | 'r8uint'
-  | 'r8sint'
-
-  // 16-bit formats
-  | 'r16uint'
-  | 'r16sint'
-  | 'r16float'
-  | 'rg8unorm'
-  | 'rg8snorm'
-  | 'rg8uint'
-  | 'rg8sint'
-
-  // 32-bit formats
-  | 'r32uint'
-  | 'r32sint'
-  | 'r32float'
-  | 'rg16uint'
-  | 'rg16sint'
-  | 'rg16float'
-  | 'rgba8unorm'
-  | 'rgba8unorm-srgb'
-  | 'rgba8snorm'
-  | 'rgba8uint'
-  | 'rgba8sint'
-  | 'bgra8unorm'
-  | 'bgra8unorm-srgb'
-  // Packed 32-bit formats
-  | 'rgb9e5ufloat'
-  | 'rgb10a2unorm'
-  | 'rg11b10ufloat'
-
-  // 64-bit formats
-  | 'rg32uint'
-  | 'rg32sint'
-  | 'rg32float'
-  | 'rgba16uint'
-  | 'rgba16sint'
-  | 'rgba16float'
-
-  // 128-bit formats
-  | 'rgba32uint'
-  | 'rgba32sint'
-  | 'rgba32float';
-
-export type CompressedTextureFormat =
-  // BC compressed formats usable if 'texture-compression-bc' is both
-  // supported by the device/user agent and enabled in requestDevice.
-  | 'bc1-rgba-unorm'
-  | 'bc1-rgba-unorm-srgb'
-  | 'bc2-rgba-unorm'
-  | 'bc2-rgba-unorm-srgb'
-  | 'bc3-rgba-unorm'
-  | 'bc3-rgba-unorm-srgb'
-  | 'bc4-r-unorm'
-  | 'bc4-r-snorm'
-  | 'bc5-rg-unorm'
-  | 'bc5-rg-snorm'
-  | 'bc6h-rgb-ufloat'
-  | 'bc6h-rgb-float'
-  | 'bc7-rgba-unorm'
-  | 'bc7-rgba-unorm-srgb'
-
-  // ETC2 compressed formats usable if "texture-compression-etc2" is both
-  // supported by the device/user agent and enabled in requestDevice.
-  | 'etc2-rgb8unorm'
-  | 'etc2-rgb8unorm-srgb'
-  | 'etc2-rgb8a1unorm'
-  | 'etc2-rgb8a1unorm-srgb'
-  | 'etc2-rgba8unorm'
-  | 'etc2-rgba8unorm-srgb'
-  | 'eac-r11unorm'
-  | 'eac-r11snorm'
-  | 'eac-rg11unorm'
-  | 'eac-rg11snorm'
-
-  // ASTC compressed formats usable if "texture-compression-astc" is both
-  // supported by the device/user agent and enabled in requestDevice.
-  // Textures must be multiple of block size (encoded in format string).
-  | 'astc-4x4-unorm'
-  | 'astc-4x4-unorm-srgb'
-  | 'astc-5x4-unorm'
-  | 'astc-5x4-unorm-srgb'
-  | 'astc-5x5-unorm'
-  | 'astc-5x5-unorm-srgb'
-  | 'astc-6x5-unorm'
-  | 'astc-6x5-unorm-srgb'
-  | 'astc-6x6-unorm'
-  | 'astc-6x6-unorm-srgb'
-  | 'astc-8x5-unorm'
-  | 'astc-8x5-unorm-srgb'
-  | 'astc-8x6-unorm'
-  | 'astc-8x6-unorm-srgb'
-  | 'astc-8x8-unorm'
-  | 'astc-8x8-unorm-srgb'
-  | 'astc-10x5-unorm'
-  | 'astc-10x5-unorm-srgb'
-  | 'astc-10x6-unorm'
-  | 'astc-10x6-unorm-srgb'
-  | 'astc-10x8-unorm'
-  | 'astc-10x8-unorm-srgb'
-  | 'astc-10x10-unorm'
-  | 'astc-10x10-unorm-srgb'
-  | 'astc-12x10-unorm'
-  | 'astc-12x10-unorm-srgb'
-  | 'astc-12x12-unorm'
-  | 'astc-12x12-unorm-srgb';
-
-/** Sized formats in WebGL 2 that are not (yet?) supported by WebGPU */
-export type WebGL2ColorTextureFormat =
-  | 'r16unorm-webgl'
-  | 'r16snorm-webgl'
-  | 'rgba4unorm-webgl'
-  | 'rgb565unorm-webgl'
-  | 'rgb5a1unorm-webgl'
-  | 'rgb8unorm-webgl'
-  | 'rgb8snorm-webgl'
-  | 'rg16unorm-webgl'
-  | 'rg16snorm-webgl'
-  | 'rgb10a2uint-webgl'
-  | 'rgb16unorm-webgl'
-  | 'rgb16snorm-webgl'
-  | 'rgba16unorm-webgl'
-  | 'rgba16snorm-webgl'
-  | 'rgb32float-webgl'
-  | 'bc1-rgb-unorm-webgl'
-  | 'bc1-rgb-unorm-srgb-webgl'
-  | 'pvrtc-rgb4unorm-webgl'
-  | 'pvrtc-rgba4unorm-webgl'
-  | 'pvrtc-rbg2unorm-webgl'
-  | 'pvrtc-rgba2unorm-webgl'
-  | 'etc1-rbg-unorm-webgl'
-  | 'atc-rgb-unorm-webgl'
-  | 'atc-rgba-unorm-webgl'
-  | 'atc-rgbai-unorm-webgl';

package/src/gpu-type-utils/vertex-format-from-attribute.ts

@@ -1,114 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {TypedArray, TypedArrayConstructor} from '../types';
-import {VertexFormat} from './vertex-formats';
-
-// import {DataType} from '../types/vertex-formats';
-// type Omit<DataType, 'float16'> unfortunately breaks Typescript inferance
-type DataType = 'uint8' | 'sint8' | 'uint16' | 'sint16' | 'uint32' | 'sint32' | 'float32';
-type DataTypeNorm = 'unorm8' | 'snorm8' | 'unorm16' | 'snorm16';
-
-export function getDataTypeFromTypedArray(
-  arrayOrType: TypedArray | TypedArrayConstructor
-): DataType {
-  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: DataType | DataTypeNorm
-): TypedArrayConstructor {
-  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: TypedArray,
-  size: number,
-  normalized?: boolean
-): VertexFormat {
-  if (!size || size > 4) {
-    throw new Error(`size ${size}`);
-  }
-
-  const components = size as 1 | 2 | 3 | 4;
-  let dataType: DataType | DataTypeNorm = 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') as 'unorm8' | 'snorm8';
-    }
-    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') as 'unorm16' | 'snorm16';
-    }
-    return `${dataType}x${components}`;
-  }
-
-  if (components === 1) {
-    return dataType;
-  }
-
-  return `${dataType}x${components}`;
-}

package/src/gpu-type-utils/vertex-formats.ts

@@ -1,90 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/** 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'
-  // WebGPU does not support normalized 32 bit integer attributes...
-  // | 'unorm32'
-  // | 'snorm32'
-  | '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 =
-  // 8 bit integers, note that only 16 bit aligned formats are supported in WebGPU (x2 and x4)
-  | 'uint8x2'
-  | 'uint8x4'
-  | 'sint8x2'
-  | 'sint8x4'
-  | 'unorm8-webgl'
-  | 'unorm8x2'
-  | 'unorm8x3-webgl'
-  | 'unorm8x4'
-  | 'snorm8-webgl'
-  | 'snorm8x2'
-  | 'snorm8x3-webgl'
-  | 'snorm8x4'
-  // 16 bit integers, note that only 32 bit aligned formats are supported in WebGPU (x2 and x4)
-  | 'uint16x2'
-  | 'uint16x4'
-  | 'sint16x2'
-  | 'sint16x4'
-  | 'unorm16x2'
-  | 'unorm16x4'
-  | 'snorm16x2'
-  | 'snorm16x4'
-  // 32 bit integers
-  | 'uint32'
-  | 'uint32x2'
-  | 'uint32x3'
-  | 'uint32x4'
-  | 'sint32'
-  | 'sint32x2'
-  | 'sint32x3'
-  | 'sint32x4'
-  // No normalized 32 bit integers in WebGPU...
-  // | 'unorm32'
-  // | 'unorm32x2'
-  // | 'unorm32x3'
-  // | 'unorm32x4'
-  // | 'snorm32'
-  // | 'snorm32x2'
-  // | 'snorm32x3'
-  // | 'snorm32x4'
-  // floats
-  | 'float16x2'
-  | 'float16x4'
-  | 'float32'
-  | 'float32x2'
-  | 'float32x3'
-  | 'float32x4';

package/src/gpu-type-utils/wgsl-utils.ts

@@ -1,22 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {ShaderAttributeType} from './shader-types';
-
-/**  Predeclared aliases @see https://www.w3.org/TR/WGSL/#vector-types */
-export const WGSL_TYPE_ALIAS_MAP: Record<string, ShaderAttributeType> = {
-  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>'
-};