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

package/dist/modules/lighting/clouds/clouds.cjs

@@ -0,0 +1,216 @@
+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 clouds_exports = {};
+__export(clouds_exports, {
+  clouds: () => clouds
+});
+module.exports = __toCommonJS(clouds_exports);
+var import_value_noise = require("../../math/value-noise/value-noise.cjs");
+const DEFAULT_UNIFORMS = {
+  cover: 0.45,
+  altitude: 1e3,
+  thickness: 1200,
+  scale: 1400,
+  density: 5e-3,
+  time: 0,
+  velocity: [14, 4],
+  sunDirection: [0, 0.8, 0.6],
+  sunColor: [1, 0.95, 0.85]
+};
+const clouds = {
+  name: "clouds",
+  dependencies: [import_value_noise.valueNoise],
+  uniformTypes: {
+    cover: "f32",
+    altitude: "f32",
+    thickness: "f32",
+    scale: "f32",
+    density: "f32",
+    time: "f32",
+    velocity: "vec2<f32>",
+    sunDirection: "vec3<f32>",
+    sunColor: "vec3<f32>"
+  },
+  defaultUniforms: DEFAULT_UNIFORMS,
+  getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+    return { ...DEFAULT_UNIFORMS, ...previousUniforms, ...props };
+  },
+  fs: (
+    /* glsl */
+    `
+layout(std140) uniform cloudsUniforms {
+  float cover;
+  float altitude;
+  float thickness;
+  float scale;
+  float density;
+  float time;
+  vec2 velocity;
+  vec3 sunDirection;
+  vec3 sunColor;
+} clouds;
+// Shared normalized density field for planar slabs and spherical shells.
+float clouds_getDensityAt(vec3 coordinate, float height) {
+  float envelope = smoothstep(0.0, 0.2, height) * (1.0 - smoothstep(0.65, 1.0, height));
+  coordinate += vec3(8.7, 3.2, clouds.time * 0.003);
+  float broad = valueNoise_noise3(coordinate);
+  float detail = valueNoise_noise3(coordinate * 2.07 + vec3(13.1, 7.3, 2.8));
+  float fine = valueNoise_noise3(coordinate * 4.23 + vec3(5.4, 11.7, 8.1));
+  float threshold = mix(0.78, 0.18, clamp(clouds.cover, 0.0, 1.0));
+  return envelope * smoothstep(threshold, threshold + 0.16, broad * 0.72 + detail * 0.2 + fine * 0.08);
+}
+
+float clouds_getDensity(vec3 position) {
+  float height = (position.z - clouds.altitude) / max(clouds.thickness, 1.0);
+  return clouds_getDensityAt(vec3((position.xy - clouds.velocity * clouds.time) / max(clouds.scale, 1.0), height * 0.8), height);
+}
+vec3 clouds_getLighting(float density, float sunDensity, float daylight, float silver) {
+  vec3 ambient = mix(vec3(0.035, 0.05, 0.085), vec3(0.28, 0.34, 0.42), daylight);
+  float sunlight = exp(-(density + sunDensity) * 2.0);
+  return ambient + clouds.sunColor * daylight * sunlight * (0.5 + silver * 0.3);
+}
+
+// Beer-Lambert extinction toward the sun through the same density used for sky rendering.
+float clouds_getTransmittance(vec3 position) {
+  if (clouds.cover <= 0.0 || clouds.density <= 0.0) return 1.0;
+  vec3 direction = normalize(clouds.sunDirection);
+  if (direction.z <= 0.02) return 1.0;
+  float start = max((clouds.altitude - position.z) / direction.z, 0.0);
+  float end = min((clouds.altitude + clouds.thickness - position.z) / direction.z, 40000.0);
+  if (end <= start) return 1.0;
+  float stepLength = (end - start) / 16.0;
+  float opticalDepth = 0.0;
+  for (int sampleIndex = 0; sampleIndex < 16; sampleIndex++) {
+    opticalDepth += clouds_getDensity(position + direction * (start + (float(sampleIndex) + 0.5) * stepLength)) * stepLength;
+  }
+  return exp(-opticalDepth * max(clouds.density, 0.0));
+}
+
+vec4 clouds_getColor(vec3 camera, vec3 rayDirection) {
+  if (clouds.cover <= 0.0 || clouds.density <= 0.0 || abs(rayDirection.z) < 0.0001) return vec4(0.0);
+  float bottom = (clouds.altitude - camera.z) / rayDirection.z;
+  float top = (clouds.altitude + max(clouds.thickness, 1.0) - camera.z) / rayDirection.z;
+  float start = max(min(bottom, top), 0.0);
+  float end = min(max(bottom, top), 20000.0);
+  if (end <= start) return vec4(0.0);
+  float jitter = valueNoise_hash(rayDirection.xy * 4096.0);
+  float stepLength = (end - start) / 64.0;
+  vec3 sunDirection = normalize(clouds.sunDirection);
+  float daylight = smoothstep(-0.08, 0.18, sunDirection.z);
+  float silver = pow(max(dot(rayDirection, sunDirection), 0.0), 12.0);
+  vec3 radiance = vec3(0.0);
+  float transmittance = 1.0;
+  for (int sampleIndex = 0; sampleIndex < 64; sampleIndex++) {
+    vec3 position = camera + rayDirection * (start + (float(sampleIndex) + jitter) * stepLength);
+    float density = clouds_getDensity(position);
+    float sunDensity = clouds_getDensity(position + sunDirection * clouds.thickness * 0.28);
+    float alpha = 1.0 - exp(-density * max(clouds.density, 0.0) * stepLength);
+    vec3 color = clouds_getLighting(density, sunDensity, daylight, silver);
+    radiance += transmittance * alpha * color;
+    transmittance *= 1.0 - alpha;
+  }
+  float distanceFade = 1.0 - smoothstep(10000.0, 20000.0, start);
+  return vec4(radiance, 1.0 - transmittance) * distanceFade;
+}
+`
+  ),
+  source: (
+    /* wgsl */
+    `
+struct cloudsUniforms {
+  cover: f32,
+  altitude: f32,
+  thickness: f32,
+  scale: f32,
+  density: f32,
+  time: f32,
+  velocity: vec2f,
+  sunDirection: vec3f,
+  sunColor: vec3f,
+};
+@group(3) @binding(auto) var<uniform> clouds: cloudsUniforms;
+fn clouds_getDensityAt(inputCoordinate: vec3f, height: f32) -> f32 {
+  let envelope = smoothstep(0.0, 0.2, height) * (1.0 - smoothstep(0.65, 1.0, height));
+  var coordinate = inputCoordinate;
+  coordinate += vec3f(8.7, 3.2, clouds.time * 0.003);
+  let broad = valueNoise_noise3(coordinate);
+  let detail = valueNoise_noise3(coordinate * 2.07 + vec3f(13.1, 7.3, 2.8));
+  let fine = valueNoise_noise3(coordinate * 4.23 + vec3f(5.4, 11.7, 8.1));
+  let threshold = mix(0.78, 0.18, clamp(clouds.cover, 0.0, 1.0));
+  return envelope * smoothstep(threshold, threshold + 0.16, broad * 0.72 + detail * 0.2 + fine * 0.08);
+}
+
+fn clouds_getDensity(position: vec3f) -> f32 {
+  let height = (position.z - clouds.altitude) / max(clouds.thickness, 1.0);
+  return clouds_getDensityAt(vec3f((position.xy - clouds.velocity * clouds.time) / max(clouds.scale, 1.0), height * 0.8), height);
+}
+fn clouds_getLighting(density: f32, sunDensity: f32, daylight: f32, silver: f32) -> vec3f {
+  let ambient = mix(vec3f(0.035, 0.05, 0.085), vec3f(0.28, 0.34, 0.42), daylight);
+  let sunlight = exp(-(density + sunDensity) * 2.0);
+  return ambient + clouds.sunColor * daylight * sunlight * (0.5 + silver * 0.3);
+}
+
+// Beer-Lambert extinction toward the sun through the same density used for sky rendering.
+fn clouds_getTransmittance(position: vec3f) -> f32 {
+  if (clouds.cover <= 0.0 || clouds.density <= 0.0) { return 1.0; }
+  var direction: vec3f = normalize(clouds.sunDirection);
+  if (direction.z <= 0.02) { return 1.0; }
+  var start: f32 = max((clouds.altitude - position.z) / direction.z, 0.0);
+  var end: f32 = min((clouds.altitude + clouds.thickness - position.z) / direction.z, 40000.0);
+  if (end <= start) { return 1.0; }
+  var stepLength: f32 = (end - start) / 16.0;
+  var opticalDepth: f32 = 0.0;
+  for (var sampleIndex: i32 = 0; sampleIndex < 16; sampleIndex++) {
+    opticalDepth += clouds_getDensity(position + direction * (start + (f32(sampleIndex) + 0.5) * stepLength)) * stepLength;
+  }
+  return exp(-opticalDepth * max(clouds.density, 0.0));
+}
+
+fn clouds_getColor(camera: vec3f, rayDirection: vec3f) -> vec4f {
+  if (clouds.cover <= 0.0 || clouds.density <= 0.0 || abs(rayDirection.z) < 0.0001) { return vec4f(0.0); }
+  let bottom = (clouds.altitude - camera.z) / rayDirection.z;
+  let top = (clouds.altitude + max(clouds.thickness, 1.0) - camera.z) / rayDirection.z;
+  let start = max(min(bottom, top), 0.0);
+  let end = min(max(bottom, top), 20000.0);
+  if (end <= start) { return vec4f(0.0); }
+  let jitter = valueNoise_hash(rayDirection.xy * 4096.0);
+  let stepLength = (end - start) / 64.0;
+  let sunDirection = normalize(clouds.sunDirection);
+  let daylight = smoothstep(-0.08, 0.18, sunDirection.z);
+  let silver = pow(max(dot(rayDirection, sunDirection), 0.0), 12.0);
+  var radiance = vec3f(0.0);
+  var transmittance = 1.0;
+  for (var sampleIndex = 0; sampleIndex < 64; sampleIndex++) {
+    let position = camera + rayDirection * (start + (f32(sampleIndex) + jitter) * stepLength);
+    let density = clouds_getDensity(position);
+    let sunDensity = clouds_getDensity(position + sunDirection * clouds.thickness * 0.28);
+    let alpha = 1.0 - exp(-density * max(clouds.density, 0.0) * stepLength);
+    let color = clouds_getLighting(density, sunDensity, daylight, silver);
+    radiance += transmittance * alpha * color;
+    transmittance *= 1.0 - alpha;
+  }
+  let distanceFade = 1.0 - smoothstep(10000.0, 20000.0, start);
+  return vec4f(radiance, 1.0 - transmittance) * distanceFade;
+}
+`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clouds
+});

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

