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

package/dist/modules/lighting/height-fog/height-fog-functions.d.ts

@@ -0,0 +1,14 @@
+/** Uniform-free analytic extinction shared by materials and screen-space effects.
+ * Lengths and heights are metres; density and falloff are inverse metres.
+ */
+export declare const heightFogFunctions: {
+    readonly name: "heightFogFunctions";
+    readonly dependencies: [{
+        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";
+    }];
+    readonly fs: "\nfloat heightFog_getRayTransmittance(float rayLength, float cameraHeight, float fragmentHeight, float density, float baseHeight, float heightFalloff) {\n  float startHeight = (cameraHeight - baseHeight) * max(heightFalloff, 0.0);\n  float endHeight = (fragmentHeight - baseHeight) * max(heightFalloff, 0.0);\n  float lowerHeight = min(startHeight, endHeight);\n  float upperHeight = max(startHeight, endHeight);\n  float averageDensity = 1.0;\n  if (upperHeight > 0.0) {\n    float heightSpan = upperHeight - lowerHeight;\n    if (heightSpan < 0.001) {\n      averageDensity = exp(-max((startHeight + endHeight) * 0.5, 0.0));\n    } else if (lowerHeight >= 0.0) {\n      averageDensity = (exp(-lowerHeight) - exp(-upperHeight)) / heightSpan;\n    } else {\n      averageDensity = (-lowerHeight + 1.0 - exp(-upperHeight)) / heightSpan;\n    }\n  }\n  return exp(-max(density, 0.0) * rayLength * averageDensity);\n}\nfloat heightFog_hash(vec2 cell) { return valueNoise_hash(cell); }\nfloat heightFog_noise(vec2 position) { return valueNoise_noise(position); }\n// Integrate drifting density along the ray so wisps occupy space rather than coat surfaces.\nfloat heightFog_getSpatialTransmittance(vec3 camera, vec3 position, vec3 upDirection,\n    float density, float baseHeight, float heightFalloff, float variation, float wispScale,\n    float time, vec3 velocity, float evolutionSpeed) {\n  if (density <= 0.0) return 1.0;\n  float rayLength = distance(camera, position);\n  if (variation <= 0.0) return heightFog_getRayTransmittance(rayLength, dot(camera, upDirection),\n    dot(position, upDirection), density, baseHeight, heightFalloff);\n  vec3 reference = abs(upDirection.z) < 0.9 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);\n  vec3 horizontal = normalize(cross(reference, upDirection));\n  vec3 forward = cross(upDirection, horizontal);\n  float transmittance = 1.0;\n  for (int sampleIndex = 0; sampleIndex < 12; sampleIndex++) {\n    float fraction = float(sampleIndex) / 12.0;\n    vec3 start = mix(camera, position, fraction);\n    vec3 end = mix(camera, position, fraction + 1.0 / 12.0);\n    vec3 samplePosition = (start + end) * 0.5 - velocity * time;\n    vec2 coordinate = vec2(dot(samplePosition, horizontal), dot(samplePosition, forward)) / max(wispScale, 1.0);\n    coordinate.y = coordinate.y * 1.8 + dot(samplePosition, upDirection) / max(wispScale, 1.0);\n    float warp = heightFog_noise(coordinate * 0.45 + vec2(8.3, 2.7) + time * evolutionSpeed * vec2(1.0, 0.37));\n    float broad = heightFog_noise(coordinate + vec2(warp * 2.0, warp * 0.8));\n    float detail = heightFog_noise(mat2(0.8, 0.6, -0.6, 0.8) * coordinate * 2.17 + vec2(17.1, 9.2) + broad * 0.7);\n    float modulation = mix(1.0, 1.8 * smoothstep(0.15, 0.85, broad * 0.7 + detail * 0.3), clamp(variation, 0.0, 1.0));\n    transmittance *= heightFog_getRayTransmittance(rayLength / 12.0, dot(start, upDirection),\n      dot(end, upDirection), density * modulation, baseHeight, heightFalloff);\n  }\n  return transmittance;\n}\n\n";
+    readonly source: "\nfn heightFog_getRayTransmittance(rayLength: f32, cameraHeight: f32, fragmentHeight: f32, density: f32, baseHeight: f32, heightFalloff: f32) -> f32 {\n  let startHeight = (cameraHeight - baseHeight) * max(heightFalloff, 0.0);\n  let endHeight = (fragmentHeight - baseHeight) * max(heightFalloff, 0.0);\n  let lowerHeight = min(startHeight, endHeight);\n  let upperHeight = max(startHeight, endHeight);\n  var averageDensity = 1.0;\n  if (upperHeight > 0.0) {\n    let heightSpan = upperHeight - lowerHeight;\n    if (heightSpan < 0.001) {\n      averageDensity = exp(-max((startHeight + endHeight) * 0.5, 0.0));\n    } else if (lowerHeight >= 0.0) {\n      averageDensity = (exp(-lowerHeight) - exp(-upperHeight)) / heightSpan;\n    } else {\n      averageDensity = (-lowerHeight + 1.0 - exp(-upperHeight)) / heightSpan;\n    }\n  }\n  return exp(-max(density, 0.0) * rayLength * averageDensity);\n}\nfn heightFog_hash(cell: vec2f) -> f32 { return valueNoise_hash(cell); }\nfn heightFog_noise(position: vec2f) -> f32 { return valueNoise_noise(position); }\n// Integrate drifting density along the ray so wisps occupy space rather than coat surfaces.\nfn heightFog_getSpatialTransmittance(camera: vec3f, position: vec3f, upDirection: vec3f,\n    density: f32, baseHeight: f32, heightFalloff: f32, variation: f32, wispScale: f32,\n    time: f32, velocity: vec3f, evolutionSpeed: f32) -> f32 {\n  if (density <= 0.0) { return 1.0; }\n  let rayLength = distance(camera, position);\n  if (variation <= 0.0) { return heightFog_getRayTransmittance(rayLength, dot(camera, upDirection),\n    dot(position, upDirection), density, baseHeight, heightFalloff); }\n  let reference = select(vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(upDirection.z) < 0.9);\n  let horizontal = normalize(cross(reference, upDirection));\n  let forward = cross(upDirection, horizontal);\n  var transmittance = 1.0;\n  for (var sampleIndex = 0; sampleIndex < 12; sampleIndex++) {\n    let fraction = f32(sampleIndex) / 12.0;\n    let start = mix(camera, position, fraction);\n    let end = mix(camera, position, fraction + 1.0 / 12.0);\n    let samplePosition = (start + end) * 0.5 - velocity * time;\n    var coordinate = vec2f(dot(samplePosition, horizontal), dot(samplePosition, forward)) / max(wispScale, 1.0);\n    coordinate.y = coordinate.y * 1.8 + dot(samplePosition, upDirection) / max(wispScale, 1.0);\n    let warp = heightFog_noise(coordinate * 0.45 + vec2f(8.3, 2.7) + time * evolutionSpeed * vec2f(1.0, 0.37));\n    let broad = heightFog_noise(coordinate + vec2f(warp * 2.0, warp * 0.8));\n    let detail = heightFog_noise(mat2x2f(vec2f(0.8, 0.6), vec2f(-0.6, 0.8)) * coordinate * 2.17 + vec2f(17.1, 9.2) + vec2f(broad * 0.7));\n    let modulation = mix(1.0, 1.8 * smoothstep(0.15, 0.85, broad * 0.7 + detail * 0.3), clamp(variation, 0.0, 1.0));\n    transmittance *= heightFog_getRayTransmittance(rayLength / 12.0, dot(start, upDirection),\n      dot(end, upDirection), density * modulation, baseHeight, heightFalloff);\n  }\n  return transmittance;\n}\n\n";
+};
+//# sourceMappingURL=height-fog-functions.d.ts.map

