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

package/dist/modules/math/random/random.cjs

@@ -0,0 +1,46 @@
+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 random_exports = {};
+__export(random_exports, {
+  random: () => random
+});
+module.exports = __toCommonJS(random_exports);
+const source = (
+  /* wgsl */
+  `fn random(scale: vec3f, seed: f32) -> f32 {
+  return fract(sin(dot(scale + vec3f(seed), vec3f(12.9898, 78.233, 151.7182))) * 43758.5453 + seed);
+}
+`
+);
+const fs = (
+  /* glsl */
+  `float random(vec3 scale, float seed) {
+  /* use the fragment position for a different seed per-pixel */
+  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+}
+`
+);
+const random = {
+  name: "random",
+  source,
+  fs
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  random
+});

package/dist/modules/math/random/random.d.ts

@@ -0,0 +1,7 @@
+/** Quick random generator for fragment shaders */
+export declare const random: {
+    readonly name: "random";
+    readonly source: "fn random(scale: vec3f, seed: f32) -> f32 {\n  return fract(sin(dot(scale + vec3f(seed), vec3f(12.9898, 78.233, 151.7182))) * 43758.5453 + seed);\n}\n";
+    readonly fs: "float random(vec3 scale, float seed) {\n  /* use the fragment position for a different seed per-pixel */\n  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\n";
+};
+//# sourceMappingURL=random.d.ts.map

package/dist/modules/math/random/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/random/random.ts"],"names":[],"mappings":"AAmBA,kDAAkD;AAClD,eAAO,MAAM,MAAM;;;;CAIsB,CAAC"}

package/dist/modules/math/random/random.js

@@ -0,0 +1,21 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+const source = /* wgsl */ `\
+fn random(scale: vec3f, seed: f32) -> f32 {
+  return fract(sin(dot(scale + vec3f(seed), vec3f(12.9898, 78.233, 151.7182))) * 43758.5453 + seed);
+}
+`;
+const fs = /* glsl */ `\
+float random(vec3 scale, float seed) {
+  /* use the fragment position for a different seed per-pixel */
+  return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+}
+`;
+/** Quick random generator for fragment shaders */
+export const random = {
+    name: 'random',
+    source,
+    fs
+};
+//# sourceMappingURL=random.js.map

package/dist/modules/math/random/random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.js","sourceRoot":"","sources":["../../../../src/modules/math/random/random.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAI5D,MAAM,MAAM,GAAG,UAAU,CAAC;;;;CAIzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;CAKrB,CAAC;AAEF,kDAAkD;AAClD,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,QAAQ;IACd,MAAM;IACN,EAAE;CACqC,CAAC"}

package/dist/modules/math/value-noise/value-noise.cjs

