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

package/dist/modules/geometry/path-dash/path-dash.cjs

@@ -0,0 +1,93 @@
+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 path_dash_exports = {};
+__export(path_dash_exports, {
+  pathDash: () => pathDash
+});
+module.exports = __toCommonJS(path_dash_exports);
+const DEFAULT_UNIFORMS = { dashLength: 12, gapLength: 8, offset: 0 };
+const pathDash = {
+  name: "pathDash",
+  bindingLayout: [{ name: "pathDash", group: 3 }],
+  firstBindingSlot: 0,
+  uniformTypes: { dashLength: "f32", gapLength: "f32", offset: "f32" },
+  defaultUniforms: DEFAULT_UNIFORMS,
+  getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+    const uniforms = { ...DEFAULT_UNIFORMS, ...previousUniforms };
+    if (props.dashLength !== void 0)
+      uniforms.dashLength = Math.max(0, props.dashLength);
+    if (props.gapLength !== void 0)
+      uniforms.gapLength = Math.max(0, props.gapLength);
+    if (props.offset !== void 0)
+      uniforms.offset = props.offset;
+    return uniforms;
+  },
+  fs: (
+    /* glsl */
+    `
+layout(std140) uniform pathDashUniforms {
+  float dashLength;
+  float gapLength;
+  float offset;
+} pathDash;
+float pathDash_integral(float coordinate, float fraction) {
+  return floor(coordinate) * fraction + min(fract(coordinate), fraction);
+}
+float pathDash_getCoverage(float distanceAlongPath) {
+  float period = max(pathDash.dashLength + pathDash.gapLength, 0.0001);
+  float coordinate = (distanceAlongPath + pathDash.offset) / period;
+  float extent = max(fwidth(coordinate), 0.0001);
+  float center = fract(coordinate);
+  float fraction = pathDash.dashLength / period;
+  float coverage = (pathDash_integral(center + extent * 0.5, fraction) - pathDash_integral(center - extent * 0.5, fraction)) / extent;
+  if (pathDash.gapLength <= 0.0) return 1.0;
+  if (pathDash.dashLength <= 0.0) return 0.0;
+  return clamp(coverage, 0.0, 1.0);
+}
+`
+  ),
+  source: (
+    /* wgsl */
+    `
+struct pathDashUniforms {
+  dashLength: f32,
+  gapLength: f32,
+  offset: f32,
+};
+@group(3) @binding(auto) var<uniform> pathDash: pathDashUniforms;
+fn pathDash_integral(coordinate: f32, fraction: f32) -> f32 {
+  return floor(coordinate) * fraction + min(fract(coordinate), fraction);
+}
+fn pathDash_getCoverage(distanceAlongPath: f32) -> f32 {
+  let period = max(pathDash.dashLength + pathDash.gapLength, 0.0001);
+  let coordinate = (distanceAlongPath + pathDash.offset) / period;
+  let extent = max(fwidth(coordinate), 0.0001);
+  let center = fract(coordinate);
+  let fraction = pathDash.dashLength / period;
+  let coverage = (pathDash_integral(center + extent * 0.5, fraction) - pathDash_integral(center - extent * 0.5, fraction)) / extent;
+  if (pathDash.gapLength <= 0.0) { return 1.0; }
+  if (pathDash.dashLength <= 0.0) { return 0.0; }
+  return clamp(coverage, 0.0, 1.0);
+}
+`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pathDash
+});

package/dist/modules/geometry/path-dash/path-dash.d.ts

