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

package/src/modules/geospatial/dggs/dggs.ts

@@ -0,0 +1,12 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {dggsWGSL} from './dggs-wgsl';
+
+/** WGSL helpers for 64-bit DGGS cell IDs encoded as two u32 words. */
+export const dggs = {
+  name: 'dggs',
+  source: dggsWGSL
+} as const satisfies ShaderModule<{}, {}>;

package/src/modules/lighting/area-lighting/area-light-types.ts

@@ -0,0 +1,71 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumberArray3} from '@math.gl/core';
+import {normalizeByteColor3} from '../../../lib/color/normalize-byte-colors';
+
+/** A uniformly emitting, one-sided rectangle or disk in world space. */
+export type AreaLight = {
+  type: 'rect' | 'disk';
+  position: Readonly<NumberArray3>;
+  /** Orthogonal world-space half-extent vectors; disk vectors represent radii. */
+  halfAxisX: Readonly<NumberArray3>;
+  halfAxisY: Readonly<NumberArray3>;
+  /** World-space emitting normal, corresponding to local -Z. */
+  normal: Readonly<NumberArray3>;
+  color?: Readonly<NumberArray3>;
+  /** Luminance in nits (cd/m²), independent of surface area. */
+  intensity?: number;
+};
+
+export type AreaLightUniform = {
+  color: Readonly<NumberArray3>;
+  position: Readonly<NumberArray3>;
+  halfAxisX: Readonly<NumberArray3>;
+  halfAxisY: Readonly<NumberArray3>;
+  normal: Readonly<NumberArray3>;
+  disk: number;
+};
+export const MAX_AREA_LIGHTS = 4;
+export function makeEmptyLight(): AreaLightUniform {
+  return {
+    color: [0, 0, 0],
+    position: [0, 0, 0],
+    halfAxisX: [0, 0, 0],
+    halfAxisY: [0, 0, 0],
+    normal: [0, 0, -1],
+    disk: 0
+  };
+}
+
+export const AREA_LIGHT_UNIFORM_TYPE = {
+  color: 'vec3<f32>',
+  position: 'vec3<f32>',
+  halfAxisX: 'vec3<f32>',
+  halfAxisY: 'vec3<f32>',
+  normal: 'vec3<f32>',
+  disk: 'i32'
+} as const;
+
+export function packAreaLights(
+  lights: readonly AreaLight[],
+  useByteColors = false
+): AreaLightUniform[] {
+  return Array.from({length: MAX_AREA_LIGHTS}, (_, index) => {
+    const light = lights[index];
+    if (!light) return makeEmptyLight();
+    const color = normalizeByteColor3(
+      light.color || (useByteColors ? [255, 255, 255] : [1, 1, 1]),
+      useByteColors
+    );
+    return {
+      position: light.position,
+      halfAxisX: light.halfAxisX,
+      halfAxisY: light.halfAxisY,
+      normal: light.normal,
+      disk: light.type === 'disk' ? 1 : 0,
+      color: color.map(component => component * (light.intensity ?? 1000)) as NumberArray3
+    };
+  });
+}

package/src/modules/lighting/area-lighting/area-lighting-shaders.ts