@@ -0,0 +1,95 @@
+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 value_noise_exports = {};
+__export(value_noise_exports, {
+  valueNoise: () => valueNoise
+});
+module.exports = __toCommonJS(value_noise_exports);
+const valueNoise = {
+  name: "valueNoise",
+  fs: (
+    /* glsl */
+    `
+float valueNoise_hash(vec2 cell) {
+  vec3 value = fract(vec3(cell.x, cell.y, cell.x) * 0.1031);
+  value += dot(value, value.yzx + 33.33);
+  return fract((value.x + value.y) * value.z);
+}
+float valueNoise_noise(vec2 position) {
+  vec2 cell = floor(position);
+  vec2 fraction = fract(position);
+  vec2 blend = fraction * fraction * (3.0 - 2.0 * fraction);
+  return mix(mix(valueNoise_hash(cell), valueNoise_hash(cell + vec2(1.0, 0.0)), blend.x),
+    mix(valueNoise_hash(cell + vec2(0.0, 1.0)), valueNoise_hash(cell + vec2(1.0)), blend.x), blend.y);
+}
+
+float valueNoise_hash3(vec3 cell) {
+  vec3 value = fract(cell * 0.1031);
+  value += dot(value, value.yzx + 33.33);
+  return fract((value.x + value.y) * value.z);
+}
+float valueNoise_noise3(vec3 position) {
+  vec3 cell = floor(position);
+  vec3 fraction = fract(position);
+  vec3 blend = fraction * fraction * (3.0 - 2.0 * fraction);
+  float bottom = mix(mix(valueNoise_hash3(cell), valueNoise_hash3(cell + vec3(1.0, 0.0, 0.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3(0.0, 1.0, 0.0)), valueNoise_hash3(cell + vec3(1.0, 1.0, 0.0)), blend.x), blend.y);
+  float top = mix(mix(valueNoise_hash3(cell + vec3(0.0, 0.0, 1.0)), valueNoise_hash3(cell + vec3(1.0, 0.0, 1.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3(0.0, 1.0, 1.0)), valueNoise_hash3(cell + vec3(1.0)), blend.x), blend.y);
+  return mix(bottom, top, blend.z);
+}
+`
+  ),
+  source: (
+    /* wgsl */
+    `
+fn valueNoise_hash(cell: vec2f) -> f32 {
+  var value = fract(vec3f(cell.x, cell.y, cell.x) * 0.1031);
+  value += vec3f(dot(value, value.yzx + vec3f(33.33)));
+  return fract((value.x + value.y) * value.z);
+}
+fn valueNoise_noise(position: vec2f) -> f32 {
+  let cell = floor(position);
+  let fraction = fract(position);
+  let blend = fraction * fraction * (vec2f(3.0) - 2.0 * fraction);
+  return mix(mix(valueNoise_hash(cell), valueNoise_hash(cell + vec2f(1.0, 0.0)), blend.x),
+    mix(valueNoise_hash(cell + vec2f(0.0, 1.0)), valueNoise_hash(cell + vec2f(1.0)), blend.x), blend.y);
+}
+
+fn valueNoise_hash3(cell: vec3f) -> f32 {
+  var value = fract(cell * 0.1031);
+  value += vec3f(dot(value, value.yzx + vec3f(33.33)));
+  return fract((value.x + value.y) * value.z);
+}
+fn valueNoise_noise3(position: vec3f) -> f32 {
+  let cell = floor(position);
+  let fraction = fract(position);
+  let blend = fraction * fraction * (vec3f(3.0) - 2.0 * fraction);
+  let bottom = mix(mix(valueNoise_hash3(cell), valueNoise_hash3(cell + vec3f(1.0, 0.0, 0.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3f(0.0, 1.0, 0.0)), valueNoise_hash3(cell + vec3f(1.0, 1.0, 0.0)), blend.x), blend.y);
+  let top = mix(mix(valueNoise_hash3(cell + vec3f(0.0, 0.0, 1.0)), valueNoise_hash3(cell + vec3f(1.0, 0.0, 1.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3f(0.0, 1.0, 1.0)), valueNoise_hash3(cell + vec3f(1.0)), blend.x), blend.y);
+  return mix(bottom, top, blend.z);
+}
+`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  valueNoise
+});

package/dist/modules/math/value-noise/value-noise.d.ts