@@ -0,0 +1,10 @@
+import type { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+export type PathDashUniforms = {
+    dashLength: number;
+    gapLength: number;
+    offset: number;
+};
+export type PathDashProps = Partial<PathDashUniforms>;
+/** Filtered dash coverage from cumulative path distance, independent of coordinate units. */
+export declare const pathDash: ShaderModule<PathDashProps, PathDashUniforms>;
+//# sourceMappingURL=path-dash.d.ts.map

package/dist/modules/geometry/path-dash/path-dash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-dash.d.ts","sourceRoot":"","sources":["../../../../src/modules/geometry/path-dash/path-dash.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,oDAAiD;AAE3E,MAAM,MAAM,gBAAgB,GAAG;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAAC;AACvF,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAGtD,6FAA6F;AAC7F,eAAO,MAAM,QAAQ,EAAE,YAAY,CAAC,aAAa,EAAE,gBAAgB,CAwDlE,CAAC"}

package/dist/modules/geometry/path-dash/path-dash.js

@@ -0,0 +1,66 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+const DEFAULT_UNIFORMS = { dashLength: 12, gapLength: 8, offset: 0 };
+/** Filtered dash coverage from cumulative path distance, independent of coordinate units. */
+export const pathDash = {
+    name: 'pathDash',
+    bindingLayout: [{ name: 'pathDash', group: 3 }],
+    firstBindingSlot: 0,
+    uniformTypes: { dashLength: 'f32', gapLength: 'f32', offset: 'f32' },
+    defaultUniforms: DEFAULT_UNIFORMS,
+    getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+        const uniforms = { ...DEFAULT_UNIFORMS, ...previousUniforms };
+        if (props.dashLength !== undefined)
+            uniforms.dashLength = Math.max(0, props.dashLength);
+        if (props.gapLength !== undefined)
+            uniforms.gapLength = Math.max(0, props.gapLength);
+        if (props.offset !== undefined)
+            uniforms.offset = props.offset;
+        return uniforms;
+    },
+    fs: /* glsl */ `
+layout(std140) uniform pathDashUniforms {
+  float dashLength;
+  float gapLength;
+  float offset;
+} pathDash;
+float pathDash_integral(float coordinate, float fraction) {
+  return floor(coordinate) * fraction + min(fract(coordinate), fraction);
+}
+float pathDash_getCoverage(float distanceAlongPath) {
+  float period = max(pathDash.dashLength + pathDash.gapLength, 0.0001);
+  float coordinate = (distanceAlongPath + pathDash.offset) / period;
+  float extent = max(fwidth(coordinate), 0.0001);
+  float center = fract(coordinate);
+  float fraction = pathDash.dashLength / period;
+  float coverage = (pathDash_integral(center + extent * 0.5, fraction) - pathDash_integral(center - extent * 0.5, fraction)) / extent;
+  if (pathDash.gapLength <= 0.0) return 1.0;
+  if (pathDash.dashLength <= 0.0) return 0.0;
+  return clamp(coverage, 0.0, 1.0);
+}
+`,
+    source: /* wgsl */ `
+struct pathDashUniforms {
+  dashLength: f32,
+  gapLength: f32,
+  offset: f32,
+};
+@group(3) @binding(auto) var<uniform> pathDash: pathDashUniforms;
+fn pathDash_integral(coordinate: f32, fraction: f32) -> f32 {
+  return floor(coordinate) * fraction + min(fract(coordinate), fraction);
+}
+fn pathDash_getCoverage(distanceAlongPath: f32) -> f32 {
+  let period = max(pathDash.dashLength + pathDash.gapLength, 0.0001);
+  let coordinate = (distanceAlongPath + pathDash.offset) / period;
+  let extent = max(fwidth(coordinate), 0.0001);
+  let center = fract(coordinate);
+  let fraction = pathDash.dashLength / period;
+  let coverage = (pathDash_integral(center + extent * 0.5, fraction) - pathDash_integral(center - extent * 0.5, fraction)) / extent;
+  if (pathDash.gapLength <= 0.0) { return 1.0; }
+  if (pathDash.dashLength <= 0.0) { return 0.0; }
+  return clamp(coverage, 0.0, 1.0);
+}
+`
+};
+//# sourceMappingURL=path-dash.js.map

package/dist/modules/geometry/path-dash/path-dash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-dash.js","sourceRoot":"","sources":["../../../../src/modules/geometry/path-dash/path-dash.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAM5D,MAAM,gBAAgB,GAAqB,EAAC,UAAU,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAC,CAAC;AAErF,6FAA6F;AAC7F,MAAM,CAAC,MAAM,QAAQ,GAAkD;IACrE,IAAI,EAAE,UAAU;IAChB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAC7C,gBAAgB,EAAE,CAAC;IACnB,YAAY,EAAE,EAAC,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAC;IAClE,eAAe,EAAE,gBAAgB;IACjC,WAAW,CAAC,KAAK,GAAG,EAAE,EAAE,gBAAgB,GAAG,gBAAgB;QACzD,MAAM,QAAQ,GAAG,EAAC,GAAG,gBAAgB,EAAE,GAAG,gBAAgB,EAAC,CAAC;QAC5D,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS;YAAE,QAAQ,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;QACxF,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS;YAAE,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;QACrF,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;YAAE,QAAQ,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAC/D,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;CAoBhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;CAqBpB;CACA,CAAC"}

