@luma.gl/core 9.3.0-alpha.2 → 9.3.0-alpha.6

package/src/shadertypes/textures/texture-format-decoder.ts

@@ -84,11 +84,20 @@ function computeTextureMemoryLayout({
   depth,
   byteAlignment
 }: TextureMemoryLayoutOptions): TextureMemoryLayout {
-  const {bytesPerPixel} = textureFormatDecoder.getInfo(format);
-  // WebGPU requires bytesPerRow to be a multiple of 256.
-  const unpaddedBytesPerRow = width * bytesPerPixel;
+  const formatInfo = textureFormatDecoder.getInfo(format);
+  const {
+    bytesPerPixel,
+    bytesPerBlock = bytesPerPixel,
+    blockWidth = 1,
+    blockHeight = 1,
+    compressed = false
+  } = formatInfo;
+  const blockColumns = compressed ? Math.ceil(width / blockWidth) : width;
+  const blockRows = compressed ? Math.ceil(height / blockHeight) : height;
+  // byteAlignment comes from the backend/call site. WebGPU buffer copies use 256, queue.writeTexture uses 1.
+  const unpaddedBytesPerRow = blockColumns * bytesPerBlock;
   const bytesPerRow = Math.ceil(unpaddedBytesPerRow / byteAlignment) * byteAlignment;
-  const rowsPerImage = height;
+  const rowsPerImage = blockRows;
   const byteLength = bytesPerRow * rowsPerImage * depth;
 
   return {
@@ -120,9 +129,10 @@ function getTextureFormatCapabilities(format: TextureFormat): TextureFormatCapab
   const isSigned = formatInfo?.signed;
   const isInteger = formatInfo?.integer;
   const isWebGLSpecific = formatInfo?.webgl;
+  const isCompressed = Boolean(formatInfo?.compressed);
 
-  // signed formats are not renderable
-  formatCapabilities.render &&= !isSigned;
+  // Only uncompressed color formats can be used as color-renderable attachments.
+  formatCapabilities.render &&= !isDepthStencil && !isCompressed;
   // signed and integer formats are not filterable
   formatCapabilities.filter &&= !isDepthStencil && !isSigned && !isInteger && !isWebGLSpecific;
 
@@ -143,6 +153,7 @@ export function getTextureFormatInfo(format: TextureFormat): TextureFormatInfo {
     formatInfo.bytesPerPixel = 1;
     formatInfo.srgb = false;
     formatInfo.compressed = true;
+    formatInfo.bytesPerBlock = getCompressedTextureBlockByteLength(format);
 
     const blockSize = getCompressedTextureBlockSize(format);
     if (blockSize) {
@@ -158,7 +169,7 @@ export function getTextureFormatInfo(format: TextureFormat): TextureFormatInfo {
     const dataType = `${type}${length}` as NormalizedDataType;
     const decodedType = getDataTypeInfo(dataType);
     const bits = decodedType.byteLength * 8;
-    const components = channels.length as 1 | 2 | 3 | 4;
+    const components = (channels?.length ?? 1) as 1 | 2 | 3 | 4;
     const bitsPerChannel: [number, number, number, number] = [
       bits,
       components >= 2 ? bits : 0,
@@ -176,7 +187,7 @@ export function getTextureFormatInfo(format: TextureFormat): TextureFormatInfo {
       signed: decodedType.signed,
       normalized: decodedType.normalized,
       bitsPerChannel,
-      bytesPerPixel: decodedType.byteLength * channels.length,
+      bytesPerPixel: decodedType.byteLength * components,
       packed: formatInfo.packed,
       srgb: formatInfo.srgb
     };
@@ -245,9 +256,63 @@ function getCompressedTextureBlockSize(
     const [, blockWidth, blockHeight] = matches;
     return {blockWidth: Number(blockWidth), blockHeight: Number(blockHeight)};
   }
+
+  if (
+    format.startsWith('bc') ||
+    format.startsWith('etc1') ||
+    format.startsWith('etc2') ||
+    format.startsWith('eac') ||
+    format.startsWith('atc')
+  ) {
+    return {blockWidth: 4, blockHeight: 4};
+  }
+
+  if (format.startsWith('pvrtc-rgb4') || format.startsWith('pvrtc-rgba4')) {
+    return {blockWidth: 4, blockHeight: 4};
+  }
+
+  if (format.startsWith('pvrtc-rgb2') || format.startsWith('pvrtc-rgba2')) {
+    return {blockWidth: 8, blockHeight: 4};
+  }
+
   return null;
 }
 
+function getCompressedTextureBlockByteLength(format: TextureFormatCompressed): number {
+  if (
+    format.startsWith('bc1') ||
+    format.startsWith('bc4') ||
+    format.startsWith('etc1') ||
+    format.startsWith('etc2-rgb8') ||
+    format.startsWith('etc2-rgb8a1') ||
+    format.startsWith('eac-r11') ||
+    format === 'atc-rgb-unorm-webgl'
+  ) {
+    return 8;
+  }
+
+  if (
+    format.startsWith('bc2') ||
+    format.startsWith('bc3') ||
+    format.startsWith('bc5') ||
+    format.startsWith('bc6h') ||
+    format.startsWith('bc7') ||
+    format.startsWith('etc2-rgba8') ||
+    format.startsWith('eac-rg11') ||
+    format.startsWith('astc') ||
+    format === 'atc-rgba-unorm-webgl' ||
+    format === 'atc-rgbai-unorm-webgl'
+  ) {
+    return 16;
+  }
+
+  if (format.startsWith('pvrtc')) {
+    return 8;
+  }
+
+  return 16;
+}
+
 /*
 'r8unorm':	{s: "float"}, // 	✓	✓	✓	},
 'r8snorm':	{s: "float"}, // 		✓		},

package/src/shadertypes/textures/texture-format-table.ts

@@ -24,6 +24,7 @@ const float32_renderable: TextureFeature = 'float32-renderable-webgl';
 const float16_renderable: TextureFeature = 'float16-renderable-webgl';
 const rgb9e5ufloat_renderable: TextureFeature = 'rgb9e5ufloat-renderable-webgl';
 const snorm8_renderable: TextureFeature = 'snorm8-renderable-webgl';
+const norm16_webgl: TextureFeature = 'norm16-webgl';
 const norm16_renderable: TextureFeature = 'norm16-renderable-webgl';
 const snorm16_renderable: TextureFeature = 'snorm16-renderable-webgl';
 
@@ -93,15 +94,15 @@ const TEXTURE_FORMAT_COLOR_DEPTH_TABLE: Readonly<Record<TextureFormatColorUncomp
   'bgra8unorm-srgb': {},
 
 
-  'r16unorm': {f: norm16_renderable},
-  'rg16unorm': {render: norm16_renderable},
-  'rgb16unorm-webgl': {f: norm16_renderable}, // rgb not renderable
-  'rgba16unorm': {render: norm16_renderable},
+  'r16unorm': {f: norm16_webgl, render: norm16_renderable},
+  'rg16unorm': {f: norm16_webgl, render: norm16_renderable},
+  'rgb16unorm-webgl': {f: norm16_webgl, render: false}, // rgb not renderable
+  'rgba16unorm': {f: norm16_webgl, render: norm16_renderable},
 
-  'r16snorm': {f: snorm16_renderable},
-  'rg16snorm': {render: snorm16_renderable},
-  'rgb16snorm-webgl': {f: norm16_renderable}, // rgb not renderable
-  'rgba16snorm': {render: snorm16_renderable},
+  'r16snorm': {f: norm16_webgl, render: snorm16_renderable},
+  'rg16snorm': {f: norm16_webgl, render: snorm16_renderable},
+  'rgb16snorm-webgl': {f: norm16_webgl, render: false}, // rgb not renderable
+  'rgba16snorm': {f: norm16_webgl, render: snorm16_renderable},
 
   'r16uint': {},
   'rg16uint': {},
@@ -225,7 +226,7 @@ const TEXTURE_FORMAT_COMPRESSED_TABLE: Readonly<Record<TextureFormatCompressed,
 
   'pvrtc-rgb4unorm-webgl': {f: texture_compression_pvrtc_webgl},
   'pvrtc-rgba4unorm-webgl': {f: texture_compression_pvrtc_webgl},
-  'pvrtc-rbg2unorm-webgl': {f: texture_compression_pvrtc_webgl},
+  'pvrtc-rgb2unorm-webgl': {f: texture_compression_pvrtc_webgl},
   'pvrtc-rgba2unorm-webgl': {f: texture_compression_pvrtc_webgl},
 
   // WEBGL_compressed_texture_etc1

package/src/shadertypes/textures/texture-formats.ts

@@ -18,6 +18,8 @@ export type TextureFormatInfo = {
   dataType?: NormalizedDataType;
   /** Number of bytes per pixel */
   bytesPerPixel: number;
+  /** Compressed formats only: Number of bytes per block */
+  bytesPerBlock?: number;
   /** Number of bits per channel (may be unreliable for packed formats) */
   bitsPerChannel: [number, number, number, number];
   /** If this is a packed data type */
@@ -116,6 +118,7 @@ export type TextureFeature =
   | 'float16-renderable-webgl'
   | 'rgb9e5ufloat-renderable-webgl'
   | 'snorm8-renderable-webgl'
+  | 'norm16-webgl'
   | 'norm16-renderable-webgl'
   | 'snorm16-renderable-webgl'
   | 'float32-filterable'
@@ -205,7 +208,7 @@ export type TextureFormatCompressed =
   | 'bc1-rgb-unorm-srgb-webgl'
   | 'pvrtc-rgb4unorm-webgl'
   | 'pvrtc-rgba4unorm-webgl'
-  | 'pvrtc-rbg2unorm-webgl'
+  | 'pvrtc-rgb2unorm-webgl'
   | 'pvrtc-rgba2unorm-webgl'
   | 'etc1-rbg-unorm-webgl'
   | 'atc-rgb-unorm-webgl'
@@ -274,6 +277,8 @@ export type TextureFormatCompressed =
   | 'astc-12x12-unorm'
   | 'astc-12x12-unorm-srgb';
 
+export type CompressedTextureFormat = TextureFormatCompressed;
+
 // Texture format helper types
 
 export type TextureFormatTypedArray<T extends TextureFormat> = DataTypeArray<

package/src/utils/array-equal.ts

@@ -4,23 +4,35 @@
 
 import {isNumberArray} from './is-array';
 
-/** Test if two arrays are deep equal, with a length limit that defaults to 16 */
+const MAX_ELEMENTWISE_ARRAY_COMPARE_LENGTH = 128;
+
+/** Test if two arrays are deep equal, with a small-array length limit that defaults to 16 */
 export function arrayEqual(a: unknown, b: unknown, limit: number = 16) {
-  if (a !== b) {
-    return false;
+  if (a === b) {
+    return true;
   }
+
   const arrayA = a;
   const arrayB = b;
-  if (!isNumberArray(arrayA)) {
+  if (!isNumberArray(arrayA) || !isNumberArray(arrayB)) {
+    return false;
+  }
+
+  if (arrayA.length !== arrayB.length) {
     return false;
   }
-  if (isNumberArray(arrayB) && arrayA.length === arrayB.length) {
-    for (let i = 0; i < arrayA.length; ++i) {
-      if (arrayB[i] !== arrayA[i]) {
-        return false;
-      }
+
+  const maxCompareLength = Math.min(limit, MAX_ELEMENTWISE_ARRAY_COMPARE_LENGTH);
+  if (arrayA.length > maxCompareLength) {
+    return false;
+  }
+
+  for (let i = 0; i < arrayA.length; ++i) {
+    if (arrayB[i] !== arrayA[i]) {
+      return false;
     }
   }
+
   return true;
 }
 

package/src/utils/assert.ts

@@ -0,0 +1,18 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Throws if condition is true and narrows type */
+export function assert(condition: unknown, message?: string): asserts condition {
+  if (!condition) {
+    const error = new Error(message ?? 'luma.gl assertion failed.');
+    Error.captureStackTrace?.(error, assert);
+    throw error;
+  }
+}
+
+/** Throws if value is not defined, narrows type */
+export function assertDefined<T>(value: T | undefined, message?: string): T {
+  assert(value, message);
+  return value;
+}

package/src/utils/stats-manager.ts

@@ -2,7 +2,29 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Stats} from '@probe.gl/stats';
+import {Stat, Stats} from '@probe.gl/stats';
+
+const GPU_TIME_AND_MEMORY_STATS = 'GPU Time and Memory';
+const GPU_TIME_AND_MEMORY_STAT_ORDER = [
+  'Adapter',
+  'GPU',
+  'GPU Type',
+  'GPU Backend',
+  'Frame Rate',
+  'CPU Time',
+  'GPU Time',
+  'GPU Memory',
+  'Buffer Memory',
+  'Texture Memory',
+  'Referenced Buffer Memory',
+  'Referenced Texture Memory',
+  'Swap Chain Texture'
+] as const;
+const ORDERED_STATS_CACHE = new WeakMap<
+  Stats,
+  {orderedStatNames: readonly string[]; statCount: number}
+>();
+const ORDERED_STAT_NAME_SET_CACHE = new WeakMap<readonly string[], Set<string>>();
 
 /**
  * Helper class managing a collection of probe.gl stats objects
@@ -19,9 +41,61 @@ export class StatsManager {
       this.stats.set(name, new Stats({id: name}));
     }
 
-    return this.stats.get(name);
+    const stats = this.stats.get(name);
+    if (name === GPU_TIME_AND_MEMORY_STATS) {
+      initializeStats(stats, GPU_TIME_AND_MEMORY_STAT_ORDER);
+    }
+
+    return stats;
   }
 }
 
 /** Global stats for all luma.gl devices */
 export const lumaStats: StatsManager = new StatsManager();
+
+function initializeStats(stats: Stats, orderedStatNames: readonly string[]): void {
+  const statsMap = stats.stats;
+  let addedOrderedStat = false;
+  for (const statName of orderedStatNames) {
+    if (!statsMap[statName]) {
+      stats.get(statName);
+      addedOrderedStat = true;
+    }
+  }
+
+  const statCount = Object.keys(statsMap).length;
+  const cachedStats = ORDERED_STATS_CACHE.get(stats);
+  if (
+    !addedOrderedStat &&
+    cachedStats?.orderedStatNames === orderedStatNames &&
+    cachedStats.statCount === statCount
+  ) {
+    return;
+  }
+
+  const reorderedStats: Record<string, Stat> = {};
+  let orderedStatNamesSet = ORDERED_STAT_NAME_SET_CACHE.get(orderedStatNames);
+  if (!orderedStatNamesSet) {
+    orderedStatNamesSet = new Set(orderedStatNames);
+    ORDERED_STAT_NAME_SET_CACHE.set(orderedStatNames, orderedStatNamesSet);
+  }
+
+  for (const statName of orderedStatNames) {
+    if (statsMap[statName]) {
+      reorderedStats[statName] = statsMap[statName];
+    }
+  }
+
+  for (const [statName, stat] of Object.entries(statsMap)) {
+    if (!orderedStatNamesSet.has(statName)) {
+      reorderedStats[statName] = stat;
+    }
+  }
+
+  for (const statName of Object.keys(statsMap)) {
+    delete statsMap[statName];
+  }
+
+  Object.assign(statsMap, reorderedStats);
+  ORDERED_STATS_CACHE.set(stats, {orderedStatNames, statCount});
+}