@@ -0,0 +1,7 @@
+/** Smooth, deterministic value noise shared by atmospheric shader modules. */
+export declare const valueNoise: {
+    readonly name: "valueNoise";
+    readonly fs: "\nfloat valueNoise_hash(vec2 cell) {\n  vec3 value = fract(vec3(cell.x, cell.y, cell.x) * 0.1031);\n  value += dot(value, value.yzx + 33.33);\n  return fract((value.x + value.y) * value.z);\n}\nfloat valueNoise_noise(vec2 position) {\n  vec2 cell = floor(position);\n  vec2 fraction = fract(position);\n  vec2 blend = fraction * fraction * (3.0 - 2.0 * fraction);\n  return mix(mix(valueNoise_hash(cell), valueNoise_hash(cell + vec2(1.0, 0.0)), blend.x),\n    mix(valueNoise_hash(cell + vec2(0.0, 1.0)), valueNoise_hash(cell + vec2(1.0)), blend.x), blend.y);\n}\n\nfloat valueNoise_hash3(vec3 cell) {\n  vec3 value = fract(cell * 0.1031);\n  value += dot(value, value.yzx + 33.33);\n  return fract((value.x + value.y) * value.z);\n}\nfloat valueNoise_noise3(vec3 position) {\n  vec3 cell = floor(position);\n  vec3 fraction = fract(position);\n  vec3 blend = fraction * fraction * (3.0 - 2.0 * fraction);\n  float bottom = mix(mix(valueNoise_hash3(cell), valueNoise_hash3(cell + vec3(1.0, 0.0, 0.0)), blend.x),\n    mix(valueNoise_hash3(cell + vec3(0.0, 1.0, 0.0)), valueNoise_hash3(cell + vec3(1.0, 1.0, 0.0)), blend.x), blend.y);\n  float top = mix(mix(valueNoise_hash3(cell + vec3(0.0, 0.0, 1.0)), valueNoise_hash3(cell + vec3(1.0, 0.0, 1.0)), blend.x),\n    mix(valueNoise_hash3(cell + vec3(0.0, 1.0, 1.0)), valueNoise_hash3(cell + vec3(1.0)), blend.x), blend.y);\n  return mix(bottom, top, blend.z);\n}\n";
+    readonly source: "\nfn valueNoise_hash(cell: vec2f) -> f32 {\n  var value = fract(vec3f(cell.x, cell.y, cell.x) * 0.1031);\n  value += vec3f(dot(value, value.yzx + vec3f(33.33)));\n  return fract((value.x + value.y) * value.z);\n}\nfn valueNoise_noise(position: vec2f) -> f32 {\n  let cell = floor(position);\n  let fraction = fract(position);\n  let blend = fraction * fraction * (vec2f(3.0) - 2.0 * fraction);\n  return mix(mix(valueNoise_hash(cell), valueNoise_hash(cell + vec2f(1.0, 0.0)), blend.x),\n    mix(valueNoise_hash(cell + vec2f(0.0, 1.0)), valueNoise_hash(cell + vec2f(1.0)), blend.x), blend.y);\n}\n\nfn valueNoise_hash3(cell: vec3f) -> f32 {\n  var value = fract(cell * 0.1031);\n  value += vec3f(dot(value, value.yzx + vec3f(33.33)));\n  return fract((value.x + value.y) * value.z);\n}\nfn valueNoise_noise3(position: vec3f) -> f32 {\n  let cell = floor(position);\n  let fraction = fract(position);\n  let blend = fraction * fraction * (vec3f(3.0) - 2.0 * fraction);\n  let bottom = mix(mix(valueNoise_hash3(cell), valueNoise_hash3(cell + vec3f(1.0, 0.0, 0.0)), blend.x),\n    mix(valueNoise_hash3(cell + vec3f(0.0, 1.0, 0.0)), valueNoise_hash3(cell + vec3f(1.0, 1.0, 0.0)), blend.x), blend.y);\n  let top = mix(mix(valueNoise_hash3(cell + vec3f(0.0, 0.0, 1.0)), valueNoise_hash3(cell + vec3f(1.0, 0.0, 1.0)), blend.x),\n    mix(valueNoise_hash3(cell + vec3f(0.0, 1.0, 1.0)), valueNoise_hash3(cell + vec3f(1.0)), blend.x), blend.y);\n  return mix(bottom, top, blend.z);\n}\n";
+};
+//# sourceMappingURL=value-noise.d.ts.map

package/dist/modules/math/value-noise/value-noise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-noise.d.ts","sourceRoot":"","sources":["../../../../src/modules/math/value-noise/value-noise.ts"],"names":[],"mappings":"AAMA,8EAA8E;AAC9E,eAAO,MAAM,UAAU;;;;CA8DU,CAAC"}

package/dist/modules/math/value-noise/value-noise.js

