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

package/dist/modules/lighting/globe-clouds/globe-clouds.d.ts

@@ -0,0 +1,53 @@
+export type GlobeCloudUniforms = {
+    planetRadius: number;
+};
+export type GlobeCloudProps = Partial<GlobeCloudUniforms>;
+/** Spherical cloud shell using the existing cloud density, noise and sunlight model.
+ * Camera and rays are globe-centered, with the planet's surface at unit radius.
+ * The shared clouds uniforms retain metre/second units; sunDirection is globe-centered XYZ.
+ */
+export declare const globeClouds: {
+    readonly name: "globeClouds";
+    readonly dependencies: [{
+        readonly name: "clouds";
+        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 uniformTypes: {
+            readonly cover: "f32";
+            readonly altitude: "f32";
+            readonly thickness: "f32";
+            readonly scale: "f32";
+            readonly density: "f32";
+            readonly time: "f32";
+            readonly velocity: "vec2<f32>";
+            readonly sunDirection: "vec3<f32>";
+            readonly sunColor: "vec3<f32>";
+        };
+        readonly defaultUniforms: import("../clouds/clouds").CloudUniforms;
+        readonly getUniforms: (props?: Partial<Partial<import("../clouds/clouds").CloudUniforms>>, previousUniforms?: import("../clouds/clouds").CloudUniforms | undefined) => {
+            cover: number;
+            altitude: number;
+            thickness: number;
+            scale: number;
+            density: number;
+            time: number;
+            velocity: [number, number];
+            sunDirection: [number, number, number];
+            sunColor: [number, number, number];
+        };
+        readonly fs: "\nlayout(std140) uniform cloudsUniforms {\n  float cover;\n  float altitude;\n  float thickness;\n  float scale;\n  float density;\n  float time;\n  vec2 velocity;\n  vec3 sunDirection;\n  vec3 sunColor;\n} clouds;\n// Shared normalized density field for planar slabs and spherical shells.\nfloat clouds_getDensityAt(vec3 coordinate, float height) {\n  float envelope = smoothstep(0.0, 0.2, height) * (1.0 - smoothstep(0.65, 1.0, height));\n  coordinate += vec3(8.7, 3.2, clouds.time * 0.003);\n  float broad = valueNoise_noise3(coordinate);\n  float detail = valueNoise_noise3(coordinate * 2.07 + vec3(13.1, 7.3, 2.8));\n  float fine = valueNoise_noise3(coordinate * 4.23 + vec3(5.4, 11.7, 8.1));\n  float threshold = mix(0.78, 0.18, clamp(clouds.cover, 0.0, 1.0));\n  return envelope * smoothstep(threshold, threshold + 0.16, broad * 0.72 + detail * 0.2 + fine * 0.08);\n}\n\nfloat clouds_getDensity(vec3 position) {\n  float height = (position.z - clouds.altitude) / max(clouds.thickness, 1.0);\n  return clouds_getDensityAt(vec3((position.xy - clouds.velocity * clouds.time) / max(clouds.scale, 1.0), height * 0.8), height);\n}\nvec3 clouds_getLighting(float density, float sunDensity, float daylight, float silver) {\n  vec3 ambient = mix(vec3(0.035, 0.05, 0.085), vec3(0.28, 0.34, 0.42), daylight);\n  float sunlight = exp(-(density + sunDensity) * 2.0);\n  return ambient + clouds.sunColor * daylight * sunlight * (0.5 + silver * 0.3);\n}\n\n// Beer-Lambert extinction toward the sun through the same density used for sky rendering.\nfloat clouds_getTransmittance(vec3 position) {\n  if (clouds.cover <= 0.0 || clouds.density <= 0.0) return 1.0;\n  vec3 direction = normalize(clouds.sunDirection);\n  if (direction.z <= 0.02) return 1.0;\n  float start = max((clouds.altitude - position.z) / direction.z, 0.0);\n  float end = min((clouds.altitude + clouds.thickness - position.z) / direction.z, 40000.0);\n  if (end <= start) return 1.0;\n  float stepLength = (end - start) / 16.0;\n  float opticalDepth = 0.0;\n  for (int sampleIndex = 0; sampleIndex < 16; sampleIndex++) {\n    opticalDepth += clouds_getDensity(position + direction * (start + (float(sampleIndex) + 0.5) * stepLength)) * stepLength;\n  }\n  return exp(-opticalDepth * max(clouds.density, 0.0));\n}\n\nvec4 clouds_getColor(vec3 camera, vec3 rayDirection) {\n  if (clouds.cover <= 0.0 || clouds.density <= 0.0 || abs(rayDirection.z) < 0.0001) return vec4(0.0);\n  float bottom = (clouds.altitude - camera.z) / rayDirection.z;\n  float top = (clouds.altitude + max(clouds.thickness, 1.0) - camera.z) / rayDirection.z;\n  float start = max(min(bottom, top), 0.0);\n  float end = min(max(bottom, top), 20000.0);\n  if (end <= start) return vec4(0.0);\n  float jitter = valueNoise_hash(rayDirection.xy * 4096.0);\n  float stepLength = (end - start) / 64.0;\n  vec3 sunDirection = normalize(clouds.sunDirection);\n  float daylight = smoothstep(-0.08, 0.18, sunDirection.z);\n  float silver = pow(max(dot(rayDirection, sunDirection), 0.0), 12.0);\n  vec3 radiance = vec3(0.0);\n  float transmittance = 1.0;\n  for (int sampleIndex = 0; sampleIndex < 64; sampleIndex++) {\n    vec3 position = camera + rayDirection * (start + (float(sampleIndex) + jitter) * stepLength);\n    float density = clouds_getDensity(position);\n    float sunDensity = clouds_getDensity(position + sunDirection * clouds.thickness * 0.28);\n    float alpha = 1.0 - exp(-density * max(clouds.density, 0.0) * stepLength);\n    vec3 color = clouds_getLighting(density, sunDensity, daylight, silver);\n    radiance += transmittance * alpha * color;\n    transmittance *= 1.0 - alpha;\n  }\n  float distanceFade = 1.0 - smoothstep(10000.0, 20000.0, start);\n  return vec4(radiance, 1.0 - transmittance) * distanceFade;\n}\n";
+        readonly source: "\nstruct cloudsUniforms {\n  cover: f32,\n  altitude: f32,\n  thickness: f32,\n  scale: f32,\n  density: f32,\n  time: f32,\n  velocity: vec2f,\n  sunDirection: vec3f,\n  sunColor: vec3f,\n};\n@group(3) @binding(auto) var<uniform> clouds: cloudsUniforms;\nfn clouds_getDensityAt(inputCoordinate: vec3f, height: f32) -> f32 {\n  let envelope = smoothstep(0.0, 0.2, height) * (1.0 - smoothstep(0.65, 1.0, height));\n  var coordinate = inputCoordinate;\n  coordinate += vec3f(8.7, 3.2, clouds.time * 0.003);\n  let broad = valueNoise_noise3(coordinate);\n  let detail = valueNoise_noise3(coordinate * 2.07 + vec3f(13.1, 7.3, 2.8));\n  let fine = valueNoise_noise3(coordinate * 4.23 + vec3f(5.4, 11.7, 8.1));\n  let threshold = mix(0.78, 0.18, clamp(clouds.cover, 0.0, 1.0));\n  return envelope * smoothstep(threshold, threshold + 0.16, broad * 0.72 + detail * 0.2 + fine * 0.08);\n}\n\nfn clouds_getDensity(position: vec3f) -> f32 {\n  let height = (position.z - clouds.altitude) / max(clouds.thickness, 1.0);\n  return clouds_getDensityAt(vec3f((position.xy - clouds.velocity * clouds.time) / max(clouds.scale, 1.0), height * 0.8), height);\n}\nfn clouds_getLighting(density: f32, sunDensity: f32, daylight: f32, silver: f32) -> vec3f {\n  let ambient = mix(vec3f(0.035, 0.05, 0.085), vec3f(0.28, 0.34, 0.42), daylight);\n  let sunlight = exp(-(density + sunDensity) * 2.0);\n  return ambient + clouds.sunColor * daylight * sunlight * (0.5 + silver * 0.3);\n}\n\n// Beer-Lambert extinction toward the sun through the same density used for sky rendering.\nfn clouds_getTransmittance(position: vec3f) -> f32 {\n  if (clouds.cover <= 0.0 || clouds.density <= 0.0) { return 1.0; }\n  var direction: vec3f = normalize(clouds.sunDirection);\n  if (direction.z <= 0.02) { return 1.0; }\n  var start: f32 = max((clouds.altitude - position.z) / direction.z, 0.0);\n  var end: f32 = min((clouds.altitude + clouds.thickness - position.z) / direction.z, 40000.0);\n  if (end <= start) { return 1.0; }\n  var stepLength: f32 = (end - start) / 16.0;\n  var opticalDepth: f32 = 0.0;\n  for (var sampleIndex: i32 = 0; sampleIndex < 16; sampleIndex++) {\n    opticalDepth += clouds_getDensity(position + direction * (start + (f32(sampleIndex) + 0.5) * stepLength)) * stepLength;\n  }\n  return exp(-opticalDepth * max(clouds.density, 0.0));\n}\n\nfn clouds_getColor(camera: vec3f, rayDirection: vec3f) -> vec4f {\n  if (clouds.cover <= 0.0 || clouds.density <= 0.0 || abs(rayDirection.z) < 0.0001) { return vec4f(0.0); }\n  let bottom = (clouds.altitude - camera.z) / rayDirection.z;\n  let top = (clouds.altitude + max(clouds.thickness, 1.0) - camera.z) / rayDirection.z;\n  let start = max(min(bottom, top), 0.0);\n  let end = min(max(bottom, top), 20000.0);\n  if (end <= start) { return vec4f(0.0); }\n  let jitter = valueNoise_hash(rayDirection.xy * 4096.0);\n  let stepLength = (end - start) / 64.0;\n  let sunDirection = normalize(clouds.sunDirection);\n  let daylight = smoothstep(-0.08, 0.18, sunDirection.z);\n  let silver = pow(max(dot(rayDirection, sunDirection), 0.0), 12.0);\n  var radiance = vec3f(0.0);\n  var transmittance = 1.0;\n  for (var sampleIndex = 0; sampleIndex < 64; sampleIndex++) {\n    let position = camera + rayDirection * (start + (f32(sampleIndex) + jitter) * stepLength);\n    let density = clouds_getDensity(position);\n    let sunDensity = clouds_getDensity(position + sunDirection * clouds.thickness * 0.28);\n    let alpha = 1.0 - exp(-density * max(clouds.density, 0.0) * stepLength);\n    let color = clouds_getLighting(density, sunDensity, daylight, silver);\n    radiance += transmittance * alpha * color;\n    transmittance *= 1.0 - alpha;\n  }\n  let distanceFade = 1.0 - smoothstep(10000.0, 20000.0, start);\n  return vec4f(radiance, 1.0 - transmittance) * distanceFade;\n}\n";
+    }];
+    readonly uniformTypes: {
+        readonly planetRadius: "f32";
+    };
+    readonly defaultUniforms: {
+        readonly planetRadius: 6370972;
+    };
+    readonly fs: "\nlayout(std140) uniform globeCloudsUniforms { float planetRadius; } globeClouds;\nvec2 globeClouds_intersectSphere(vec3 camera, vec3 direction, float radius) {\n  float projected = dot(camera, direction);\n  float discriminant = projected * projected - dot(camera, camera) + radius * radius;\n  if (discriminant < 0.0) return vec2(-1.0);\n  float root = sqrt(discriminant);\n  return vec2(-projected - root, -projected + root);\n}\nfloat globeClouds_getDensity(vec3 position) {\n  float height = ((length(position) - 1.0) * globeClouds.planetRadius - clouds.altitude) / max(clouds.thickness, 1.0);\n  // Rotate a 3D field rather than wrapping longitude UVs: no seams or pinched poles.\n  vec2 angle = clouds.velocity * clouds.time / globeClouds.planetRadius;\n  vec3 rotated = vec3(cos(angle.x) * position.x + sin(angle.x) * position.y,\n    -sin(angle.x) * position.x + cos(angle.x) * position.y, position.z);\n  rotated = vec3(rotated.x, cos(angle.y) * rotated.y + sin(angle.y) * rotated.z,\n    -sin(angle.y) * rotated.y + cos(angle.y) * rotated.z);\n  return clouds_getDensityAt(rotated * globeClouds.planetRadius / max(clouds.scale, 1.0), height);\n}\nvec4 globeClouds_getColor(vec3 camera, vec3 direction) {\n  if (clouds.cover <= 0.0 || clouds.density <= 0.0) return vec4(0.0);\n  float bottom = 1.0 + clouds.altitude / globeClouds.planetRadius;\n  float top = bottom + max(clouds.thickness, 1.0) / globeClouds.planetRadius;\n  vec2 outer = globeClouds_intersectSphere(camera, direction, top);\n  if (outer.y <= 0.0) return vec4(0.0);\n  float start = max(outer.x, 0.0);\n  float end = outer.y;\n  vec2 inner = globeClouds_intersectSphere(camera, direction, bottom);\n  if (length(camera) < bottom) start = max(start, inner.y);\n  else if (inner.x >= start) end = min(end, inner.x);\n  vec2 ground = globeClouds_intersectSphere(camera, direction, 1.0);\n  if (ground.x >= 0.0) end = min(end, ground.x);\n  if (end <= start) return vec4(0.0);\n  float stepLength = (end - start) / 32.0;\n  float jitter = valueNoise_hash(direction.xy * 4096.0);\n  vec3 sunlightDirection = normalize(clouds.sunDirection);\n  float silver = pow(max(dot(direction, sunlightDirection), 0.0), 12.0);\n  vec3 radiance = vec3(0.0);\n  float transmittance = 1.0;\n  for (int sampleIndex = 0; sampleIndex < 32; sampleIndex++) {\n    vec3 position = camera + direction * (start + (float(sampleIndex) + jitter) * stepLength);\n    float density = globeClouds_getDensity(position);\n    float sunDensity = globeClouds_getDensity(position + sunlightDirection * clouds.thickness * 0.28 / globeClouds.planetRadius);\n    float daylight = smoothstep(-0.08, 0.18, dot(normalize(position), sunlightDirection));\n    float alpha = 1.0 - exp(-density * clouds.density * stepLength * globeClouds.planetRadius);\n    radiance += transmittance * alpha * clouds_getLighting(density * 0.25, sunDensity * 0.25, daylight, silver);\n    transmittance *= 1.0 - alpha;\n    if (transmittance < 0.01) break;\n  }\n  return vec4(radiance, 1.0 - transmittance);\n}\n";
+    readonly source: "\nstruct globeCloudsUniforms { planetRadius: f32 };\n@group(3) @binding(auto) var<uniform> globeClouds: globeCloudsUniforms;\nfn globeClouds_intersectSphere(camera: vec3f, direction: vec3f, radius: f32) -> vec2f {\n  let projected = dot(camera, direction);\n  let discriminant = projected * projected - dot(camera, camera) + radius * radius;\n  if (discriminant < 0.0) { return vec2f(-1.0); }\n  let root = sqrt(discriminant);\n  return vec2f(-projected - root, -projected + root);\n}\nfn globeClouds_getDensity(position: vec3f) -> f32 {\n  let height = ((length(position) - 1.0) * globeClouds.planetRadius - clouds.altitude) / max(clouds.thickness, 1.0);\n  let angle = clouds.velocity * clouds.time / globeClouds.planetRadius;\n  var rotated = vec3f(cos(angle.x) * position.x + sin(angle.x) * position.y,\n    -sin(angle.x) * position.x + cos(angle.x) * position.y, position.z);\n  rotated = vec3f(rotated.x, cos(angle.y) * rotated.y + sin(angle.y) * rotated.z,\n    -sin(angle.y) * rotated.y + cos(angle.y) * rotated.z);\n  return clouds_getDensityAt(rotated * globeClouds.planetRadius / max(clouds.scale, 1.0), height);\n}\nfn globeClouds_getColor(camera: vec3f, direction: vec3f) -> vec4f {\n  if (clouds.cover <= 0.0 || clouds.density <= 0.0) { return vec4f(0.0); }\n  let bottom = 1.0 + clouds.altitude / globeClouds.planetRadius;\n  let top = bottom + max(clouds.thickness, 1.0) / globeClouds.planetRadius;\n  let outer = globeClouds_intersectSphere(camera, direction, top);\n  if (outer.y <= 0.0) { return vec4f(0.0); }\n  var start = max(outer.x, 0.0);\n  var end = outer.y;\n  let inner = globeClouds_intersectSphere(camera, direction, bottom);\n  if (length(camera) < bottom) { start = max(start, inner.y); }\n  else if (inner.x >= start) { end = min(end, inner.x); }\n  let ground = globeClouds_intersectSphere(camera, direction, 1.0);\n  if (ground.x >= 0.0) { end = min(end, ground.x); }\n  if (end <= start) { return vec4f(0.0); }\n  let stepLength = (end - start) / 32.0;\n  let jitter = valueNoise_hash(direction.xy * 4096.0);\n  let sunlightDirection = normalize(clouds.sunDirection);\n  let silver = pow(max(dot(direction, sunlightDirection), 0.0), 12.0);\n  var radiance = vec3f(0.0);\n  var transmittance = 1.0;\n  for (var sampleIndex = 0; sampleIndex < 32; sampleIndex++) {\n    let position = camera + direction * (start + (f32(sampleIndex) + jitter) * stepLength);\n    let density = globeClouds_getDensity(position);\n    let sunDensity = globeClouds_getDensity(position + sunlightDirection * clouds.thickness * 0.28 / globeClouds.planetRadius);\n    let daylight = smoothstep(-0.08, 0.18, dot(normalize(position), sunlightDirection));\n    let alpha = 1.0 - exp(-density * clouds.density * stepLength * globeClouds.planetRadius);\n    radiance += transmittance * alpha * clouds_getLighting(density * 0.25, sunDensity * 0.25, daylight, silver);\n    transmittance *= 1.0 - alpha;\n    if (transmittance < 0.01) { break; }\n  }\n  return vec4f(radiance, 1.0 - transmittance);\n}\n";
+};
+//# sourceMappingURL=globe-clouds.d.ts.map

