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

package/dist/modules/lighting/contact-shadow/contact-shadow.js

@@ -0,0 +1,307 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+const IDENTITY_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+export const contactShadowTrace = {
+    name: 'contactShadowTrace',
+    source: /* wgsl */ `\
+struct contactShadowTraceUniforms {
+  projectionMatrix: mat4x4f,
+  inverseProjectionMatrix: mat4x4f,
+  lightDirectionView: vec3f,
+  maxDistance: f32,
+  thickness: f32,
+  stepCount: f32,
+  frameIndex: f32,
+  normalBias: f32,
+};
+@group(0) @binding(auto) var<uniform> contactShadowTrace: contactShadowTraceUniforms;
+@group(0) @binding(auto) var depthTexture: texture_depth_2d;
+@group(0) @binding(auto) var depthTextureSampler: sampler;
+@group(0) @binding(auto) var normalTexture: texture_2d<f32>;
+@group(0) @binding(auto) var normalTextureSampler: sampler;
+
+fn contactShadow_reconstructViewPosition(uv: vec2f, depth: f32) -> vec3f {
+  let clip = vec4f(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, depth, 1.0);
+  let view = contactShadowTrace.inverseProjectionMatrix * clip;
+  return view.xyz / max(abs(view.w), 0.00001);
+}
+
+fn contactShadow_projectViewPosition(position: vec3f) -> vec2f {
+  let clip = contactShadowTrace.projectionMatrix * vec4f(position, 1.0);
+  let ndc = clip.xy / max(abs(clip.w), 0.00001);
+  return vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
+}
+
+fn contactShadowTrace_sampleColor(
+  sourceTexture: texture_2d<f32>, sourceTextureSampler: sampler, texSize: vec2f, texCoord: vec2f
+) -> vec4f {
+  let centerDepth = textureSampleLevel(depthTexture, depthTextureSampler, texCoord, 0);
+  if (centerDepth >= 0.99999) { return vec4f(1.0); }
+  let centerNormal = normalize(textureSampleLevel(normalTexture, normalTextureSampler, texCoord, 0.0).xyz * 2.0 - 1.0);
+  let centerPosition = contactShadow_reconstructViewPosition(texCoord, centerDepth) + centerNormal * contactShadowTrace.normalBias;
+  let rayDirection = normalize(contactShadowTrace.lightDirectionView);
+  let noise = fract(sin(dot(texCoord * texSize + contactShadowTrace.frameIndex, vec2f(12.9898, 78.233))) * 43758.5453);
+  for (var index: i32 = 0; index < 40; index++) {
+    if (f32(index) >= contactShadowTrace.stepCount) { break; }
+    let fraction = (f32(index) + 0.35 + noise * 0.5) / max(contactShadowTrace.stepCount, 1.0);
+    let travel = contactShadowTrace.maxDistance * fraction * fraction;
+    let rayPosition = centerPosition + rayDirection * travel;
+    let sampleUv = contactShadow_projectViewPosition(rayPosition);
+    if (any(sampleUv <= vec2f(0.0)) || any(sampleUv >= vec2f(1.0))) { break; }
+    let sampleDepth = textureSampleLevel(depthTexture, depthTextureSampler, sampleUv, 0);
+    if (sampleDepth >= 0.99999) { continue; }
+    let scenePosition = contactShadow_reconstructViewPosition(sampleUv, sampleDepth);
+    let depthDelta = (-rayPosition.z) - (-scenePosition.z);
+    let hitThickness = contactShadowTrace.thickness + travel * 0.02;
+    if (depthDelta >= 0.0 && depthDelta <= hitThickness) {
+      let distanceFade = 1.0 - clamp(travel / contactShadowTrace.maxDistance, 0.0, 1.0);
+      return vec4f(vec3f(1.0 - distanceFade), 1.0);
+    }
+    if (depthDelta > hitThickness * 8.0) { break; }
+  }
+  return vec4f(1.0);
+}`,
+    fs: /* glsl */ `
+layout(std140) uniform contactShadowTraceUniforms {
+  mat4 projectionMatrix;
+  mat4 inverseProjectionMatrix;
+  vec3 lightDirectionView;
+  float maxDistance;
+  float thickness;
+  float stepCount;
+  float frameIndex;
+  float normalBias;
+} contactShadowTrace;
+uniform sampler2D depthTexture;
+uniform sampler2D normalTexture;
+vec3 contactShadow_reconstructViewPosition(vec2 uv, float depth) {
+  vec4 view = contactShadowTrace.inverseProjectionMatrix * vec4(uv * 2.0 - 1.0, depth * 2.0 - 1.0, 1.0);
+  return view.xyz / max(abs(view.w), 0.00001);
+}
+vec2 contactShadow_projectViewPosition(vec3 position) {
+  vec4 clip = contactShadowTrace.projectionMatrix * vec4(position,1.0);
+  return clip.xy / max(abs(clip.w),0.00001) * 0.5 + 0.5;
+}
+vec4 contactShadowTrace_sampleColor(sampler2D sourceTexture,vec2 texSize,vec2 texCoord) {
+  float centerDepth = texture(depthTexture,texCoord).r;
+  if(centerDepth >= 0.99999) return vec4(1.0);
+  vec3 centerNormal = normalize(texture(normalTexture,texCoord).xyz * 2.0 - 1.0);
+  vec3 centerPosition = contactShadow_reconstructViewPosition(texCoord,centerDepth) + centerNormal * contactShadowTrace.normalBias;
+  vec3 rayDirection = normalize(contactShadowTrace.lightDirectionView);
+  float noise = fract(sin(dot(texCoord * texSize + contactShadowTrace.frameIndex,vec2(12.9898,78.233))) * 43758.5453);
+  for(int index=0;index<40;index++) {
+    if(float(index)>=contactShadowTrace.stepCount) break;
+    float fraction=(float(index)+0.35+noise*0.5)/max(contactShadowTrace.stepCount,1.0);
+    float travel=contactShadowTrace.maxDistance*fraction*fraction;
+    vec3 rayPosition=centerPosition+rayDirection*travel;
+    vec2 sampleUv=contactShadow_projectViewPosition(rayPosition);
+    if(any(lessThanEqual(sampleUv,vec2(0.0)))||any(greaterThanEqual(sampleUv,vec2(1.0))))break;
+    float sampleDepth=texture(depthTexture,sampleUv).r;
+    if(sampleDepth>=0.99999)continue;
+    vec3 scenePosition=contactShadow_reconstructViewPosition(sampleUv,sampleDepth);
+    float depthDelta=(-rayPosition.z)-(-scenePosition.z);
+    float hitThickness=contactShadowTrace.thickness+travel*0.02;
+    if(depthDelta>=0.0&&depthDelta<=hitThickness) {
+      float distanceFade=1.0-clamp(travel/contactShadowTrace.maxDistance,0.0,1.0);
+      return vec4(vec3(1.0-distanceFade),1.0);
+    }
+    if(depthDelta>hitThickness*8.0)break;
+  }
+  return vec4(1.0);
+}
+`,
+    bindingLayout: [
+        { name: 'depthTexture', group: 0 },
+        { name: 'normalTexture', group: 0 }
+    ],
+    props: {},
+    uniforms: {},
+    bindings: {},
+    uniformTypes: {
+        projectionMatrix: 'mat4x4<f32>',
+        inverseProjectionMatrix: 'mat4x4<f32>',
+        lightDirectionView: 'vec3<f32>',
+        maxDistance: 'f32',
+        thickness: 'f32',
+        stepCount: 'f32',
+        frameIndex: 'f32',
+        normalBias: 'f32'
+    },
+    propTypes: {
+        projectionMatrix: { value: IDENTITY_MATRIX, private: true },
+        inverseProjectionMatrix: { value: IDENTITY_MATRIX, private: true },
+        lightDirectionView: { value: [0, 1, 0], private: true },
+        maxDistance: { value: 4, min: 0.1, softMax: 16 },
+        thickness: { value: 0.12, min: 0.005, softMax: 1 },
+        stepCount: { value: 24, min: 1, max: 40 },
+        frameIndex: { value: 0, private: true },
+        normalBias: { value: 0.035, min: 0, softMax: 0.2 }
+    },
+    passes: [{ sampler: true }]
+};
+export const contactShadowBilateralBlur = {
+    name: 'contactShadowBilateralBlur',
+    source: /* wgsl */ `\
+struct contactShadowBilateralBlurUniforms {
+  direction: vec2f,
+  radius: f32,
+  depthSigma: f32,
+  normalPower: f32,
+};
+@group(0) @binding(auto) var<uniform> contactShadowBilateralBlur: contactShadowBilateralBlurUniforms;
+@group(0) @binding(auto) var depthTexture: texture_depth_2d;
+@group(0) @binding(auto) var depthTextureSampler: sampler;
+@group(0) @binding(auto) var normalTexture: texture_2d<f32>;
+@group(0) @binding(auto) var normalTextureSampler: sampler;
+
+fn contactShadowBilateralBlur_sampleColor(
+  sourceTexture: texture_2d<f32>, sourceTextureSampler: sampler, texSize: vec2f, texCoord: vec2f
+) -> vec4f {
+  let sourceDimensions = vec2f(textureDimensions(sourceTexture));
+  let texel = contactShadowBilateralBlur.direction / sourceDimensions;
+  let centerDepth = textureSampleLevel(depthTexture, depthTextureSampler, texCoord, 0);
+  let centerNormal = normalize(textureSampleLevel(normalTexture, normalTextureSampler, texCoord, 0.0).xyz * 2.0 - 1.0);
+  var result = textureSampleLevel(sourceTexture, sourceTextureSampler, texCoord, 0.0).r;
+  var totalWeight = 1.0;
+  for (var index: i32 = 1; index <= 6; index++) {
+    if (f32(index) > contactShadowBilateralBlur.radius) { break; }
+    for (var side: i32 = -1; side <= 1; side += 2) {
+      let sampleUv = clamp(texCoord + texel * f32(index * side), vec2f(0.0), vec2f(1.0));
+      let sampleDepth = textureSampleLevel(depthTexture, depthTextureSampler, sampleUv, 0);
+      let sampleNormal = normalize(textureSampleLevel(normalTexture, normalTextureSampler, sampleUv, 0.0).xyz * 2.0 - 1.0);
+      let depthDelta = abs(sampleDepth - centerDepth);
+      let depthWeight = exp(-(depthDelta * depthDelta) / max(2.0 * contactShadowBilateralBlur.depthSigma * contactShadowBilateralBlur.depthSigma, 0.000001));
+      let normalWeight = pow(max(dot(centerNormal, sampleNormal), 0.0), contactShadowBilateralBlur.normalPower);
+      let spatialWeight = exp(-f32(index * index) / 8.0);
+      let weight = depthWeight * normalWeight * spatialWeight;
+      result += textureSampleLevel(sourceTexture, sourceTextureSampler, sampleUv, 0.0).r * weight;
+      totalWeight += weight;
+    }
+  }
+  let visibility = result / totalWeight;
+  return vec4f(vec3f(visibility), 1.0);
+}`,
+    fs: /* glsl */ `
+layout(std140) uniform contactShadowBilateralBlurUniforms {
+  vec2 direction;
+  float radius;
+  float depthSigma;
+  float normalPower;
+} contactShadowBilateralBlur;
+uniform sampler2D depthTexture;
+uniform sampler2D normalTexture;
+vec4 contactShadowBilateralBlur_sampleColor(sampler2D sourceTexture,vec2 texSize,vec2 texCoord) {
+  vec2 texel=contactShadowBilateralBlur.direction/vec2(textureSize(sourceTexture,0));
+  float centerDepth=texture(depthTexture,texCoord).r;
+  vec3 centerNormal=normalize(texture(normalTexture,texCoord).xyz*2.0-1.0);
+  float result=texture(sourceTexture,texCoord).r;
+  float totalWeight=1.0;
+  for(int index=1;index<=6;index++) {
+    if(float(index)>contactShadowBilateralBlur.radius)break;
+    for(int side=-1;side<=1;side+=2) {
+      vec2 sampleUv=clamp(texCoord+texel*float(index*side),vec2(0.0),vec2(1.0));
+      float sampleDepth=texture(depthTexture,sampleUv).r;
+      vec3 sampleNormal=normalize(texture(normalTexture,sampleUv).xyz*2.0-1.0);
+      float depthDelta=abs(sampleDepth-centerDepth);
+      float depthWeight=exp(-(depthDelta*depthDelta)/max(2.0*contactShadowBilateralBlur.depthSigma*contactShadowBilateralBlur.depthSigma,0.000001));
+      float normalWeight=pow(max(dot(centerNormal,sampleNormal),0.0),contactShadowBilateralBlur.normalPower);
+      float spatialWeight=exp(-float(index*index)/8.0);
+      float weight=depthWeight*normalWeight*spatialWeight;
+      result+=texture(sourceTexture,sampleUv).r*weight;totalWeight+=weight;
+    }
+  }
+  return vec4(vec3(result/totalWeight),1.0);
+}
+`,
+    bindingLayout: [
+        { name: 'depthTexture', group: 0 },
+        { name: 'normalTexture', group: 0 }
+    ],
+    props: {},
+    uniforms: {},
+    bindings: {},
+    uniformTypes: {
+        direction: 'vec2<f32>',
+        radius: 'f32',
+        depthSigma: 'f32',
+        normalPower: 'f32'
+    },
+    propTypes: {
+        direction: { value: [1, 0], private: true },
+        radius: { value: 4, min: 1, max: 6 },
+        depthSigma: { value: 0.006, min: 0.0001, softMax: 0.05 },
+        normalPower: { value: 24, min: 1, softMax: 64 }
+    },
+    passes: [{ sampler: true }]
+};
+export const contactShadowComposite = {
+    name: 'contactShadowComposite',
+    source: /* wgsl */ `\
+struct contactShadowCompositeUniforms {
+  strength: f32,
+  debugMode: f32,
+};
+@group(0) @binding(auto) var<uniform> contactShadowComposite: contactShadowCompositeUniforms;
+@group(0) @binding(auto) var contactShadowTexture: texture_2d<f32>;
+@group(0) @binding(auto) var contactShadowTextureSampler: sampler;
+@group(0) @binding(auto) var directionalDirectTexture: texture_2d<f32>;
+@group(0) @binding(auto) var directionalDirectTextureSampler: sampler;
+@group(0) @binding(auto) var shadowDebugTexture: texture_2d<f32>;
+@group(0) @binding(auto) var shadowDebugTextureSampler: sampler;
+
+fn contactShadowComposite_sampleColor(
+  sourceTexture: texture_2d<f32>, sourceTextureSampler: sampler, texSize: vec2f, texCoord: vec2f
+) -> vec4f {
+  let color = textureSampleLevel(sourceTexture, sourceTextureSampler, texCoord, 0.0);
+  let contact = textureSampleLevel(contactShadowTexture, contactShadowTextureSampler, texCoord, 0.0).r;
+  let appliedContact = mix(1.0, contact, contactShadowComposite.strength);
+  if (contactShadowComposite.debugMode > 0.5 && contactShadowComposite.debugMode < 1.5) {
+    return vec4f(vec3f(contact), 1.0);
+  }
+  if (contactShadowComposite.debugMode >= 1.5) {
+    let factors = textureSampleLevel(shadowDebugTexture, shadowDebugTextureSampler, texCoord, 0.0).rgb;
+    return vec4f(vec3f(factors.x * factors.y * factors.z * contact), 1.0);
+  }
+  let directionalDirect = textureSampleLevel(
+    directionalDirectTexture,
+    directionalDirectTextureSampler,
+    texCoord,
+    0.0
+  ).rgb;
+  return vec4f(max(color.rgb - directionalDirect * (1.0 - appliedContact), vec3f(0.0)), color.a);
+}`,
+    fs: /* glsl */ `
+layout(std140) uniform contactShadowCompositeUniforms {
+  float strength;
+  float debugMode;
+} contactShadowComposite;
+uniform sampler2D contactShadowTexture;
+uniform sampler2D directionalDirectTexture;
+uniform sampler2D shadowDebugTexture;
+vec4 contactShadowComposite_sampleColor(sampler2D sourceTexture,vec2 texSize,vec2 texCoord) {
+  vec4 color=texture(sourceTexture,texCoord);
+  float contact=texture(contactShadowTexture,texCoord).r;
+  float appliedContact=mix(1.0,contact,contactShadowComposite.strength);
+  if(contactShadowComposite.debugMode>0.5&&contactShadowComposite.debugMode<1.5)return vec4(vec3(contact),1.0);
+  if(contactShadowComposite.debugMode>=1.5){vec3 factors=texture(shadowDebugTexture,texCoord).rgb;return vec4(vec3(factors.x*factors.y*factors.z*contact),1.0);}
+  vec3 directionalDirect=texture(directionalDirectTexture,texCoord).rgb;
+  return vec4(max(color.rgb-directionalDirect*(1.0-appliedContact),vec3(0.0)),color.a);
+}
+`,
+    bindingLayout: [
+        { name: 'contactShadowTexture', group: 0 },
+        { name: 'directionalDirectTexture', group: 0 },
+        { name: 'shadowDebugTexture', group: 0 }
+    ],
+    props: {},
+    uniforms: {},
+    bindings: {},
+    uniformTypes: { strength: 'f32', debugMode: 'f32' },
+    propTypes: {
+        strength: { value: 1, min: 0, max: 1 },
+        debugMode: { value: 0, min: 0, max: 2, private: true }
+    },
+    passes: [{ sampler: true }]
+};
+//# sourceMappingURL=contact-shadow.js.map

