@luma.gl/shadertools 9.3.5 → 9.4.0-alpha.1

package/dist/modules/color/float-colors.d.ts

@@ -1,21 +1,85 @@
-export type FloatColorsProps = {
+import type { Binding } from '@luma.gl/core';
+/** Props for semantic color normalization helpers. */
+export type ColorsProps = {
     /**
      * When true, semantic colors are interpreted as 0-255 byte-style values and normalized in shader code.
      * When false, semantic colors are interpreted directly as floats.
      */
     useByteColors?: boolean;
 };
-export type FloatColorsUniforms = {
+/** Uniforms consumed by semantic color normalization helpers. */
+export type ColorsUniforms = {
     /** Controls whether shader helpers normalize semantic colors from byte space. */
     useByteColors: boolean;
 };
+/** Backward-compatible props alias for shaders that import `floatColors`. */
+export type FloatColorsProps = ColorsProps;
+/** Backward-compatible uniform alias for shaders that import `floatColors`. */
+export type FloatColorsUniforms = ColorsUniforms;
+/** Packed storage color formats decoded by `storageColors`. */
+export type StorageColorFormat = 'rgba8unorm' | 'rgba16float' | 'rgba32float';
+/** Numeric WGSL tags written to `storageColors.format`. */
+export declare const STORAGE_COLOR_FORMAT: {
+    readonly RGBA8UNORM: 0;
+    readonly RGBA16FLOAT: 1;
+    readonly RGBA32FLOAT: 2;
+};
+/** Numeric WGSL tag for one packed storage color format. */
+export type StorageColorFormatValue = (typeof STORAGE_COLOR_FORMAT)[keyof typeof STORAGE_COLOR_FORMAT];
+/** Bytes occupied by one tightly packed storage color row. */
+export declare const STORAGE_COLOR_FORMAT_BYTE_LENGTHS: Record<StorageColorFormat, number>;
+/** Default byte stride for one tightly packed storage color row. */
+export declare const STORAGE_COLOR_DEFAULT_BYTE_STRIDES: Record<StorageColorFormat, number>;
+/** Props for reading packed color rows from a read-only storage buffer. */
+export type StorageColorsProps = {
+    /** Storage buffer containing raw packed color words. */
+    colorBuffer?: Binding;
+    /** Per-row storage color representation. Defaults to `rgba8unorm`. */
+    format?: StorageColorFormat | StorageColorFormatValue;
+    /** Byte offset to the first color. Must be 4-byte aligned. Defaults to `0`. */
+    byteOffset?: number;
+    /** Bytes between color rows. Must be 4-byte aligned. Defaults to the packed format size. */
+    byteStride?: number;
+};
+/** Uniforms consumed by the packed storage color reader. */
+export type StorageColorsUniforms = {
+    /** Numeric `STORAGE_COLOR_FORMAT` tag used by WGSL. */
+    format: StorageColorFormatValue;
+    /** Uint32 words between storage color rows. */
+    wordStride: number;
+    /** Uint32 word offset to the first storage color row. */
+    wordOffset: number;
+    /** Reserved field retaining a 16-byte uniform block. */
+    _padding: number;
+};
+/** Bindings consumed by the packed storage color reader. */
+export type StorageColorsBindings = {
+    /** Raw packed storage color buffer exposed as `array<u32>`. */
+    storageColorsBuffer?: Binding;
+};
+/** Semantic color normalization helpers named `colors_*`. */
+export declare const colors: {
+    readonly name: "colors";
+    readonly props: ColorsProps;
+    readonly uniforms: ColorsUniforms;
+    readonly vs: string;
+    readonly fs: string;
+    readonly source: string;
+    readonly uniformTypes: {
+        readonly useByteColors: "f32";
+    };
+    readonly defaultUniforms: {
+        readonly useByteColors: true;
+    };
+};
+/** Legacy semantic color normalization helpers named `floatColors_*`. */
 export declare const floatColors: {
     readonly name: "floatColors";
     readonly props: FloatColorsProps;
     readonly uniforms: FloatColorsUniforms;
-    readonly vs: "layout(std140) uniform floatColorsUniforms {\n  float useByteColors;\n} floatColors;\n\nvec3 floatColors_normalize(vec3 inputColor) {\n  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;\n}\n\nvec4 floatColors_normalize(vec4 inputColor) {\n  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;\n}\n\nvec4 floatColors_premultiplyAlpha(vec4 inputColor) {\n  return vec4(inputColor.rgb * inputColor.a, inputColor.a);\n}\n\nvec4 floatColors_unpremultiplyAlpha(vec4 inputColor) {\n  return inputColor.a > 0.0 ? vec4(inputColor.rgb / inputColor.a, inputColor.a) : vec4(0.0);\n}\n\nvec4 floatColors_premultiply_alpha(vec4 inputColor) {\n  return floatColors_premultiplyAlpha(inputColor);\n}\n\nvec4 floatColors_unpremultiply_alpha(vec4 inputColor) {\n  return floatColors_unpremultiplyAlpha(inputColor);\n}\n";
-    readonly fs: "layout(std140) uniform floatColorsUniforms {\n  float useByteColors;\n} floatColors;\n\nvec3 floatColors_normalize(vec3 inputColor) {\n  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;\n}\n\nvec4 floatColors_normalize(vec4 inputColor) {\n  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;\n}\n\nvec4 floatColors_premultiplyAlpha(vec4 inputColor) {\n  return vec4(inputColor.rgb * inputColor.a, inputColor.a);\n}\n\nvec4 floatColors_unpremultiplyAlpha(vec4 inputColor) {\n  return inputColor.a > 0.0 ? vec4(inputColor.rgb / inputColor.a, inputColor.a) : vec4(0.0);\n}\n\nvec4 floatColors_premultiply_alpha(vec4 inputColor) {\n  return floatColors_premultiplyAlpha(inputColor);\n}\n\nvec4 floatColors_unpremultiply_alpha(vec4 inputColor) {\n  return floatColors_unpremultiplyAlpha(inputColor);\n}\n";
-    readonly source: "struct floatColorsUniforms {\n  useByteColors: f32\n};\n\n@group(0) @binding(auto) var<uniform> floatColors : floatColorsUniforms;\n\nfn floatColors_normalize(inputColor: vec3<f32>) -> vec3<f32> {\n  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);\n}\n\nfn floatColors_normalize4(inputColor: vec4<f32>) -> vec4<f32> {\n  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);\n}\n\nfn floatColors_premultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {\n  return vec4<f32>(inputColor.rgb * inputColor.a, inputColor.a);\n}\n\nfn floatColors_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {\n  return select(\n    vec4<f32>(0.0),\n    vec4<f32>(inputColor.rgb / inputColor.a, inputColor.a),\n    inputColor.a > 0.0\n  );\n}\n\nfn floatColors_premultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {\n  return floatColors_premultiplyAlpha(inputColor);\n}\n\nfn floatColors_unpremultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {\n  return floatColors_unpremultiplyAlpha(inputColor);\n}\n";
+    readonly vs: string;
+    readonly fs: string;
+    readonly source: string;
     readonly uniformTypes: {
         readonly useByteColors: "f32";
     };
@@ -23,4 +87,46 @@ export declare const floatColors: {
         readonly useByteColors: true;
     };
 };
+/**
+ * WGSL reader for packed RGBA storage rows.
+ *
+ * Include {@link colors} separately when semantic color normalization helpers are also needed.
+ */
+export declare const storageColors: {
+    readonly name: "storageColors";
+    readonly props: StorageColorsProps;
+    readonly uniforms: StorageColorsUniforms;
+    readonly bindings: StorageColorsBindings;
+    readonly source: string;
+    readonly uniformTypes: {
+        readonly format: "u32";
+        readonly wordStride: "u32";
+        readonly wordOffset: "u32";
+        readonly _padding: "u32";
+    };
+    readonly defaultUniforms: {
+        readonly format: 0;
+        readonly wordStride: number;
+        readonly wordOffset: 0;
+        readonly _padding: 0;
+    };
+    readonly bindingLayout: readonly [{
+        readonly name: "storageColors";
+        readonly group: 0;
+    }, {
+        readonly name: "storageColorsBuffer";
+        readonly group: 0;
+    }];
+    readonly getUniforms: (props?: StorageColorsProps) => {
+        storageColorsBuffer?: Binding | undefined;
+        /** Numeric `STORAGE_COLOR_FORMAT` tag used by WGSL. */
+        format: StorageColorFormatValue;
+        /** Uint32 words between storage color rows. */
+        wordStride: number;
+        /** Uint32 word offset to the first storage color row. */
+        wordOffset: number;
+        /** Reserved field retaining a 16-byte uniform block. */
+        _padding: number;
+    };
+};
 //# sourceMappingURL=float-colors.d.ts.map

package/dist/modules/color/float-colors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"float-colors.d.ts","sourceRoot":"","sources":["../../../src/modules/color/float-colors.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,iFAAiF;IACjF,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAoEF,eAAO,MAAM,WAAW;;oBAET,gBAAgB;uBACb,mBAAmB;;;;;;;;;;CAUmC,CAAC"}
+{"version":3,"file":"float-colors.d.ts","sourceRoot":"","sources":["../../../src/modules/color/float-colors.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAG3C,sDAAsD;AACtD,MAAM,MAAM,WAAW,GAAG;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,iEAAiE;AACjE,MAAM,MAAM,cAAc,GAAG;IAC3B,iFAAiF;IACjF,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,6EAA6E;AAC7E,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC;AAC3C,+EAA+E;AAC/E,MAAM,MAAM,mBAAmB,GAAG,cAAc,CAAC;AAEjD,+DAA+D;AAC/D,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,aAAa,GAAG,aAAa,CAAC;AAE9E,2DAA2D;AAC3D,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX,4DAA4D;AAC5D,MAAM,MAAM,uBAAuB,GACjC,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAEnE,8DAA8D;AAC9D,eAAO,MAAM,iCAAiC,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAIhF,CAAC;AAEF,oEAAoE;AACpE,eAAO,MAAM,kCAAkC,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,CAEjF,CAAC;AAEF,2EAA2E;AAC3E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,wDAAwD;IACxD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,sEAAsE;IACtE,MAAM,CAAC,EAAE,kBAAkB,GAAG,uBAAuB,CAAC;IACtD,+EAA+E;IAC/E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4FAA4F;IAC5F,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,4DAA4D;AAC5D,MAAM,MAAM,qBAAqB,GAAG;IAClC,uDAAuD;IACvD,MAAM,EAAE,uBAAuB,CAAC;IAChC,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,4DAA4D;AAC5D,MAAM,MAAM,qBAAqB,GAAG;IAClC,+DAA+D;IAC/D,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AA6MF,6DAA6D;AAC7D,eAAO,MAAM,MAAM;;oBAEJ,WAAW;uBACR,cAAc;;;;;;;;;;CAM8B,CAAC;AAE/D,yEAAyE;AACzE,eAAO,MAAM,WAAW;;oBAET,gBAAgB;uBACb,mBAAmB;;;;;;;;;;CAMmC,CAAC;AAEzE;;;;GAIG;AACH,eAAO,MAAM,aAAa;;oBAEX,kBAAkB;uBACf,qBAAqB;uBACrB,qBAAqB;;;;;;;;;;;;;;;;;;;;;mCAQlB,kBAAkB;;QApQrC,uDAAuD;gBAC/C,uBAAuB;QAC/B,+CAA+C;oBACnC,MAAM;QAClB,yDAAyD;oBAC7C,MAAM;QAClB,wDAAwD;kBAC9C,MAAM;;CAmQiF,CAAC"}

package/dist/modules/color/float-colors.js

@@ -1,55 +1,154 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-const GLSL_UNIFORMS = /* glsl */ `\
-layout(std140) uniform floatColorsUniforms {
+/** Numeric WGSL tags written to `storageColors.format`. */
+export const STORAGE_COLOR_FORMAT = {
+    RGBA8UNORM: 0,
+    RGBA16FLOAT: 1,
+    RGBA32FLOAT: 2
+};
+/** Bytes occupied by one tightly packed storage color row. */
+export const STORAGE_COLOR_FORMAT_BYTE_LENGTHS = {
+    rgba8unorm: 4,
+    rgba16float: 8,
+    rgba32float: 16
+};
+/** Default byte stride for one tightly packed storage color row. */
+export const STORAGE_COLOR_DEFAULT_BYTE_STRIDES = {
+    ...STORAGE_COLOR_FORMAT_BYTE_LENGTHS
+};
+const STORAGE_COLOR_FORMAT_BY_NAME = {
+    rgba8unorm: STORAGE_COLOR_FORMAT.RGBA8UNORM,
+    rgba16float: STORAGE_COLOR_FORMAT.RGBA16FLOAT,
+    rgba32float: STORAGE_COLOR_FORMAT.RGBA32FLOAT
+};
+const STORAGE_COLOR_FORMAT_NAME_BY_VALUE = {
+    [STORAGE_COLOR_FORMAT.RGBA8UNORM]: 'rgba8unorm',
+    [STORAGE_COLOR_FORMAT.RGBA16FLOAT]: 'rgba16float',
+    [STORAGE_COLOR_FORMAT.RGBA32FLOAT]: 'rgba32float'
+};
+const COLORS_UNIFORM_TYPES = {
+    useByteColors: 'f32'
+};
+const COLORS_DEFAULT_UNIFORMS = {
+    useByteColors: true
+};
+const STORAGE_COLORS_UNIFORM_TYPES = {
+    format: 'u32',
+    wordStride: 'u32',
+    wordOffset: 'u32',
+    _padding: 'u32'
+};
+const STORAGE_COLORS_DEFAULT_UNIFORMS = {
+    format: STORAGE_COLOR_FORMAT.RGBA8UNORM,
+    wordStride: STORAGE_COLOR_DEFAULT_BYTE_STRIDES.rgba8unorm / Uint32Array.BYTES_PER_ELEMENT,
+    wordOffset: 0,
+    _padding: 0
+};
+const COLORS_GLSL = buildGLSLColorModuleSource('colors');
+const FLOAT_COLORS_GLSL = buildGLSLColorModuleSource('floatColors');
+const COLORS_WGSL = buildWGSLColorModuleSource('colors');
+const FLOAT_COLORS_WGSL = buildWGSLColorModuleSource('floatColors');
+const STORAGE_COLORS_WGSL = /* wgsl */ `\
+struct storageColorsUniforms {
+  format: u32,
+  wordStride: u32,
+  wordOffset: u32,
+  _padding: u32
+};
+
+@group(0) @binding(auto) var<uniform> storageColors : storageColorsUniforms;
+@group(0) @binding(auto) var<storage, read> storageColorsBuffer : array<u32>;
+
+const STORAGE_COLOR_FORMAT_RGBA8UNORM : u32 = ${STORAGE_COLOR_FORMAT.RGBA8UNORM}u;
+const STORAGE_COLOR_FORMAT_RGBA16FLOAT : u32 = ${STORAGE_COLOR_FORMAT.RGBA16FLOAT}u;
+
+fn storageColors_getWordIndex(rowIndex: u32) -> u32 {
+  return storageColors.wordOffset + rowIndex * storageColors.wordStride;
+}
+
+fn storageColors_readRgba8UnormColor(wordIndex: u32) -> vec4<f32> {
+  return unpack4x8unorm(storageColorsBuffer[wordIndex]);
+}
+
+fn storageColors_readRgba16FloatColor(wordIndex: u32) -> vec4<f32> {
+  let redGreen = unpack2x16float(storageColorsBuffer[wordIndex]);
+  let blueAlpha = unpack2x16float(storageColorsBuffer[wordIndex + 1u]);
+  return vec4<f32>(redGreen.x, redGreen.y, blueAlpha.x, blueAlpha.y);
+}
+
+fn storageColors_readRgba32FloatColor(wordIndex: u32) -> vec4<f32> {
+  return vec4<f32>(
+    bitcast<f32>(storageColorsBuffer[wordIndex]),
+    bitcast<f32>(storageColorsBuffer[wordIndex + 1u]),
+    bitcast<f32>(storageColorsBuffer[wordIndex + 2u]),
+    bitcast<f32>(storageColorsBuffer[wordIndex + 3u])
+  );
+}
+
+fn storageColors_readColor(rowIndex: u32) -> vec4<f32> {
+  let wordIndex = storageColors_getWordIndex(rowIndex);
+  if (storageColors.format == STORAGE_COLOR_FORMAT_RGBA8UNORM) {
+    return storageColors_readRgba8UnormColor(wordIndex);
+  }
+  if (storageColors.format == STORAGE_COLOR_FORMAT_RGBA16FLOAT) {
+    return storageColors_readRgba16FloatColor(wordIndex);
+  }
+  return storageColors_readRgba32FloatColor(wordIndex);
+}
+`;
+function buildGLSLColorModuleSource(primaryPrefix) {
+    return /* glsl */ `\
+layout(std140) uniform ${primaryPrefix}Uniforms {
   float useByteColors;
-} floatColors;
+} ${primaryPrefix};
 
-vec3 floatColors_normalize(vec3 inputColor) {
-  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+vec3 ${primaryPrefix}_normalize(vec3 inputColor) {
+  return ${primaryPrefix}.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
 }
 
-vec4 floatColors_normalize(vec4 inputColor) {
-  return floatColors.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+vec4 ${primaryPrefix}_normalize(vec4 inputColor) {
+  return ${primaryPrefix}.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
 }
 
-vec4 floatColors_premultiplyAlpha(vec4 inputColor) {
+vec4 ${primaryPrefix}_premultiplyAlpha(vec4 inputColor) {
   return vec4(inputColor.rgb * inputColor.a, inputColor.a);
 }
 
-vec4 floatColors_unpremultiplyAlpha(vec4 inputColor) {
+vec4 ${primaryPrefix}_unpremultiplyAlpha(vec4 inputColor) {
   return inputColor.a > 0.0 ? vec4(inputColor.rgb / inputColor.a, inputColor.a) : vec4(0.0);
 }
 
-vec4 floatColors_premultiply_alpha(vec4 inputColor) {
-  return floatColors_premultiplyAlpha(inputColor);
+vec4 ${primaryPrefix}_premultiply_alpha(vec4 inputColor) {
+  return ${primaryPrefix}_premultiplyAlpha(inputColor);
 }
 
-vec4 floatColors_unpremultiply_alpha(vec4 inputColor) {
-  return floatColors_unpremultiplyAlpha(inputColor);
+vec4 ${primaryPrefix}_unpremultiply_alpha(vec4 inputColor) {
+  return ${primaryPrefix}_unpremultiplyAlpha(inputColor);
 }
 `;
-const WGSL_UNIFORMS = /* wgsl */ `\
-struct floatColorsUniforms {
+}
+function buildWGSLColorModuleSource(primaryPrefix) {
+    return /* wgsl */ `\
+struct ${primaryPrefix}Uniforms {
   useByteColors: f32
 };
 
-@group(0) @binding(auto) var<uniform> floatColors : floatColorsUniforms;
+@group(0) @binding(auto) var<uniform> ${primaryPrefix} : ${primaryPrefix}Uniforms;
 
-fn floatColors_normalize(inputColor: vec3<f32>) -> vec3<f32> {
-  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);
+fn ${primaryPrefix}_normalize(inputColor: vec3<f32>) -> vec3<f32> {
+  return select(inputColor, inputColor / 255.0, ${primaryPrefix}.useByteColors > 0.5);
 }
 
-fn floatColors_normalize4(inputColor: vec4<f32>) -> vec4<f32> {
-  return select(inputColor, inputColor / 255.0, floatColors.useByteColors > 0.5);
+fn ${primaryPrefix}_normalize4(inputColor: vec4<f32>) -> vec4<f32> {
+  return select(inputColor, inputColor / 255.0, ${primaryPrefix}.useByteColors > 0.5);
 }
 
-fn floatColors_premultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+fn ${primaryPrefix}_premultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
   return vec4<f32>(inputColor.rgb * inputColor.a, inputColor.a);
 }
 
-fn floatColors_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+fn ${primaryPrefix}_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
   return select(
     vec4<f32>(0.0),
     vec4<f32>(inputColor.rgb / inputColor.a, inputColor.a),
@@ -57,26 +156,93 @@ fn floatColors_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
   );
 }
 
-fn floatColors_premultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
-  return floatColors_premultiplyAlpha(inputColor);
+fn ${primaryPrefix}_premultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return ${primaryPrefix}_premultiplyAlpha(inputColor);
 }
 
-fn floatColors_unpremultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
-  return floatColors_unpremultiplyAlpha(inputColor);
+fn ${primaryPrefix}_unpremultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return ${primaryPrefix}_unpremultiplyAlpha(inputColor);
 }
 `;
+}
+function getStorageColorsUniforms(props = {}) {
+    const format = resolveStorageColorFormat(props.format);
+    const formatName = STORAGE_COLOR_FORMAT_NAME_BY_VALUE[format];
+    const byteStride = props.byteStride ?? STORAGE_COLOR_DEFAULT_BYTE_STRIDES[formatName];
+    const byteOffset = props.byteOffset ?? 0;
+    const minimumByteStride = STORAGE_COLOR_FORMAT_BYTE_LENGTHS[formatName];
+    validateStorageColorByteAlignment('byteStride', byteStride);
+    validateStorageColorByteAlignment('byteOffset', byteOffset);
+    if (byteStride < minimumByteStride) {
+        throw new Error(`storageColors byteStride must be at least ${minimumByteStride} for ${formatName}`);
+    }
+    return {
+        format,
+        wordStride: byteStride / Uint32Array.BYTES_PER_ELEMENT,
+        wordOffset: byteOffset / Uint32Array.BYTES_PER_ELEMENT,
+        _padding: 0
+    };
+}
+function resolveStorageColorFormat(format = 'rgba8unorm') {
+    if (typeof format === 'number') {
+        if (format in STORAGE_COLOR_FORMAT_NAME_BY_VALUE) {
+            return format;
+        }
+    }
+    else if (format in STORAGE_COLOR_FORMAT_BY_NAME) {
+        return STORAGE_COLOR_FORMAT_BY_NAME[format];
+    }
+    throw new Error(`storageColors format must be one of ${Object.keys(STORAGE_COLOR_FORMAT_BY_NAME).join(', ')}`);
+}
+function validateStorageColorByteAlignment(name, value) {
+    if (!Number.isInteger(value) || value < 0 || value % Uint32Array.BYTES_PER_ELEMENT !== 0) {
+        throw new Error(`storageColors ${name} must be a non-negative 4-byte aligned integer`);
+    }
+}
+/** Semantic color normalization helpers named `colors_*`. */
+export const colors = {
+    name: 'colors',
+    props: {},
+    uniforms: {},
+    vs: COLORS_GLSL,
+    fs: COLORS_GLSL,
+    source: COLORS_WGSL,
+    uniformTypes: COLORS_UNIFORM_TYPES,
+    defaultUniforms: COLORS_DEFAULT_UNIFORMS
+};
+/** Legacy semantic color normalization helpers named `floatColors_*`. */
 export const floatColors = {
     name: 'floatColors',
     props: {},
     uniforms: {},
-    vs: GLSL_UNIFORMS,
-    fs: GLSL_UNIFORMS,
-    source: WGSL_UNIFORMS,
-    uniformTypes: {
-        useByteColors: 'f32'
-    },
-    defaultUniforms: {
-        useByteColors: true
+    vs: FLOAT_COLORS_GLSL,
+    fs: FLOAT_COLORS_GLSL,
+    source: FLOAT_COLORS_WGSL,
+    uniformTypes: COLORS_UNIFORM_TYPES,
+    defaultUniforms: COLORS_DEFAULT_UNIFORMS
+};
+/**
+ * WGSL reader for packed RGBA storage rows.
+ *
+ * Include {@link colors} separately when semantic color normalization helpers are also needed.
+ */
+export const storageColors = {
+    name: 'storageColors',
+    props: {},
+    uniforms: {},
+    bindings: {},
+    source: STORAGE_COLORS_WGSL,
+    uniformTypes: STORAGE_COLORS_UNIFORM_TYPES,
+    defaultUniforms: STORAGE_COLORS_DEFAULT_UNIFORMS,
+    bindingLayout: [
+        { name: 'storageColors', group: 0 },
+        { name: 'storageColorsBuffer', group: 0 }
+    ],
+    getUniforms(props = {}) {
+        return {
+            ...getStorageColorsUniforms(props),
+            ...(props.colorBuffer ? { storageColorsBuffer: props.colorBuffer } : {})
+        };
     }
 };
 //# sourceMappingURL=float-colors.js.map

package/dist/modules/color/float-colors.js.map

@@ -1 +1 @@
-{"version":3,"file":"float-colors.js","sourceRoot":"","sources":["../../../src/modules/color/float-colors.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAiBpC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BhC,CAAC;AAEF,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkChC,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE,aAAa;IACnB,KAAK,EAAE,EAAsB;IAC7B,QAAQ,EAAE,EAAyB;IACnC,EAAE,EAAE,aAAa;IACjB,EAAE,EAAE,aAAa;IACjB,MAAM,EAAE,aAAa;IACrB,YAAY,EAAE;QACZ,aAAa,EAAE,KAAK;KACrB;IACD,eAAe,EAAE;QACf,aAAa,EAAE,IAAI;KACpB;CACqE,CAAC"}
+{"version":3,"file":"float-colors.js","sourceRoot":"","sources":["../../../src/modules/color/float-colors.ts"],"names":[],"mappings":"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"}

package/dist/modules/engine/clip/clip.d.ts

@@ -0,0 +1,12 @@
+import type { ShaderPlugin } from "../../../lib/shader-plugin.js";
+export type ClipShaderPluginProps = {
+    /** Enables clipping. Defaults to true. */
+    enabled?: boolean;
+    /** Inclusive lower and exclusive upper bounds. Defaults to [0, 0, 1, 1]. */
+    bounds?: readonly [number, number, number, number];
+    /** Clips whole instances by their anchor or individual fragments. Defaults to geometry. */
+    mode?: 'instance' | 'geometry';
+};
+/** Coordinate-system-neutral instance and geometry clipping. */
+export declare const clipShaderPlugin: ShaderPlugin;
+//# sourceMappingURL=clip.d.ts.map

package/dist/modules/engine/clip/clip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clip.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/clip/clip.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,YAAY,EAAC,sCAAmC;AAE7D,MAAM,MAAM,qBAAqB,GAAG;IAClC,0CAA0C;IAC1C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnD,2FAA2F;IAC3F,IAAI,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;CAChC,CAAC;AAqFF,gEAAgE;AAChE,eAAO,MAAM,gBAAgB,EAAE,YAgD9B,CAAC"}

package/dist/modules/engine/clip/clip.js

@@ -0,0 +1,129 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const CLIP_MODE_GEOMETRY = 0;
+const CLIP_MODE_INSTANCE = 1;
+const clipShaderModule = {
+    name: 'clip',
+    props: {},
+    uniforms: {},
+    bindingLayout: [{ name: 'clip', group: 2 }],
+    uniformTypes: {
+        enabled: 'i32',
+        mode: 'i32',
+        bounds: 'vec4<f32>'
+    },
+    defaultUniforms: {
+        enabled: 1,
+        mode: CLIP_MODE_GEOMETRY,
+        bounds: [0, 0, 1, 1]
+    },
+    vs: /* glsl */ `\
+layout(std140) uniform clipUniforms {
+  highp int enabled;
+  highp int mode;
+  highp vec4 bounds;
+} clipState;
+
+bool clip_isInBounds(vec2 coordinates) {
+  return coordinates.x >= clipState.bounds.x &&
+    coordinates.y >= clipState.bounds.y &&
+    coordinates.x < clipState.bounds.z &&
+    coordinates.y < clipState.bounds.w;
+}
+`,
+    fs: /* glsl */ `\
+layout(std140) uniform clipUniforms {
+  highp int enabled;
+  highp int mode;
+  highp vec4 bounds;
+} clipState;
+
+bool clip_isInBounds(vec2 coordinates) {
+  return coordinates.x >= clipState.bounds.x &&
+    coordinates.y >= clipState.bounds.y &&
+    coordinates.x < clipState.bounds.z &&
+    coordinates.y < clipState.bounds.w;
+}
+`,
+    source: /* wgsl */ `\
+struct ClipUniforms {
+  enabled: i32,
+  mode: i32,
+  bounds: vec4<f32>,
+};
+
+@group(2) @binding(auto) var<uniform> clipUniforms: ClipUniforms;
+
+fn clip_isInBounds(coordinates: vec2<f32>) -> bool {
+  return coordinates.x >= clipUniforms.bounds.x &&
+    coordinates.y >= clipUniforms.bounds.y &&
+    coordinates.x < clipUniforms.bounds.z &&
+    coordinates.y < clipUniforms.bounds.w;
+}
+`,
+    getUniforms(props = {}) {
+        const uniforms = {};
+        if (props.enabled !== undefined) {
+            uniforms.enabled = Number(props.enabled);
+        }
+        if (props.mode !== undefined) {
+            uniforms.mode = props.mode === 'instance' ? CLIP_MODE_INSTANCE : CLIP_MODE_GEOMETRY;
+        }
+        if (props.bounds !== undefined) {
+            uniforms.bounds = props.bounds;
+        }
+        return uniforms;
+    }
+};
+/** Coordinate-system-neutral instance and geometry clipping. */
+export const clipShaderPlugin = {
+    name: 'clip',
+    modules: [clipShaderModule],
+    varyings: {
+        clipCoordinates: { type: 'vec2<f32>', interpolation: 'smooth' }
+    },
+    glsl: {
+        injections: [
+            {
+                target: 'vs:CLIP_POSITION',
+                injection: `\
+clipCoordinates = geometryCoordinates;
+if (clipState.enabled != 0 && clipState.mode == ${CLIP_MODE_INSTANCE} &&
+    !clip_isInBounds(instanceCoordinates)) {
+  position = vec4(2.0, 2.0, 2.0, 1.0);
+}`
+            },
+            {
+                target: 'fs:CLIP_COLOR',
+                injection: `\
+if (clipState.enabled != 0 && clipState.mode == ${CLIP_MODE_GEOMETRY} &&
+    !clip_isInBounds(clipCoordinates)) {
+  discard;
+}`
+            }
+        ]
+    },
+    wgsl: {
+        injections: [
+            {
+                target: 'vs:CLIP_POSITION',
+                injection: `\
+clipCoordinates = geometryCoordinates;
+if (clipUniforms.enabled != 0 && clipUniforms.mode == ${CLIP_MODE_INSTANCE} &&
+    !clip_isInBounds(instanceCoordinates)) {
+  *position = vec4<f32>(2.0, 2.0, 2.0, 1.0);
+}`
+            },
+            {
+                target: 'fs:CLIP_COLOR',
+                injection: `\
+if (clipUniforms.enabled != 0 && clipUniforms.mode == ${CLIP_MODE_GEOMETRY} &&
+    !clip_isInBounds(clipCoordinates)) {
+  discard;
+}`
+            }
+        ]
+    }
+};
+//# sourceMappingURL=clip.js.map

package/dist/modules/engine/clip/clip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clip.js","sourceRoot":"","sources":["../../../../src/modules/engine/clip/clip.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAoBpC,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAC7B,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAE7B,MAAM,gBAAgB,GAAG;IACvB,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,EAA2B;IAClC,QAAQ,EAAE,EAAkB;IAC5B,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IACzC,YAAY,EAAE;QACZ,OAAO,EAAE,KAAK;QACd,IAAI,EAAE,KAAK;QACX,MAAM,EAAE,WAAW;KACpB;IACD,eAAe,EAAE;QACf,OAAO,EAAE,CAAC;QACV,IAAI,EAAE,kBAAkB;QACxB,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;KACrB;IACD,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;CAahB;IACC,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;CAahB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;CAepB;IACC,WAAW,CAAC,QAA+B,EAAE;QAC3C,MAAM,QAAQ,GAA0B,EAAE,CAAC;QAC3C,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAChC,QAAQ,CAAC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC3C,CAAC;QACD,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,QAAQ,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,kBAAkB,CAAC;QACtF,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC/B,QAAQ,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QACjC,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;CACuE,CAAC;AAE3E,gEAAgE;AAChE,MAAM,CAAC,MAAM,gBAAgB,GAAiB;IAC5C,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,CAAC,gBAAgB,CAAC;IAC3B,QAAQ,EAAE;QACR,eAAe,EAAE,EAAC,IAAI,EAAE,WAAW,EAAE,aAAa,EAAE,QAAQ,EAAC;KAC9D;IACD,IAAI,EAAE;QACJ,UAAU,EAAE;YACV;gBACE,MAAM,EAAE,kBAAkB;gBAC1B,SAAS,EAAE;;kDAE+B,kBAAkB;;;EAGlE;aACK;YACD;gBACE,MAAM,EAAE,eAAe;gBACvB,SAAS,EAAE;kDAC+B,kBAAkB;;;EAGlE;aACK;SACF;KACF;IACD,IAAI,EAAE;QACJ,UAAU,EAAE;YACV;gBACE,MAAM,EAAE,kBAAkB;gBAC1B,SAAS,EAAE;;wDAEqC,kBAAkB;;;EAGxE;aACK;YACD;gBACE,MAAM,EAAE,eAAe;gBACvB,SAAS,EAAE;wDACqC,kBAAkB;;;EAGxE;aACK;SACF;KACF;CACF,CAAC"}

package/dist/modules/engine/filter/filter.d.ts

@@ -0,0 +1,12 @@
+import type { ShaderPlugin } from "../../../lib/shader-plugin.js";
+export type FilterShaderPluginProps = {
+    /** Enables range filtering. Defaults to true. */
+    enabled?: boolean;
+    /** Inclusive minimum accepted value. Defaults to 0. */
+    min?: number;
+    /** Inclusive maximum accepted value. Defaults to 1. */
+    max?: number;
+};
+/** Scalar inclusive-range filtering for shaders that expose the `FILTER_POSITION` vertex hook. */
+export declare const filterShaderPlugin: ShaderPlugin;
+//# sourceMappingURL=filter.d.ts.map

package/dist/modules/engine/filter/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/filter/filter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,YAAY,EAAC,sCAAmC;AAE7D,MAAM,MAAM,uBAAuB,GAAG;IACpC,iDAAiD;IACjD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,uDAAuD;IACvD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AA+DF,kGAAkG;AAClG,eAAO,MAAM,kBAAkB,EAAE,YA4BhC,CAAC"}