package/dist/modules/lighting/height-fog/height-fog-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"height-fog-functions.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/height-fog/height-fog-functions.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;CAyGE,CAAC"}

package/dist/modules/lighting/height-fog/height-fog-functions.js

@@ -0,0 +1,114 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { valueNoise } from "../../math/value-noise/value-noise.js";
+/** Uniform-free analytic extinction shared by materials and screen-space effects.
+ * Lengths and heights are metres; density and falloff are inverse metres.
+ */
+export const heightFogFunctions = {
+    name: 'heightFogFunctions',
+    dependencies: [valueNoise],
+    fs: /* glsl */ `
+float heightFog_getRayTransmittance(float rayLength, float cameraHeight, float fragmentHeight, float density, float baseHeight, float heightFalloff) {
+  float startHeight = (cameraHeight - baseHeight) * max(heightFalloff, 0.0);
+  float endHeight = (fragmentHeight - baseHeight) * max(heightFalloff, 0.0);
+  float lowerHeight = min(startHeight, endHeight);
+  float upperHeight = max(startHeight, endHeight);
+  float averageDensity = 1.0;
+  if (upperHeight > 0.0) {
+    float heightSpan = upperHeight - lowerHeight;
+    if (heightSpan < 0.001) {
+      averageDensity = exp(-max((startHeight + endHeight) * 0.5, 0.0));
+    } else if (lowerHeight >= 0.0) {
+      averageDensity = (exp(-lowerHeight) - exp(-upperHeight)) / heightSpan;
+    } else {
+      averageDensity = (-lowerHeight + 1.0 - exp(-upperHeight)) / heightSpan;
+    }
+  }
+  return exp(-max(density, 0.0) * rayLength * averageDensity);
+}
+float heightFog_hash(vec2 cell) { return valueNoise_hash(cell); }
+float heightFog_noise(vec2 position) { return valueNoise_noise(position); }
+// Integrate drifting density along the ray so wisps occupy space rather than coat surfaces.
+float heightFog_getSpatialTransmittance(vec3 camera, vec3 position, vec3 upDirection,
+    float density, float baseHeight, float heightFalloff, float variation, float wispScale,
+    float time, vec3 velocity, float evolutionSpeed) {
+  if (density <= 0.0) return 1.0;
+  float rayLength = distance(camera, position);
+  if (variation <= 0.0) return heightFog_getRayTransmittance(rayLength, dot(camera, upDirection),
+    dot(position, upDirection), density, baseHeight, heightFalloff);
+  vec3 reference = abs(upDirection.z) < 0.9 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+  vec3 horizontal = normalize(cross(reference, upDirection));
+  vec3 forward = cross(upDirection, horizontal);
+  float transmittance = 1.0;
+  for (int sampleIndex = 0; sampleIndex < 12; sampleIndex++) {
+    float fraction = float(sampleIndex) / 12.0;
+    vec3 start = mix(camera, position, fraction);
+    vec3 end = mix(camera, position, fraction + 1.0 / 12.0);
+    vec3 samplePosition = (start + end) * 0.5 - velocity * time;
+    vec2 coordinate = vec2(dot(samplePosition, horizontal), dot(samplePosition, forward)) / max(wispScale, 1.0);
+    coordinate.y = coordinate.y * 1.8 + dot(samplePosition, upDirection) / max(wispScale, 1.0);
+    float warp = heightFog_noise(coordinate * 0.45 + vec2(8.3, 2.7) + time * evolutionSpeed * vec2(1.0, 0.37));
+    float broad = heightFog_noise(coordinate + vec2(warp * 2.0, warp * 0.8));
+    float detail = heightFog_noise(mat2(0.8, 0.6, -0.6, 0.8) * coordinate * 2.17 + vec2(17.1, 9.2) + broad * 0.7);
+    float modulation = mix(1.0, 1.8 * smoothstep(0.15, 0.85, broad * 0.7 + detail * 0.3), clamp(variation, 0.0, 1.0));
+    transmittance *= heightFog_getRayTransmittance(rayLength / 12.0, dot(start, upDirection),
+      dot(end, upDirection), density * modulation, baseHeight, heightFalloff);
+  }
+  return transmittance;
+}
+
+`,
+    source: /* wgsl */ `
+fn heightFog_getRayTransmittance(rayLength: f32, cameraHeight: f32, fragmentHeight: f32, density: f32, baseHeight: f32, heightFalloff: f32) -> f32 {
+  let startHeight = (cameraHeight - baseHeight) * max(heightFalloff, 0.0);
+  let endHeight = (fragmentHeight - baseHeight) * max(heightFalloff, 0.0);
+  let lowerHeight = min(startHeight, endHeight);
+  let upperHeight = max(startHeight, endHeight);
+  var averageDensity = 1.0;
+  if (upperHeight > 0.0) {
+    let heightSpan = upperHeight - lowerHeight;
+    if (heightSpan < 0.001) {
+      averageDensity = exp(-max((startHeight + endHeight) * 0.5, 0.0));
+    } else if (lowerHeight >= 0.0) {
+      averageDensity = (exp(-lowerHeight) - exp(-upperHeight)) / heightSpan;
+    } else {
+      averageDensity = (-lowerHeight + 1.0 - exp(-upperHeight)) / heightSpan;
+    }
+  }
+  return exp(-max(density, 0.0) * rayLength * averageDensity);
+}
+fn heightFog_hash(cell: vec2f) -> f32 { return valueNoise_hash(cell); }
+fn heightFog_noise(position: vec2f) -> f32 { return valueNoise_noise(position); }
+// Integrate drifting density along the ray so wisps occupy space rather than coat surfaces.
+fn heightFog_getSpatialTransmittance(camera: vec3f, position: vec3f, upDirection: vec3f,
+    density: f32, baseHeight: f32, heightFalloff: f32, variation: f32, wispScale: f32,
+    time: f32, velocity: vec3f, evolutionSpeed: f32) -> f32 {
+  if (density <= 0.0) { return 1.0; }
+  let rayLength = distance(camera, position);
+  if (variation <= 0.0) { return heightFog_getRayTransmittance(rayLength, dot(camera, upDirection),
+    dot(position, upDirection), density, baseHeight, heightFalloff); }
+  let reference = select(vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(upDirection.z) < 0.9);
+  let horizontal = normalize(cross(reference, upDirection));
+  let forward = cross(upDirection, horizontal);
+  var transmittance = 1.0;
+  for (var sampleIndex = 0; sampleIndex < 12; sampleIndex++) {
+    let fraction = f32(sampleIndex) / 12.0;
+    let start = mix(camera, position, fraction);
+    let end = mix(camera, position, fraction + 1.0 / 12.0);
+    let samplePosition = (start + end) * 0.5 - velocity * time;
+    var coordinate = vec2f(dot(samplePosition, horizontal), dot(samplePosition, forward)) / max(wispScale, 1.0);
+    coordinate.y = coordinate.y * 1.8 + dot(samplePosition, upDirection) / max(wispScale, 1.0);
+    let warp = heightFog_noise(coordinate * 0.45 + vec2f(8.3, 2.7) + time * evolutionSpeed * vec2f(1.0, 0.37));
+    let broad = heightFog_noise(coordinate + vec2f(warp * 2.0, warp * 0.8));
+    let detail = heightFog_noise(mat2x2f(vec2f(0.8, 0.6), vec2f(-0.6, 0.8)) * coordinate * 2.17 + vec2f(17.1, 9.2) + vec2f(broad * 0.7));
+    let modulation = mix(1.0, 1.8 * smoothstep(0.15, 0.85, broad * 0.7 + detail * 0.3), clamp(variation, 0.0, 1.0));
+    transmittance *= heightFog_getRayTransmittance(rayLength / 12.0, dot(start, upDirection),
+      dot(end, upDirection), density * modulation, baseHeight, heightFalloff);
+  }
+  return transmittance;
+}
+
+`
+};
+//# sourceMappingURL=height-fog-functions.js.map