@@ -0,0 +1,58 @@
+export type CloudUniforms = {
+    /** Fractional cloud cover, from clear (0) to overcast (1). */
+    cover: number;
+    /** Bottom and thickness of the cloud slab, in metres above the coordinate origin. */
+    altitude: number;
+    thickness: number;
+    /** Horizontal size of cloud formations, in metres. */
+    scale: number;
+    /** Extinction coefficient, in inverse metres. */
+    density: number;
+    /** Elapsed seconds; callers own animation. */
+    time: number;
+    /** East/north drift velocity in metres per second. */
+    velocity: [number, number];
+    /** Direction toward the sun in east/north/up coordinates; nonzero. */
+    sunDirection: [number, number, number];
+    /** Linear sunlight tint. */
+    sunColor: [number, number, number];
+};
+export type CloudProps = Partial<CloudUniforms>;
+/** Sixty-four-sample cloud slab with approximate sunlight scattering. Returns premultiplied RGBA.
+ * Positions/directions use a local east/north/up frame, with lengths in metres.
+ * Receivers can sample clouds_getTransmittance to attenuate direct sunlight.
+ */
+export declare const clouds: {
+    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: CloudUniforms;
+    readonly getUniforms: (props?: Partial<Partial<CloudUniforms>>, previousUniforms?: 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";
+};
+//# sourceMappingURL=clouds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clouds.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/clouds/clouds.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,aAAa,GAAG;IAC1B,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd,qFAAqF;IACrF,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3B,sEAAsE;IACtE,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,4BAA4B;IAC5B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;AAchD;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;eAnCV,MAAM;kBAEH,MAAM;mBACL,MAAM;eAEV,MAAM;iBAEJ,MAAM;cAET,MAAM;kBAEF,CAAC,MAAM,EAAE,MAAM,CAAC;sBAEZ,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;kBAE5B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;;;;CA+LwB,CAAC"}

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

@@ -0,0 +1,192 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { valueNoise } from "../../math/value-noise/value-noise.js";
+const DEFAULT_UNIFORMS = {
+    cover: 0.45,
+    altitude: 1000,
+    thickness: 1200,
+    scale: 1400,
+    density: 0.005,
+    time: 0,
+    velocity: [14, 4],
+    sunDirection: [0, 0.8, 0.6],
+    sunColor: [1, 0.95, 0.85]
+};
+/** Sixty-four-sample cloud slab with approximate sunlight scattering. Returns premultiplied RGBA.
+ * Positions/directions use a local east/north/up frame, with lengths in metres.
+ * Receivers can sample clouds_getTransmittance to attenuate direct sunlight.
+ */
+export const clouds = {
+    name: 'clouds',
+    dependencies: [valueNoise],
+    uniformTypes: {
+        cover: 'f32',
+        altitude: 'f32',
+        thickness: 'f32',
+        scale: 'f32',
+        density: 'f32',
+        time: 'f32',
+        velocity: 'vec2<f32>',
+        sunDirection: 'vec3<f32>',
+        sunColor: 'vec3<f32>'
+    },
+    defaultUniforms: DEFAULT_UNIFORMS,
+    getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+        return { ...DEFAULT_UNIFORMS, ...previousUniforms, ...props };
+    },
+    fs: /* glsl */ `
+layout(std140) uniform cloudsUniforms {
+  float cover;
+  float altitude;
+  float thickness;
+  float scale;
+  float density;
+  float time;
+  vec2 velocity;
+  vec3 sunDirection;
+  vec3 sunColor;
+} clouds;
+// Shared normalized density field for planar slabs and spherical shells.
+float clouds_getDensityAt(vec3 coordinate, float height) {
+  float envelope = smoothstep(0.0, 0.2, height) * (1.0 - smoothstep(0.65, 1.0, height));
+  coordinate += vec3(8.7, 3.2, clouds.time * 0.003);
+  float broad = valueNoise_noise3(coordinate);
+  float detail = valueNoise_noise3(coordinate * 2.07 + vec3(13.1, 7.3, 2.8));
+  float fine = valueNoise_noise3(coordinate * 4.23 + vec3(5.4, 11.7, 8.1));
+  float threshold = mix(0.78, 0.18, clamp(clouds.cover, 0.0, 1.0));
+  return envelope * smoothstep(threshold, threshold + 0.16, broad * 0.72 + detail * 0.2 + fine * 0.08);
+}
+
+float clouds_getDensity(vec3 position) {
+  float height = (position.z - clouds.altitude) / max(clouds.thickness, 1.0);
+  return clouds_getDensityAt(vec3((position.xy - clouds.velocity * clouds.time) / max(clouds.scale, 1.0), height * 0.8), height);
+}
+vec3 clouds_getLighting(float density, float sunDensity, float daylight, float silver) {
+  vec3 ambient = mix(vec3(0.035, 0.05, 0.085), vec3(0.28, 0.34, 0.42), daylight);
+  float sunlight = exp(-(density + sunDensity) * 2.0);
+  return ambient + clouds.sunColor * daylight * sunlight * (0.5 + silver * 0.3);
+}
+
+// Beer-Lambert extinction toward the sun through the same density used for sky rendering.
+float clouds_getTransmittance(vec3 position) {
+  if (clouds.cover <= 0.0 || clouds.density <= 0.0) return 1.0;
+  vec3 direction = normalize(clouds.sunDirection);
+  if (direction.z <= 0.02) return 1.0;
+  float start = max((clouds.altitude - position.z) / direction.z, 0.0);
+  float end = min((clouds.altitude + clouds.thickness - position.z) / direction.z, 40000.0);
+  if (end <= start) return 1.0;
+  float stepLength = (end - start) / 16.0;
+  float opticalDepth = 0.0;
+  for (int sampleIndex = 0; sampleIndex < 16; sampleIndex++) {
+    opticalDepth += clouds_getDensity(position + direction * (start + (float(sampleIndex) + 0.5) * stepLength)) * stepLength;
+  }
+  return exp(-opticalDepth * max(clouds.density, 0.0));
+}
+
+vec4 clouds_getColor(vec3 camera, vec3 rayDirection) {
+  if (clouds.cover <= 0.0 || clouds.density <= 0.0 || abs(rayDirection.z) < 0.0001) return vec4(0.0);
+  float bottom = (clouds.altitude - camera.z) / rayDirection.z;
+  float top = (clouds.altitude + max(clouds.thickness, 1.0) - camera.z) / rayDirection.z;
+  float start = max(min(bottom, top), 0.0);
+  float end = min(max(bottom, top), 20000.0);
+  if (end <= start) return vec4(0.0);
+  float jitter = valueNoise_hash(rayDirection.xy * 4096.0);
+  float stepLength = (end - start) / 64.0;
+  vec3 sunDirection = normalize(clouds.sunDirection);
+  float daylight = smoothstep(-0.08, 0.18, sunDirection.z);
+  float silver = pow(max(dot(rayDirection, sunDirection), 0.0), 12.0);
+  vec3 radiance = vec3(0.0);
+  float transmittance = 1.0;
+  for (int sampleIndex = 0; sampleIndex < 64; sampleIndex++) {
+    vec3 position = camera + rayDirection * (start + (float(sampleIndex) + jitter) * stepLength);
+    float density = clouds_getDensity(position);
+    float sunDensity = clouds_getDensity(position + sunDirection * clouds.thickness * 0.28);
+    float alpha = 1.0 - exp(-density * max(clouds.density, 0.0) * stepLength);
+    vec3 color = clouds_getLighting(density, sunDensity, daylight, silver);
+    radiance += transmittance * alpha * color;
+    transmittance *= 1.0 - alpha;
+  }
+  float distanceFade = 1.0 - smoothstep(10000.0, 20000.0, start);
+  return vec4(radiance, 1.0 - transmittance) * distanceFade;
+}
+`,
+    source: /* wgsl */ `
+struct cloudsUniforms {
+  cover: f32,
+  altitude: f32,
+  thickness: f32,
+  scale: f32,
+  density: f32,
+  time: f32,
+  velocity: vec2f,
+  sunDirection: vec3f,
+  sunColor: vec3f,
+};
+@group(3) @binding(auto) var<uniform> clouds: cloudsUniforms;
+fn clouds_getDensityAt(inputCoordinate: vec3f, height: f32) -> f32 {
+  let envelope = smoothstep(0.0, 0.2, height) * (1.0 - smoothstep(0.65, 1.0, height));
+  var coordinate = inputCoordinate;
+  coordinate += vec3f(8.7, 3.2, clouds.time * 0.003);
+  let broad = valueNoise_noise3(coordinate);
+  let detail = valueNoise_noise3(coordinate * 2.07 + vec3f(13.1, 7.3, 2.8));
+  let fine = valueNoise_noise3(coordinate * 4.23 + vec3f(5.4, 11.7, 8.1));
+  let threshold = mix(0.78, 0.18, clamp(clouds.cover, 0.0, 1.0));
+  return envelope * smoothstep(threshold, threshold + 0.16, broad * 0.72 + detail * 0.2 + fine * 0.08);
+}
+
+fn clouds_getDensity(position: vec3f) -> f32 {
+  let height = (position.z - clouds.altitude) / max(clouds.thickness, 1.0);
+  return clouds_getDensityAt(vec3f((position.xy - clouds.velocity * clouds.time) / max(clouds.scale, 1.0), height * 0.8), height);
+}
+fn clouds_getLighting(density: f32, sunDensity: f32, daylight: f32, silver: f32) -> vec3f {
+  let ambient = mix(vec3f(0.035, 0.05, 0.085), vec3f(0.28, 0.34, 0.42), daylight);
+  let sunlight = exp(-(density + sunDensity) * 2.0);
+  return ambient + clouds.sunColor * daylight * sunlight * (0.5 + silver * 0.3);
+}
+
+// Beer-Lambert extinction toward the sun through the same density used for sky rendering.
+fn clouds_getTransmittance(position: vec3f) -> f32 {
+  if (clouds.cover <= 0.0 || clouds.density <= 0.0) { return 1.0; }
+  var direction: vec3f = normalize(clouds.sunDirection);
+  if (direction.z <= 0.02) { return 1.0; }
+  var start: f32 = max((clouds.altitude - position.z) / direction.z, 0.0);
+  var end: f32 = min((clouds.altitude + clouds.thickness - position.z) / direction.z, 40000.0);
+  if (end <= start) { return 1.0; }
+  var stepLength: f32 = (end - start) / 16.0;
+  var opticalDepth: f32 = 0.0;
+  for (var sampleIndex: i32 = 0; sampleIndex < 16; sampleIndex++) {
+    opticalDepth += clouds_getDensity(position + direction * (start + (f32(sampleIndex) + 0.5) * stepLength)) * stepLength;
+  }
+  return exp(-opticalDepth * max(clouds.density, 0.0));
+}
+
+fn clouds_getColor(camera: vec3f, rayDirection: vec3f) -> vec4f {
+  if (clouds.cover <= 0.0 || clouds.density <= 0.0 || abs(rayDirection.z) < 0.0001) { return vec4f(0.0); }
+  let bottom = (clouds.altitude - camera.z) / rayDirection.z;
+  let top = (clouds.altitude + max(clouds.thickness, 1.0) - camera.z) / rayDirection.z;
+  let start = max(min(bottom, top), 0.0);
+  let end = min(max(bottom, top), 20000.0);
+  if (end <= start) { return vec4f(0.0); }
+  let jitter = valueNoise_hash(rayDirection.xy * 4096.0);
+  let stepLength = (end - start) / 64.0;
+  let sunDirection = normalize(clouds.sunDirection);
+  let daylight = smoothstep(-0.08, 0.18, sunDirection.z);
+  let silver = pow(max(dot(rayDirection, sunDirection), 0.0), 12.0);
+  var radiance = vec3f(0.0);
+  var transmittance = 1.0;
+  for (var sampleIndex = 0; sampleIndex < 64; sampleIndex++) {
+    let position = camera + rayDirection * (start + (f32(sampleIndex) + jitter) * stepLength);
+    let density = clouds_getDensity(position);
+    let sunDensity = clouds_getDensity(position + sunDirection * clouds.thickness * 0.28);
+    let alpha = 1.0 - exp(-density * max(clouds.density, 0.0) * stepLength);
+    let color = clouds_getLighting(density, sunDensity, daylight, silver);
+    radiance += transmittance * alpha * color;
+    transmittance *= 1.0 - alpha;
+  }
+  let distanceFade = 1.0 - smoothstep(10000.0, 20000.0, start);
+  return vec4f(radiance, 1.0 - transmittance) * distanceFade;
+}
+`
+};
+//# sourceMappingURL=clouds.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clouds.js","sourceRoot":"","sources":["../../../../src/modules/lighting/clouds/clouds.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAG5D,OAAO,EAAC,UAAU,EAAC,8CAA2C;AAuB9D,MAAM,gBAAgB,GAAkB;IACtC,KAAK,EAAE,IAAI;IACX,QAAQ,EAAE,IAAI;IACd,SAAS,EAAE,IAAI;IACf,KAAK,EAAE,IAAI;IACX,OAAO,EAAE,KAAK;IACd,IAAI,EAAE,CAAC;IACP,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;IACjB,YAAY,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC;IAC3B,QAAQ,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC;CAC1B,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI,EAAE,QAAQ;IACd,YAAY,EAAE,CAAC,UAAU,CAAC;IAC1B,YAAY,EAAE;QACZ,KAAK,EAAE,KAAK;QACZ,QAAQ,EAAE,KAAK;QACf,SAAS,EAAE,KAAK;QAChB,KAAK,EAAE,KAAK;QACZ,OAAO,EAAE,KAAK;QACd,IAAI,EAAE,KAAK;QACX,QAAQ,EAAE,WAAW;QACrB,YAAY,EAAE,WAAW;QACzB,QAAQ,EAAE,WAAW;KACtB;IACD,eAAe,EAAE,gBAAgB;IACjC,WAAW,CAAC,KAAK,GAAG,EAAE,EAAE,gBAAgB,GAAG,gBAAgB;QACzD,OAAO,EAAC,GAAG,gBAAgB,EAAE,GAAG,gBAAgB,EAAE,GAAG,KAAK,EAAC,CAAC;IAC9D,CAAC;IACD,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EpB;CAC2D,CAAC"}

