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

package/dist/modules/lighting/atmosphere/atmosphere.cjs

@@ -0,0 +1,253 @@
+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 atmosphere_exports = {};
+__export(atmosphere_exports, {
+  atmosphere: () => atmosphere
+});
+module.exports = __toCommonJS(atmosphere_exports);
+const DEFAULT_UNIFORMS = {
+  enabled: 1,
+  sunDirection: [0, 0.8, 0.6],
+  sunIntensity: 20,
+  haze: 1,
+  rayleigh: 1,
+  planetRadius: 6371e3,
+  exposure: 1,
+  groundColor: [0.18, 0.17, 0.14]
+};
+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);
+}
+`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  atmosphere
+});

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

@@ -0,0 +1,45 @@
+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>;
+/** Single-scattering Rayleigh/Mie sky and aerial perspective. Distances are metres.
+ * Includes a spherical planet's solar occlusion, without multiple scattering or ozone.
+ */
+export declare const atmosphere: {
+    readonly name: "atmosphere";
+    readonly uniformTypes: {
+        readonly enabled: "f32";
+        readonly sunDirection: "vec3<f32>";
+        readonly sunIntensity: "f32";
+        readonly haze: "f32";
+        readonly rayleigh: "f32";
+        readonly planetRadius: "f32";
+        readonly exposure: "f32";
+        readonly groundColor: "vec3<f32>";
+    };
+    readonly defaultUniforms: AtmosphereUniforms;
+    readonly getUniforms: (props?: Partial<Partial<AtmosphereUniforms>>, previousUniforms?: AtmosphereUniforms | undefined) => {
+        enabled: number;
+        sunDirection: [number, number, number];
+        sunIntensity: number;
+        haze: number;
+        rayleigh: number;
+        planetRadius: number;
+        exposure: number;
+        groundColor: [number, number, number];
+    };
+    readonly fs: "\nlayout(std140) uniform atmosphereUniforms {\n  float enabled;\n  vec3 sunDirection;\n  float sunIntensity;\n  float haze;\n  float rayleigh;\n  float planetRadius;\n  float exposure;\n  vec3 groundColor;\n} atmosphere;\nstruct AtmosphereSample {\n  vec3 radiance;\n  vec3 transmittance;\n};\n\nvec2 atmosphere_intersectSphere(vec3 origin, vec3 direction, float radius) {\n  float projected = dot(origin, direction);\n  float discriminant = projected * projected - (dot(origin.xy, origin.xy) + (origin.z - radius) * (origin.z + radius));\n  if (discriminant < 0.0) return vec2(-1.0);\n  float root = sqrt(discriminant);\n  return vec2(-projected - root, -projected + root);\n}\nvec2 atmosphere_getDensity(vec3 position) {\n  float height = max(length(position) - atmosphere.planetRadius, 0.0);\n  return exp(-vec2(height / 8000.0, height / 1200.0));\n}\nAtmosphereSample atmosphere_getScattering(vec3 camera, vec3 direction, float distanceLimit) {\n  AtmosphereSample result;\n  result.radiance = vec3(0.0);\n  result.transmittance = vec3(1.0);\n  if (atmosphere.enabled < 0.5 || distanceLimit <= 0.0) return result;\n  vec3 origin = vec3(camera.xy, atmosphere.planetRadius + max(camera.z, 1.0));\n  vec2 shell = atmosphere_intersectSphere(origin, direction, atmosphere.planetRadius + 100000.0);\n  float start = max(shell.x, 0.0);\n  float end = min(shell.y, distanceLimit);\n  vec2 ground = atmosphere_intersectSphere(origin, direction, atmosphere.planetRadius);\n  if (ground.x > 0.0) end = min(end, ground.x);\n  if (end <= start) return result;\n  vec3 sunlight = normalize(atmosphere.sunDirection);\n  vec3 rayleigh = vec3(0.0000058, 0.0000135, 0.0000331) * max(atmosphere.rayleigh, 0.0);\n  vec3 mie = vec3(0.000021) * max(atmosphere.haze, 0.0);\n  float cosine = dot(direction, sunlight);\n  float rayleighPhase = 0.0596831 * (1.0 + cosine * cosine);\n  float asymmetry = 0.76;\n  float miePhase = (1.0 - asymmetry * asymmetry) / (12.566371 * pow(max(1.0 + asymmetry * asymmetry - 2.0 * asymmetry * cosine, 0.001), 1.5));\n  float stepLength = (end - start) / 12.0;\n  vec2 opticalDepth = vec2(0.0);\n  vec3 radiance = vec3(0.0);\n  for (int sampleIndex = 0; sampleIndex < 12; sampleIndex++) {\n    vec3 position = origin + direction * (start + (float(sampleIndex) + 0.5) * stepLength);\n    vec2 density = atmosphere_getDensity(position);\n    vec2 centerDepth = opticalDepth + density * stepLength * 0.5;\n    opticalDepth += density * stepLength;\n    vec2 solarGround = atmosphere_intersectSphere(position, sunlight, atmosphere.planetRadius);\n    if (solarGround.x > 0.0) continue;\n    float solarDistance = max(atmosphere_intersectSphere(position, sunlight, atmosphere.planetRadius + 100000.0).y, 0.0);\n    float solarStep = solarDistance / 4.0;\n    vec2 solarDepth = vec2(0.0);\n    for (int solarIndex = 0; solarIndex < 4; solarIndex++) {\n      solarDepth += atmosphere_getDensity(position + sunlight * ((float(solarIndex) + 0.5) * solarStep)) * solarStep;\n    }\n    vec3 attenuation = exp(-rayleigh * (centerDepth.x + solarDepth.x) - mie * (centerDepth.y + solarDepth.y));\n    radiance += attenuation * (rayleigh * density.x * rayleighPhase + mie * density.y * miePhase) * stepLength;\n  }\n  result.radiance = radiance * max(atmosphere.sunIntensity, 0.0);\n  result.transmittance = exp(-rayleigh * opticalDepth.x - mie * opticalDepth.y);\n  return result;\n}\nvec3 atmosphere_getSkyColor(vec3 camera, vec3 direction) {\n  if (atmosphere.enabled < 0.5) return vec3(0.0);\n  AtmosphereSample scatteringSample = atmosphere_getScattering(camera, normalize(direction), 1000000.0);\n  vec3 origin = vec3(camera.xy, atmosphere.planetRadius + max(camera.z, 1.0));\n  vec3 sunlight = normalize(atmosphere.sunDirection);\n  float groundDistance = atmosphere_intersectSphere(origin, normalize(direction), atmosphere.planetRadius).x;\n  if (groundDistance > 0.0 && sunlight.z > 0.0) {\n    // Approximate direct irradiance at the ground boundary, attenuated on its way to the eye.\n    float elevation = max(sunlight.z, 0.02);\n    vec3 extinction = vec3(0.0000058, 0.0000135, 0.0000331) * max(atmosphere.rayleigh, 0.0) * 8000.0\n      + vec3(0.000021) * max(atmosphere.haze, 0.0) * 1200.0;\n    scatteringSample.radiance += atmosphere.groundColor * atmosphere.sunIntensity * sunlight.z / 3.141593\n      * exp(-extinction / elevation) * scatteringSample.transmittance;\n  }\n  return vec3(1.0) - exp(-scatteringSample.radiance * atmosphere.exposure);\n}\nvec4 atmosphere_getColor(vec4 color, vec3 position, vec3 camera) {\n  vec3 difference = position - camera;\n  float distance = length(difference);\n  if (distance < 0.001 || atmosphere.enabled < 0.5) return color;\n  AtmosphereSample scatteringSample = atmosphere_getScattering(camera, difference / distance, distance);\n  vec3 scattering = vec3(1.0) - exp(-scatteringSample.radiance * atmosphere.exposure);\n  return vec4(color.rgb * scatteringSample.transmittance + scattering, color.a);\n}\n";
+    readonly source: "\nstruct atmosphereUniforms {\n  enabled: f32,\n  sunDirection: vec3f,\n  sunIntensity: f32,\n  haze: f32,\n  rayleigh: f32,\n  planetRadius: f32,\n  exposure: f32,\n  groundColor: vec3f,\n};\n@group(3) @binding(auto) var<uniform> atmosphere: atmosphereUniforms;\nstruct AtmosphereSample { radiance: vec3f,\n  transmittance: vec3f };\n\nfn atmosphere_intersectSphere(origin: vec3f,\n  direction: vec3f,\n  radius: f32) -> vec2f {\n  var projected: f32 = dot(origin, direction);\n  var discriminant: f32 = projected * projected - (dot(origin.xy, origin.xy) + (origin.z - radius) * (origin.z + radius));\n  if (discriminant < 0.0) { return vec2f(-1.0); }\n  var root: f32 = sqrt(discriminant);\n  return vec2f(-projected - root, -projected + root);\n}\nfn atmosphere_getDensity(position: vec3f) -> vec2f {\n  var height: f32 = max(length(position) - atmosphere.planetRadius, 0.0);\n  return exp(-vec2f(height / 8000.0, height / 1200.0));\n}\nfn atmosphere_getScattering(camera: vec3f,\n  direction: vec3f,\n  distanceLimit: f32) -> AtmosphereSample {\n  var result: AtmosphereSample;\n  result.radiance = vec3f(0.0);\n  result.transmittance = vec3f(1.0);\n  if (atmosphere.enabled < 0.5 || distanceLimit <= 0.0) { return result; }\n  var origin: vec3f = vec3f(camera.xy, atmosphere.planetRadius + max(camera.z, 1.0));\n  var shell: vec2f = atmosphere_intersectSphere(origin, direction, atmosphere.planetRadius + 100000.0);\n  var start: f32 = max(shell.x, 0.0);\n  var end: f32 = min(shell.y, distanceLimit);\n  var ground: vec2f = atmosphere_intersectSphere(origin, direction, atmosphere.planetRadius);\n  if (ground.x > 0.0) { end = min(end, ground.x); }\n  if (end <= start) { return result; }\n  var sunlight: vec3f = normalize(atmosphere.sunDirection);\n  var rayleigh: vec3f = vec3f(0.0000058, 0.0000135, 0.0000331) * max(atmosphere.rayleigh, 0.0);\n  var mie: vec3f = vec3f(0.000021) * max(atmosphere.haze, 0.0);\n  var cosine: f32 = dot(direction, sunlight);\n  var rayleighPhase: f32 = 0.0596831 * (1.0 + cosine * cosine);\n  var asymmetry: f32 = 0.76;\n  var miePhase: f32 = (1.0 - asymmetry * asymmetry) / (12.566371 * pow(max(1.0 + asymmetry * asymmetry - 2.0 * asymmetry * cosine, 0.001), 1.5));\n  var stepLength: f32 = (end - start) / 12.0;\n  var opticalDepth: vec2f = vec2f(0.0);\n  var radiance: vec3f = vec3f(0.0);\n  for (var sampleIndex: i32 = 0; sampleIndex < 12; sampleIndex++) {\n    var position: vec3f = origin + direction * (start + (f32(sampleIndex) + 0.5) * stepLength);\n    var density: vec2f = atmosphere_getDensity(position);\n    var centerDepth: vec2f = opticalDepth + density * stepLength * 0.5;\n    opticalDepth += density * stepLength;\n    var solarGround: vec2f = atmosphere_intersectSphere(position, sunlight, atmosphere.planetRadius);\n    if (solarGround.x > 0.0) { continue; }\n    var solarDistance: f32 = max(atmosphere_intersectSphere(position, sunlight, atmosphere.planetRadius + 100000.0).y, 0.0);\n    var solarStep: f32 = solarDistance / 4.0;\n    var solarDepth: vec2f = vec2f(0.0);\n    for (var solarIndex: i32 = 0; solarIndex < 4; solarIndex++) {\n      solarDepth += atmosphere_getDensity(position + sunlight * ((f32(solarIndex) + 0.5) * solarStep)) * solarStep;\n    }\n    var attenuation: vec3f = exp(-rayleigh * (centerDepth.x + solarDepth.x) - mie * (centerDepth.y + solarDepth.y));\n    radiance += attenuation * (rayleigh * density.x * rayleighPhase + mie * density.y * miePhase) * stepLength;\n  }\n  result.radiance = radiance * max(atmosphere.sunIntensity, 0.0);\n  result.transmittance = exp(-rayleigh * opticalDepth.x - mie * opticalDepth.y);\n  return result;\n}\nfn atmosphere_getSkyColor(camera: vec3f,\n  direction: vec3f) -> vec3f {\n  if (atmosphere.enabled < 0.5) { return vec3f(0.0); }\n  var scatteringSample: AtmosphereSample = atmosphere_getScattering(camera, normalize(direction), 1000000.0);\n  let origin = vec3f(camera.xy, atmosphere.planetRadius + max(camera.z, 1.0));\n  let sunlight = normalize(atmosphere.sunDirection);\n  let groundDistance = atmosphere_intersectSphere(origin, normalize(direction), atmosphere.planetRadius).x;\n  if (groundDistance > 0.0 && sunlight.z > 0.0) {\n    // Approximate direct irradiance at the ground boundary, attenuated on its way to the eye.\n    let elevation = max(sunlight.z, 0.02);\n    let extinction = vec3f(0.0000058, 0.0000135, 0.0000331) * max(atmosphere.rayleigh, 0.0) * 8000.0\n      + vec3f(0.000021) * max(atmosphere.haze, 0.0) * 1200.0;\n    scatteringSample.radiance += atmosphere.groundColor * atmosphere.sunIntensity * sunlight.z / 3.141593\n      * exp(-extinction / elevation) * scatteringSample.transmittance;\n  }\n  return vec3f(1.0) - exp(-scatteringSample.radiance * atmosphere.exposure);\n}\nfn atmosphere_getColor(color: vec4f,\n  position: vec3f,\n  camera: vec3f) -> vec4f {\n  var difference: vec3f = position - camera;\n  var distance: f32 = length(difference);\n  if (distance < 0.001 || atmosphere.enabled < 0.5) { return color; }\n  var scatteringSample: AtmosphereSample = atmosphere_getScattering(camera, difference / distance, distance);\n  var scattering: vec3f = vec3f(1.0) - exp(-scatteringSample.radiance * atmosphere.exposure);\n  return vec4f(color.rgb * scatteringSample.transmittance + scattering, color.a);\n}\n";
+};
+//# sourceMappingURL=atmosphere.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"atmosphere.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/atmosphere/atmosphere.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,uFAAuF;IACvF,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC,CAAC;AACF,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAY1D;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;iBA5BZ,MAAM;sBAED,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;sBACxB,MAAM;cAEd,MAAM;kBACF,MAAM;sBAEF,MAAM;kBACV,MAAM;qBAEH,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;;;;CAmO+B,CAAC"}

package/dist/modules/lighting/atmosphere/atmosphere.js

@@ -0,0 +1,228 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+const DEFAULT_UNIFORMS = {
+    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);
+}
+`
+};
+//# sourceMappingURL=atmosphere.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"atmosphere.js","sourceRoot":"","sources":["../../../../src/modules/lighting/atmosphere/atmosphere.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAmB5D,MAAM,gBAAgB,GAAuB;IAC3C,OAAO,EAAE,CAAC;IACV,YAAY,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC;IAC3B,YAAY,EAAE,EAAE;IAChB,IAAI,EAAE,CAAC;IACP,QAAQ,EAAE,CAAC;IACX,YAAY,EAAE,OAAO;IACrB,QAAQ,EAAE,CAAC;IACX,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,YAAY;IAClB,YAAY,EAAE;QACZ,OAAO,EAAE,KAAK;QACd,YAAY,EAAE,WAAW;QACzB,YAAY,EAAE,KAAK;QACnB,IAAI,EAAE,KAAK;QACX,QAAQ,EAAE,KAAK;QACf,YAAY,EAAE,KAAK;QACnB,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,WAAW;KACzB;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6FhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmGpB;CACqE,CAAC"}