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

package/src/modules/lighting/firefly/firefly.ts

@@ -0,0 +1,64 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type FireflyProps = {
+  enabled?: number;
+  time?: number;
+  radius?: number;
+  speed?: number;
+  pulse?: number;
+};
+export type FireflyUniforms = Required<FireflyProps>;
+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);
+  }`
+} as const satisfies ShaderModule<FireflyProps, FireflyUniforms>;

package/src/modules/lighting/globe-clouds/globe-clouds.ts

@@ -0,0 +1,124 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {clouds} from '../clouds/clouds';
+
+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 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);
+}
+`
+} as const satisfies ShaderModule<GlobeCloudProps, GlobeCloudUniforms>;

package/src/modules/lighting/gouraud-material/gouraud-material.ts

@@ -0,0 +1,55 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {NumberArray3} from '@math.gl/core';
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {floatColors} from '../../color/float-colors';
+import {lighting} from '../lights/lighting';
+import {PHONG_VS, PHONG_FS} from '../phong-material/phong-shaders-glsl';
+import {PHONG_WGSL} from '../phong-material/phong-shaders-wgsl';
+
+export type GouraudMaterialProps = {
+  unlit?: boolean;
+  ambient?: number;
+  diffuse?: number;
+  /** Specularity exponent */
+  shininess?: number;
+  specularColor?: [number, number, number];
+};
+
+const DEFAULT_SPECULAR_COLOR: NumberArray3 = [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: ShaderModule<GouraudMaterialProps> = {
+  props: {} as GouraudMaterialProps,
+
+  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: GouraudMaterialProps) {
+    return {...gouraudMaterial.defaultUniforms, ...props};
+  }
+};

package/src/modules/lighting/height-fog/README.md

@@ -0,0 +1,36 @@
+# heightFog
+
+Analytic fog extinction for fragment shaders in GLSL and WGSL. Call
+`heightFog_getColor(color, position, cameraPosition)` with both positions in the same
+local east/north/up metre coordinates. It preserves alpha and mixes linear RGB with
+`heightFog.color`. `heightFog_getTransmittance(position, cameraPosition)` returns the
+unscattered fraction for custom compositing.
+
+`density` is base extinction per metre, `baseHeight` is in metres, and `heightFalloff`
+is inverse metres. Density stays constant below the base and decays exponentially above
+it. Zero density disables fog; zero falloff gives uniform distance fog. The ray integral
+handles horizontal rays and rays crossing the base without a marching loop or history.
+This is a constant-color atmosphere approximation, without shadowing or directional scattering.
+
+
+`heightFogFunctions` exposes the same calculation without a uniform block. Its
+`heightFog_getRayTransmittance(rayLength, cameraHeight, fragmentHeight, density, baseHeight, heightFalloff)`
+function accepts scalar metre-space ray length and heights, allowing callers to choose an up
+axis and supply their own uniform layout. The `heightFog` material module depends on it, as does
+`@luma.gl/engine/effects`' analytic height-fog pass. The two paths therefore share the density integral.
+
+
+For drifting wisps, set `variation` from 0 to 1, `wispScale` in metres, `velocity`
+in metres per second, and `time` in seconds. Defaults keep the uniform analytic path.
+With variation enabled, twelve ray segments sample warped, multiscale world-space
+noise; each segment retains the analytic height integral. This is a bounded-cost density
+approximation, not a volumetric fluid simulation. Pausing time freezes it; zero velocity
+keeps a static, nonuniform field. Both material and depth-pass fog call the same
+`heightFog_getSpatialTransmittance` helper. It needs no noise textures or temporal history.
+The tint remains constant; density varies. Very long rays through small wisps can undersample
+this fixed twelve-segment approximation, so choose bank sizes appropriate to the scene.
+
+Set `evolutionSpeed` above zero for gentle internal deformation in addition to advection.
+Zero retains the rigid density field. Applications control time; freeze it to pause both
+forms of motion. When changing drift speed interactively, integrate distance over time
+instead of multiplying the new speed by the entire elapsed clock.