package/dist/modules/lighting/firefly/firefly.cjs

@@ -0,0 +1,74 @@
+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 firefly_exports = {};
+__export(firefly_exports, {
+  firefly: () => firefly
+});
+module.exports = __toCommonJS(firefly_exports);
+const uniforms = { enabled: 0, time: 0, radius: 8, speed: 0.6, pulse: 0.85 };
+const firefly = {
+  name: "firefly",
+  uniformTypes: { enabled: "f32", time: "f32", radius: "f32", speed: "f32", pulse: "f32" },
+  defaultUniforms: uniforms,
+  getUniforms(props = {}, previous = uniforms) {
+    return { ...uniforms, ...previous, ...props };
+  },
+  source: `struct FireflyUniforms {enabled: f32, time: f32, radius: f32, speed: f32, pulse: f32};
+  @group(3) @binding(auto) var<uniform> firefly: FireflyUniforms;
+  fn firefly_getPosition(position: vec3f, seed: f32, time: f32) -> vec3f {
+    if (firefly.enabled <= 0.0) { return position; }
+    let phase = seed * 2.399963;
+    let travel = time * firefly.speed;
+    let offset = vec3f(sin(travel * 0.71 + phase) + sin(travel * 1.31 + phase * 1.7) * 0.35,
+      cos(travel * 0.83 + phase * 1.2) + sin(travel * 0.47 + phase * 2.3) * 0.4,
+      sin(travel * 0.59 + phase * 1.9) * 0.3);
+    return position + offset * firefly.radius * firefly.enabled;
+  }
+  fn firefly_getBrightness(seed: f32, time: f32) -> f32 {
+    if (firefly.enabled <= 0.0) { return 1.0; }
+    let phase = seed * 2.399963;
+    let pulse = pow(0.5 + 0.5 * sin(time * firefly.speed * (1.6 + fract(seed * 0.37)) + phase), 3.0);
+    return mix(1.0, mix(0.08, 1.0, pulse), firefly.pulse * firefly.enabled);
+  }`,
+  vs: `layout(std140) uniform fireflyUniforms {
+    float enabled;
+    float time;
+    float radius;
+    float speed;
+    float pulse;
+  } firefly;
+  vec3 firefly_getPosition(vec3 position, float seed, float time) {
+    if (firefly.enabled <= 0.0) { return position; }
+    float phase = seed * 2.399963;
+    float travel = time * firefly.speed;
+    vec3 offset = vec3(sin(travel * 0.71 + phase) + sin(travel * 1.31 + phase * 1.7) * 0.35,
+      cos(travel * 0.83 + phase * 1.2) + sin(travel * 0.47 + phase * 2.3) * 0.4,
+      sin(travel * 0.59 + phase * 1.9) * 0.3);
+    return position + offset * firefly.radius * firefly.enabled;
+  }
+  float firefly_getBrightness(float seed, float time) {
+    if (firefly.enabled <= 0.0) { return 1.0; }
+    float phase = seed * 2.399963;
+    float pulse = pow(0.5 + 0.5 * sin(time * firefly.speed * (1.6 + fract(seed * 0.37)) + phase), 3.0);
+    return mix(1.0, mix(0.08, 1.0, pulse), firefly.pulse * firefly.enabled);
+  }`
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  firefly
+});

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