package/dist/modules/lighting/globe-clouds/globe-clouds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globe-clouds.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/globe-clouds/globe-clouds.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,kBAAkB,GAAG;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAAC;AACxD,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6G8C,CAAC"}

package/dist/modules/lighting/globe-clouds/globe-clouds.js

@@ -0,0 +1,119 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { clouds } from "../clouds/clouds.js";
+/** Spherical cloud shell using the existing cloud density, noise and sunlight model.
+ * Camera and rays are globe-centered, with the planet's surface at unit radius.
+ * The shared clouds uniforms retain metre/second units; sunDirection is globe-centered XYZ.
+ */
+export const globeClouds = {
+    name: 'globeClouds',
+    dependencies: [clouds],
+    uniformTypes: { planetRadius: 'f32' },
+    defaultUniforms: { planetRadius: 6370972 },
+    fs: /* glsl */ `
+layout(std140) uniform globeCloudsUniforms { float planetRadius; } globeClouds;
+vec2 globeClouds_intersectSphere(vec3 camera, vec3 direction, float radius) {
+  float projected = dot(camera, direction);
+  float discriminant = projected * projected - dot(camera, camera) + radius * radius;
+  if (discriminant < 0.0) return vec2(-1.0);
+  float root = sqrt(discriminant);
+  return vec2(-projected - root, -projected + root);
+}
+float globeClouds_getDensity(vec3 position) {
+  float height = ((length(position) - 1.0) * globeClouds.planetRadius - clouds.altitude) / max(clouds.thickness, 1.0);
+  // Rotate a 3D field rather than wrapping longitude UVs: no seams or pinched poles.
+  vec2 angle = clouds.velocity * clouds.time / globeClouds.planetRadius;
+  vec3 rotated = vec3(cos(angle.x) * position.x + sin(angle.x) * position.y,
+    -sin(angle.x) * position.x + cos(angle.x) * position.y, position.z);
+  rotated = vec3(rotated.x, cos(angle.y) * rotated.y + sin(angle.y) * rotated.z,
+    -sin(angle.y) * rotated.y + cos(angle.y) * rotated.z);
+  return clouds_getDensityAt(rotated * globeClouds.planetRadius / max(clouds.scale, 1.0), height);
+}
+vec4 globeClouds_getColor(vec3 camera, vec3 direction) {
+  if (clouds.cover <= 0.0 || clouds.density <= 0.0) return vec4(0.0);
+  float bottom = 1.0 + clouds.altitude / globeClouds.planetRadius;
+  float top = bottom + max(clouds.thickness, 1.0) / globeClouds.planetRadius;
+  vec2 outer = globeClouds_intersectSphere(camera, direction, top);
+  if (outer.y <= 0.0) return vec4(0.0);
+  float start = max(outer.x, 0.0);
+  float end = outer.y;
+  vec2 inner = globeClouds_intersectSphere(camera, direction, bottom);
+  if (length(camera) < bottom) start = max(start, inner.y);
+  else if (inner.x >= start) end = min(end, inner.x);
+  vec2 ground = globeClouds_intersectSphere(camera, direction, 1.0);
+  if (ground.x >= 0.0) end = min(end, ground.x);
+  if (end <= start) return vec4(0.0);
+  float stepLength = (end - start) / 32.0;
+  float jitter = valueNoise_hash(direction.xy * 4096.0);
+  vec3 sunlightDirection = normalize(clouds.sunDirection);
+  float silver = pow(max(dot(direction, sunlightDirection), 0.0), 12.0);
+  vec3 radiance = vec3(0.0);
+  float transmittance = 1.0;
+  for (int sampleIndex = 0; sampleIndex < 32; sampleIndex++) {
+    vec3 position = camera + direction * (start + (float(sampleIndex) + jitter) * stepLength);
+    float density = globeClouds_getDensity(position);
+    float sunDensity = globeClouds_getDensity(position + sunlightDirection * clouds.thickness * 0.28 / globeClouds.planetRadius);
+    float daylight = smoothstep(-0.08, 0.18, dot(normalize(position), sunlightDirection));
+    float alpha = 1.0 - exp(-density * clouds.density * stepLength * globeClouds.planetRadius);
+    radiance += transmittance * alpha * clouds_getLighting(density * 0.25, sunDensity * 0.25, daylight, silver);
+    transmittance *= 1.0 - alpha;
+    if (transmittance < 0.01) break;
+  }
+  return vec4(radiance, 1.0 - transmittance);
+}
+`,
+    source: /* wgsl */ `
+struct globeCloudsUniforms { planetRadius: f32 };
+@group(3) @binding(auto) var<uniform> globeClouds: globeCloudsUniforms;
+fn globeClouds_intersectSphere(camera: vec3f, direction: vec3f, radius: f32) -> vec2f {
+  let projected = dot(camera, direction);
+  let discriminant = projected * projected - dot(camera, camera) + radius * radius;
+  if (discriminant < 0.0) { return vec2f(-1.0); }
+  let root = sqrt(discriminant);
+  return vec2f(-projected - root, -projected + root);
+}
+fn globeClouds_getDensity(position: vec3f) -> f32 {
+  let height = ((length(position) - 1.0) * globeClouds.planetRadius - clouds.altitude) / max(clouds.thickness, 1.0);
+  let angle = clouds.velocity * clouds.time / globeClouds.planetRadius;
+  var rotated = vec3f(cos(angle.x) * position.x + sin(angle.x) * position.y,
+    -sin(angle.x) * position.x + cos(angle.x) * position.y, position.z);
+  rotated = vec3f(rotated.x, cos(angle.y) * rotated.y + sin(angle.y) * rotated.z,
+    -sin(angle.y) * rotated.y + cos(angle.y) * rotated.z);
+  return clouds_getDensityAt(rotated * globeClouds.planetRadius / max(clouds.scale, 1.0), height);
+}
+fn globeClouds_getColor(camera: vec3f, direction: vec3f) -> vec4f {
+  if (clouds.cover <= 0.0 || clouds.density <= 0.0) { return vec4f(0.0); }
+  let bottom = 1.0 + clouds.altitude / globeClouds.planetRadius;
+  let top = bottom + max(clouds.thickness, 1.0) / globeClouds.planetRadius;
+  let outer = globeClouds_intersectSphere(camera, direction, top);
+  if (outer.y <= 0.0) { return vec4f(0.0); }
+  var start = max(outer.x, 0.0);
+  var end = outer.y;
+  let inner = globeClouds_intersectSphere(camera, direction, bottom);
+  if (length(camera) < bottom) { start = max(start, inner.y); }
+  else if (inner.x >= start) { end = min(end, inner.x); }
+  let ground = globeClouds_intersectSphere(camera, direction, 1.0);
+  if (ground.x >= 0.0) { end = min(end, ground.x); }
+  if (end <= start) { return vec4f(0.0); }
+  let stepLength = (end - start) / 32.0;
+  let jitter = valueNoise_hash(direction.xy * 4096.0);
+  let sunlightDirection = normalize(clouds.sunDirection);
+  let silver = pow(max(dot(direction, sunlightDirection), 0.0), 12.0);
+  var radiance = vec3f(0.0);
+  var transmittance = 1.0;
+  for (var sampleIndex = 0; sampleIndex < 32; sampleIndex++) {
+    let position = camera + direction * (start + (f32(sampleIndex) + jitter) * stepLength);
+    let density = globeClouds_getDensity(position);
+    let sunDensity = globeClouds_getDensity(position + sunlightDirection * clouds.thickness * 0.28 / globeClouds.planetRadius);
+    let daylight = smoothstep(-0.08, 0.18, dot(normalize(position), sunlightDirection));
+    let alpha = 1.0 - exp(-density * clouds.density * stepLength * globeClouds.planetRadius);
+    radiance += transmittance * alpha * clouds_getLighting(density * 0.25, sunDensity * 0.25, daylight, silver);
+    transmittance *= 1.0 - alpha;
+    if (transmittance < 0.01) { break; }
+  }
+  return vec4f(radiance, 1.0 - transmittance);
+}
+`
+};
+//# sourceMappingURL=globe-clouds.js.map