package/dist/modules/lighting/height-fog/height-fog-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"height-fog-functions.js","sourceRoot":"","sources":["../../../../src/modules/lighting/height-fog/height-fog-functions.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAG5D,OAAO,EAAC,UAAU,EAAC,8CAA2C;AAE9D;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,IAAI,EAAE,oBAAoB;IAC1B,YAAY,EAAE,CAAC,UAAU,CAAC;IAC1B,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDpB;CACgC,CAAC"}

package/dist/modules/lighting/height-fog/height-fog.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 height_fog_exports = {};
+__export(height_fog_exports, {
+  heightFog: () => heightFog
+});
+module.exports = __toCommonJS(height_fog_exports);
+var import_height_fog_functions = require("./height-fog-functions.cjs");
+const heightFog = {
+  name: "heightFog",
+  dependencies: [import_height_fog_functions.heightFogFunctions],
+  bindingLayout: [{ name: "heightFog", group: 3 }],
+  uniformTypes: {
+    color: "vec3<f32>",
+    density: "f32",
+    baseHeight: "f32",
+    heightFalloff: "f32",
+    variation: "f32",
+    wispScale: "f32",
+    velocity: "vec3<f32>",
+    time: "f32",
+    evolutionSpeed: "f32"
+  },
+  defaultUniforms: {
+    color: [0.65, 0.72, 0.78],
+    density: 0,
+    baseHeight: 0,
+    heightFalloff: 0.01,
+    variation: 0,
+    wispScale: 160,
+    velocity: [0, 0, 0],
+    time: 0,
+    evolutionSpeed: 0
+  },
+  getUniforms(props = {}) {
+    return props;
+  },
+  fs: (
+    /* glsl */
+    `
+layout(std140) uniform heightFogUniforms {
+  vec3 color;
+  float density;
+  float baseHeight;
+  float heightFalloff;
+  float variation;
+  float wispScale;
+  vec3 velocity;
+  float time;
+  float evolutionSpeed;
+} heightFog;
+float heightFog_getTransmittance(vec3 position, vec3 cameraPosition) {
+  return heightFog_getSpatialTransmittance(cameraPosition, position, vec3(0.0, 0.0, 1.0),
+    heightFog.density, heightFog.baseHeight, heightFog.heightFalloff, heightFog.variation, heightFog.wispScale, heightFog.time, heightFog.velocity, heightFog.evolutionSpeed);
+}
+vec4 heightFog_getColor(vec4 color, vec3 position, vec3 cameraPosition) {
+  return vec4(mix(heightFog.color, color.rgb, heightFog_getTransmittance(position, cameraPosition)), color.a);
+}
+`
+  ),
+  source: (
+    /* wgsl */
+    `
+struct heightFogUniforms {
+  color: vec3<f32>,
+  density: f32,
+  baseHeight: f32,
+  heightFalloff: f32,
+  variation: f32,
+  wispScale: f32,
+  velocity: vec3<f32>,
+  time: f32,
+  evolutionSpeed: f32,
+};
+@group(3) @binding(auto) var<uniform> heightFog: heightFogUniforms;
+fn heightFog_getTransmittance(position: vec3<f32>, cameraPosition: vec3<f32>) -> f32 {
+  return heightFog_getSpatialTransmittance(cameraPosition, position, vec3<f32>(0.0, 0.0, 1.0),
+    heightFog.density, heightFog.baseHeight, heightFog.heightFalloff, heightFog.variation, heightFog.wispScale, heightFog.time, heightFog.velocity, heightFog.evolutionSpeed);
+}
+fn heightFog_getColor(color: vec4<f32>, position: vec3<f32>, cameraPosition: vec3<f32>) -> vec4<f32> {
+  return vec4<f32>(mix(heightFog.color, color.rgb, heightFog_getTransmittance(position, cameraPosition)), color.a);
+}
+`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  heightFog
+});