@@ -0,0 +1,36 @@
+export type FireflyProps = {
+    enabled?: number;
+    time?: number;
+    radius?: number;
+    speed?: number;
+    pulse?: number;
+};
+export type FireflyUniforms = Required<FireflyProps>;
+/** Seeded smooth wandering and independently phased bioluminescence. Positions are in metres. */
+export declare const firefly: {
+    readonly name: "firefly";
+    readonly uniformTypes: {
+        readonly enabled: "f32";
+        readonly time: "f32";
+        readonly radius: "f32";
+        readonly speed: "f32";
+        readonly pulse: "f32";
+    };
+    readonly defaultUniforms: {
+        enabled: number;
+        time: number;
+        radius: number;
+        speed: number;
+        pulse: number;
+    };
+    readonly getUniforms: (props?: Partial<FireflyProps>, previous?: Required<FireflyProps> | undefined) => {
+        enabled: number;
+        time: number;
+        radius: number;
+        speed: number;
+        pulse: number;
+    };
+    readonly source: "struct FireflyUniforms {enabled: f32, time: f32, radius: f32, speed: f32, pulse: f32};\n  @group(3) @binding(auto) var<uniform> firefly: FireflyUniforms;\n  fn firefly_getPosition(position: vec3f, seed: f32, time: f32) -> vec3f {\n    if (firefly.enabled <= 0.0) { return position; }\n    let phase = seed * 2.399963;\n    let travel = time * firefly.speed;\n    let offset = vec3f(sin(travel * 0.71 + phase) + sin(travel * 1.31 + phase * 1.7) * 0.35,\n      cos(travel * 0.83 + phase * 1.2) + sin(travel * 0.47 + phase * 2.3) * 0.4,\n      sin(travel * 0.59 + phase * 1.9) * 0.3);\n    return position + offset * firefly.radius * firefly.enabled;\n  }\n  fn firefly_getBrightness(seed: f32, time: f32) -> f32 {\n    if (firefly.enabled <= 0.0) { return 1.0; }\n    let phase = seed * 2.399963;\n    let pulse = pow(0.5 + 0.5 * sin(time * firefly.speed * (1.6 + fract(seed * 0.37)) + phase), 3.0);\n    return mix(1.0, mix(0.08, 1.0, pulse), firefly.pulse * firefly.enabled);\n  }";
+    readonly vs: "layout(std140) uniform fireflyUniforms {\n    float enabled;\n    float time;\n    float radius;\n    float speed;\n    float pulse;\n  } firefly;\n  vec3 firefly_getPosition(vec3 position, float seed, float time) {\n    if (firefly.enabled <= 0.0) { return position; }\n    float phase = seed * 2.399963;\n    float travel = time * firefly.speed;\n    vec3 offset = vec3(sin(travel * 0.71 + phase) + sin(travel * 1.31 + phase * 1.7) * 0.35,\n      cos(travel * 0.83 + phase * 1.2) + sin(travel * 0.47 + phase * 2.3) * 0.4,\n      sin(travel * 0.59 + phase * 1.9) * 0.3);\n    return position + offset * firefly.radius * firefly.enabled;\n  }\n  float firefly_getBrightness(float seed, float time) {\n    if (firefly.enabled <= 0.0) { return 1.0; }\n    float phase = seed * 2.399963;\n    float pulse = pow(0.5 + 0.5 * sin(time * firefly.speed * (1.6 + fract(seed * 0.37)) + phase), 3.0);\n    return mix(1.0, mix(0.08, 1.0, pulse), firefly.pulse * firefly.enabled);\n  }";
+};
+//# sourceMappingURL=firefly.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"firefly.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/firefly/firefly.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;AAGrD,iGAAiG;AACjG,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;iBAVR,MAAM;cACT,MAAM;gBACJ,MAAM;eACP,MAAM;eACN,MAAM;;;;CAoDgD,CAAC"}