@@ -0,0 +1,68 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/** Smooth, deterministic value noise shared by atmospheric shader modules. */
+export const valueNoise = {
+    name: 'valueNoise',
+    fs: /* glsl */ `
+float valueNoise_hash(vec2 cell) {
+  vec3 value = fract(vec3(cell.x, cell.y, cell.x) * 0.1031);
+  value += dot(value, value.yzx + 33.33);
+  return fract((value.x + value.y) * value.z);
+}
+float valueNoise_noise(vec2 position) {
+  vec2 cell = floor(position);
+  vec2 fraction = fract(position);
+  vec2 blend = fraction * fraction * (3.0 - 2.0 * fraction);
+  return mix(mix(valueNoise_hash(cell), valueNoise_hash(cell + vec2(1.0, 0.0)), blend.x),
+    mix(valueNoise_hash(cell + vec2(0.0, 1.0)), valueNoise_hash(cell + vec2(1.0)), blend.x), blend.y);
+}
+
+float valueNoise_hash3(vec3 cell) {
+  vec3 value = fract(cell * 0.1031);
+  value += dot(value, value.yzx + 33.33);
+  return fract((value.x + value.y) * value.z);
+}
+float valueNoise_noise3(vec3 position) {
+  vec3 cell = floor(position);
+  vec3 fraction = fract(position);
+  vec3 blend = fraction * fraction * (3.0 - 2.0 * fraction);
+  float bottom = mix(mix(valueNoise_hash3(cell), valueNoise_hash3(cell + vec3(1.0, 0.0, 0.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3(0.0, 1.0, 0.0)), valueNoise_hash3(cell + vec3(1.0, 1.0, 0.0)), blend.x), blend.y);
+  float top = mix(mix(valueNoise_hash3(cell + vec3(0.0, 0.0, 1.0)), valueNoise_hash3(cell + vec3(1.0, 0.0, 1.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3(0.0, 1.0, 1.0)), valueNoise_hash3(cell + vec3(1.0)), blend.x), blend.y);
+  return mix(bottom, top, blend.z);
+}
+`,
+    source: /* wgsl */ `
+fn valueNoise_hash(cell: vec2f) -> f32 {
+  var value = fract(vec3f(cell.x, cell.y, cell.x) * 0.1031);
+  value += vec3f(dot(value, value.yzx + vec3f(33.33)));
+  return fract((value.x + value.y) * value.z);
+}
+fn valueNoise_noise(position: vec2f) -> f32 {
+  let cell = floor(position);
+  let fraction = fract(position);
+  let blend = fraction * fraction * (vec2f(3.0) - 2.0 * fraction);
+  return mix(mix(valueNoise_hash(cell), valueNoise_hash(cell + vec2f(1.0, 0.0)), blend.x),
+    mix(valueNoise_hash(cell + vec2f(0.0, 1.0)), valueNoise_hash(cell + vec2f(1.0)), blend.x), blend.y);
+}
+
+fn valueNoise_hash3(cell: vec3f) -> f32 {
+  var value = fract(cell * 0.1031);
+  value += vec3f(dot(value, value.yzx + vec3f(33.33)));
+  return fract((value.x + value.y) * value.z);
+}
+fn valueNoise_noise3(position: vec3f) -> f32 {
+  let cell = floor(position);
+  let fraction = fract(position);
+  let blend = fraction * fraction * (vec3f(3.0) - 2.0 * fraction);
+  let bottom = mix(mix(valueNoise_hash3(cell), valueNoise_hash3(cell + vec3f(1.0, 0.0, 0.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3f(0.0, 1.0, 0.0)), valueNoise_hash3(cell + vec3f(1.0, 1.0, 0.0)), blend.x), blend.y);
+  let top = mix(mix(valueNoise_hash3(cell + vec3f(0.0, 0.0, 1.0)), valueNoise_hash3(cell + vec3f(1.0, 0.0, 1.0)), blend.x),
+    mix(valueNoise_hash3(cell + vec3f(0.0, 1.0, 1.0)), valueNoise_hash3(cell + vec3f(1.0)), blend.x), blend.y);
+  return mix(bottom, top, blend.z);
+}
+`
+};
+//# sourceMappingURL=value-noise.js.map

package/dist/modules/math/value-noise/value-noise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-noise.js","sourceRoot":"","sources":["../../../../src/modules/math/value-noise/value-noise.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAI5D,8EAA8E;AAC9E,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BpB;CACgC,CAAC"}

package/dist/modules/volume/volume-raymarch.cjs