@@ -0,0 +1,72 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export const areaLightingGLSL = /* glsl */ `
+layout(std140) uniform areaLightingUniforms {
+  int lightCount;
+  int sampleCount;
+  AreaLightUniform lights[4];
+} areaLighting;
+
+int areaLighting_getLightCount() { return lighting.areaLightCount + areaLighting.lightCount; }
+AreaLightUniform areaLighting_getLight(int index) {
+  if (index < lighting.areaLightCount) return lighting.areaLights[index];
+  return areaLighting.lights[index - lighting.areaLightCount];
+}
+
+PointLight areaLighting_getSample(int lightIndex, int sampleIndex, vec3 receiver) {
+  AreaLightUniform light = areaLighting_getLight(lightIndex);
+  int grid = int(sqrt(float(areaLighting.sampleCount)));
+  vec2 coordinate = (vec2(float(sampleIndex % grid), float(sampleIndex / grid)) + 0.5) / float(grid);
+  float area = 4.0 * length(light.halfAxisX) * length(light.halfAxisY);
+  if (light.disk != 0) {
+    float radius = sqrt(coordinate.y);
+    float angle = coordinate.x * 6.28318530718;
+    coordinate = radius * vec2(cos(angle), sin(angle));
+    area *= 0.785398163397;
+  } else {
+    coordinate = coordinate * 2.0 - 1.0;
+  }
+  vec3 position = light.position + coordinate.x * light.halfAxisX + coordinate.y * light.halfAxisY;
+  vec3 displacement = receiver - position;
+  float distanceSquared = max(dot(displacement, displacement), 0.000001);
+  float emissionCosine = max(dot(light.normal, displacement * inversesqrt(distanceSquared)), 0.0);
+  return PointLight(light.color * (area * emissionCosine / (float(areaLighting.sampleCount) * distanceSquared)), position, vec3(1.0, 0.0, 0.0));
+}
+`;
+
+export const areaLightingWGSL = /* wgsl */ `
+struct AreaLightingUniforms {
+  lightCount: i32,
+  sampleCount: i32,
+  lights: array<AreaLightUniform, 4>,
+};
+@group(2) @binding(auto) var<uniform> areaLighting: AreaLightingUniforms;
+
+fn areaLighting_getLightCount() -> i32 { return lighting.areaLightCount + areaLighting.lightCount; }
+fn areaLighting_getLight(index: i32) -> AreaLightUniform {
+  if (index < lighting.areaLightCount) { return lighting.areaLights[index]; }
+  return areaLighting.lights[index - lighting.areaLightCount];
+}
+
+fn areaLighting_getSample(lightIndex: i32, sampleIndex: i32, receiver: vec3f) -> PointLight {
+  let light = areaLighting_getLight(lightIndex);
+  let grid = i32(sqrt(f32(areaLighting.sampleCount)));
+  var coordinate = (vec2f(f32(sampleIndex % grid), f32(sampleIndex / grid)) + 0.5) / f32(grid);
+  var area = 4.0 * length(light.halfAxisX) * length(light.halfAxisY);
+  if (light.disk != 0) {
+    let radius = sqrt(coordinate.y);
+    let angle = coordinate.x * 6.28318530718;
+    coordinate = radius * vec2f(cos(angle), sin(angle));
+    area *= 0.785398163397;
+  } else {
+    coordinate = coordinate * 2.0 - 1.0;
+  }
+  let position = light.position + coordinate.x * light.halfAxisX + coordinate.y * light.halfAxisY;
+  let displacement = receiver - position;
+  let distanceSquared = max(dot(displacement, displacement), 0.000001);
+  let emissionCosine = max(dot(light.normal, displacement * inverseSqrt(distanceSquared)), 0.0);
+  return PointLight(light.color * (area * emissionCosine / (f32(areaLighting.sampleCount) * distanceSquared)), position, vec3f(1.0, 0.0, 0.0));
+}
+`;

package/src/modules/lighting/area-lighting/area-lighting.ts

@@ -0,0 +1,63 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {lighting} from '../lights/lighting';
+import {areaLTCGLSL, areaLTCWGSL} from './ltc-shaders';
+import {areaLightingGLSL, areaLightingWGSL} from './area-lighting-shaders';
+
+export type {AreaLight} from './area-light-types';
+import {
+  type AreaLight,
+  type AreaLightUniform,
+  MAX_AREA_LIGHTS,
+  AREA_LIGHT_UNIFORM_TYPE,
+  packAreaLights,
+  makeEmptyLight
+} from './area-light-types';
+
+export type AreaLightingProps = {
+  lights?: readonly AreaLight[];
+  useByteColors?: boolean;
+  sampleCount?: 16 | 64 | 256;
+};
+type AreaLightingUniforms = {
+  lightCount: number;
+  sampleCount: number;
+  lights: readonly AreaLightUniform[];
+};
+
+/** Area-light compatibility props and shader resources for LTC or numerical reference integration. */
+export const areaLighting = {
+  name: 'areaLighting',
+  props: {} as AreaLightingProps,
+  uniforms: {} as AreaLightingUniforms,
+  dependencies: [lighting],
+  defaultUniforms: {
+    lightCount: 0,
+    sampleCount: 64,
+    lights: Array.from({length: MAX_AREA_LIGHTS}, makeEmptyLight)
+  },
+  uniformTypes: {
+    lightCount: 'i32',
+    sampleCount: 'i32',
+    lights: [AREA_LIGHT_UNIFORM_TYPE, MAX_AREA_LIGHTS]
+  },
+  bindingLayout: [
+    {name: 'areaLighting', group: 2},
+    {name: 'areaLTCMatrix', group: 2},
+    {name: 'areaLTCAmplitude', group: 2}
+  ],
+  source: areaLightingWGSL + areaLTCWGSL,
+  vs: areaLightingGLSL + areaLTCGLSL,
+  fs: areaLightingGLSL + areaLTCGLSL,
+  getUniforms(props: AreaLightingProps = {}): AreaLightingUniforms {
+    const source = props.lights || [];
+    return {
+      lightCount: Math.min(source.length, MAX_AREA_LIGHTS),
+      sampleCount: props.sampleCount || 64,
+      lights: packAreaLights(source, props.useByteColors)
+    };
+  }
+} as const satisfies ShaderModule<AreaLightingProps, AreaLightingUniforms, {}>;