package/dist/modules/lighting/firefly/firefly.js

@@ -0,0 +1,53 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+const uniforms = { enabled: 0, time: 0, radius: 8, speed: 0.6, pulse: 0.85 };
+/** Seeded smooth wandering and independently phased bioluminescence. Positions are in metres. */
+export const firefly = {
+    name: 'firefly',
+    uniformTypes: { enabled: 'f32', time: 'f32', radius: 'f32', speed: 'f32', pulse: 'f32' },
+    defaultUniforms: uniforms,
+    getUniforms(props = {}, previous = uniforms) {
+        return { ...uniforms, ...previous, ...props };
+    },
+    source: `struct FireflyUniforms {enabled: f32, time: f32, radius: f32, speed: f32, pulse: f32};
+  @group(3) @binding(auto) var<uniform> firefly: FireflyUniforms;
+  fn firefly_getPosition(position: vec3f, seed: f32, time: f32) -> vec3f {
+    if (firefly.enabled <= 0.0) { return position; }
+    let phase = seed * 2.399963;
+    let travel = time * firefly.speed;
+    let offset = vec3f(sin(travel * 0.71 + phase) + sin(travel * 1.31 + phase * 1.7) * 0.35,
+      cos(travel * 0.83 + phase * 1.2) + sin(travel * 0.47 + phase * 2.3) * 0.4,
+      sin(travel * 0.59 + phase * 1.9) * 0.3);
+    return position + offset * firefly.radius * firefly.enabled;
+  }
+  fn firefly_getBrightness(seed: f32, time: f32) -> f32 {
+    if (firefly.enabled <= 0.0) { return 1.0; }
+    let phase = seed * 2.399963;
+    let pulse = pow(0.5 + 0.5 * sin(time * firefly.speed * (1.6 + fract(seed * 0.37)) + phase), 3.0);
+    return mix(1.0, mix(0.08, 1.0, pulse), firefly.pulse * firefly.enabled);
+  }`,
+    vs: `layout(std140) uniform fireflyUniforms {
+    float enabled;
+    float time;
+    float radius;
+    float speed;
+    float pulse;
+  } firefly;
+  vec3 firefly_getPosition(vec3 position, float seed, float time) {
+    if (firefly.enabled <= 0.0) { return position; }
+    float phase = seed * 2.399963;
+    float travel = time * firefly.speed;
+    vec3 offset = vec3(sin(travel * 0.71 + phase) + sin(travel * 1.31 + phase * 1.7) * 0.35,
+      cos(travel * 0.83 + phase * 1.2) + sin(travel * 0.47 + phase * 2.3) * 0.4,
+      sin(travel * 0.59 + phase * 1.9) * 0.3);
+    return position + offset * firefly.radius * firefly.enabled;
+  }
+  float firefly_getBrightness(float seed, float time) {
+    if (firefly.enabled <= 0.0) { return 1.0; }
+    float phase = seed * 2.399963;
+    float pulse = pow(0.5 + 0.5 * sin(time * firefly.speed * (1.6 + fract(seed * 0.37)) + phase), 3.0);
+    return mix(1.0, mix(0.08, 1.0, pulse), firefly.pulse * firefly.enabled);
+  }`
+};
+//# sourceMappingURL=firefly.js.map