@luma.gl/core 9.2.5 → 9.3.0-alpha.10

package/dist/shadertypes/vertex-arrays/vertex-formats.d.ts

@@ -1,27 +0,0 @@
-import { NormalizedDataType } from "../data-types/data-types.js";
-/**
- * Describes the **memory format** and interpretation (normalization) of a buffer that will be supplied to vertex attributes
- * @note Must be compatible with the AttributeShaderType of the shaders, see documentation.
- * @note This is a superset of WebGPU vertex formats to allow for some flexibility for WebGL only applications
- * @todo Add device.isTextureFormatSupported() method?
- */
-export type VertexFormat = 'uint8' | 'uint8x2' | 'uint8x4' | 'sint8' | 'sint8x2' | 'sint8x4' | 'unorm8' | 'unorm8x2' | 'unorm8x3-webgl' | 'unorm8x4' | 'unorm8x4-bgra' | 'unorm10-10-10-2' | 'snorm8' | 'snorm8x2' | 'snorm8x3-webgl' | 'snorm8x4' | 'uint16' | 'sint16' | 'unorm16' | 'snorm16' | 'uint16x2' | 'uint16x4' | 'sint16x2' | 'sint16x4' | 'unorm16x2' | 'unorm16x4' | 'snorm16x2' | 'snorm16x4' | 'uint32' | 'uint32x2' | 'uint32x3' | 'uint32x4' | 'sint32' | 'sint32x2' | 'sint32x3' | 'sint32x4' | 'float16' | 'float16x2' | 'float16x4' | 'float32' | 'float32x2' | 'float32x3' | 'float32x4';
-export type VertexFormatInfo = {
-    /** Type of each component */
-    type: NormalizedDataType;
-    /** Length in bytes */
-    byteLength: number;
-    /** 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 bgra format? */
-    bgra?: boolean;
-    /** Is this a webgl only format? */
-    webglOnly?: boolean;
-};
-//# sourceMappingURL=vertex-formats.d.ts.map

package/dist/shadertypes/vertex-arrays/vertex-formats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vertex-formats.d.ts","sourceRoot":"","sources":["../../../src/shadertypes/vertex-arrays/vertex-formats.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,kBAAkB,EAAC,oCAAiC;AAI5D;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAEpB,OAAO,GACP,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,SAAS,GACT,QAAQ,GACR,UAAU,GACV,gBAAgB,GAChB,UAAU,GACV,eAAe,GACf,iBAAiB,GAEjB,QAAQ,GACR,UAAU,GACV,gBAAgB,GAChB,UAAU,GAEV,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,SAAS,GACT,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,SAAS,GACT,WAAW,GACX,WAAW,GACX,SAAS,GACT,WAAW,GACX,WAAW,GACX,WAAW,CAAC;AAEhB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,6BAA6B;IAC7B,IAAI,EAAE,kBAAkB,CAAC;IACzB,sBAAsB;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC1B,6EAA6E;IAC7E,OAAO,EAAE,OAAO,CAAC;IACjB,+BAA+B;IAC/B,MAAM,EAAE,OAAO,CAAC;IAChB,mCAAmC;IACnC,UAAU,EAAE,OAAO,CAAC;IACpB,6BAA6B;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,mCAAmC;IACnC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC"}

package/dist/shadertypes/vertex-arrays/vertex-formats.js.map

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

package/src/portable/uniform-buffer-layout.ts