package/dist/modules/lighting/globe-clouds/globe-clouds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globe-clouds.js","sourceRoot":"","sources":["../../../../src/modules/lighting/globe-clouds/globe-clouds.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAG5D,OAAO,EAAC,MAAM,EAAC,4BAAyB;AAKxC;;;GAGG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI,EAAE,aAAa;IACnB,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,YAAY,EAAE,EAAC,YAAY,EAAE,KAAK,EAAC;IACnC,eAAe,EAAE,EAAC,YAAY,EAAE,OAAO,EAAC;IACxC,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDpB;CACqE,CAAC"}

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

@@ -0,0 +1,61 @@
+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 gouraud_material_exports = {};
+__export(gouraud_material_exports, {
+  gouraudMaterial: () => gouraudMaterial
+});
+module.exports = __toCommonJS(gouraud_material_exports);
+var import_float_colors = require("../../color/float-colors.cjs");
+var import_lighting = require("../lights/lighting.cjs");
+var import_phong_shaders_glsl = require("../phong-material/phong-shaders-glsl.cjs");
+var import_phong_shaders_wgsl = require("../phong-material/phong-shaders-wgsl.cjs");
+const DEFAULT_SPECULAR_COLOR = [38.25, 38.25, 38.25];
+const gouraudMaterial = {
+  props: {},
+  name: "gouraudMaterial",
+  bindingLayout: [{ name: "gouraudMaterial", group: 3 }],
+  // Note these are switched between phong and gouraud
+  vs: import_phong_shaders_glsl.PHONG_FS.replace("phongMaterial", "gouraudMaterial"),
+  fs: import_phong_shaders_glsl.PHONG_VS.replace("phongMaterial", "gouraudMaterial"),
+  source: import_phong_shaders_wgsl.PHONG_WGSL.replaceAll("phongMaterial", "gouraudMaterial"),
+  defines: {
+    LIGHTING_VERTEX: true
+  },
+  dependencies: [import_lighting.lighting, import_float_colors.floatColors],
+  uniformTypes: {
+    unlit: "i32",
+    ambient: "f32",
+    diffuse: "f32",
+    shininess: "f32",
+    specularColor: "vec3<f32>"
+  },
+  defaultUniforms: {
+    unlit: false,
+    ambient: 0.35,
+    diffuse: 0.6,
+    shininess: 32,
+    specularColor: DEFAULT_SPECULAR_COLOR
+  },
+  getUniforms(props) {
+    return { ...gouraudMaterial.defaultUniforms, ...props };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gouraudMaterial
+});

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

