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

package/src/adapter-utils/get-attribute-from-layouts.ts

@@ -3,14 +3,14 @@
 // Copyright (c) vis.gl contributors
 
 import {log} from '../utils/log';
-import type {PrimitiveDataType, NormalizedDataType} from '../shadertypes/data-types';
-import type {AttributeShaderType} from '../shadertypes/shader-types';
-import type {VertexFormat} from '../shadertypes/vertex-formats';
-import {getAttributeShaderTypeInfo} from '../shadertypes/utils/decode-shader-types';
+import type {PrimitiveDataType, NormalizedDataType} from '../shadertypes/data-types/data-types';
+import type {AttributeShaderType} from '../shadertypes/data-types/shader-types';
+import type {VertexFormat} from '../shadertypes/vertex-arrays/vertex-formats';
+import {getAttributeShaderTypeInfo} from '../shadertypes/data-types/decode-shader-types';
 import {
   getVertexFormatInfo,
   getCompatibleVertexFormat
-} from '../shadertypes/utils/decode-vertex-format';
+} from '../shadertypes/vertex-arrays/decode-vertex-format';
 import type {ShaderLayout, AttributeDeclaration} from '../adapter/types/shader-layout';
 import type {BufferLayout} from '../adapter/types/buffer-layout';
 

package/src/index.ts

@@ -21,17 +21,13 @@ export type {CanvasContextProps} from './adapter/canvas-context';
 export {CanvasContext} from './adapter/canvas-context';
 
 // GPU RESOURCES
-export type {ResourceProps} from './adapter/resources/resource';
-export {Resource} from './adapter/resources/resource';
+export {Resource, type ResourceProps} from './adapter/resources/resource';
 
-export type {BufferProps} from './adapter/resources/buffer';
-export {Buffer} from './adapter/resources/buffer';
+export {Buffer, type BufferProps, type BufferMapCallback} from './adapter/resources/buffer';
 
-export type {TextureProps} from './adapter/resources/texture';
-export {Texture} from './adapter/resources/texture';
+export {Texture, type TextureProps} from './adapter/resources/texture';
 
-export type {TextureViewProps} from './adapter/resources/texture-view';
-export {TextureView} from './adapter/resources/texture-view';
+export {TextureView, type TextureViewProps} from './adapter/resources/texture-view';
 
 export type {ExternalTextureProps} from './adapter/resources/external-texture';
 export {ExternalTexture} from './adapter/resources/external-texture';
@@ -72,6 +68,9 @@ export {TransformFeedback} from './adapter/resources/transform-feedback';
 export type {QuerySetProps} from './adapter/resources/query-set';
 export {QuerySet} from './adapter/resources/query-set';
 
+export type {PipelineLayoutProps} from './adapter/resources/pipeline-layout';
+export {PipelineLayout} from './adapter/resources/pipeline-layout';
+
 // PORTABLE API - UNIFORM BUFFERS
 export {UniformBufferLayout} from './portable/uniform-buffer-layout';
 export {UniformBlock} from './portable/uniform-block';
@@ -82,7 +81,11 @@ export {UniformStore} from './portable/uniform-store';
 export type {CompilerMessage} from './adapter/types/compiler-message';
 
 export type {ExternalImage} from './image-utils/image-types';
-export type {CopyExternalImageOptions, CopyImageDataOptions} from './adapter/resources/texture';
+
+export {
+  type CopyExternalImageOptions,
+  type CopyImageDataOptions
+} from './adapter/resources/texture';
 
 export type {Parameters, PrimitiveTopology, IndexFormat} from './adapter/types/parameters';
 