@@ -0,0 +1,107 @@
+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 volume_raymarch_exports = {};
+__export(volume_raymarch_exports, {
+  volumeRaymarch: () => volumeRaymarch
+});
+module.exports = __toCommonJS(volume_raymarch_exports);
+const source = (
+  /* wgsl */
+  `fn volumeRaymarch_intersectBox(origin: vec3f, direction: vec3f, minimum: vec3f, maximum: vec3f) -> vec2f {
+  let safeDirection = select(vec3f(0.000001), direction, abs(direction) > vec3f(0.000001));
+  let first = (minimum - origin) / safeDirection;
+  let second = (maximum - origin) / safeDirection;
+  let nearPlane = min(first, second);
+  let farPlane = max(first, second);
+  return vec2f(
+    max(max(nearPlane.x, nearPlane.y), nearPlane.z),
+    min(min(farPlane.x, farPlane.y), farPlane.z)
+  );
+}
+
+fn volumeRaymarch_mixScalar(corners: array<f32, 8>, blend: vec3f) -> f32 {
+  let lower = mix(mix(corners[0], corners[1], blend.x), mix(corners[2], corners[3], blend.x), blend.y);
+  let upper = mix(mix(corners[4], corners[5], blend.x), mix(corners[6], corners[7], blend.x), blend.y);
+  return mix(lower, upper, blend.z);
+}
+
+fn volumeRaymarch_mixVector(corners: array<vec3f, 8>, blend: vec3f) -> vec3f {
+  let lower = mix(mix(corners[0], corners[1], blend.x), mix(corners[2], corners[3], blend.x), blend.y);
+  let upper = mix(mix(corners[4], corners[5], blend.x), mix(corners[6], corners[7], blend.x), blend.y);
+  return mix(lower, upper, blend.z);
+}
+
+fn volumeRaymarch_sequentialColor(value: f32, lowColor: vec3f, highColor: vec3f) -> vec3f {
+  return mix(lowColor, highColor, clamp(value, 0.0, 1.0));
+}
+
+fn volumeRaymarch_signedColor(value: f32, negativeColor: vec3f, neutralColor: vec3f, positiveColor: vec3f) -> vec3f {
+  let amount = clamp(abs(value), 0.0, 1.0);
+  let signedTarget = select(negativeColor, positiveColor, value >= 0.0);
+  return mix(neutralColor, signedTarget, amount);
+}
+
+fn volumeRaymarch_directionColor(vector: vec3f) -> vec3f {
+  let direction = normalize(vector + vec3f(0.00001));
+  return 0.18 + 0.82 * (direction * 0.5 + 0.5);
+}
+
+fn volumeRaymarch_segmentDistance(point: vec3f, start: vec3f, end: vec3f) -> f32 {
+  let segment = end - start;
+  let fraction = clamp(dot(point - start, segment) / max(dot(segment, segment), 0.000001), 0.0, 1.0);
+  return length(point - (start + segment * fraction));
+}
+
+fn volumeRaymarch_arrowDistance(
+  point: vec3f,
+  center: vec3f,
+  direction: vec3f,
+  arrowLength: f32,
+  shaftRadius: f32,
+  headRadius: f32
+) -> vec2f {
+  let tail = center - direction * arrowLength * 0.48;
+  let shoulder = center + direction * arrowLength * 0.18;
+  let tip = center + direction * arrowLength * 0.52;
+  let shaftDistance = volumeRaymarch_segmentDistance(point, tail, shoulder) - shaftRadius;
+  let headVector = point - shoulder;
+  let headLength = max(length(tip - shoulder), 0.000001);
+  let headPosition = dot(headVector, direction);
+  let taperedRadius = headRadius * (1.0 - clamp(headPosition / headLength, 0.0, 1.0));
+  let radialDistance = length(headVector - direction * headPosition);
+  let headDistance = max(
+    radialDistance - taperedRadius,
+    max(-headPosition, headPosition - headLength)
+  );
+  return vec2f(min(shaftDistance, headDistance), headDistance);
+}
+
+fn volumeRaymarch_composite(accumulated: vec4f, color: vec3f, alpha: f32) -> vec4f {
+  let contribution = (1.0 - accumulated.a) * clamp(alpha, 0.0, 1.0);
+  return vec4f(accumulated.rgb + color * contribution, accumulated.a + contribution);
+}
+`
+);
+const volumeRaymarch = {
+  name: "volumeRaymarch",
+  source
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  volumeRaymarch
+});

package/dist/modules/volume/volume-raymarch.d.ts