@@ -1,118 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {PrimitiveDataType} from '../shadertypes/data-types/data-types';
-import type {VariableShaderType} from '../shadertypes/data-types/shader-types';
-import {alignTo} from '../shadertypes/data-types/decode-data-types';
-import {getVariableShaderTypeInfo} from '../shadertypes/data-types/decode-shader-types';
-
-import type {UniformValue} from '../adapter/types/uniforms';
-import {getScratchArrayBuffer} from '../utils/array-utils-flat';
-import {isNumberArray} from '../utils/is-array';
-import {log} from '../utils/log';
-
-/**
- * Smallest buffer size that can be used for uniform buffers.
- * TODO - does this depend on device?
- */
-const minBufferSize: number = 1024;
-
-/**
- * Std140 layout for uniform buffers
- * Supports manual listing of uniforms
- */
-export class UniformBufferLayout {
-  readonly layout: Record<string, {offset: number; size: number; type: PrimitiveDataType}> = {};
-
-  /** number of bytes needed for buffer allocation */
-  readonly byteLength: number;
-
-  /** Create a new UniformBufferLayout given a map of attributes. */
-  constructor(
-    uniformTypes: Record<string, VariableShaderType>,
-    uniformSizes: Record<string, number> = {}
-  ) {
-    /** number of 4 byte slots taken */
-    let size: number = 0;
-
-    // Add layout (type, size and offset) definitions for each uniform in the layout
-    for (const [key, uniformType] of Object.entries(uniformTypes)) {
-      const typeAndComponents = getVariableShaderTypeInfo(uniformType);
-      const {type, components} = typeAndComponents;
-      // Calculate total count for uniform arrays.
-      const count = components * (uniformSizes?.[key] ?? 1);
-      // First, align (bump) current offset to an even multiple of current object (1, 2, 4)
-      size = alignTo(size, count);
-      // Use the aligned size as the offset of the current uniform.
-      const offset = size;
-      // Then, add our object's padded size ((1, 2, multiple of 4) to the current offset
-      size += count;
-      this.layout[key] = {type, size: count, offset};
-    }
-    size += (4 - (size % 4)) % 4;
-
-    const actualByteLength = size * 4;
-    this.byteLength = Math.max(actualByteLength, minBufferSize);
-  }
-
-  /** Get the data for the complete buffer */
-  getData(uniformValues: Record<string, UniformValue>): Uint8Array {
-    // Allocate three typed arrays pointing at same memory
-    const arrayBuffer = getScratchArrayBuffer(this.byteLength);
-    const typedArrays = {
-      i32: new Int32Array(arrayBuffer),
-      u32: new Uint32Array(arrayBuffer),
-      f32: new Float32Array(arrayBuffer),
-      // TODO not implemented
-      f16: new Uint16Array(arrayBuffer)
-    };
-
-    for (const [name, value] of Object.entries(uniformValues)) {
-      const uniformLayout = this.layout[name];
-      if (!uniformLayout) {
-        log.warn(`Supplied uniform value ${name} not present in uniform block layout`)();
-        // eslint-disable-next-line no-continue
-        continue;
-      }
-
-      const {type, size, offset} = uniformLayout;
-      const typedArray = typedArrays[type];
-      if (size === 1) {
-        if (typeof value !== 'number' && typeof value !== 'boolean') {
-          log.warn(
-            `Supplied value for single component uniform ${name} is not a number: ${value}`
-          )();
-          // eslint-disable-next-line no-continue
-          continue;
-        }
-        // single value -> just set it
-        typedArray[offset] = Number(value);
-      } else {
-        if (!isNumberArray(value)) {
-          log.warn(
-            `Supplied value for multi component / array uniform ${name} is not a numeric array: ${value}`
-          )();
-          // eslint-disable-next-line no-continue
-          continue;
-        }
-        // vector/matrix -> copy the supplied (typed) array, starting from offset
-        // TODO: we should limit or check size in case the supplied data overflows
-        typedArray.set(value, offset);
-      }
-    }
-
-    return new Uint8Array(arrayBuffer, 0, this.byteLength);
-  }
-
-  /** Does this layout have a field with specified name */
-  has(name: string) {
-    return Boolean(this.layout[name]);
-  }
-
-  /** Get offset and size for a field with specified name */
-  get(name: string): {offset: number; size: number} | undefined {
-    const layout = this.layout[name];
-    return layout;
-  }
-}

package/src/shadertypes/data-types/shader-types.ts