package/dist/modules/geometry/pattern-fill/pattern-fill-shaders.cjs

@@ -0,0 +1,117 @@
+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 pattern_fill_shaders_exports = {};
+__export(pattern_fill_shaders_exports, {
+  PATTERN_FILL_GLSL: () => PATTERN_FILL_GLSL,
+  PATTERN_FILL_WGSL: () => PATTERN_FILL_WGSL
+});
+module.exports = __toCommonJS(pattern_fill_shaders_exports);
+const PATTERN_FILL_GLSL = (
+  /* glsl */
+  `
+layout(std140) uniform patternFillUniforms {
+  int patternType;
+  float spacing;
+  float width;
+  float angle;
+  vec2 offset;
+} patternFill;
+
+// Integral of a unit-period pulse. Filtering the integral preserves mean coverage at distance.
+float patternFill_integral(float coordinate, float width) {
+  return floor(coordinate) * width + min(fract(coordinate), width);
+}
+float patternFill_stripe(float coordinate, float footprint, float width) {
+  float extent = max(footprint, 0.0001);
+  float center = fract(coordinate + width * 0.5);
+  return clamp((patternFill_integral(center + extent * 0.5, width) -
+    patternFill_integral(center - extent * 0.5, width)) / extent, 0.0, 1.0);
+}
+
+float patternFill_getCoverage(vec2 coordinates) {
+  float cosine = cos(patternFill.angle);
+  float sine = sin(patternFill.angle);
+  vec2 local = coordinates - patternFill.offset;
+  vec2 rotated = vec2(dot(local, vec2(cosine, sine)), dot(local, vec2(-sine, cosine)));
+  vec2 phase = rotated / max(patternFill.spacing, 0.0001);
+  // Evaluate derivatives before pattern selection so WGSL and GLSL use the same footprint.
+  vec2 footprint = fwidth(phase);
+  float width = clamp(patternFill.width, 0.0, 1.0);
+  float first = patternFill_stripe(phase.x, footprint.x, width);
+  float second = patternFill_stripe(phase.y, footprint.y, width);
+  vec2 cell = fract(phase + 0.5) - 0.5;
+  float radius = width * 0.5;
+  float dots = clamp(0.5 + (radius - length(cell)) / max(length(footprint), 0.0001), 0.0, 1.0);
+  float dotMean = 3.141592653589793 * radius * radius;
+  dots = mix(dots, dotMean, smoothstep(0.35, 1.0, max(footprint.x, footprint.y)));
+  if (width <= 0.0) return 0.0;
+  if (patternFill.patternType == 2) return dots;
+  if (patternFill.patternType == 1) return first + second - first * second;
+  return first;
+}
+`
+);
+const PATTERN_FILL_WGSL = (
+  /* wgsl */
+  `
+struct patternFillUniforms {
+  patternType: i32,
+  spacing: f32,
+  width: f32,
+  angle: f32,
+  offset: vec2<f32>,
+};
+@group(3) @binding(auto) var<uniform> patternFill: patternFillUniforms;
+
+fn patternFill_integral(coordinate: f32, width: f32) -> f32 {
+  return floor(coordinate) * width + min(fract(coordinate), width);
+}
+fn patternFill_stripe(coordinate: f32, footprint: f32, width: f32) -> f32 {
+  let extent = max(footprint, 0.0001);
+  let center = fract(coordinate + width * 0.5);
+  return clamp((patternFill_integral(center + extent * 0.5, width) -
+    patternFill_integral(center - extent * 0.5, width)) / extent, 0.0, 1.0);
+}
+
+fn patternFill_getCoverage(coordinates: vec2<f32>) -> f32 {
+  let cosine = cos(patternFill.angle);
+  let sine = sin(patternFill.angle);
+  let local = coordinates - patternFill.offset;
+  let rotated = vec2<f32>(dot(local, vec2<f32>(cosine, sine)), dot(local, vec2<f32>(-sine, cosine)));
+  let phase = rotated / max(patternFill.spacing, 0.0001);
+  let footprint = fwidth(phase);
+  let width = clamp(patternFill.width, 0.0, 1.0);
+  let first = patternFill_stripe(phase.x, footprint.x, width);
+  let second = patternFill_stripe(phase.y, footprint.y, width);
+  let cell = fract(phase + 0.5) - 0.5;
+  let radius = width * 0.5;
+  var dots = clamp(0.5 + (radius - length(cell)) / max(length(footprint), 0.0001), 0.0, 1.0);
+  let dotMean = 3.141592653589793 * radius * radius;
+  dots = mix(dots, dotMean, smoothstep(0.35, 1.0, max(footprint.x, footprint.y)));
+  if (width <= 0.0) { return 0.0; }
+  if (patternFill.patternType == 2) { return dots; }
+  if (patternFill.patternType == 1) { return first + second - first * second; }
+  return first;
+}
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PATTERN_FILL_GLSL,
+  PATTERN_FILL_WGSL
+});

package/dist/modules/geometry/pattern-fill/pattern-fill-shaders.d.ts

@@ -0,0 +1,3 @@
+export declare const PATTERN_FILL_GLSL = "\nlayout(std140) uniform patternFillUniforms {\n  int patternType;\n  float spacing;\n  float width;\n  float angle;\n  vec2 offset;\n} patternFill;\n\n// Integral of a unit-period pulse. Filtering the integral preserves mean coverage at distance.\nfloat patternFill_integral(float coordinate, float width) {\n  return floor(coordinate) * width + min(fract(coordinate), width);\n}\nfloat patternFill_stripe(float coordinate, float footprint, float width) {\n  float extent = max(footprint, 0.0001);\n  float center = fract(coordinate + width * 0.5);\n  return clamp((patternFill_integral(center + extent * 0.5, width) -\n    patternFill_integral(center - extent * 0.5, width)) / extent, 0.0, 1.0);\n}\n\nfloat patternFill_getCoverage(vec2 coordinates) {\n  float cosine = cos(patternFill.angle);\n  float sine = sin(patternFill.angle);\n  vec2 local = coordinates - patternFill.offset;\n  vec2 rotated = vec2(dot(local, vec2(cosine, sine)), dot(local, vec2(-sine, cosine)));\n  vec2 phase = rotated / max(patternFill.spacing, 0.0001);\n  // Evaluate derivatives before pattern selection so WGSL and GLSL use the same footprint.\n  vec2 footprint = fwidth(phase);\n  float width = clamp(patternFill.width, 0.0, 1.0);\n  float first = patternFill_stripe(phase.x, footprint.x, width);\n  float second = patternFill_stripe(phase.y, footprint.y, width);\n  vec2 cell = fract(phase + 0.5) - 0.5;\n  float radius = width * 0.5;\n  float dots = clamp(0.5 + (radius - length(cell)) / max(length(footprint), 0.0001), 0.0, 1.0);\n  float dotMean = 3.141592653589793 * radius * radius;\n  dots = mix(dots, dotMean, smoothstep(0.35, 1.0, max(footprint.x, footprint.y)));\n  if (width <= 0.0) return 0.0;\n  if (patternFill.patternType == 2) return dots;\n  if (patternFill.patternType == 1) return first + second - first * second;\n  return first;\n}\n";
+export declare const PATTERN_FILL_WGSL = "\nstruct patternFillUniforms {\n  patternType: i32,\n  spacing: f32,\n  width: f32,\n  angle: f32,\n  offset: vec2<f32>,\n};\n@group(3) @binding(auto) var<uniform> patternFill: patternFillUniforms;\n\nfn patternFill_integral(coordinate: f32, width: f32) -> f32 {\n  return floor(coordinate) * width + min(fract(coordinate), width);\n}\nfn patternFill_stripe(coordinate: f32, footprint: f32, width: f32) -> f32 {\n  let extent = max(footprint, 0.0001);\n  let center = fract(coordinate + width * 0.5);\n  return clamp((patternFill_integral(center + extent * 0.5, width) -\n    patternFill_integral(center - extent * 0.5, width)) / extent, 0.0, 1.0);\n}\n\nfn patternFill_getCoverage(coordinates: vec2<f32>) -> f32 {\n  let cosine = cos(patternFill.angle);\n  let sine = sin(patternFill.angle);\n  let local = coordinates - patternFill.offset;\n  let rotated = vec2<f32>(dot(local, vec2<f32>(cosine, sine)), dot(local, vec2<f32>(-sine, cosine)));\n  let phase = rotated / max(patternFill.spacing, 0.0001);\n  let footprint = fwidth(phase);\n  let width = clamp(patternFill.width, 0.0, 1.0);\n  let first = patternFill_stripe(phase.x, footprint.x, width);\n  let second = patternFill_stripe(phase.y, footprint.y, width);\n  let cell = fract(phase + 0.5) - 0.5;\n  let radius = width * 0.5;\n  var dots = clamp(0.5 + (radius - length(cell)) / max(length(footprint), 0.0001), 0.0, 1.0);\n  let dotMean = 3.141592653589793 * radius * radius;\n  dots = mix(dots, dotMean, smoothstep(0.35, 1.0, max(footprint.x, footprint.y)));\n  if (width <= 0.0) { return 0.0; }\n  if (patternFill.patternType == 2) { return dots; }\n  if (patternFill.patternType == 1) { return first + second - first * second; }\n  return first;\n}\n";
+//# sourceMappingURL=pattern-fill-shaders.d.ts.map

package/dist/modules/geometry/pattern-fill/pattern-fill-shaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-fill-shaders.d.ts","sourceRoot":"","sources":["../../../../src/modules/geometry/pattern-fill/pattern-fill-shaders.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB,ozDAyC7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,srDAwC7B,CAAC"}

package/dist/modules/geometry/pattern-fill/pattern-fill-shaders.js

@@ -0,0 +1,87 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export const PATTERN_FILL_GLSL = /* glsl */ `
+layout(std140) uniform patternFillUniforms {
+  int patternType;
+  float spacing;
+  float width;
+  float angle;
+  vec2 offset;
+} patternFill;
+
+// Integral of a unit-period pulse. Filtering the integral preserves mean coverage at distance.
+float patternFill_integral(float coordinate, float width) {
+  return floor(coordinate) * width + min(fract(coordinate), width);
+}
+float patternFill_stripe(float coordinate, float footprint, float width) {
+  float extent = max(footprint, 0.0001);
+  float center = fract(coordinate + width * 0.5);
+  return clamp((patternFill_integral(center + extent * 0.5, width) -
+    patternFill_integral(center - extent * 0.5, width)) / extent, 0.0, 1.0);
+}
+
+float patternFill_getCoverage(vec2 coordinates) {
+  float cosine = cos(patternFill.angle);
+  float sine = sin(patternFill.angle);
+  vec2 local = coordinates - patternFill.offset;
+  vec2 rotated = vec2(dot(local, vec2(cosine, sine)), dot(local, vec2(-sine, cosine)));
+  vec2 phase = rotated / max(patternFill.spacing, 0.0001);
+  // Evaluate derivatives before pattern selection so WGSL and GLSL use the same footprint.
+  vec2 footprint = fwidth(phase);
+  float width = clamp(patternFill.width, 0.0, 1.0);
+  float first = patternFill_stripe(phase.x, footprint.x, width);
+  float second = patternFill_stripe(phase.y, footprint.y, width);
+  vec2 cell = fract(phase + 0.5) - 0.5;
+  float radius = width * 0.5;
+  float dots = clamp(0.5 + (radius - length(cell)) / max(length(footprint), 0.0001), 0.0, 1.0);
+  float dotMean = 3.141592653589793 * radius * radius;
+  dots = mix(dots, dotMean, smoothstep(0.35, 1.0, max(footprint.x, footprint.y)));
+  if (width <= 0.0) return 0.0;
+  if (patternFill.patternType == 2) return dots;
+  if (patternFill.patternType == 1) return first + second - first * second;
+  return first;
+}
+`;
+export const PATTERN_FILL_WGSL = /* wgsl */ `
+struct patternFillUniforms {
+  patternType: i32,
+  spacing: f32,
+  width: f32,
+  angle: f32,
+  offset: vec2<f32>,
+};
+@group(3) @binding(auto) var<uniform> patternFill: patternFillUniforms;
+
+fn patternFill_integral(coordinate: f32, width: f32) -> f32 {
+  return floor(coordinate) * width + min(fract(coordinate), width);
+}
+fn patternFill_stripe(coordinate: f32, footprint: f32, width: f32) -> f32 {
+  let extent = max(footprint, 0.0001);
+  let center = fract(coordinate + width * 0.5);
+  return clamp((patternFill_integral(center + extent * 0.5, width) -
+    patternFill_integral(center - extent * 0.5, width)) / extent, 0.0, 1.0);
+}
+
+fn patternFill_getCoverage(coordinates: vec2<f32>) -> f32 {
+  let cosine = cos(patternFill.angle);
+  let sine = sin(patternFill.angle);
+  let local = coordinates - patternFill.offset;
+  let rotated = vec2<f32>(dot(local, vec2<f32>(cosine, sine)), dot(local, vec2<f32>(-sine, cosine)));
+  let phase = rotated / max(patternFill.spacing, 0.0001);
+  let footprint = fwidth(phase);
+  let width = clamp(patternFill.width, 0.0, 1.0);
+  let first = patternFill_stripe(phase.x, footprint.x, width);
+  let second = patternFill_stripe(phase.y, footprint.y, width);
+  let cell = fract(phase + 0.5) - 0.5;
+  let radius = width * 0.5;
+  var dots = clamp(0.5 + (radius - length(cell)) / max(length(footprint), 0.0001), 0.0, 1.0);
+  let dotMean = 3.141592653589793 * radius * radius;
+  dots = mix(dots, dotMean, smoothstep(0.35, 1.0, max(footprint.x, footprint.y)));
+  if (width <= 0.0) { return 0.0; }
+  if (patternFill.patternType == 2) { return dots; }
+  if (patternFill.patternType == 1) { return first + second - first * second; }
+  return first;
+}
+`;
+//# sourceMappingURL=pattern-fill-shaders.js.map

package/dist/modules/geometry/pattern-fill/pattern-fill-shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-fill-shaders.js","sourceRoot":"","sources":["../../../../src/modules/geometry/pattern-fill/pattern-fill-shaders.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAE5D,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyC3C,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwC3C,CAAC"}

package/dist/modules/geometry/pattern-fill/pattern-fill.cjs

@@ -0,0 +1,64 @@
+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 pattern_fill_exports = {};
+__export(pattern_fill_exports, {
+  patternFill: () => patternFill
+});
+module.exports = __toCommonJS(pattern_fill_exports);
+var import_pattern_fill_shaders = require("./pattern-fill-shaders.cjs");
+const DEFAULT_UNIFORMS = {
+  patternType: 0,
+  spacing: 8,
+  width: 0.12,
+  angle: Math.PI / 4,
+  offset: [0, 0]
+};
+const patternFill = {
+  name: "patternFill",
+  firstBindingSlot: 0,
+  bindingLayout: [{ name: "patternFill", group: 3 }],
+  source: import_pattern_fill_shaders.PATTERN_FILL_WGSL,
+  fs: import_pattern_fill_shaders.PATTERN_FILL_GLSL,
+  uniformTypes: {
+    patternType: "i32",
+    spacing: "f32",
+    width: "f32",
+    angle: "f32",
+    offset: "vec2<f32>"
+  },
+  defaultUniforms: DEFAULT_UNIFORMS,
+  getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+    const uniforms = { ...DEFAULT_UNIFORMS, ...previousUniforms };
+    if (props.pattern !== void 0) {
+      uniforms.patternType = { hatch: 0, crosshatch: 1, dots: 2 }[props.pattern];
+    }
+    if (props.spacing !== void 0)
+      uniforms.spacing = Math.max(props.spacing, 1e-4);
+    if (props.width !== void 0)
+      uniforms.width = Math.min(1, Math.max(0, props.width));
+    if (props.angle !== void 0)
+      uniforms.angle = props.angle;
+    if (props.offset !== void 0)
+      uniforms.offset = props.offset;
+    return uniforms;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  patternFill
+});

package/dist/modules/geometry/pattern-fill/pattern-fill.d.ts

@@ -0,0 +1,14 @@
+import type { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+export type PatternFillUniforms = {
+    patternType: number;
+    spacing: number;
+    width: number;
+    angle: number;
+    offset: readonly [number, number];
+};
+export type PatternFillProps = Partial<Omit<PatternFillUniforms, 'patternType'>> & {
+    pattern?: 'hatch' | 'crosshatch' | 'dots';
+};
+/** Fragment coverage for coordinate-anchored, filtered hatch and dot fills. */
+export declare const patternFill: ShaderModule<PatternFillProps, PatternFillUniforms>;
+//# sourceMappingURL=pattern-fill.d.ts.map

package/dist/modules/geometry/pattern-fill/pattern-fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-fill.d.ts","sourceRoot":"","sources":["../../../../src/modules/geometry/pattern-fill/pattern-fill.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,oDAAiD;AAG3E,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,mBAAmB,EAAE,aAAa,CAAC,CAAC,GAAG;IACjF,OAAO,CAAC,EAAE,OAAO,GAAG,YAAY,GAAG,MAAM,CAAC;CAC3C,CAAC;AAUF,+EAA+E;AAC/E,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,gBAAgB,EAAE,mBAAmB,CAyB3E,CAAC"}

package/dist/modules/geometry/pattern-fill/pattern-fill.js

@@ -0,0 +1,43 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { PATTERN_FILL_GLSL, PATTERN_FILL_WGSL } from "./pattern-fill-shaders.js";
+const DEFAULT_UNIFORMS = {
+    patternType: 0,
+    spacing: 8,
+    width: 0.12,
+    angle: Math.PI / 4,
+    offset: [0, 0]
+};
+/** Fragment coverage for coordinate-anchored, filtered hatch and dot fills. */
+export const patternFill = {
+    name: 'patternFill',
+    firstBindingSlot: 0,
+    bindingLayout: [{ name: 'patternFill', group: 3 }],
+    source: PATTERN_FILL_WGSL,
+    fs: PATTERN_FILL_GLSL,
+    uniformTypes: {
+        patternType: 'i32',
+        spacing: 'f32',
+        width: 'f32',
+        angle: 'f32',
+        offset: 'vec2<f32>'
+    },
+    defaultUniforms: DEFAULT_UNIFORMS,
+    getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+        const uniforms = { ...DEFAULT_UNIFORMS, ...previousUniforms };
+        if (props.pattern !== undefined) {
+            uniforms.patternType = { hatch: 0, crosshatch: 1, dots: 2 }[props.pattern];
+        }
+        if (props.spacing !== undefined)
+            uniforms.spacing = Math.max(props.spacing, 0.0001);
+        if (props.width !== undefined)
+            uniforms.width = Math.min(1, Math.max(0, props.width));
+        if (props.angle !== undefined)
+            uniforms.angle = props.angle;
+        if (props.offset !== undefined)
+            uniforms.offset = props.offset;
+        return uniforms;
+    }
+};
+//# sourceMappingURL=pattern-fill.js.map

package/dist/modules/geometry/pattern-fill/pattern-fill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-fill.js","sourceRoot":"","sources":["../../../../src/modules/geometry/pattern-fill/pattern-fill.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAG5D,OAAO,EAAC,iBAAiB,EAAE,iBAAiB,EAAC,kCAA+B;AAc5E,MAAM,gBAAgB,GAAwB;IAC5C,WAAW,EAAE,CAAC;IACd,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC;IAClB,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;CACf,CAAC;AAEF,+EAA+E;AAC/E,MAAM,CAAC,MAAM,WAAW,GAAwD;IAC9E,IAAI,EAAE,aAAa;IACnB,gBAAgB,EAAE,CAAC;IACnB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAChD,MAAM,EAAE,iBAAiB;IACzB,EAAE,EAAE,iBAAiB;IACrB,YAAY,EAAE;QACZ,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,KAAK;QACd,KAAK,EAAE,KAAK;QACZ,KAAK,EAAE,KAAK;QACZ,MAAM,EAAE,WAAW;KACpB;IACD,eAAe,EAAE,gBAAgB;IACjC,WAAW,CAAC,KAAK,GAAG,EAAE,EAAE,gBAAgB,GAAG,gBAAgB;QACzD,MAAM,QAAQ,GAAG,EAAC,GAAG,gBAAgB,EAAE,GAAG,gBAAgB,EAAC,CAAC;QAC5D,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAChC,QAAQ,CAAC,WAAW,GAAG,EAAC,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC3E,CAAC;QACD,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACpF,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;YAAE,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QACtF,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS;YAAE,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QAC5D,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;YAAE,QAAQ,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAC/D,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF,CAAC"}

package/dist/modules/geometry/point-glow/point-glow.cjs

@@ -0,0 +1,104 @@
+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 point_glow_exports = {};
+__export(point_glow_exports, {
+  pointGlow: () => pointGlow
+});
+module.exports = __toCommonJS(point_glow_exports);
+const DEFAULT_UNIFORMS = {
+  coreRadius: 0.12,
+  coreIntensity: 1,
+  haloIntensity: 0.6,
+  falloff: 5
+};
+const pointGlow = {
+  name: "pointGlow",
+  firstBindingSlot: 0,
+  bindingLayout: [{ name: "pointGlow", group: 3 }],
+  uniformTypes: {
+    coreRadius: "f32",
+    coreIntensity: "f32",
+    haloIntensity: "f32",
+    falloff: "f32"
+  },
+  defaultUniforms: DEFAULT_UNIFORMS,
+  getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+    const uniforms = { ...DEFAULT_UNIFORMS, ...previousUniforms };
+    if (props.coreRadius !== void 0)
+      uniforms.coreRadius = Math.min(1, Math.max(0, props.coreRadius));
+    if (props.coreIntensity !== void 0)
+      uniforms.coreIntensity = Math.max(0, props.coreIntensity);
+    if (props.haloIntensity !== void 0)
+      uniforms.haloIntensity = Math.max(0, props.haloIntensity);
+    if (props.falloff !== void 0)
+      uniforms.falloff = Math.max(0.01, props.falloff);
+    return uniforms;
+  },
+  fs: (
+    /* glsl */
+    `
+layout(std140) uniform pointGlowUniforms {
+  float coreRadius;
+  float coreIntensity;
+  float haloIntensity;
+  float falloff;
+} pointGlow;
+
+// Coordinates span [-1, 1] across the sprite; tint is linear RGB.
+vec3 pointGlow_getColor(vec2 coordinates, vec3 tint) {
+  float radius = length(coordinates);
+  float edgeWidth = max(fwidth(radius), 0.0001);
+  float envelope = 1.0 - smoothstep(1.0 - edgeWidth, 1.0, radius);
+  float core = 1.0 - smoothstep(pointGlow.coreRadius - edgeWidth * 0.5,
+    pointGlow.coreRadius + edgeWidth * 0.5, radius);
+  if (pointGlow.coreRadius <= 0.0) core = 0.0;
+  float outer = exp(-pointGlow.falloff);
+  float halo = max(0.0, (exp(-pointGlow.falloff * radius * radius) - outer) / (1.0 - outer));
+  return (vec3(core * pointGlow.coreIntensity) + tint * halo * pointGlow.haloIntensity) * envelope;
+}
+`
+  ),
+  source: (
+    /* wgsl */
+    `
+struct pointGlowUniforms {
+  coreRadius: f32,
+  coreIntensity: f32,
+  haloIntensity: f32,
+  falloff: f32,
+};
+@group(3) @binding(auto) var<uniform> pointGlow: pointGlowUniforms;
+
+fn pointGlow_getColor(coordinates: vec2<f32>, tint: vec3<f32>) -> vec3<f32> {
+  let radius = length(coordinates);
+  let edgeWidth = max(fwidth(radius), 0.0001);
+  let envelope = 1.0 - smoothstep(1.0 - edgeWidth, 1.0, radius);
+  var core = 1.0 - smoothstep(pointGlow.coreRadius - edgeWidth * 0.5,
+    pointGlow.coreRadius + edgeWidth * 0.5, radius);
+  if (pointGlow.coreRadius <= 0.0) { core = 0.0; }
+  let outer = exp(-pointGlow.falloff);
+  let halo = max(0.0, (exp(-pointGlow.falloff * radius * radius) - outer) / (1.0 - outer));
+  return (vec3<f32>(core * pointGlow.coreIntensity) + tint * halo * pointGlow.haloIntensity) * envelope;
+}
+`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pointGlow
+});

package/dist/modules/geometry/point-glow/point-glow.d.ts

@@ -0,0 +1,11 @@
+import type { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+export type PointGlowUniforms = {
+    coreRadius: number;
+    coreIntensity: number;
+    haloIntensity: number;
+    falloff: number;
+};
+export type PointGlowProps = Partial<PointGlowUniforms>;
+/** Linear radiance for a bounded point sprite. Blend additively or composite into an HDR target. */
+export declare const pointGlow: ShaderModule<PointGlowProps, PointGlowUniforms>;
+//# sourceMappingURL=point-glow.d.ts.map

package/dist/modules/geometry/point-glow/point-glow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"point-glow.d.ts","sourceRoot":"","sources":["../../../../src/modules/geometry/point-glow/point-glow.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,oDAAiD;AAE3E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AACF,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;AASxD,oGAAoG;AACpG,eAAO,MAAM,SAAS,EAAE,YAAY,CAAC,cAAc,EAAE,iBAAiB,CAgErE,CAAC"}