package/dist/modules/lighting/height-fog/height-fog.d.ts

@@ -0,0 +1,60 @@
+export type HeightFogUniforms = {
+    color: [number, number, number];
+    density: number;
+    baseHeight: number;
+    heightFalloff: number;
+    /** Spatial density variation, from uniform (0) to wispy (1). */
+    variation: number;
+    /** Horizontal size of fog banks in metres. */
+    wispScale: number;
+    /** Fog advection in metres per second in the same frame as the positions. */
+    velocity: [number, number, number];
+    time: number;
+    /** Rate of internal wisp deformation; zero keeps a rigidly advected field. */
+    evolutionSpeed: number;
+};
+export type HeightFogProps = Partial<HeightFogUniforms>;
+/** Analytic extinction through a height-dependent atmosphere. All distances are metres. */
+export declare const heightFog: {
+    readonly name: "heightFog";
+    readonly dependencies: [{
+        readonly name: "heightFogFunctions";
+        readonly dependencies: [{
+            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";
+        }];
+        readonly fs: "\nfloat heightFog_getRayTransmittance(float rayLength, float cameraHeight, float fragmentHeight, float density, float baseHeight, float heightFalloff) {\n  float startHeight = (cameraHeight - baseHeight) * max(heightFalloff, 0.0);\n  float endHeight = (fragmentHeight - baseHeight) * max(heightFalloff, 0.0);\n  float lowerHeight = min(startHeight, endHeight);\n  float upperHeight = max(startHeight, endHeight);\n  float averageDensity = 1.0;\n  if (upperHeight > 0.0) {\n    float heightSpan = upperHeight - lowerHeight;\n    if (heightSpan < 0.001) {\n      averageDensity = exp(-max((startHeight + endHeight) * 0.5, 0.0));\n    } else if (lowerHeight >= 0.0) {\n      averageDensity = (exp(-lowerHeight) - exp(-upperHeight)) / heightSpan;\n    } else {\n      averageDensity = (-lowerHeight + 1.0 - exp(-upperHeight)) / heightSpan;\n    }\n  }\n  return exp(-max(density, 0.0) * rayLength * averageDensity);\n}\nfloat heightFog_hash(vec2 cell) { return valueNoise_hash(cell); }\nfloat heightFog_noise(vec2 position) { return valueNoise_noise(position); }\n// Integrate drifting density along the ray so wisps occupy space rather than coat surfaces.\nfloat heightFog_getSpatialTransmittance(vec3 camera, vec3 position, vec3 upDirection,\n    float density, float baseHeight, float heightFalloff, float variation, float wispScale,\n    float time, vec3 velocity, float evolutionSpeed) {\n  if (density <= 0.0) return 1.0;\n  float rayLength = distance(camera, position);\n  if (variation <= 0.0) return heightFog_getRayTransmittance(rayLength, dot(camera, upDirection),\n    dot(position, upDirection), density, baseHeight, heightFalloff);\n  vec3 reference = abs(upDirection.z) < 0.9 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);\n  vec3 horizontal = normalize(cross(reference, upDirection));\n  vec3 forward = cross(upDirection, horizontal);\n  float transmittance = 1.0;\n  for (int sampleIndex = 0; sampleIndex < 12; sampleIndex++) {\n    float fraction = float(sampleIndex) / 12.0;\n    vec3 start = mix(camera, position, fraction);\n    vec3 end = mix(camera, position, fraction + 1.0 / 12.0);\n    vec3 samplePosition = (start + end) * 0.5 - velocity * time;\n    vec2 coordinate = vec2(dot(samplePosition, horizontal), dot(samplePosition, forward)) / max(wispScale, 1.0);\n    coordinate.y = coordinate.y * 1.8 + dot(samplePosition, upDirection) / max(wispScale, 1.0);\n    float warp = heightFog_noise(coordinate * 0.45 + vec2(8.3, 2.7) + time * evolutionSpeed * vec2(1.0, 0.37));\n    float broad = heightFog_noise(coordinate + vec2(warp * 2.0, warp * 0.8));\n    float detail = heightFog_noise(mat2(0.8, 0.6, -0.6, 0.8) * coordinate * 2.17 + vec2(17.1, 9.2) + broad * 0.7);\n    float modulation = mix(1.0, 1.8 * smoothstep(0.15, 0.85, broad * 0.7 + detail * 0.3), clamp(variation, 0.0, 1.0));\n    transmittance *= heightFog_getRayTransmittance(rayLength / 12.0, dot(start, upDirection),\n      dot(end, upDirection), density * modulation, baseHeight, heightFalloff);\n  }\n  return transmittance;\n}\n\n";
+        readonly source: "\nfn heightFog_getRayTransmittance(rayLength: f32, cameraHeight: f32, fragmentHeight: f32, density: f32, baseHeight: f32, heightFalloff: f32) -> f32 {\n  let startHeight = (cameraHeight - baseHeight) * max(heightFalloff, 0.0);\n  let endHeight = (fragmentHeight - baseHeight) * max(heightFalloff, 0.0);\n  let lowerHeight = min(startHeight, endHeight);\n  let upperHeight = max(startHeight, endHeight);\n  var averageDensity = 1.0;\n  if (upperHeight > 0.0) {\n    let heightSpan = upperHeight - lowerHeight;\n    if (heightSpan < 0.001) {\n      averageDensity = exp(-max((startHeight + endHeight) * 0.5, 0.0));\n    } else if (lowerHeight >= 0.0) {\n      averageDensity = (exp(-lowerHeight) - exp(-upperHeight)) / heightSpan;\n    } else {\n      averageDensity = (-lowerHeight + 1.0 - exp(-upperHeight)) / heightSpan;\n    }\n  }\n  return exp(-max(density, 0.0) * rayLength * averageDensity);\n}\nfn heightFog_hash(cell: vec2f) -> f32 { return valueNoise_hash(cell); }\nfn heightFog_noise(position: vec2f) -> f32 { return valueNoise_noise(position); }\n// Integrate drifting density along the ray so wisps occupy space rather than coat surfaces.\nfn heightFog_getSpatialTransmittance(camera: vec3f, position: vec3f, upDirection: vec3f,\n    density: f32, baseHeight: f32, heightFalloff: f32, variation: f32, wispScale: f32,\n    time: f32, velocity: vec3f, evolutionSpeed: f32) -> f32 {\n  if (density <= 0.0) { return 1.0; }\n  let rayLength = distance(camera, position);\n  if (variation <= 0.0) { return heightFog_getRayTransmittance(rayLength, dot(camera, upDirection),\n    dot(position, upDirection), density, baseHeight, heightFalloff); }\n  let reference = select(vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(upDirection.z) < 0.9);\n  let horizontal = normalize(cross(reference, upDirection));\n  let forward = cross(upDirection, horizontal);\n  var transmittance = 1.0;\n  for (var sampleIndex = 0; sampleIndex < 12; sampleIndex++) {\n    let fraction = f32(sampleIndex) / 12.0;\n    let start = mix(camera, position, fraction);\n    let end = mix(camera, position, fraction + 1.0 / 12.0);\n    let samplePosition = (start + end) * 0.5 - velocity * time;\n    var coordinate = vec2f(dot(samplePosition, horizontal), dot(samplePosition, forward)) / max(wispScale, 1.0);\n    coordinate.y = coordinate.y * 1.8 + dot(samplePosition, upDirection) / max(wispScale, 1.0);\n    let warp = heightFog_noise(coordinate * 0.45 + vec2f(8.3, 2.7) + time * evolutionSpeed * vec2f(1.0, 0.37));\n    let broad = heightFog_noise(coordinate + vec2f(warp * 2.0, warp * 0.8));\n    let detail = heightFog_noise(mat2x2f(vec2f(0.8, 0.6), vec2f(-0.6, 0.8)) * coordinate * 2.17 + vec2f(17.1, 9.2) + vec2f(broad * 0.7));\n    let modulation = mix(1.0, 1.8 * smoothstep(0.15, 0.85, broad * 0.7 + detail * 0.3), clamp(variation, 0.0, 1.0));\n    transmittance *= heightFog_getRayTransmittance(rayLength / 12.0, dot(start, upDirection),\n      dot(end, upDirection), density * modulation, baseHeight, heightFalloff);\n  }\n  return transmittance;\n}\n\n";
+    }];
+    readonly bindingLayout: readonly [{
+        readonly name: "heightFog";
+        readonly group: 3;
+    }];
+    readonly uniformTypes: {
+        readonly color: "vec3<f32>";
+        readonly density: "f32";
+        readonly baseHeight: "f32";
+        readonly heightFalloff: "f32";
+        readonly variation: "f32";
+        readonly wispScale: "f32";
+        readonly velocity: "vec3<f32>";
+        readonly time: "f32";
+        readonly evolutionSpeed: "f32";
+    };
+    readonly defaultUniforms: {
+        readonly color: [0.65, 0.72, 0.78];
+        readonly density: 0;
+        readonly baseHeight: 0;
+        readonly heightFalloff: 0.01;
+        readonly variation: 0;
+        readonly wispScale: 160;
+        readonly velocity: [0, 0, 0];
+        readonly time: 0;
+        readonly evolutionSpeed: 0;
+    };
+    readonly getUniforms: (props?: HeightFogProps) => Partial<HeightFogUniforms>;
+    readonly fs: "\nlayout(std140) uniform heightFogUniforms {\n  vec3 color;\n  float density;\n  float baseHeight;\n  float heightFalloff;\n  float variation;\n  float wispScale;\n  vec3 velocity;\n  float time;\n  float evolutionSpeed;\n} heightFog;\nfloat heightFog_getTransmittance(vec3 position, vec3 cameraPosition) {\n  return heightFog_getSpatialTransmittance(cameraPosition, position, vec3(0.0, 0.0, 1.0),\n    heightFog.density, heightFog.baseHeight, heightFog.heightFalloff, heightFog.variation, heightFog.wispScale, heightFog.time, heightFog.velocity, heightFog.evolutionSpeed);\n}\nvec4 heightFog_getColor(vec4 color, vec3 position, vec3 cameraPosition) {\n  return vec4(mix(heightFog.color, color.rgb, heightFog_getTransmittance(position, cameraPosition)), color.a);\n}\n";
+    readonly source: "\nstruct heightFogUniforms {\n  color: vec3<f32>,\n  density: f32,\n  baseHeight: f32,\n  heightFalloff: f32,\n  variation: f32,\n  wispScale: f32,\n  velocity: vec3<f32>,\n  time: f32,\n  evolutionSpeed: f32,\n};\n@group(3) @binding(auto) var<uniform> heightFog: heightFogUniforms;\nfn heightFog_getTransmittance(position: vec3<f32>, cameraPosition: vec3<f32>) -> f32 {\n  return heightFog_getSpatialTransmittance(cameraPosition, position, vec3<f32>(0.0, 0.0, 1.0),\n    heightFog.density, heightFog.baseHeight, heightFog.heightFalloff, heightFog.variation, heightFog.wispScale, heightFog.time, heightFog.velocity, heightFog.evolutionSpeed);\n}\nfn heightFog_getColor(color: vec4<f32>, position: vec3<f32>, cameraPosition: vec3<f32>) -> vec4<f32> {\n  return vec4<f32>(mix(heightFog.color, color.rgb, heightFog_getTransmittance(position, cameraPosition)), color.a);\n}\n";
+};
+//# sourceMappingURL=height-fog.d.ts.map