package/src/modules/lighting/height-fog/height-fog-functions.ts

@@ -0,0 +1,116 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {valueNoise} from '../../math/value-noise/value-noise';
+
+/** 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;
+}
+
+`
+} as const satisfies ShaderModule;

package/src/modules/lighting/height-fog/height-fog.ts

@@ -0,0 +1,96 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {heightFogFunctions} from './height-fog-functions';
+
+export type HeightFogUniforms = {
+  color: [number, number, number];
+  density: number;
+  baseHeight: number;
+  heightFalloff: number;
+  /** Spatial density variation, from uniform (0) to wispy (1). */
+  variation: number;
+  /** Horizontal size of fog banks in metres. */
+  wispScale: number;
+  /** Fog advection in metres per second in the same frame as the positions. */
+  velocity: [number, number, number];
+  time: number;
+  /** Rate of internal wisp deformation; zero keeps a rigidly advected field. */
+  evolutionSpeed: number;
+};
+export type HeightFogProps = Partial<HeightFogUniforms>;
+
+/** Analytic extinction through a height-dependent atmosphere. All distances are metres. */
+export const heightFog = {
+  name: 'heightFog',
+  dependencies: [heightFogFunctions],
+  bindingLayout: [{name: 'heightFog', group: 3}],
+  uniformTypes: {
+    color: 'vec3<f32>',
+    density: 'f32',
+    baseHeight: 'f32',
+    heightFalloff: 'f32',
+    variation: 'f32',
+    wispScale: 'f32',
+    velocity: 'vec3<f32>',
+    time: 'f32',
+    evolutionSpeed: 'f32'
+  },
+  defaultUniforms: {
+    color: [0.65, 0.72, 0.78],
+    density: 0,
+    baseHeight: 0,
+    heightFalloff: 0.01,
+    variation: 0,
+    wispScale: 160,
+    velocity: [0, 0, 0],
+    time: 0,
+    evolutionSpeed: 0
+  },
+  getUniforms(props: HeightFogProps = {}) {
+    return props;
+  },
+  fs: /* glsl */ `
+layout(std140) uniform heightFogUniforms {
+  vec3 color;
+  float density;
+  float baseHeight;
+  float heightFalloff;
+  float variation;
+  float wispScale;
+  vec3 velocity;
+  float time;
+  float evolutionSpeed;
+} heightFog;
+float heightFog_getTransmittance(vec3 position, vec3 cameraPosition) {
+  return heightFog_getSpatialTransmittance(cameraPosition, position, vec3(0.0, 0.0, 1.0),
+    heightFog.density, heightFog.baseHeight, heightFog.heightFalloff, heightFog.variation, heightFog.wispScale, heightFog.time, heightFog.velocity, heightFog.evolutionSpeed);
+}
+vec4 heightFog_getColor(vec4 color, vec3 position, vec3 cameraPosition) {
+  return vec4(mix(heightFog.color, color.rgb, heightFog_getTransmittance(position, cameraPosition)), color.a);
+}
+`,
+  source: /* wgsl */ `
+struct heightFogUniforms {
+  color: vec3<f32>,
+  density: f32,
+  baseHeight: f32,
+  heightFalloff: f32,
+  variation: f32,
+  wispScale: f32,
+  velocity: vec3<f32>,
+  time: f32,
+  evolutionSpeed: f32,
+};
+@group(3) @binding(auto) var<uniform> heightFog: heightFogUniforms;
+fn heightFog_getTransmittance(position: vec3<f32>, cameraPosition: vec3<f32>) -> f32 {
+  return heightFog_getSpatialTransmittance(cameraPosition, position, vec3<f32>(0.0, 0.0, 1.0),
+    heightFog.density, heightFog.baseHeight, heightFog.heightFalloff, heightFog.variation, heightFog.wispScale, heightFog.time, heightFog.velocity, heightFog.evolutionSpeed);
+}
+fn heightFog_getColor(color: vec4<f32>, position: vec3<f32>, cameraPosition: vec3<f32>) -> vec4<f32> {
+  return vec4<f32>(mix(heightFog.color, color.rgb, heightFog_getTransmittance(position, cameraPosition)), color.a);
+}
+`
+} as const satisfies ShaderModule<HeightFogProps, HeightFogUniforms>;