package/src/modules/lighting/area-lighting/ltc-shaders.ts

@@ -0,0 +1,163 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export const areaLTCGLSL = /* glsl */ `
+#ifdef USE_AREA_LIGHT_LTC
+uniform sampler2D areaLTCMatrix;
+uniform sampler2D areaLTCAmplitude;
+// GGX fit and Fresnel decomposition: Heitz, Dupuy, Hill and Neubelt, SIGGRAPH 2016.
+// Explicit bilinear lookup avoids requiring filterable float32 textures on WebGPU.
+vec4 areaLTC_lookup(sampler2D table, vec2 coordinate) {
+  vec2 position = clamp(coordinate, 0.0, 1.0) * 63.0;
+  ivec2 lower = ivec2(floor(position));
+  ivec2 upper = min(lower + ivec2(1), ivec2(63));
+  vec2 fraction = fract(position);
+  return mix(mix(texelFetch(table, lower, 0), texelFetch(table, ivec2(upper.x, lower.y), 0), fraction.x),
+             mix(texelFetch(table, ivec2(lower.x, upper.y), 0), texelFetch(table, upper, 0), fraction.x), fraction.y);
+}
+
+// Exact horizon clipping followed by the spherical polygon edge integral.
+// Disk support uses an inscribed 32-gon; the area error is below 0.65 percent.
+float areaLTC_integral(AreaLightUniform light, vec3 receiver, vec3 normal, vec3 view, mat3 inverseTransform) {
+  if (dot(light.normal, receiver - light.position) <= 0.0) return 0.0;
+  vec3 tangent = view - normal * dot(view, normal);
+  if (dot(tangent, tangent) < 1e-8) {
+    vec3 axis = abs(normal.z) < 0.9 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+    tangent = cross(axis, normal);
+  }
+  tangent = normalize(tangent);
+  mat3 transform = inverseTransform * transpose(mat3(tangent, -cross(normal, tangent), normal));
+  vec3 vertices[33];
+  int count = light.disk != 0 ? 32 : 4;
+  for (int index = 0; index < 32; index++) {
+    if (index >= count) break;
+    vec2 coordinate;
+    if (light.disk != 0) {
+      float angle = float(index) * 6.28318530718 / 32.0;
+      coordinate = vec2(cos(angle), -sin(angle));
+    } else {
+      coordinate = index == 0 ? vec2(1.0, -1.0) : index == 1 ? vec2(-1.0, -1.0) : index == 2 ? vec2(-1.0, 1.0) : vec2(1.0, 1.0);
+    }
+    vertices[index] = transform * (light.position + coordinate.x * light.halfAxisX + coordinate.y * light.halfAxisY - receiver);
+  }
+  vec3 clipped[34];
+  int clippedCount = 0;
+  for (int index = 0; index < 32; index++) {
+    if (index >= count) break;
+    vec3 start = vertices[index];
+    vec3 end = vertices[(index + 1) % count];
+    if (start.z > 0.0) { clipped[clippedCount] = start; clippedCount++; }
+    if ((start.z > 0.0) != (end.z > 0.0)) {
+      clipped[clippedCount] = mix(start, end, start.z / (start.z - end.z));
+      clippedCount++;
+    }
+  }
+  if (clippedCount < 3) return 0.0;
+  vec3 integral = vec3(0.0);
+  for (int index = 0; index < 34; index++) {
+    if (index >= clippedCount) break;
+    vec3 start = normalize(clipped[index]);
+    vec3 end = normalize(clipped[(index + 1) % clippedCount]);
+    vec3 edge = cross(start, end);
+    float sine = length(edge);
+    if (sine > 1e-7) integral += edge * (acos(clamp(dot(start, end), -1.0, 1.0)) / sine);
+  }
+  return min(abs(integral.z) / 6.28318530718, 1.0);
+}
+
+vec3 areaLTC_specular(AreaLightUniform light, vec3 receiver, vec3 normal, vec3 view, float roughness, vec3 reflectance0, vec3 reflectance90) {
+  vec2 coordinate = vec2(roughness, sqrt(1.0 - clamp(dot(normal, view), 0.0, 1.0)));
+  vec4 coefficients = areaLTC_lookup(areaLTCMatrix, coordinate);
+  vec4 amplitude = areaLTC_lookup(areaLTCAmplitude, coordinate);
+  mat3 inverseTransform = mat3(vec3(coefficients.x, 0.0, coefficients.y), vec3(0.0, 1.0, 0.0), vec3(coefficients.z, 0.0, coefficients.w));
+  vec3 fresnel = reflectance0 * amplitude.x + (reflectance90 - reflectance0) * amplitude.y;
+  return light.color * fresnel * areaLTC_integral(light, receiver, normal, view, inverseTransform);
+}
+
+vec3 areaLTC_evaluate(int index, vec3 receiver, vec3 normal, vec3 view, float roughness, vec3 diffuseColor, vec3 reflectance0, vec3 reflectance90) {
+  AreaLightUniform light = areaLighting_getLight(index);
+  float diffuseIntegral = areaLTC_integral(light, receiver, normal, view, mat3(1.0));
+  return light.color * diffuseColor * (vec3(1.0) - reflectance0) * diffuseIntegral +
+    areaLTC_specular(light, receiver, normal, view, roughness, reflectance0, reflectance90);
+}
+#endif
+`;
+
+export const areaLTCWGSL = /* wgsl */ `
+#ifdef USE_AREA_LIGHT_LTC
+@group(2) @binding(auto) var areaLTCMatrix: texture_2d<f32>;
+@group(2) @binding(auto) var areaLTCAmplitude: texture_2d<f32>;
+fn areaLTC_lookup(table: texture_2d<f32>, coordinate: vec2f) -> vec4f {
+  let position = clamp(coordinate, vec2f(0.0), vec2f(1.0)) * 63.0;
+  let lower = vec2i(floor(position));
+  let upper = min(lower + vec2i(1), vec2i(63));
+  let fraction = fract(position);
+  return mix(mix(textureLoad(table, lower, 0), textureLoad(table, vec2i(upper.x, lower.y), 0), fraction.x),
+             mix(textureLoad(table, vec2i(lower.x, upper.y), 0), textureLoad(table, upper, 0), fraction.x), fraction.y);
+}
+fn areaLTC_integral(light: AreaLightUniform, receiver: vec3f, normal: vec3f, view: vec3f, inverseTransform: mat3x3f) -> f32 {
+  if (dot(light.normal, receiver - light.position) <= 0.0) { return 0.0; }
+  var tangent = view - normal * dot(view, normal);
+  if (dot(tangent, tangent) < 1e-8) {
+    let axis = select(vec3f(0.0, 1.0, 0.0), vec3f(0.0, 0.0, 1.0), abs(normal.z) < 0.9);
+    tangent = cross(axis, normal);
+  }
+  tangent = normalize(tangent);
+  let transform = inverseTransform * transpose(mat3x3f(tangent, -cross(normal, tangent), normal));
+  var vertices: array<vec3f, 33>;
+  let count = select(4, 32, light.disk != 0);
+  for (var index = 0; index < 32; index++) {
+    if (index >= count) { break; }
+    var coordinate: vec2f;
+    if (light.disk != 0) {
+      let angle = f32(index) * 6.28318530718 / 32.0;
+      coordinate = vec2f(cos(angle), -sin(angle));
+    } else {
+      coordinate = vec2f(1.0, 1.0);
+      if (index == 0) { coordinate = vec2f(1.0, -1.0); }
+      if (index == 1) { coordinate = vec2f(-1.0, -1.0); }
+      if (index == 2) { coordinate = vec2f(-1.0, 1.0); }
+    }
+    vertices[index] = transform * (light.position + coordinate.x * light.halfAxisX + coordinate.y * light.halfAxisY - receiver);
+  }
+  var clipped: array<vec3f, 34>;
+  var clippedCount = 0;
+  for (var index = 0; index < 32; index++) {
+    if (index >= count) { break; }
+    let start = vertices[index];
+    let end = vertices[(index + 1) % count];
+    if (start.z > 0.0) { clipped[clippedCount] = start; clippedCount++; }
+    if ((start.z > 0.0) != (end.z > 0.0)) {
+      clipped[clippedCount] = mix(start, end, start.z / (start.z - end.z));
+      clippedCount++;
+    }
+  }
+  if (clippedCount < 3) { return 0.0; }
+  var integral = vec3f(0.0);
+  for (var index = 0; index < 34; index++) {
+    if (index >= clippedCount) { break; }
+    let start = normalize(clipped[index]);
+    let end = normalize(clipped[(index + 1) % clippedCount]);
+    let edge = cross(start, end);
+    let sine = length(edge);
+    if (sine > 1e-7) { integral += edge * (acos(clamp(dot(start, end), -1.0, 1.0)) / sine); }
+  }
+  return min(abs(integral.z) / 6.28318530718, 1.0);
+}
+fn areaLTC_specular(light: AreaLightUniform, receiver: vec3f, normal: vec3f, view: vec3f, roughness: f32, reflectance0: vec3f, reflectance90: vec3f) -> vec3f {
+  let coordinate = vec2f(roughness, sqrt(1.0 - clamp(dot(normal, view), 0.0, 1.0)));
+  let coefficients = areaLTC_lookup(areaLTCMatrix, coordinate);
+  let amplitude = areaLTC_lookup(areaLTCAmplitude, coordinate);
+  let inverseTransform = mat3x3f(vec3f(coefficients.x, 0.0, coefficients.y), vec3f(0.0, 1.0, 0.0), vec3f(coefficients.z, 0.0, coefficients.w));
+  let fresnel = reflectance0 * amplitude.x + (reflectance90 - reflectance0) * amplitude.y;
+  return light.color * fresnel * areaLTC_integral(light, receiver, normal, view, inverseTransform);
+}
+fn areaLTC_evaluate(index: i32, receiver: vec3f, normal: vec3f, view: vec3f, roughness: f32, diffuseColor: vec3f, reflectance0: vec3f, reflectance90: vec3f) -> vec3f {
+  let light = areaLighting_getLight(index);
+  let diffuseIntegral = areaLTC_integral(light, receiver, normal, view, mat3x3f(vec3f(1.0,0.0,0.0),vec3f(0.0,1.0,0.0),vec3f(0.0,0.0,1.0)));
+  return light.color * diffuseColor * (vec3f(1.0) - reflectance0) * diffuseIntegral +
+    areaLTC_specular(light, receiver, normal, view, roughness, reflectance0, reflectance90);
+}
+#endif
+`;