package/dist/modules/lighting/height-fog/height-fog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"height-fog.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/height-fog/height-fog.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;AAExD,2FAA2F;AAC3F,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA0BD,cAAc;;;CA4CiC,CAAC"}

package/dist/modules/lighting/height-fog/height-fog.js

@@ -0,0 +1,77 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { heightFogFunctions } from "./height-fog-functions.js";
+/** Analytic extinction through a height-dependent atmosphere. All distances are metres. */
+export const heightFog = {
+    name: 'heightFog',
+    dependencies: [heightFogFunctions],
+    bindingLayout: [{ name: 'heightFog', group: 3 }],
+    uniformTypes: {
+        color: 'vec3<f32>',
+        density: 'f32',
+        baseHeight: 'f32',
+        heightFalloff: 'f32',
+        variation: 'f32',
+        wispScale: 'f32',
+        velocity: 'vec3<f32>',
+        time: 'f32',
+        evolutionSpeed: 'f32'
+    },
+    defaultUniforms: {
+        color: [0.65, 0.72, 0.78],
+        density: 0,
+        baseHeight: 0,
+        heightFalloff: 0.01,
+        variation: 0,
+        wispScale: 160,
+        velocity: [0, 0, 0],
+        time: 0,
+        evolutionSpeed: 0
+    },
+    getUniforms(props = {}) {
+        return props;
+    },
+    fs: /* glsl */ `
+layout(std140) uniform heightFogUniforms {
+  vec3 color;
+  float density;
+  float baseHeight;
+  float heightFalloff;
+  float variation;
+  float wispScale;
+  vec3 velocity;
+  float time;
+  float evolutionSpeed;
+} heightFog;
+float heightFog_getTransmittance(vec3 position, vec3 cameraPosition) {
+  return heightFog_getSpatialTransmittance(cameraPosition, position, vec3(0.0, 0.0, 1.0),
+    heightFog.density, heightFog.baseHeight, heightFog.heightFalloff, heightFog.variation, heightFog.wispScale, heightFog.time, heightFog.velocity, heightFog.evolutionSpeed);
+}
+vec4 heightFog_getColor(vec4 color, vec3 position, vec3 cameraPosition) {
+  return vec4(mix(heightFog.color, color.rgb, heightFog_getTransmittance(position, cameraPosition)), color.a);
+}
+`,
+    source: /* wgsl */ `
+struct heightFogUniforms {
+  color: vec3<f32>,
+  density: f32,
+  baseHeight: f32,
+  heightFalloff: f32,
+  variation: f32,
+  wispScale: f32,
+  velocity: vec3<f32>,
+  time: f32,
+  evolutionSpeed: f32,
+};
+@group(3) @binding(auto) var<uniform> heightFog: heightFogUniforms;
+fn heightFog_getTransmittance(position: vec3<f32>, cameraPosition: vec3<f32>) -> f32 {
+  return heightFog_getSpatialTransmittance(cameraPosition, position, vec3<f32>(0.0, 0.0, 1.0),
+    heightFog.density, heightFog.baseHeight, heightFog.heightFalloff, heightFog.variation, heightFog.wispScale, heightFog.time, heightFog.velocity, heightFog.evolutionSpeed);
+}
+fn heightFog_getColor(color: vec4<f32>, position: vec3<f32>, cameraPosition: vec3<f32>) -> vec4<f32> {
+  return vec4<f32>(mix(heightFog.color, color.rgb, heightFog_getTransmittance(position, cameraPosition)), color.a);
+}
+`
+};
+//# sourceMappingURL=height-fog.js.map