@@ -0,0 +1,6 @@
+/** WGSL helpers shared by structured-volume ray marchers. */
+export declare const volumeRaymarch: {
+    readonly name: "volumeRaymarch";
+    readonly source: "fn volumeRaymarch_intersectBox(origin: vec3f, direction: vec3f, minimum: vec3f, maximum: vec3f) -> vec2f {\n  let safeDirection = select(vec3f(0.000001), direction, abs(direction) > vec3f(0.000001));\n  let first = (minimum - origin) / safeDirection;\n  let second = (maximum - origin) / safeDirection;\n  let nearPlane = min(first, second);\n  let farPlane = max(first, second);\n  return vec2f(\n    max(max(nearPlane.x, nearPlane.y), nearPlane.z),\n    min(min(farPlane.x, farPlane.y), farPlane.z)\n  );\n}\n\nfn volumeRaymarch_mixScalar(corners: array<f32, 8>, blend: vec3f) -> f32 {\n  let lower = mix(mix(corners[0], corners[1], blend.x), mix(corners[2], corners[3], blend.x), blend.y);\n  let upper = mix(mix(corners[4], corners[5], blend.x), mix(corners[6], corners[7], blend.x), blend.y);\n  return mix(lower, upper, blend.z);\n}\n\nfn volumeRaymarch_mixVector(corners: array<vec3f, 8>, blend: vec3f) -> vec3f {\n  let lower = mix(mix(corners[0], corners[1], blend.x), mix(corners[2], corners[3], blend.x), blend.y);\n  let upper = mix(mix(corners[4], corners[5], blend.x), mix(corners[6], corners[7], blend.x), blend.y);\n  return mix(lower, upper, blend.z);\n}\n\nfn volumeRaymarch_sequentialColor(value: f32, lowColor: vec3f, highColor: vec3f) -> vec3f {\n  return mix(lowColor, highColor, clamp(value, 0.0, 1.0));\n}\n\nfn volumeRaymarch_signedColor(value: f32, negativeColor: vec3f, neutralColor: vec3f, positiveColor: vec3f) -> vec3f {\n  let amount = clamp(abs(value), 0.0, 1.0);\n  let signedTarget = select(negativeColor, positiveColor, value >= 0.0);\n  return mix(neutralColor, signedTarget, amount);\n}\n\nfn volumeRaymarch_directionColor(vector: vec3f) -> vec3f {\n  let direction = normalize(vector + vec3f(0.00001));\n  return 0.18 + 0.82 * (direction * 0.5 + 0.5);\n}\n\nfn volumeRaymarch_segmentDistance(point: vec3f, start: vec3f, end: vec3f) -> f32 {\n  let segment = end - start;\n  let fraction = clamp(dot(point - start, segment) / max(dot(segment, segment), 0.000001), 0.0, 1.0);\n  return length(point - (start + segment * fraction));\n}\n\nfn volumeRaymarch_arrowDistance(\n  point: vec3f,\n  center: vec3f,\n  direction: vec3f,\n  arrowLength: f32,\n  shaftRadius: f32,\n  headRadius: f32\n) -> vec2f {\n  let tail = center - direction * arrowLength * 0.48;\n  let shoulder = center + direction * arrowLength * 0.18;\n  let tip = center + direction * arrowLength * 0.52;\n  let shaftDistance = volumeRaymarch_segmentDistance(point, tail, shoulder) - shaftRadius;\n  let headVector = point - shoulder;\n  let headLength = max(length(tip - shoulder), 0.000001);\n  let headPosition = dot(headVector, direction);\n  let taperedRadius = headRadius * (1.0 - clamp(headPosition / headLength, 0.0, 1.0));\n  let radialDistance = length(headVector - direction * headPosition);\n  let headDistance = max(\n    radialDistance - taperedRadius,\n    max(-headPosition, headPosition - headLength)\n  );\n  return vec2f(min(shaftDistance, headDistance), headDistance);\n}\n\nfn volumeRaymarch_composite(accumulated: vec4f, color: vec3f, alpha: f32) -> vec4f {\n  let contribution = (1.0 - accumulated.a) * clamp(alpha, 0.0, 1.0);\n  return vec4f(accumulated.rgb + color * contribution, accumulated.a + contribution);\n}\n";
+};
+//# sourceMappingURL=volume-raymarch.d.ts.map

package/dist/modules/volume/volume-raymarch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volume-raymarch.d.ts","sourceRoot":"","sources":["../../../src/modules/volume/volume-raymarch.ts"],"names":[],"mappings":"AAkFA,6DAA6D;AAC7D,eAAO,MAAM,cAAc;;;CAGc,CAAC"}

package/dist/modules/volume/volume-raymarch.js