package/dist/modules/lighting/contact-shadow/contact-shadow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contact-shadow.js","sourceRoot":"","sources":["../../../../src/modules/lighting/contact-shadow/contact-shadow.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,74 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var firefly_exports = {};
+__export(firefly_exports, {
+  firefly: () => firefly
+});
+module.exports = __toCommonJS(firefly_exports);
+const uniforms = { enabled: 0, time: 0, radius: 8, speed: 0.6, pulse: 0.85 };
+const firefly = {
+  name: "firefly",
+  uniformTypes: { enabled: "f32", time: "f32", radius: "f32", speed: "f32", pulse: "f32" },
+  defaultUniforms: uniforms,
+  getUniforms(props = {}, previous = uniforms) {
+    return { ...uniforms, ...previous, ...props };
+  },
+  source: `struct FireflyUniforms {enabled: f32, time: f32, radius: f32, speed: f32, pulse: f32};
+  @group(3) @binding(auto) var<uniform> firefly: FireflyUniforms;
+  fn firefly_getPosition(position: vec3f, seed: f32, time: f32) -> vec3f {
+    if (firefly.enabled <= 0.0) { return position; }
+    let phase = seed * 2.399963;
+    let travel = time * firefly.speed;
+    let offset = vec3f(sin(travel * 0.71 + phase) + sin(travel * 1.31 + phase * 1.7) * 0.35,
+      cos(travel * 0.83 + phase * 1.2) + sin(travel * 0.47 + phase * 2.3) * 0.4,
+      sin(travel * 0.59 + phase * 1.9) * 0.3);
+    return position + offset * firefly.radius * firefly.enabled;
+  }
+  fn firefly_getBrightness(seed: f32, time: f32) -> f32 {
+    if (firefly.enabled <= 0.0) { return 1.0; }
+    let phase = seed * 2.399963;
+    let pulse = pow(0.5 + 0.5 * sin(time * firefly.speed * (1.6 + fract(seed * 0.37)) + phase), 3.0);
+    return mix(1.0, mix(0.08, 1.0, pulse), firefly.pulse * firefly.enabled);
+  }`,
+  vs: `layout(std140) uniform fireflyUniforms {
+    float enabled;
+    float time;
+    float radius;
+    float speed;
+    float pulse;
+  } firefly;
+  vec3 firefly_getPosition(vec3 position, float seed, float time) {
+    if (firefly.enabled <= 0.0) { return position; }
+    float phase = seed * 2.399963;
+    float travel = time * firefly.speed;
+    vec3 offset = vec3(sin(travel * 0.71 + phase) + sin(travel * 1.31 + phase * 1.7) * 0.35,
+      cos(travel * 0.83 + phase * 1.2) + sin(travel * 0.47 + phase * 2.3) * 0.4,
+      sin(travel * 0.59 + phase * 1.9) * 0.3);
+    return position + offset * firefly.radius * firefly.enabled;
+  }
+  float firefly_getBrightness(float seed, float time) {
+    if (firefly.enabled <= 0.0) { return 1.0; }
+    float phase = seed * 2.399963;
+    float pulse = pow(0.5 + 0.5 * sin(time * firefly.speed * (1.6 + fract(seed * 0.37)) + phase), 3.0);
+    return mix(1.0, mix(0.08, 1.0, pulse), firefly.pulse * firefly.enabled);
+  }`
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  firefly
+});

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"firefly.js","sourceRoot":"","sources":["../../../../src/modules/lighting/firefly/firefly.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAY5D,MAAM,QAAQ,GAAG,EAAC,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC;AAE3E,iGAAiG;AACjG,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,IAAI,EAAE,SAAS;IACf,YAAY,EAAE,EAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAC;IACtF,eAAe,EAAE,QAAQ;IACzB,WAAW,CAAC,KAAK,GAAG,EAAE,EAAE,QAAQ,GAAG,QAAQ;QACzC,OAAO,EAAC,GAAG,QAAQ,EAAE,GAAG,QAAQ,EAAE,GAAG,KAAK,EAAC,CAAC;IAC9C,CAAC;IACD,MAAM,EAAE;;;;;;;;;;;;;;;;IAgBN;IACF,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;;IAqBF;CAC4D,CAAC"}

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

@@ -0,0 +1,143 @@
+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 globe_clouds_exports = {};
+__export(globe_clouds_exports, {
+  globeClouds: () => globeClouds
+});
+module.exports = __toCommonJS(globe_clouds_exports);
+var import_clouds = require("../clouds/clouds.cjs");
+const globeClouds = {
+  name: "globeClouds",
+  dependencies: [import_clouds.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);
+}
+`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  globeClouds
+});