package/dist/modules/lighting/height-fog/height-fog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"height-fog.js","sourceRoot":"","sources":["../../../../src/modules/lighting/height-fog/height-fog.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAG5D,OAAO,EAAC,kBAAkB,EAAC,kCAA+B;AAmB1D,2FAA2F;AAC3F,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,IAAI,EAAE,WAAW;IACjB,YAAY,EAAE,CAAC,kBAAkB,CAAC;IAClC,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAC9C,YAAY,EAAE;QACZ,KAAK,EAAE,WAAW;QAClB,OAAO,EAAE,KAAK;QACd,UAAU,EAAE,KAAK;QACjB,aAAa,EAAE,KAAK;QACpB,SAAS,EAAE,KAAK;QAChB,SAAS,EAAE,KAAK;QAChB,QAAQ,EAAE,WAAW;QACrB,IAAI,EAAE,KAAK;QACX,cAAc,EAAE,KAAK;KACtB;IACD,eAAe,EAAE;QACf,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;QACzB,OAAO,EAAE,CAAC;QACV,UAAU,EAAE,CAAC;QACb,aAAa,EAAE,IAAI;QACnB,SAAS,EAAE,CAAC;QACZ,SAAS,EAAE,GAAG;QACd,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACnB,IAAI,EAAE,CAAC;QACP,cAAc,EAAE,CAAC;KAClB;IACD,WAAW,CAAC,QAAwB,EAAE;QACpC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;CAmBhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;CAoBpB;CACmE,CAAC"}