@@ -0,0 +1,84 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+const source = /* wgsl */ `\
+fn volumeRaymarch_intersectBox(origin: vec3f, direction: vec3f, minimum: vec3f, maximum: vec3f) -> vec2f {
+  let safeDirection = select(vec3f(0.000001), direction, abs(direction) > vec3f(0.000001));
+  let first = (minimum - origin) / safeDirection;
+  let second = (maximum - origin) / safeDirection;
+  let nearPlane = min(first, second);
+  let farPlane = max(first, second);
+  return vec2f(
+    max(max(nearPlane.x, nearPlane.y), nearPlane.z),
+    min(min(farPlane.x, farPlane.y), farPlane.z)
+  );
+}
+
+fn volumeRaymarch_mixScalar(corners: array<f32, 8>, blend: vec3f) -> f32 {
+  let lower = mix(mix(corners[0], corners[1], blend.x), mix(corners[2], corners[3], blend.x), blend.y);
+  let upper = mix(mix(corners[4], corners[5], blend.x), mix(corners[6], corners[7], blend.x), blend.y);
+  return mix(lower, upper, blend.z);
+}
+
+fn volumeRaymarch_mixVector(corners: array<vec3f, 8>, blend: vec3f) -> vec3f {
+  let lower = mix(mix(corners[0], corners[1], blend.x), mix(corners[2], corners[3], blend.x), blend.y);
+  let upper = mix(mix(corners[4], corners[5], blend.x), mix(corners[6], corners[7], blend.x), blend.y);
+  return mix(lower, upper, blend.z);
+}
+
+fn volumeRaymarch_sequentialColor(value: f32, lowColor: vec3f, highColor: vec3f) -> vec3f {
+  return mix(lowColor, highColor, clamp(value, 0.0, 1.0));
+}
+
+fn volumeRaymarch_signedColor(value: f32, negativeColor: vec3f, neutralColor: vec3f, positiveColor: vec3f) -> vec3f {
+  let amount = clamp(abs(value), 0.0, 1.0);
+  let signedTarget = select(negativeColor, positiveColor, value >= 0.0);
+  return mix(neutralColor, signedTarget, amount);
+}
+
+fn volumeRaymarch_directionColor(vector: vec3f) -> vec3f {
+  let direction = normalize(vector + vec3f(0.00001));
+  return 0.18 + 0.82 * (direction * 0.5 + 0.5);
+}
+
+fn volumeRaymarch_segmentDistance(point: vec3f, start: vec3f, end: vec3f) -> f32 {
+  let segment = end - start;
+  let fraction = clamp(dot(point - start, segment) / max(dot(segment, segment), 0.000001), 0.0, 1.0);
+  return length(point - (start + segment * fraction));
+}
+
+fn volumeRaymarch_arrowDistance(
+  point: vec3f,
+  center: vec3f,
+  direction: vec3f,
+  arrowLength: f32,
+  shaftRadius: f32,
+  headRadius: f32
+) -> vec2f {
+  let tail = center - direction * arrowLength * 0.48;
+  let shoulder = center + direction * arrowLength * 0.18;
+  let tip = center + direction * arrowLength * 0.52;
+  let shaftDistance = volumeRaymarch_segmentDistance(point, tail, shoulder) - shaftRadius;
+  let headVector = point - shoulder;
+  let headLength = max(length(tip - shoulder), 0.000001);
+  let headPosition = dot(headVector, direction);
+  let taperedRadius = headRadius * (1.0 - clamp(headPosition / headLength, 0.0, 1.0));
+  let radialDistance = length(headVector - direction * headPosition);
+  let headDistance = max(
+    radialDistance - taperedRadius,
+    max(-headPosition, headPosition - headLength)
+  );
+  return vec2f(min(shaftDistance, headDistance), headDistance);
+}
+
+fn volumeRaymarch_composite(accumulated: vec4f, color: vec3f, alpha: f32) -> vec4f {
+  let contribution = (1.0 - accumulated.a) * clamp(alpha, 0.0, 1.0);
+  return vec4f(accumulated.rgb + color * contribution, accumulated.a + contribution);
+}
+`;
+/** WGSL helpers shared by structured-volume ray marchers. */
+export const volumeRaymarch = {
+    name: 'volumeRaymarch',
+    source
+};
+//# sourceMappingURL=volume-raymarch.js.map

package/dist/modules/volume/volume-raymarch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"volume-raymarch.js","sourceRoot":"","sources":["../../../src/modules/volume/volume-raymarch.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAI5D,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0EzB,CAAC;AAEF,6DAA6D;AAC7D,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,MAAM;CACiC,CAAC"}

package/dist/types/align-to.cjs

@@ -0,0 +1,38 @@
+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 align_to_exports = {};
+__export(align_to_exports, {
+  alignTo: () => alignTo
+});
+module.exports = __toCommonJS(align_to_exports);
+function alignTo(size, count) {
+  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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alignTo
+});

package/dist/types/align-to.d.ts

@@ -0,0 +1,3 @@
+/** Align offset to 1, 2 or 4 elements (4, 8 or 16 bytes) */
+export declare function alignTo(size: number, count: number): number;
+//# sourceMappingURL=align-to.d.ts.map

package/dist/types/align-to.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"align-to.d.ts","sourceRoot":"","sources":["../../src/types/align-to.ts"],"names":[],"mappings":"AAIA,4DAA4D;AAC5D,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAO3D"}

package/dist/types/align-to.js

@@ -0,0 +1,13 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/** Align offset to 1, 2 or 4 elements (4, 8 or 16 bytes) */
+export function alignTo(size, count) {
+    // biome-ignore format: preserve layout
+    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
+    }
+}
+//# sourceMappingURL=align-to.js.map