@@ -110,7 +113,12 @@ export type {
   ComputeShaderLayout,
   AttributeDeclaration,
   BindingDeclaration,
-  Binding
+  Binding,
+  UniformBufferBindingLayout,
+  StorageBufferBindingLayout,
+  TextureBindingLayout,
+  SamplerBindingLayout,
+  StorageTextureBindingLayout
 } from './adapter/types/shader-layout';
 export type {BufferLayout, BufferAttributeLayout} from './adapter/types/buffer-layout';
 export type {
@@ -133,41 +141,58 @@ export type {
   BigTypedArrayConstructor
 } from './types';
 
-// GPU TYPE UTILS - GPU MEMORY LAYOUT TYPES - EXTERNAL
-
-export type {PrimitiveDataType, SignedDataType, NormalizedDataType} from './shadertypes/data-types';
-export type {AttributeShaderType, VariableShaderType} from './shadertypes/shader-types';
-export type {VertexFormat} from './shadertypes/vertex-formats';
-export type {
-  TextureFormat,
-  ColorTextureFormat,
-  DepthStencilTextureFormat,
-  TextureCompression,
-  TextureFormatInfo,
-  TextureFormatCapabilities
-} from './shadertypes/texture-formats';
-
-// GPU TYPE UTILS - GPU MEMORY LAYOUT HELPERS - CAN BE USED BY APPS BUT MOSTLY USED INTERNALLY
+// GPU TYPE UTILS - BASIC DATA TYPES
 
+export {
+  type PrimitiveDataType,
+  type SignedDataType,
+  type NormalizedDataType,
+  type DataTypeInfo,
+  type DataTypeArray,
+  type NormalizedDataTypeArray
+} from './shadertypes/data-types/data-types';
+export {
+  type AttributeShaderType,
+  type VariableShaderType
+} from './shadertypes/data-types/shader-types';
 export {
   getDataTypeInfo,
-  getDataTypeFromTypedArray,
-  getTypedArrayFromDataType,
-  makeNormalizedDataType
-} from './shadertypes/utils/decode-data-types';
+  getDataType,
+  getTypedArrayConstructor,
+  getNormalizedDataType
+} from './shadertypes/data-types/decode-data-types';
 export {
   getVariableShaderTypeInfo,
   getAttributeShaderTypeInfo
-} from './shadertypes/utils/decode-shader-types';
+} from './shadertypes/data-types/decode-shader-types';
+
+// GPU TYPE UTILS - VERTEX ARRAYs
+
+export {type VertexFormat} from './shadertypes/vertex-arrays/vertex-formats';
+
 export {
   getVertexFormatInfo,
   getVertexFormatFromAttribute,
   makeVertexFormat
-} from './shadertypes/utils/decode-vertex-format';
+} from './shadertypes/vertex-arrays/decode-vertex-format';
+
+// GPU TYPE UTILS - Texture Formats
+
+export {
+  type TextureFormat,
+  type TextureFormatColor,
+  type TextureFormatDepthStencil,
+  type TextureCompression,
+  type TextureFormatInfo,
+  type TextureFormatCapabilities
+} from './shadertypes/textures/texture-formats';
+
 export {
-  getTextureFormatInfo,
-  getTextureFormatCapabilities
-} from './shadertypes/utils/decode-texture-format';
+  TextureFormatDecoder,
+  textureFormatDecoder
+} from './shadertypes/textures/texture-format-decoder';
+
+export {type PixelData, readPixel, writePixel} from './shadertypes/textures/pixel-utils';
 
 // GENERAL EXPORTS - FOR APPLICATIONS
 
@@ -186,11 +211,10 @@ export type {
 export {log} from './utils/log';
 export {getScratchArray} from './utils/array-utils-flat';
 export type {AttributeInfo} from './adapter-utils/get-attribute-from-layouts';
-export {BufferLayoutHelper as _BufferLayoutHelper} from './adapter-utils/buffer-layout-helper';
 export {getAttributeInfosFromLayouts} from './adapter-utils/get-attribute-from-layouts';
 
 // TEST EXPORTS
 export {
   getTextureFormatDefinition as _getTextureFormatDefinition,
   getTextureFormatTable as _getTextureFormatTable
-} from './shadertypes/utils/texture-format-table';
+} from './shadertypes/textures/texture-format-table';