package/dist/modules/lighting/ibl/ibl.cjs

@@ -0,0 +1,63 @@
+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 ibl_exports = {};
+__export(ibl_exports, {
+  ibl: () => ibl,
+  iblGLSL: () => iblGLSL,
+  iblWGSL: () => iblWGSL
+});
+module.exports = __toCommonJS(ibl_exports);
+const iblWGSL = (
+  /* wgsl */
+  `#ifdef USE_IBL
+@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;
+@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;
+#endif
+`
+);
+const iblGLSL = (
+  /* glsl */
+  `#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+`
+);
+const ibl = {
+  name: "ibl",
+  firstBindingSlot: 32,
+  bindingLayout: [
+    { name: "pbr_diffuseEnvSampler", group: 2 },
+    { name: "pbr_specularEnvSampler", group: 2 },
+    { name: "pbr_brdfLUT", group: 2 }
+  ],
+  source: iblWGSL,
+  vs: iblGLSL,
+  fs: iblGLSL
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ibl,
+  iblGLSL,
+  iblWGSL
+});

package/dist/modules/lighting/ibl/ibl.d.ts

@@ -0,0 +1,25 @@
+export type IBLBindings<TextureT = unknown> = {
+    pbr_diffuseEnvSampler?: TextureT | null;
+    pbr_specularEnvSampler?: TextureT | null;
+    pbr_brdfLUT?: TextureT | null;
+};
+export declare const iblWGSL = "#ifdef USE_IBL\n@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;\n@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;\n@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;\n@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;\n@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;\n@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;\n#endif\n";
+export declare const iblGLSL = "#ifdef USE_IBL\nuniform samplerCube pbr_diffuseEnvSampler;\nuniform samplerCube pbr_specularEnvSampler;\nuniform sampler2D pbr_brdfLUT;\n#endif\n";
+export declare const ibl: {
+    readonly name: "ibl";
+    readonly firstBindingSlot: 32;
+    readonly bindingLayout: readonly [{
+        readonly name: "pbr_diffuseEnvSampler";
+        readonly group: 2;
+    }, {
+        readonly name: "pbr_specularEnvSampler";
+        readonly group: 2;
+    }, {
+        readonly name: "pbr_brdfLUT";
+        readonly group: 2;
+    }];
+    readonly source: "#ifdef USE_IBL\n@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;\n@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;\n@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;\n@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;\n@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;\n@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;\n#endif\n";
+    readonly vs: "#ifdef USE_IBL\nuniform samplerCube pbr_diffuseEnvSampler;\nuniform samplerCube pbr_specularEnvSampler;\nuniform sampler2D pbr_brdfLUT;\n#endif\n";
+    readonly fs: "#ifdef USE_IBL\nuniform samplerCube pbr_diffuseEnvSampler;\nuniform samplerCube pbr_specularEnvSampler;\nuniform sampler2D pbr_brdfLUT;\n#endif\n";
+};
+//# sourceMappingURL=ibl.d.ts.map