package/dist/types/align-to.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"align-to.js","sourceRoot":"","sources":["../../src/types/align-to.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAE5D,4DAA4D;AAC5D,MAAM,UAAU,OAAO,CAAC,IAAY,EAAE,KAAa;IACjD,uCAAuC;IACvC,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,oCAAoC;QACzD,KAAK,CAAC,CAAC,CAAC,OAAO,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,oCAAoC;QACtE,OAAO,CAAC,CAAC,OAAO,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,oCAAoC;IACrF,CAAC;AACH,CAAC"}

package/dist/types/primitive-data-types.cjs

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 primitive_data_types_exports = {};
+module.exports = __toCommonJS(primitive_data_types_exports);

package/dist/types/primitive-data-types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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';
+//# sourceMappingURL=primitive-data-types.d.ts.map

package/dist/types/primitive-data-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive-data-types.d.ts","sourceRoot":"","sources":["../../src/types/primitive-data-types.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC"}

package/dist/types/primitive-data-types.js

@@ -0,0 +1,5 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export {};
+//# sourceMappingURL=primitive-data-types.js.map

package/dist/types/primitive-data-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive-data-types.js","sourceRoot":"","sources":["../../src/types/primitive-data-types.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D"}

package/dist/types/sampler-props.cjs

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 sampler_props_exports = {};
+module.exports = __toCommonJS(sampler_props_exports);

package/dist/types/sampler-props.d.ts

@@ -0,0 +1,26 @@
+export type CompareFunction = 'never' | 'less' | 'equal' | 'less-equal' | 'greater' | 'not-equal' | 'greater-equal' | 'always';
+export type SamplerProps = {
+    /** Comparison / shadow samplers are used with depth textures. See the `Sampler.compare` field */
+    type?: 'color-sampler' | 'comparison-sampler';
+    /** Edge value sampling in X direction */
+    addressModeU?: 'clamp-to-edge' | 'repeat' | 'mirror-repeat';
+    /** Edge value sampling in Y direction */
+    addressModeV?: 'clamp-to-edge' | 'repeat' | 'mirror-repeat';
+    /** Edge value sampling in Z direction */
+    addressModeW?: 'clamp-to-edge' | 'repeat' | 'mirror-repeat';
+    /** Magnification: the area of the fragment in texture space is smaller than a texel */
+    magFilter?: 'nearest' | 'linear';
+    /** Minification: the area of the fragment in texture space is larger than a texel */
+    minFilter?: 'nearest' | 'linear';
+    /** mipmapping: select between multiple mipmaps based on angle and size of the texture relative to the screen. */
+    mipmapFilter?: 'none' | 'nearest' | 'linear';
+    /** Affects the mipmap image selection */
+    lodMinClamp?: number;
+    /** Affects the mipmap image selection */
+    lodMaxClamp?: number;
+    /** Maximum number of samples that can be taken of the texture during any one texture fetch */
+    maxAnisotropy?: number;
+    /** How to compare reference values provided in shader shadow sampler calls with those pulled from the texture */
+    compare?: CompareFunction;
+};
+//# sourceMappingURL=sampler-props.d.ts.map

package/dist/types/sampler-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler-props.d.ts","sourceRoot":"","sources":["../../src/types/sampler-props.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,eAAe,GACvB,OAAO,GACP,MAAM,GACN,OAAO,GACP,YAAY,GACZ,SAAS,GACT,WAAW,GACX,eAAe,GACf,QAAQ,CAAC;AAEb,MAAM,MAAM,YAAY,GAAG;IACzB,iGAAiG;IACjG,IAAI,CAAC,EAAE,eAAe,GAAG,oBAAoB,CAAC;IAC9C,yCAAyC;IACzC,YAAY,CAAC,EAAE,eAAe,GAAG,QAAQ,GAAG,eAAe,CAAC;IAC5D,yCAAyC;IACzC,YAAY,CAAC,EAAE,eAAe,GAAG,QAAQ,GAAG,eAAe,CAAC;IAC5D,yCAAyC;IACzC,YAAY,CAAC,EAAE,eAAe,GAAG,QAAQ,GAAG,eAAe,CAAC;IAE5D,uFAAuF;IACvF,SAAS,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;IACjC,qFAAqF;IACrF,SAAS,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;IACjC,iHAAiH;IACjH,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC7C,yCAAyC;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8FAA8F;IAC9F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iHAAiH;IACjH,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B,CAAC"}

package/dist/types/sampler-props.js

@@ -0,0 +1,5 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export {};
+//# sourceMappingURL=sampler-props.js.map

package/dist/types/sampler-props.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampler-props.js","sourceRoot":"","sources":["../../src/types/sampler-props.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D"}