@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.5

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

@@ -0,0 +1,248 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/** 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;
+} ${primaryPrefix};
+
+vec3 ${primaryPrefix}_normalize(vec3 inputColor) {
+  return ${primaryPrefix}.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+}
+
+vec4 ${primaryPrefix}_normalize(vec4 inputColor) {
+  return ${primaryPrefix}.useByteColors > 0.5 ? inputColor / 255.0 : inputColor;
+}
+
+vec4 ${primaryPrefix}_premultiplyAlpha(vec4 inputColor) {
+  return vec4(inputColor.rgb * inputColor.a, inputColor.a);
+}
+
+vec4 ${primaryPrefix}_unpremultiplyAlpha(vec4 inputColor) {
+  return inputColor.a > 0.0 ? vec4(inputColor.rgb / inputColor.a, inputColor.a) : vec4(0.0);
+}
+
+vec4 ${primaryPrefix}_premultiply_alpha(vec4 inputColor) {
+  return ${primaryPrefix}_premultiplyAlpha(inputColor);
+}
+
+vec4 ${primaryPrefix}_unpremultiply_alpha(vec4 inputColor) {
+  return ${primaryPrefix}_unpremultiplyAlpha(inputColor);
+}
+`;
+}
+function buildWGSLColorModuleSource(primaryPrefix) {
+    return /* wgsl */ `\
+struct ${primaryPrefix}Uniforms {
+  useByteColors: f32
+};
+
+@group(0) @binding(auto) var<uniform> ${primaryPrefix} : ${primaryPrefix}Uniforms;
+
+fn ${primaryPrefix}_normalize(inputColor: vec3<f32>) -> vec3<f32> {
+  return select(inputColor, inputColor / 255.0, ${primaryPrefix}.useByteColors > 0.5);
+}
+
+fn ${primaryPrefix}_normalize4(inputColor: vec4<f32>) -> vec4<f32> {
+  return select(inputColor, inputColor / 255.0, ${primaryPrefix}.useByteColors > 0.5);
+}
+
+fn ${primaryPrefix}_premultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return vec4<f32>(inputColor.rgb * inputColor.a, inputColor.a);
+}
+
+fn ${primaryPrefix}_unpremultiplyAlpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return select(
+    vec4<f32>(0.0),
+    vec4<f32>(inputColor.rgb / inputColor.a, inputColor.a),
+    inputColor.a > 0.0
+  );
+}
+
+fn ${primaryPrefix}_premultiply_alpha(inputColor: vec4<f32>) -> vec4<f32> {
+  return ${primaryPrefix}_premultiplyAlpha(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: 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

@@ -0,0 +1 @@
+{"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.cjs

@@ -0,0 +1,152 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clip_exports = {};
+__export(clip_exports, {
+  clipShaderPlugin: () => clipShaderPlugin
+});
+module.exports = __toCommonJS(clip_exports);
+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 !== void 0) {
+      uniforms.enabled = Number(props.enabled);
+    }
+    if (props.mode !== void 0) {
+      uniforms.mode = props.mode === "instance" ? CLIP_MODE_INSTANCE : CLIP_MODE_GEOMETRY;
+    }
+    if (props.bounds !== void 0) {
+      uniforms.bounds = props.bounds;
+    }
+    return uniforms;
+  }
+};
+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;
+}`
+      }
+    ]
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clipShaderPlugin
+});

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
+// SPDX-FileCopyrightText: 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,4DAA4D;AAoB5D,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.cjs

@@ -0,0 +1,111 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var filter_exports = {};
+__export(filter_exports, {
+  filterShaderPlugin: () => filterShaderPlugin
+});
+module.exports = __toCommonJS(filter_exports);
+const filterShaderModule = {
+  name: "filter",
+  props: {},
+  uniforms: {},
+  bindingLayout: [{ name: "filter", group: 2 }],
+  uniformTypes: {
+    enabled: "i32",
+    min: "f32",
+    max: "f32"
+  },
+  defaultUniforms: {
+    enabled: 1,
+    min: 0,
+    max: 1
+  },
+  vs: (
+    /* glsl */
+    `layout(std140) uniform filterUniforms {
+  int enabled;
+  float min;
+  float max;
+} filterState;
+
+bool filter_isVisible(float value) {
+  return filterState.enabled == 0 || (value >= filterState.min && value <= filterState.max);
+}
+`
+  ),
+  source: (
+    /* wgsl */
+    `struct FilterUniforms {
+  enabled: i32,
+  min: f32,
+  max: f32,
+};
+
+@group(2) @binding(auto) var<uniform> filterUniforms: FilterUniforms;
+
+fn filter_isVisible(value: f32) -> bool {
+  return filterUniforms.enabled == 0 ||
+    (value >= filterUniforms.min && value <= filterUniforms.max);
+}
+`
+  ),
+  getUniforms(props = {}) {
+    const uniforms = {};
+    if (props.enabled !== void 0) {
+      uniforms.enabled = Number(props.enabled);
+    }
+    if (props.min !== void 0) {
+      uniforms.min = props.min;
+    }
+    if (props.max !== void 0) {
+      uniforms.max = props.max;
+    }
+    return uniforms;
+  }
+};
+const filterShaderPlugin = {
+  name: "filter",
+  modules: [filterShaderModule],
+  vertexInputs: {
+    filterValues: "f32"
+  },
+  glsl: {
+    injections: [
+      {
+        target: "vs:FILTER_POSITION",
+        injection: `if (!filter_isVisible(filterValues)) {
+  position = vec4(2.0, 2.0, 2.0, 1.0);
+}`
+      }
+    ]
+  },
+  wgsl: {
+    injections: [
+      {
+        target: "vs:FILTER_POSITION",
+        injection: `if (!filter_isVisible(filterValues)) {
+  *position = vec4<f32>(2.0, 2.0, 2.0, 1.0);
+}`
+      }
+    ]
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterShaderPlugin
+});

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"}