package/dist/modules/lighting/ibl/ibl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ibl.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/ibl/ibl.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,WAAW,CAAC,QAAQ,GAAG,OAAO,IAAI;IAC5C,qBAAqB,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IACxC,sBAAsB,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IACzC,WAAW,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC/B,CAAC;AAEF,eAAO,MAAM,OAAO,gbASnB,CAAC;AAEF,eAAO,MAAM,OAAO,sJAMnB,CAAC;AAEF,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;CAW+C,CAAC"}

package/dist/modules/lighting/ibl/ibl.js

@@ -0,0 +1,33 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export const iblWGSL = /* wgsl */ `\
+#ifdef USE_IBL
+@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;
+@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;
+#endif
+`;
+export const iblGLSL = /* glsl */ `\
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+`;
+export const ibl = {
+    name: 'ibl',
+    firstBindingSlot: 32,
+    bindingLayout: [
+        { name: 'pbr_diffuseEnvSampler', group: 2 },
+        { name: 'pbr_specularEnvSampler', group: 2 },
+        { name: 'pbr_brdfLUT', group: 2 }
+    ],
+    source: iblWGSL,
+    vs: iblGLSL,
+    fs: iblGLSL
+};
+//# sourceMappingURL=ibl.js.map

package/dist/modules/lighting/ibl/ibl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ibl.js","sourceRoot":"","sources":["../../../../src/modules/lighting/ibl/ibl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAU5D,MAAM,CAAC,MAAM,OAAO,GAAG,UAAU,CAAC;;;;;;;;;CASjC,CAAC;AAEF,MAAM,CAAC,MAAM,OAAO,GAAG,UAAU,CAAC;;;;;;CAMjC,CAAC;AAEF,MAAM,CAAC,MAAM,GAAG,GAAG;IACjB,IAAI,EAAE,KAAK;IACX,gBAAgB,EAAE,EAAE;IACpB,aAAa,EAAE;QACb,EAAC,IAAI,EAAE,uBAAuB,EAAE,KAAK,EAAE,CAAC,EAAC;QACzC,EAAC,IAAI,EAAE,wBAAwB,EAAE,KAAK,EAAE,CAAC,EAAC;QAC1C,EAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,EAAC;KAChC;IACD,MAAM,EAAE,OAAO;IACf,EAAE,EAAE,OAAO;IACX,EAAE,EAAE,OAAO;CACkD,CAAC"}

package/dist/modules/lighting/lambert-material/lambert-material.cjs

@@ -0,0 +1,54 @@
+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 lambert_material_exports = {};
+__export(lambert_material_exports, {
+  lambertMaterial: () => lambertMaterial
+});
+module.exports = __toCommonJS(lambert_material_exports);
+var import_lighting = require("../lights/lighting.cjs");
+var import_lambert_shaders_wgsl = require("./lambert-shaders-wgsl.cjs");
+var import_lambert_shaders_glsl = require("./lambert-shaders-glsl.cjs");
+const lambertMaterial = {
+  name: "lambertMaterial",
+  firstBindingSlot: 0,
+  bindingLayout: [{ name: "lambertMaterial", group: 3 }],
+  dependencies: [import_lighting.lighting],
+  source: import_lambert_shaders_wgsl.LAMBERT_WGSL,
+  vs: import_lambert_shaders_glsl.LAMBERT_VS,
+  fs: import_lambert_shaders_glsl.LAMBERT_FS,
+  defines: {
+    LIGHTING_FRAGMENT: true
+  },
+  uniformTypes: {
+    unlit: "i32",
+    ambient: "f32",
+    diffuse: "f32"
+  },
+  defaultUniforms: {
+    unlit: false,
+    ambient: 0.35,
+    diffuse: 0.6
+  },
+  getUniforms(props) {
+    return { ...lambertMaterial.defaultUniforms, ...props };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lambertMaterial
+});

package/dist/modules/lighting/lambert-material/lambert-material.d.ts

@@ -0,0 +1,10 @@
+import { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+/** Uniform props for the built-in diffuse-only Lambert material model. */
+export type LambertMaterialProps = {
+    unlit?: boolean;
+    ambient?: number;
+    diffuse?: number;
+};
+/** A matte material model that applies diffuse-only Lambert lighting per fragment. */
+export declare const lambertMaterial: ShaderModule<LambertMaterialProps>;
+//# sourceMappingURL=lambert-material.d.ts.map

package/dist/modules/lighting/lambert-material/lambert-material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambert-material.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lambert-material/lambert-material.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAKtE,0EAA0E;AAC1E,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,oBAAoB,CAwB9D,CAAC"}