@@ -1,87 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {PrimitiveDataType} from './data-types';
-
-/**
- * Describes the type of an attribute as defined in the shader source code.
- * @note This is a subset of shader variable types
- * @note Buffers with various `VertexFormat`s can be supplied for each type, GPU will convert them at runtime/
- */
-export type AttributeShaderType =
-  | PrimitiveDataType
-  | `vec2<${PrimitiveDataType}>`
-  | `vec3<${PrimitiveDataType}>`
-  | `vec4<${PrimitiveDataType}>`;
-
-/**
- * Describes the type of a variable that can declared in shader source code.
- * @note Uniforms can be declared using these types
- * @note Uniforms can be of a wider range of types than attributes.
- * @note to WebGL users: "bindings" (textures, samplers, and uniform buffers) are considered "bindings", not shader variables/uniforms
- */
-export type VariableShaderType =
-  | PrimitiveDataType
-  | `vec2<${PrimitiveDataType}>`
-  | `vec3<${PrimitiveDataType}>`
-  | `vec4<${PrimitiveDataType}>`
-  | `mat2x2<${PrimitiveDataType}>`
-  | `mat2x3<${PrimitiveDataType}>`
-  | `mat2x4<${PrimitiveDataType}>`
-  | `mat3x2<${PrimitiveDataType}>`
-  | `mat3x3<${PrimitiveDataType}>`
-  | `mat3x4<${PrimitiveDataType}>`
-  | `mat4x2<${PrimitiveDataType}>`
-  | `mat4x3<${PrimitiveDataType}>`
-  | `mat4x4<${PrimitiveDataType}>`;
-
-/* Suffixes used by WGSL alias types */
-type ShaderTypeAliasSuffix = 'f' | 'i' | 'u' | 'h';
-
-/** Shorthand type aliases recognized by WGSL */
-export type AttributeShaderTypeAlias =
-  | `vec2${ShaderTypeAliasSuffix}`
-  | `vec3${ShaderTypeAliasSuffix}`
-  | `vec4${ShaderTypeAliasSuffix}`;
-
-/** Shorthand type aliases recognized by WGSL */
-export type VariableShaderTypeAlias =
-  | AttributeShaderTypeAlias
-  | `mat2x2${ShaderTypeAliasSuffix}`
-  | `mat2x3${ShaderTypeAliasSuffix}`
-  | `mat2x4${ShaderTypeAliasSuffix}`
-  | `mat3x2${ShaderTypeAliasSuffix}`
-  | `mat3x3${ShaderTypeAliasSuffix}`
-  | `mat3x4${ShaderTypeAliasSuffix}`
-  | `mat4x2${ShaderTypeAliasSuffix}`
-  | `mat4x3${ShaderTypeAliasSuffix}`
-  | `mat4x4${ShaderTypeAliasSuffix}`;
-
-/** A composite shader type can include structs and arrays, recursively */
-export type CompositeShaderType = VariableShaderType | StructShaderType | ArrayShaderType;
-
-/** Represents a struct in WGSL */
-export type StructShaderType = {
-  members: Record<string, CompositeShaderType>;
-};
-
-/** Represents an array in WGSL */
-export type ArrayShaderType = {
-  type: CompositeShaderType;
-  length: number;
-};
-
-/** Information extracted from a AttributeShaderType constant */
-export type AttributeShaderTypeInfo = {
-  /** WGSL-style primitive data type, f32, i32, u32 */
-  primitiveType: PrimitiveDataType;
-  /** 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;
-};

package/src/shadertypes/vertex-arrays/decode-vertex-format.ts

@@ -1,124 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {TypedArray} from '../../types';
-import type {NormalizedDataType, PrimitiveDataType, SignedDataType} from '../data-types/data-types';
-import type {VertexFormat, VertexFormatInfo} from './vertex-formats';
-import {getDataTypeInfo, getDataType, getNormalizedDataType} from '../data-types/decode-data-types';
-
-/**
- * Decodes a vertex format, returning type, components, byte  length and flags (integer, signed, normalized)
- */
-export function getVertexFormatInfo(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 NormalizedDataType;
-  const components = (count ? parseInt(count) : 1) as 1 | 2 | 3 | 4;
-  // decode the type
-  const decodedType = getDataTypeInfo(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;
-}
-
-/** Build a vertex format from a signed data type and a component */
-export function makeVertexFormat(
-  signedDataType: SignedDataType,
-  components: 1 | 2 | 3 | 4,
-  normalized?: boolean
-): VertexFormat {
-  const dataType: NormalizedDataType = normalized
-    ? getNormalizedDataType(signedDataType)
-    : signedDataType;
-
-  switch (dataType) {
-    // TODO - Special cases for WebGL (not supported on WebGPU), overrides the check below
-    case 'unorm8':
-      if (components === 1) {
-        return 'unorm8';
-      }
-      if (components === 3) {
-        return 'unorm8x3-webgl';
-      }
-      return `${dataType}x${components}`;
-
-    case 'snorm8':
-    case 'uint8':
-    case 'sint8':
-    // WebGPU 8 bit formats must be aligned to 16 bit boundaries');
-    // fall through
-    case 'uint16':
-    case 'sint16':
-    case 'unorm16':
-    case 'snorm16':
-    case 'float16':
-      // WebGPU 16 bit formats must be aligned to 32 bit boundaries
-      if (components === 1 || components === 3) {
-        throw new Error(`size: ${components}`);
-      }
-      return `${dataType}x${components}`;
-
-    default:
-      return components === 1 ? dataType : `${dataType}x${components}`;
-  }
-}
-
-/** 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;
-  const signedDataType = getDataType(typedArray);
-  return makeVertexFormat(signedDataType, components, normalized);
-}
-
-/** Return a "default" vertex format for a certain shader data type
- The simplest vertex format that matches the shader attribute's data type */
-
-export function getCompatibleVertexFormat(opts: {
-  primitiveType: PrimitiveDataType;
-  components: 1 | 2 | 3 | 4;
-}): VertexFormat {
-  let vertexType: NormalizedDataType;
-  switch (opts.primitiveType) {
-    case 'f32':
-      vertexType = 'float32';
-      break;
-    case 'i32':
-      vertexType = 'sint32';
-      break;
-    case 'u32':
-      vertexType = 'uint32';
-      break;
-    case 'f16':
-      return opts.components <= 2 ? 'float16x2' : 'float16x4';
-  }
-
-  // TODO logic does not work for float16
-  if (opts.components === 1) {
-    return vertexType;
-  }
-  return `${vertexType}x${opts.components}`;
-}

package/src/shadertypes/vertex-arrays/vertex-formats.ts

@@ -1,91 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {NormalizedDataType} from '../data-types/data-types';
-
-/*
- */
-/**
- * Describes the **memory format** and interpretation (normalization) of a buffer that will be supplied to vertex attributes
- * @note Must be compatible with the AttributeShaderType of the shaders, see documentation.
- * @note This is a superset of WebGPU vertex formats to allow for 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)
-  | 'uint8' // Chrome 133+
-  | 'uint8x2'
-  | 'uint8x4'
-  | 'sint8' // Chrome 133+
-  | 'sint8x2'
-  | 'sint8x4'
-  | 'unorm8' // Chrome 133+
-  | 'unorm8x2'
-  | 'unorm8x3-webgl' // Not in WebGPU
-  | 'unorm8x4'
-  | 'unorm8x4-bgra' // Chrome 133+
-  | 'unorm10-10-10-2' // Chrome 119+
-  // | 'snorm-10-10-10-2' // Not in WebGPU, DXD12 doesn't support
-  | 'snorm8' // Chrome 133+
-  | 'snorm8x2'
-  | 'snorm8x3-webgl'
-  | 'snorm8x4'
-  // 16 bit integers, that only 32 bit aligned formats are supported in WebGPU (x2 and x4)
-  | 'uint16' // Chrome 133+
-  | 'sint16' // Chrome 133+
-  | 'unorm16' // Chrome 133+
-  | 'snorm16' // Chrome 133+
-  | '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
-  | 'float16' // Chrome 133+
-  | 'float16x2'
-  | 'float16x4'
-  | 'float32'
-  | 'float32x2'
-  | 'float32x3'
-  | 'float32x4';
-
-export type VertexFormatInfo = {
-  /** Type of each component */
-  type: NormalizedDataType;
-  /** Length in bytes */
-  byteLength: number;
-  /** 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 bgra format? */
-  bgra?: boolean;
-  /** Is this a webgl only format? */
-  webglOnly?: boolean;
-};