package/src/modules/lighting/atmosphere/README.md

@@ -0,0 +1,25 @@
+# atmosphere
+
+Portable GLSL/WGSL single-scattering Rayleigh/Mie sky and aerial perspective. The sun direction,
+camera, and surface positions use a local east/north/up frame in metres, with z = altitude.
+The analytic planet is a sphere with `planetRadius` (default 6,371,000 m); the atmosphere
+extends 100 km above it. This is a local tangent-frame renderer, rather than a globe adapter.
+
+`atmosphere_getSkyColor(camera, normalizedDirection)` returns exposure-mapped sky RGB.
+`atmosphere_getColor(color, position, camera)` applies atmospheric extinction and in-scattering
+to geometry, preserving alpha. Set `enabled` to zero to leave geometry untouched.
+`atmosphere_getScattering` returns linear radiance and RGB transmittance for applications with
+their own HDR compositor. `sunIntensity`, `rayleigh`, `haze` and `exposure` control illumination,
+molecular scattering, aerosol scattering, and display exposure respectively. `groundColor`
+sets an approximate diffuse ground boundary beneath the horizon. A nonzero
+`sunDirection` is required. Incremental uniform updates preserve previous values.
+
+The fixed integration uses twelve view samples and four sunlight samples. Planet occlusion
+removes sunlight from the night side. The implementation omits multiple scattering, ozone,
+terrain shadows and cloud attenuation of atmospheric light; it is not a spectral atmosphere
+model. Long near-horizon paths and very low sunlight can undersample density. Use separate
+celestial layers for disks; this module provides the scattering halo.
+
+`AtmosphereLayer` supplies shared perspective camera rays, far depth, picking exclusion and
+premultiplied opacity for deck.gl flat maps on WebGPU and WebGL2. Draw it before SunLayer,
+MoonLayer, CloudLayer and opaque scene layers. Orthographic and globe views are skipped.