package/src/modules/lighting/ibl/ibl.ts

@@ -0,0 +1,43 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type IBLBindings<TextureT = unknown> = {
+  pbr_diffuseEnvSampler?: TextureT | null;
+  pbr_specularEnvSampler?: TextureT | null;
+  pbr_brdfLUT?: TextureT | null;
+};
+
+export const iblWGSL = /* wgsl */ `\
+#ifdef USE_IBL
+@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;
+@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;
+#endif
+`;
+
+export const iblGLSL = /* glsl */ `\
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+`;
+
+export const ibl = {
+  name: 'ibl',
+  firstBindingSlot: 32,
+  bindingLayout: [
+    {name: 'pbr_diffuseEnvSampler', group: 2},
+    {name: 'pbr_specularEnvSampler', group: 2},
+    {name: 'pbr_brdfLUT', group: 2}
+  ],
+  source: iblWGSL,
+  vs: iblGLSL,
+  fs: iblGLSL
+} as const satisfies ShaderModule<IBLBindings, {}, IBLBindings>;

package/src/modules/lighting/lambert-material/lambert-material.ts

@@ -0,0 +1,42 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {lighting} from '../lights/lighting';
+import {LAMBERT_WGSL} from './lambert-shaders-wgsl';
+import {LAMBERT_VS, LAMBERT_FS} from './lambert-shaders-glsl';
+
+/** Uniform props for the built-in diffuse-only Lambert material model. */
+export type LambertMaterialProps = {
+  unlit?: boolean;
+  ambient?: number;
+  diffuse?: number;
+};
+
+/** A matte material model that applies diffuse-only Lambert lighting per fragment. */
+export const lambertMaterial: ShaderModule<LambertMaterialProps> = {
+  name: 'lambertMaterial',
+  firstBindingSlot: 0,
+  bindingLayout: [{name: 'lambertMaterial', group: 3}],
+  dependencies: [lighting],
+  source: LAMBERT_WGSL,
+  vs: LAMBERT_VS,
+  fs: LAMBERT_FS,
+  defines: {
+    LIGHTING_FRAGMENT: true
+  },
+  uniformTypes: {
+    unlit: 'i32',
+    ambient: 'f32',
+    diffuse: 'f32'
+  },
+  defaultUniforms: {
+    unlit: false,
+    ambient: 0.35,
+    diffuse: 0.6
+  },
+  getUniforms(props?: LambertMaterialProps) {
+    return {...lambertMaterial.defaultUniforms, ...props};
+  }
+};

package/src/modules/lighting/lambert-material/lambert-shaders-glsl.ts

@@ -0,0 +1,61 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export const LAMBERT_VS = /* glsl */ `\
+layout(std140) uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+`;
+
+export const LAMBERT_FS = /* glsl */ `\
+layout(std140) uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+
+vec3 lambert_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 normal_worldspace, vec3 color) {
+  float lambertian = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * material.diffuse * surfaceColor * color;
+}
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
+  vec3 lightColor = surfaceColor;
+
+  if (material.unlit) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lambert_getLightColor(surfaceColor, light_direction, normal_worldspace, pointLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 light_position_worldspace = spotLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lambert_getLightColor(surfaceColor, light_direction, normal_worldspace, spotLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lambert_getLightColor(surfaceColor, -directionalLight.direction, normal_worldspace, directionalLight.color);
+  }
+
+  return lightColor;
+}
+`;