package/src/portable/uniform-block.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {VariableShaderType} from '../shadertypes/shader-types';
+import type {VariableShaderType} from '../shadertypes/data-types/shader-types';
 import type {UniformValue} from '../adapter/types/uniforms';
 import {
   ShaderLayout,

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

@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {PrimitiveDataType} from '../shadertypes/data-types';
-import type {VariableShaderType} from '../shadertypes/shader-types';
-import {alignTo} from '../shadertypes/utils/decode-data-types';
-import {getVariableShaderTypeInfo} from '../shadertypes/utils/decode-shader-types';
+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';

package/src/portable/uniform-store.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {VariableShaderType} from '../shadertypes/shader-types';
+import type {VariableShaderType} from '../shadertypes/data-types/shader-types';
 import type {UniformValue} from '../adapter/types/uniforms';
 import type {Device} from '../adapter/device';
 import {Buffer} from '../adapter/resources/buffer';

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

@@ -0,0 +1,96 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/**
+ * Primitive data types that shaders can perform calculations in and declare variables with.
+ * @note attribute inputs and texture samples can be populated from a different in-memory types, see below.
+ * @note `f16` requires the `f16` extension
+ */
+export type PrimitiveDataType = 'u32' | 'i32' | 'f32' | 'f16';
+
+/**
+ * Signed data types describe signed and unsigned integers as well as floats of varying sizes
+ * @note These formats describe physical memory layouts in vertex and pixel formats, they are not used inside shaders
+ */
+export type SignedDataType =
+  | 'uint8'
+  | 'sint8'
+  | 'uint16'
+  | 'sint16'
+  | 'uint32'
+  | 'sint32'
+  | 'float16'
+  | 'float32';
+
+/**
+ * Normalized data types describe signed and unsigned integers as well as floats of varying sizes together with normalization behavior
+ * @note These formats describe physical memory layouts in vertex and pixel formats, they are not used inside shaders
+ * @note Normalization means that these formats are converted into floats on read (shader must use f32 to process them)
+ * @note WebGPU does not support normalized 32 bit integer attributes: 'unorm32' | 'snorm32'
+ */
+export type NormalizedDataType = SignedDataType | 'unorm8' | 'snorm8' | 'unorm16' | 'snorm16';
+
+/** Returns information about a signed or normalized DataType */
+export type DataTypeInfo = {
+  signedType: SignedDataType;
+  primitiveType: PrimitiveDataType;
+  byteLength: 1 | 2 | 4;
+  normalized: boolean;
+  integer: boolean;
+  signed: boolean;
+};
+
+/** Returns a typed array appropriate to hold the actual values of a data type (integers for normalized integers) */
+export type DataTypeArray<T extends NormalizedDataType> = T extends 'uint8'
+  ? Uint8Array
+  : T extends 'sint8'
+    ? Int8Array
+    : T extends 'unorm8'
+      ? Uint8Array
+      : T extends 'snorm8'
+        ? Int8Array
+        : T extends 'uint16'
+          ? Uint16Array
+          : T extends 'sint16'
+            ? Int16Array
+            : T extends 'unorm16'
+              ? Uint16Array
+              : T extends 'snorm16'
+                ? Int16Array
+                : T extends 'uint32'
+                  ? Uint32Array
+                  : T extends 'sint32'
+                    ? Int32Array
+                    : T extends 'float16'
+                      ? Uint16Array
+                      : T extends 'float32'
+                        ? Float32Array
+                        : never;
+
+/** Returns a type array appropriate to hold the logical values of a data type (floats for normalized integers) */
+export type NormalizedDataTypeArray<T extends NormalizedDataType> = T extends 'uint8'
+  ? Uint8Array
+  : T extends 'sint8'
+    ? Int8Array
+    : T extends 'unorm8'
+      ? Float32Array
+      : T extends 'snorm8'
+        ? Float32Array
+        : T extends 'uint16'
+          ? Uint16Array
+          : T extends 'sint16'
+            ? Int16Array
+            : T extends 'unorm16'
+              ? Uint16Array
+              : T extends 'snorm16'
+                ? Int16Array
+                : T extends 'uint32'
+                  ? Uint32Array
+                  : T extends 'sint32'
+                    ? Int32Array
+                    : T extends 'float16'
+                      ? Float32Array
+                      : T extends 'float32'
+                        ? Float32Array
+                        : never;

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

@@ -0,0 +1,91 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {TypedArray, TypedArrayConstructor} from '../../types';
+import {PrimitiveDataType, SignedDataType, NormalizedDataType, DataTypeInfo} from './data-types';
+
+/**
+ * Gets info about a data type constant (signed or normalized)
+ * @returns underlying primitive / signed types, byte length, normalization, integer, signed flags
+ */
+export function getDataTypeInfo(type: NormalizedDataType): DataTypeInfo {
+  const [signedType, primitiveType, byteLength] = NORMALIZED_TYPE_MAP[type];
+  const normalized: boolean = type.includes('norm');
+  const integer: boolean = !normalized && !type.startsWith('float');
+  const signed: boolean = type.startsWith('s');
+  return {
+    signedType,
+    primitiveType,
+    byteLength,
+    normalized,
+    integer,
+    signed
+  };
+}
+
+/** Build a vertex format from a signed data type and a component */
+export function getNormalizedDataType(signedDataType: SignedDataType): NormalizedDataType {
+  const dataType: NormalizedDataType = signedDataType;
+  // prettier-ignore
+  switch (dataType) {
+    case 'uint8': return 'unorm8';
+    case 'sint8': return 'snorm8';
+    case 'uint16': return 'unorm16';
+    case 'sint16': return 'snorm16';
+    default: return dataType;
+  }
+}
+
+/** 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
+  }
+}
+
+/** Returns the VariableShaderType that corresponds to a typed array */
+export function getDataType(arrayOrType: TypedArray | TypedArrayConstructor): SignedDataType {
+  const Constructor = ArrayBuffer.isView(arrayOrType) ? arrayOrType.constructor : arrayOrType;
+  if (Constructor === Uint8ClampedArray) {
+    return 'uint8';
+  }
+  const info = Object.values(NORMALIZED_TYPE_MAP).find(entry => Constructor === entry[4]);
+  if (!info) {
+    throw new Error(Constructor.name);
+  }
+  return info[0];
+}
+
+/** Returns the TypedArray that corresponds to a shader data type */
+export function getTypedArrayConstructor(type: NormalizedDataType): TypedArrayConstructor {
+  const [, , , , Constructor] = NORMALIZED_TYPE_MAP[type];
+  return Constructor;
+}
+
+const NORMALIZED_TYPE_MAP: Record<
+  NormalizedDataType,
+  [
+    SignedDataType,
+    PrimitiveDataType,
+    bytes: 1 | 2 | 4,
+    normalized: boolean,
+    arrayConstructor: TypedArrayConstructor
+  ]
+> = {
+  uint8: ['uint8', 'u32', 1, false, Uint8Array],
+  sint8: ['sint8', 'i32', 1, false, Int8Array],
+  unorm8: ['uint8', 'f32', 1, true, Uint8Array],
+  snorm8: ['sint8', 'f32', 1, true, Int8Array],
+  uint16: ['uint16', 'u32', 2, false, Uint16Array],
+  sint16: ['sint16', 'i32', 2, false, Int16Array],
+  unorm16: ['uint16', 'u32', 2, true, Uint16Array],
+  snorm16: ['sint16', 'i32', 2, true, Int16Array],
+  float16: ['float16', 'f16', 2, false, Uint16Array],
+  float32: ['float32', 'f32', 4, false, Float32Array],
+  uint32: ['uint32', 'u32', 4, false, Uint32Array],
+  sint32: ['sint32', 'i32', 4, false, Int32Array]
+};

package/src/shadertypes/{utils → data-types}/decode-shader-types.ts

@@ -2,14 +2,14 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {PrimitiveDataType} from '../data-types';
+import {PrimitiveDataType} from './data-types';
 import type {
   VariableShaderType,
   AttributeShaderType,
   AttributeShaderTypeInfo,
   VariableShaderTypeAlias,
   AttributeShaderTypeAlias
-} from '../shader-types';
+} from './shader-types';
 
 /** Split a uniform type string into type and components */
 export function getVariableShaderTypeInfo(format: VariableShaderType): {

package/src/shadertypes/textures/pixel-utils.ts

@@ -0,0 +1,239 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export type ImageData = {
+  /** Offset into the data (in addition to any offset built-in to the ArrayBufferView) */
+  byteOffset?: number;
+  /** The stride, in bytes, between the beginning of each texel block row and the subsequent texel block row. Required if there are multiple texel block rows (i.e. the copy height or depth is more than one block). */
+  bytesPerRow?: number;
+  /** Number or rows per image (needed if multiple images are being set) */
+  rowsPerImage?: number;
+  /** Bits per channel */
+  bitsPerChannel: [number, number, number, number];
+};
+
+export type PixelData = {
+  arrayBuffer: ArrayBuffer;
+  width: number;
+  height: number;
+  /** Bytes per pixel */
+  bytesPerPixel: number;
+  bytesPerRow: number;
+  bitsPerChannel: [number, number, number, number];
+};
+
+/**
+ * Extracts a single RGBA pixel value from PixelData at the given (x, y) coordinate.
+ *
+ * The pixel's data is assumed to be packed according to pixelData.bitsPerChannel.
+ * The pixel data for a given row is padded to pixelData.bytesPerRow.
+ *
+ * @param pixelData - The metadata and data for the pixel buffer.
+ * @param x - The x coordinate (0-based).
+ * @param y - The y coordinate (0-based).
+ * @returns A tuple [r, g, b, a] where each channel is the extracted numeric value.
+ *
+* @example
+
+Assume you obtained an ArrayBuffer from copyTextureToBuffer and have the following metadata:
+
+  const pixelData: PixelData = {
+    bitsPerChannel: [5, 6, 5, 0], // For example, a 16-bit RGB565 format (no alpha)
+    width: 800,
+    height: 600,
+    bytesPerPixel: 2,           // 16 bits per pixel
+    bytesPerRow: 1600,          // Assuming no extra padding
+    arrayBuffer: myTextureBuffer, // Obtained from copyTextureToBuffer
+  };
+
+You can then extract the pixel at (x, y) like so:
+
+  const rgba = extractPixel(pixelData, x, y);
+  console.log("Extracted RGBA:", rgba);
+
+For RGBA formats where all channels are present (e.g. [8, 8, 8, 8]), the function will extract a 4-channel pixel value.
+*/
+
+export function readPixel(
+  pixelData: PixelData,
+  x: number,
+  y: number,
+  bitsPerChannel: [number, number, number, number]
+): [number, number, number, number] {
+  if (x < 0 || x >= pixelData.width || y < 0 || y >= pixelData.height) {
+    throw new Error('Coordinates out of bounds.');
+  }
+
+  // Compute the byte offset of the pixel in the buffer.
+  const byteOffset = y * pixelData.bytesPerRow + x * pixelData.bytesPerPixel;
+
+  // Create a Uint8Array view for this pixel's bytes.
+  // We only need to view pixelData.bytesPerPixel bytes.
+  const pixelDataView = new DataView(pixelData.arrayBuffer, byteOffset, pixelData.bytesPerPixel);
+
+  let bitOffsetWithinPixel = 0;
+  const channels: number[] = [];
+
+  // Extract each of the four channels.
+  for (let i = 0; i < 4; i++) {
+    const bits = bitsPerChannel[i];
+    // If a channel's bit width is zero or negative, consider it not present.
+    if (bits <= 0) {
+      channels.push(0);
+    } else {
+      const channelValue = readBitsFromDataView(pixelDataView, bitOffsetWithinPixel, bits);
+      channels.push(channelValue);
+      bitOffsetWithinPixel += bits;
+    }
+  }
+
+  return [channels[0], channels[1], channels[2], channels[3]];
+}
+
+/**
+ * Encodes an RGBA pixel into a DataView at a given bit offset according to a specified bit layout.
+ *
+ * The channels are written sequentially in the order R, G, B, A. For each channel, the number
+ * of bits is taken from the bitsPerChannel array. Channel values are masked to fit within the specified width.
+ *
+ * @param dataView - The DataView into which the pixel will be encoded.
+ * @param bitOffset - The bit offset in the DataView where the pixel should be written.
+ * @param bitsPerChannel - A tuple specifying the number of bits for each channel: [R, G, B, A].
+ * @param pixel - A tuple [r, g, b, a] containing the channel values (as numbers).
+ *
+ * @example
+
+Assume you want to encode a pixel into a packed format where:
+  - Red uses 5 bits
+  - Green uses 6 bits
+  - Blue uses 5 bits
+  - Alpha is not used (0 bits)
+And the pixel format is packed into 16 bits total.
+
+You might have:
+  const bitsPerChannel: [number, number, number, number] = [5, 6, 5, 0];
+  const pixel: [number, number, number, number] = [15, 31, 15, 0]; // Example values
+  const buffer = new ArrayBuffer(2); // 16 bits = 2 bytes
+  const dataView = new DataView(buffer);
+
+Now encode the pixel at bit offset 0:
+  encodePixel(dataView, 0, bitsPerChannel, pixel);
+
+The dataView now contains the 16-bit packed pixel value in big-endian order.
+*/
+export function writePixel(
+  dataView: DataView,
+  bitOffset: number,
+  bitsPerChannel: [number, number, number, number],
+  pixel: [number, number, number, number]
+): void {
+  let currentBitOffset = bitOffset;
+  for (let channel = 0; channel < 4; channel++) {
+    const bits = bitsPerChannel[channel];
+    // Clamp the channel value to the maximum allowed by the bit width.
+    const maxValue = (1 << bits) - 1;
+    const channelValue = pixel[channel] & maxValue;
+    writeBitsToDataView(dataView, currentBitOffset, bits, channelValue);
+    currentBitOffset += bits;
+  }
+}
+
+/**
+ * Reads a specified number of bits from a DataView starting at a given bit offset.
+ *
+ * For channels with a bit width of 8, 16, or 32 bits and when the bitOffset is byte-aligned,
+ * this function uses DataView methods for fast extraction.
+ *
+ * Bits are assumed to be stored in big-endian order (i.e. the most-significant bit is at position 7 in each byte).
+ *
+ * @param dataView - The DataView containing the data.
+ * @param bitOffset - The offset (in bits) within the data from which to start reading.
+ * @param bitCount - The number of bits to read (supported range: 1 to 32).
+ * @returns The extracted value as a number.
+ */
+export function readBitsFromDataView(
+  dataView: DataView,
+  bitOffset: number,
+  bitCount: number
+): number {
+  // Check if we can optimize when bitOffset is byte-aligned.
+  if (bitOffset % 8 === 0) {
+    const byteOffset = bitOffset / 8;
+    if (bitCount === 8 && byteOffset + 1 <= dataView.byteLength) {
+      return dataView.getUint8(byteOffset);
+    } else if (bitCount === 16 && byteOffset + 2 <= dataView.byteLength) {
+      // false for big-endian reading.
+      return dataView.getUint16(byteOffset, false);
+    } else if (bitCount === 32 && byteOffset + 4 <= dataView.byteLength) {
+      return dataView.getUint32(byteOffset, false);
+    }
+  }
+
+  // Fallback: bit-level extraction for non-aligned or non-standard bit widths.
+  let value = 0;
+  for (let i = 0; i < bitCount; i++) {
+    const overallBitIndex = bitOffset + i;
+    const byteIndex = Math.floor(overallBitIndex / 8);
+    const bitIndex = overallBitIndex % 8;
+    // Read the byte and extract the bit at position (7 - bitIndex).
+    const byteValue = dataView.getUint8(byteIndex);
+    const bit = (byteValue >> (7 - bitIndex)) & 1;
+    value = (value << 1) | bit;
+  }
+  return value;
+}
+
+/**
+ * Writes a specified number of bits from a value into a DataView at a given bit offset.
+ *
+ * For channels with a bit width of 8, 16, or 32 bits and when the bit offset is byte-aligned,
+ * this function uses DataView methods for fast writing.
+ *
+ * Bits are assumed to be stored in big-endian order (i.e. the most-significant bit is at position 7 in each byte).
+ *
+ * @param dataView - The DataView to write into.
+ * @param bitOffset - The bit offset at which to begin writing.
+ * @param bitCount - The number of bits to write (supported range: 1 to 32).
+ * @param value - The numeric value whose lower bitCount bits will be written.
+ */
+export function writeBitsToDataView(
+  dataView: DataView,
+  bitOffset: number,
+  bitCount: number,
+  value: number
+): void {
+  // If the bitOffset is byte-aligned, we may optimize for common bit widths.
+  if (bitOffset % 8 === 0) {
+    const byteOffset = bitOffset / 8;
+    if (bitCount === 8 && byteOffset + 1 <= dataView.byteLength) {
+      dataView.setUint8(byteOffset, value & 0xff);
+      return;
+    } else if (bitCount === 16 && byteOffset + 2 <= dataView.byteLength) {
+      dataView.setUint16(byteOffset, value & 0xffff, false); // big-endian
+      return;
+    } else if (bitCount === 32 && byteOffset + 4 <= dataView.byteLength) {
+      dataView.setUint32(byteOffset, value, false); // big-endian
+      return;
+    }
+  }
+
+  // Fallback: write bit-by-bit.
+  for (let i = 0; i < bitCount; i++) {
+    const overallBitIndex = bitOffset + i;
+    const byteIndex = Math.floor(overallBitIndex / 8);
+    const bitIndex = overallBitIndex % 8;
+    const mask = 1 << (7 - bitIndex);
+    // Extract the i-th bit from value (starting from the most-significant bit)
+    const bitValue = (value >> (bitCount - 1 - i)) & 1;
+    // Read the current byte.
+    let currentByte = dataView.getUint8(byteIndex);
+    // Clear the target bit.
+    currentByte &= ~mask;
+    // Set the target bit if bitValue is 1.
+    if (bitValue) {
+      currentByte |= mask;
+    }
+    dataView.setUint8(byteIndex, currentByte);
+  }
+}