package/src/modules/lighting/atmosphere/atmosphere.ts

@@ -0,0 +1,246 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type AtmosphereUniforms = {
+  enabled: number;
+  /** Direction toward the sun in a local east/north/up frame; must be nonzero. */
+  sunDirection: [number, number, number];
+  sunIntensity: number;
+  /** Aerosol and molecular scattering multipliers. */
+  haze: number;
+  rayleigh: number;
+  /** Planet radius in metres. Positions use a local tangent frame, with z = altitude. */
+  planetRadius: number;
+  exposure: number;
+  /** Diffuse ground boundary beneath the horizon, in linear RGB. */
+  groundColor: [number, number, number];
+};
+export type AtmosphereProps = Partial<AtmosphereUniforms>;
+const DEFAULT_UNIFORMS: AtmosphereUniforms = {
+  enabled: 1,
+  sunDirection: [0, 0.8, 0.6],
+  sunIntensity: 20,
+  haze: 1,
+  rayleigh: 1,
+  planetRadius: 6371000,
+  exposure: 1,
+  groundColor: [0.18, 0.17, 0.14]
+};
+
+/** Single-scattering Rayleigh/Mie sky and aerial perspective. Distances are metres.
+ * Includes a spherical planet's solar occlusion, without multiple scattering or ozone.
+ */
+export const atmosphere = {
+  name: 'atmosphere',
+  uniformTypes: {
+    enabled: 'f32',
+    sunDirection: 'vec3<f32>',
+    sunIntensity: 'f32',
+    haze: 'f32',
+    rayleigh: 'f32',
+    planetRadius: 'f32',
+    exposure: 'f32',
+    groundColor: 'vec3<f32>'
+  },
+  defaultUniforms: DEFAULT_UNIFORMS,
+  getUniforms(props = {}, previousUniforms = DEFAULT_UNIFORMS) {
+    return {...DEFAULT_UNIFORMS, ...previousUniforms, ...props};
+  },
+  fs: /* glsl */ `
+layout(std140) uniform atmosphereUniforms {
+  float enabled;
+  vec3 sunDirection;
+  float sunIntensity;
+  float haze;
+  float rayleigh;
+  float planetRadius;
+  float exposure;
+  vec3 groundColor;
+} atmosphere;
+struct AtmosphereSample {
+  vec3 radiance;
+  vec3 transmittance;
+};
+
+vec2 atmosphere_intersectSphere(vec3 origin, vec3 direction, float radius) {
+  float projected = dot(origin, direction);
+  float discriminant = projected * projected - (dot(origin.xy, origin.xy) + (origin.z - radius) * (origin.z + radius));
+  if (discriminant < 0.0) return vec2(-1.0);
+  float root = sqrt(discriminant);
+  return vec2(-projected - root, -projected + root);
+}
+vec2 atmosphere_getDensity(vec3 position) {
+  float height = max(length(position) - atmosphere.planetRadius, 0.0);
+  return exp(-vec2(height / 8000.0, height / 1200.0));
+}
+AtmosphereSample atmosphere_getScattering(vec3 camera, vec3 direction, float distanceLimit) {
+  AtmosphereSample result;
+  result.radiance = vec3(0.0);
+  result.transmittance = vec3(1.0);
+  if (atmosphere.enabled < 0.5 || distanceLimit <= 0.0) return result;
+  vec3 origin = vec3(camera.xy, atmosphere.planetRadius + max(camera.z, 1.0));
+  vec2 shell = atmosphere_intersectSphere(origin, direction, atmosphere.planetRadius + 100000.0);
+  float start = max(shell.x, 0.0);
+  float end = min(shell.y, distanceLimit);
+  vec2 ground = atmosphere_intersectSphere(origin, direction, atmosphere.planetRadius);
+  if (ground.x > 0.0) end = min(end, ground.x);
+  if (end <= start) return result;
+  vec3 sunlight = normalize(atmosphere.sunDirection);
+  vec3 rayleigh = vec3(0.0000058, 0.0000135, 0.0000331) * max(atmosphere.rayleigh, 0.0);
+  vec3 mie = vec3(0.000021) * max(atmosphere.haze, 0.0);
+  float cosine = dot(direction, sunlight);
+  float rayleighPhase = 0.0596831 * (1.0 + cosine * cosine);
+  float asymmetry = 0.76;
+  float miePhase = (1.0 - asymmetry * asymmetry) / (12.566371 * pow(max(1.0 + asymmetry * asymmetry - 2.0 * asymmetry * cosine, 0.001), 1.5));
+  float stepLength = (end - start) / 12.0;
+  vec2 opticalDepth = vec2(0.0);
+  vec3 radiance = vec3(0.0);
+  for (int sampleIndex = 0; sampleIndex < 12; sampleIndex++) {
+    vec3 position = origin + direction * (start + (float(sampleIndex) + 0.5) * stepLength);
+    vec2 density = atmosphere_getDensity(position);
+    vec2 centerDepth = opticalDepth + density * stepLength * 0.5;
+    opticalDepth += density * stepLength;
+    vec2 solarGround = atmosphere_intersectSphere(position, sunlight, atmosphere.planetRadius);
+    if (solarGround.x > 0.0) continue;
+    float solarDistance = max(atmosphere_intersectSphere(position, sunlight, atmosphere.planetRadius + 100000.0).y, 0.0);
+    float solarStep = solarDistance / 4.0;
+    vec2 solarDepth = vec2(0.0);
+    for (int solarIndex = 0; solarIndex < 4; solarIndex++) {
+      solarDepth += atmosphere_getDensity(position + sunlight * ((float(solarIndex) + 0.5) * solarStep)) * solarStep;
+    }
+    vec3 attenuation = exp(-rayleigh * (centerDepth.x + solarDepth.x) - mie * (centerDepth.y + solarDepth.y));
+    radiance += attenuation * (rayleigh * density.x * rayleighPhase + mie * density.y * miePhase) * stepLength;
+  }
+  result.radiance = radiance * max(atmosphere.sunIntensity, 0.0);
+  result.transmittance = exp(-rayleigh * opticalDepth.x - mie * opticalDepth.y);
+  return result;
+}
+vec3 atmosphere_getSkyColor(vec3 camera, vec3 direction) {
+  if (atmosphere.enabled < 0.5) return vec3(0.0);
+  AtmosphereSample scatteringSample = atmosphere_getScattering(camera, normalize(direction), 1000000.0);
+  vec3 origin = vec3(camera.xy, atmosphere.planetRadius + max(camera.z, 1.0));
+  vec3 sunlight = normalize(atmosphere.sunDirection);
+  float groundDistance = atmosphere_intersectSphere(origin, normalize(direction), atmosphere.planetRadius).x;
+  if (groundDistance > 0.0 && sunlight.z > 0.0) {
+    // Approximate direct irradiance at the ground boundary, attenuated on its way to the eye.
+    float elevation = max(sunlight.z, 0.02);
+    vec3 extinction = vec3(0.0000058, 0.0000135, 0.0000331) * max(atmosphere.rayleigh, 0.0) * 8000.0
+      + vec3(0.000021) * max(atmosphere.haze, 0.0) * 1200.0;
+    scatteringSample.radiance += atmosphere.groundColor * atmosphere.sunIntensity * sunlight.z / 3.141593
+      * exp(-extinction / elevation) * scatteringSample.transmittance;
+  }
+  return vec3(1.0) - exp(-scatteringSample.radiance * atmosphere.exposure);
+}
+vec4 atmosphere_getColor(vec4 color, vec3 position, vec3 camera) {
+  vec3 difference = position - camera;
+  float distance = length(difference);
+  if (distance < 0.001 || atmosphere.enabled < 0.5) return color;
+  AtmosphereSample scatteringSample = atmosphere_getScattering(camera, difference / distance, distance);
+  vec3 scattering = vec3(1.0) - exp(-scatteringSample.radiance * atmosphere.exposure);
+  return vec4(color.rgb * scatteringSample.transmittance + scattering, color.a);
+}
+`,
+  source: /* wgsl */ `
+struct atmosphereUniforms {
+  enabled: f32,
+  sunDirection: vec3f,
+  sunIntensity: f32,
+  haze: f32,
+  rayleigh: f32,
+  planetRadius: f32,
+  exposure: f32,
+  groundColor: vec3f,
+};
+@group(3) @binding(auto) var<uniform> atmosphere: atmosphereUniforms;
+struct AtmosphereSample { radiance: vec3f,
+  transmittance: vec3f };
+
+fn atmosphere_intersectSphere(origin: vec3f,
+  direction: vec3f,
+  radius: f32) -> vec2f {
+  var projected: f32 = dot(origin, direction);
+  var discriminant: f32 = projected * projected - (dot(origin.xy, origin.xy) + (origin.z - radius) * (origin.z + radius));
+  if (discriminant < 0.0) { return vec2f(-1.0); }
+  var root: f32 = sqrt(discriminant);
+  return vec2f(-projected - root, -projected + root);
+}
+fn atmosphere_getDensity(position: vec3f) -> vec2f {
+  var height: f32 = max(length(position) - atmosphere.planetRadius, 0.0);
+  return exp(-vec2f(height / 8000.0, height / 1200.0));
+}
+fn atmosphere_getScattering(camera: vec3f,
+  direction: vec3f,
+  distanceLimit: f32) -> AtmosphereSample {
+  var result: AtmosphereSample;
+  result.radiance = vec3f(0.0);
+  result.transmittance = vec3f(1.0);
+  if (atmosphere.enabled < 0.5 || distanceLimit <= 0.0) { return result; }
+  var origin: vec3f = vec3f(camera.xy, atmosphere.planetRadius + max(camera.z, 1.0));
+  var shell: vec2f = atmosphere_intersectSphere(origin, direction, atmosphere.planetRadius + 100000.0);
+  var start: f32 = max(shell.x, 0.0);
+  var end: f32 = min(shell.y, distanceLimit);
+  var ground: vec2f = atmosphere_intersectSphere(origin, direction, atmosphere.planetRadius);
+  if (ground.x > 0.0) { end = min(end, ground.x); }
+  if (end <= start) { return result; }
+  var sunlight: vec3f = normalize(atmosphere.sunDirection);
+  var rayleigh: vec3f = vec3f(0.0000058, 0.0000135, 0.0000331) * max(atmosphere.rayleigh, 0.0);
+  var mie: vec3f = vec3f(0.000021) * max(atmosphere.haze, 0.0);
+  var cosine: f32 = dot(direction, sunlight);
+  var rayleighPhase: f32 = 0.0596831 * (1.0 + cosine * cosine);
+  var asymmetry: f32 = 0.76;
+  var miePhase: f32 = (1.0 - asymmetry * asymmetry) / (12.566371 * pow(max(1.0 + asymmetry * asymmetry - 2.0 * asymmetry * cosine, 0.001), 1.5));
+  var stepLength: f32 = (end - start) / 12.0;
+  var opticalDepth: vec2f = vec2f(0.0);
+  var radiance: vec3f = vec3f(0.0);
+  for (var sampleIndex: i32 = 0; sampleIndex < 12; sampleIndex++) {
+    var position: vec3f = origin + direction * (start + (f32(sampleIndex) + 0.5) * stepLength);
+    var density: vec2f = atmosphere_getDensity(position);
+    var centerDepth: vec2f = opticalDepth + density * stepLength * 0.5;
+    opticalDepth += density * stepLength;
+    var solarGround: vec2f = atmosphere_intersectSphere(position, sunlight, atmosphere.planetRadius);
+    if (solarGround.x > 0.0) { continue; }
+    var solarDistance: f32 = max(atmosphere_intersectSphere(position, sunlight, atmosphere.planetRadius + 100000.0).y, 0.0);
+    var solarStep: f32 = solarDistance / 4.0;
+    var solarDepth: vec2f = vec2f(0.0);
+    for (var solarIndex: i32 = 0; solarIndex < 4; solarIndex++) {
+      solarDepth += atmosphere_getDensity(position + sunlight * ((f32(solarIndex) + 0.5) * solarStep)) * solarStep;
+    }
+    var attenuation: vec3f = exp(-rayleigh * (centerDepth.x + solarDepth.x) - mie * (centerDepth.y + solarDepth.y));
+    radiance += attenuation * (rayleigh * density.x * rayleighPhase + mie * density.y * miePhase) * stepLength;
+  }
+  result.radiance = radiance * max(atmosphere.sunIntensity, 0.0);
+  result.transmittance = exp(-rayleigh * opticalDepth.x - mie * opticalDepth.y);
+  return result;
+}
+fn atmosphere_getSkyColor(camera: vec3f,
+  direction: vec3f) -> vec3f {
+  if (atmosphere.enabled < 0.5) { return vec3f(0.0); }
+  var scatteringSample: AtmosphereSample = atmosphere_getScattering(camera, normalize(direction), 1000000.0);
+  let origin = vec3f(camera.xy, atmosphere.planetRadius + max(camera.z, 1.0));
+  let sunlight = normalize(atmosphere.sunDirection);
+  let groundDistance = atmosphere_intersectSphere(origin, normalize(direction), atmosphere.planetRadius).x;
+  if (groundDistance > 0.0 && sunlight.z > 0.0) {
+    // Approximate direct irradiance at the ground boundary, attenuated on its way to the eye.
+    let elevation = max(sunlight.z, 0.02);
+    let extinction = vec3f(0.0000058, 0.0000135, 0.0000331) * max(atmosphere.rayleigh, 0.0) * 8000.0
+      + vec3f(0.000021) * max(atmosphere.haze, 0.0) * 1200.0;
+    scatteringSample.radiance += atmosphere.groundColor * atmosphere.sunIntensity * sunlight.z / 3.141593
+      * exp(-extinction / elevation) * scatteringSample.transmittance;
+  }
+  return vec3f(1.0) - exp(-scatteringSample.radiance * atmosphere.exposure);
+}
+fn atmosphere_getColor(color: vec4f,
+  position: vec3f,
+  camera: vec3f) -> vec4f {
+  var difference: vec3f = position - camera;
+  var distance: f32 = length(difference);
+  if (distance < 0.001 || atmosphere.enabled < 0.5) { return color; }
+  var scatteringSample: AtmosphereSample = atmosphere_getScattering(camera, difference / distance, distance);
+  var scattering: vec3f = vec3f(1.0) - exp(-scatteringSample.radiance * atmosphere.exposure);
+  return vec4f(color.rgb * scatteringSample.transmittance + scattering, color.a);
+}
+`
+} as const satisfies ShaderModule<AtmosphereProps, AtmosphereUniforms>;