@@ -0,0 +1,12 @@
+import { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+export type GouraudMaterialProps = {
+    unlit?: boolean;
+    ambient?: number;
+    diffuse?: number;
+    /** Specularity exponent */
+    shininess?: number;
+    specularColor?: [number, number, number];
+};
+/** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
+export declare const gouraudMaterial: ShaderModule<GouraudMaterialProps>;
+//# sourceMappingURL=gouraud-material.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gouraud-material.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-material.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAC,oDAAiD;AAMtE,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C,CAAC;AAIF,yIAAyI;AACzI,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,oBAAoB,CA+B9D,CAAC"}

package/dist/modules/lighting/gouraud-material/gouraud-material.js

@@ -0,0 +1,40 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { floatColors } from "../../color/float-colors.js";
+import { lighting } from "../lights/lighting.js";
+import { PHONG_VS, PHONG_FS } from "../phong-material/phong-shaders-glsl.js";
+import { PHONG_WGSL } from "../phong-material/phong-shaders-wgsl.js";
+const DEFAULT_SPECULAR_COLOR = [38.25, 38.25, 38.25];
+/** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
+export const gouraudMaterial = {
+    props: {},
+    name: 'gouraudMaterial',
+    bindingLayout: [{ name: 'gouraudMaterial', group: 3 }],
+    // Note these are switched between phong and gouraud
+    vs: PHONG_FS.replace('phongMaterial', 'gouraudMaterial'),
+    fs: PHONG_VS.replace('phongMaterial', 'gouraudMaterial'),
+    source: PHONG_WGSL.replaceAll('phongMaterial', 'gouraudMaterial'),
+    defines: {
+        LIGHTING_VERTEX: true
+    },
+    dependencies: [lighting, floatColors],
+    uniformTypes: {
+        unlit: 'i32',
+        ambient: 'f32',
+        diffuse: 'f32',
+        shininess: 'f32',
+        specularColor: 'vec3<f32>'
+    },
+    defaultUniforms: {
+        unlit: false,
+        ambient: 0.35,
+        diffuse: 0.6,
+        shininess: 32,
+        specularColor: DEFAULT_SPECULAR_COLOR
+    },
+    getUniforms(props) {
+        return { ...gouraudMaterial.defaultUniforms, ...props };
+    }
+};
+//# sourceMappingURL=gouraud-material.js.map

package/dist/modules/lighting/gouraud-material/gouraud-material.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gouraud-material.js","sourceRoot":"","sources":["../../../../src/modules/lighting/gouraud-material/gouraud-material.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAI5D,OAAO,EAAC,WAAW,EAAC,oCAAiC;AACrD,OAAO,EAAC,QAAQ,EAAC,8BAA2B;AAC5C,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,gDAA6C;AACxE,OAAO,EAAC,UAAU,EAAC,gDAA6C;AAWhE,MAAM,sBAAsB,GAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AAEnE,yIAAyI;AACzI,MAAM,CAAC,MAAM,eAAe,GAAuC;IACjE,KAAK,EAAE,EAA0B;IAEjC,IAAI,EAAE,iBAAiB;IACvB,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IACpD,oDAAoD;IACpD,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,eAAe,EAAE,iBAAiB,CAAC;IACxD,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,eAAe,EAAE,iBAAiB,CAAC;IACxD,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,eAAe,EAAE,iBAAiB,CAAC;IACjE,OAAO,EAAE;QACP,eAAe,EAAE,IAAI;KACtB;IACD,YAAY,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC;IACrC,YAAY,EAAE;QACZ,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,KAAK;QAChB,aAAa,EAAE,WAAW;KAC3B;IACD,eAAe,EAAE;QACf,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,GAAG;QACZ,SAAS,EAAE,EAAE;QACb,aAAa,EAAE,sBAAsB;KACtC;IAED,WAAW,CAAC,KAA2B;QACrC,OAAO,EAAC,GAAG,eAAe,CAAC,eAAe,EAAE,GAAG,KAAK,EAAC,CAAC;IACxD,CAAC;CACF,CAAC"}

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

@@ -0,0 +1,139 @@
+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_functions_exports = {};
+__export(height_fog_functions_exports, {
+  heightFogFunctions: () => heightFogFunctions
+});
+module.exports = __toCommonJS(height_fog_functions_exports);
+var import_value_noise = require("../../math/value-noise/value-noise.cjs");
+const heightFogFunctions = {
+  name: "heightFogFunctions",
+  dependencies: [import_value_noise.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;
+}
+
+`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  heightFogFunctions
+});

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