@3driseai/3drise-viewer 0.1.9 → 0.1.11

package/dist/hooks/useThunder.d.ts

@@ -0,0 +1,37 @@
+import * as THREE from 'three';
+import type { CloudDeckConfig, ThunderConfig } from '../types/cloudConfigs';
+/**
+ * Flash scheduling for lightning.
+ *
+ * On the CPU rather than as a time hash in the shader, because three consumers need
+ * the *same* event: the volumetric emission uniforms, the scene light, and the
+ * temporal resolve (which has to stop blending while a flash is on screen, or the
+ * flash both under-reads and then ghosts for twenty frames). A GPU-side hash can
+ * drive only the first of those.
+ *
+ * Two things make it read as lightning rather than a blinking lamp:
+ *
+ *  - **Exponential spacing.** Storms do not fire on a metronome. Waiting an
+ *    exponentially distributed interval around the mean rate is the actual arrival
+ *    process, and it costs one log().
+ *  - **Multi-stroke flicker.** A single bolt is 2-5 return strokes over ~200 ms, each
+ *    a fast attack and exponential decay. One clean flash looks synthetic; the
+ *    stutter is what the eye recognises.
+ */
+export interface ThunderState {
+    /** 0 when dark. Peaks at ThunderConfig.intensity. */
+    intensity: number;
+    /** Bolt position in world space. Only meaningful while intensity > 0. */
+    position: THREE.Vector3;
+    /** True while the bolt is actually emitting light. */
+    active: boolean;
+}
+export interface ThunderDriver {
+    /** Advance by delta seconds and return the current state. */
+    update(dt: number, deck: CloudDeckConfig, cfg: ThunderConfig, camera: THREE.Camera): ThunderState;
+}
+export declare function createThunderDriver(): ThunderDriver;
+/** One driver per mounted pass, stable across renders. */
+export declare function useThunder(): ThunderDriver;
+export default useThunder;
+//# sourceMappingURL=useThunder.d.ts.map

package/dist/hooks/useThunder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useThunder.d.ts","sourceRoot":"","sources":["../../src/hooks/useThunder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE5E;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,YAAY;IACzB,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC;IACxB,sDAAsD;IACtD,MAAM,EAAE,OAAO,CAAC;CACnB;AAID,MAAM,WAAW,aAAa;IAC1B,6DAA6D;IAC7D,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,YAAY,CAAC;CACrG;AAuED,wBAAgB,mBAAmB,IAAI,aAAa,CAiEnD;AAED,0DAA0D;AAC1D,wBAAgB,UAAU,IAAI,aAAa,CAM1C;AAED,eAAe,UAAU,CAAC"}

package/dist/hooks/useThunder.js

@@ -0,0 +1,145 @@
+import { useMemo, useRef } from 'react';
+import * as THREE from 'three';
+/**
+ * Put the bolt somewhere the camera can actually see.
+ *
+ * Scattering bolts randomly around the origin wastes most of them: a flash behind the
+ * viewer lights nothing they are looking at, so at 8 a minute the sky mostly does
+ * nothing while the compute still runs. Instead pick a random point on screen, fire a
+ * ray through it, and take where that ray crosses the bolt's altitude. The flash is
+ * then guaranteed on screen and at the right height in the deck.
+ *
+ * Kept away from the frame edge (±0.75 of NDC) so the glow is not half cut off, and
+ * clamped in distance so a near-horizontal ray does not put the bolt at the horizon.
+ */
+function placeInView(out, camera, altitude, maxDistance) {
+    // Try a few points on screen and take the first that reaches cloud altitude within
+    // range. More than one try because how far a ray travels to the deck depends
+    // entirely on how steeply it climbs: looking level, a ray needs tens of kilometres
+    // to reach a 4 km base, while one aimed higher gets there in a couple. Sampling
+    // again with a different screen position is what lets a level camera still find a
+    // near bolt instead of only ever landing one at the horizon.
+    let bestT = Infinity;
+    let bestDir = null;
+    for (let i = 0; i < 4; i++) {
+        // Kept off the frame edge so the glow is not half cut off.
+        const ndc = _ndc.set((Math.random() - 0.5) * 1.5, (Math.random() - 0.5) * 1.5, 0.5);
+        const rd = _dir.copy(ndc).unproject(camera).sub(camera.position).normalize();
+        const dy = rd.y;
+        if (Math.abs(dy) < 1e-4)
+            continue;
+        const t = (altitude - camera.position.y) / dy;
+        if (t <= 0)
+            continue;
+        if (t <= maxDistance) {
+            bestT = t;
+            bestDir = _picked.copy(rd);
+            break;
+        }
+        if (t < bestT) {
+            bestT = t;
+            bestDir = _picked.copy(rd);
+        }
+    }
+    if (bestDir && isFinite(bestT)) {
+        // Past the limit only when every sample overshot — a very flat view of a high
+        // deck. Take it anyway rather than dropping to the fallback: a distant flash on
+        // the horizon is still a flash the viewer can see, which is the whole point.
+        out.copy(camera.position).addScaledVector(bestDir, Math.min(bestT, maxDistance * 4));
+        out.y = altitude;
+        return;
+    }
+    // No ray reaches the deck at all — camera pointed down, or level with it.
+    const fwd = _dir;
+    camera.getWorldDirection(fwd);
+    fwd.y = 0;
+    if (fwd.lengthSq() < 1e-6)
+        fwd.set(0, 0, -1);
+    fwd.normalize();
+    out.copy(camera.position).addScaledVector(fwd, maxDistance * (0.35 + Math.random() * 0.4));
+    out.y = altitude;
+}
+const _ndc = new THREE.Vector3();
+const _dir = new THREE.Vector3();
+const _picked = new THREE.Vector3();
+/** Exponential inter-arrival time for a mean rate given per minute. */
+function nextInterval(ratePerMinute) {
+    const perSecond = Math.max(ratePerMinute, 0.01) / 60;
+    return -Math.log(1 - Math.random()) / perSecond;
+}
+export function createThunderDriver() {
+    let clock = 0;
+    let nextAt = 0;
+    let strokes = [];
+    let endsAt = 0;
+    let seeded = false;
+    const position = new THREE.Vector3();
+    const state = { intensity: 0, position, active: false };
+    const spawn = (deck, cfg, camera) => {
+        const n = Math.max(1, Math.round(cfg.strokes));
+        strokes = [];
+        let t = clock;
+        for (let i = 0; i < n; i++) {
+            // The first stroke is the brightest; the rest are returns, each weaker.
+            strokes.push({ start: t, peak: i === 0 ? 1 : 0.35 + Math.random() * 0.45 });
+            // Gaps of roughly one to three stroke lengths, which is the real cadence.
+            t += cfg.strokeDuration * (1 + Math.random() * 2.5);
+        }
+        endsAt = t + cfg.strokeDuration * 4;
+        // Schedule the next event from the START of this one, not its end. Adding the
+        // interval to endsAt makes the true period (interval + event duration), so the
+        // slider under-delivers — badly at high rates, where the ~0.5 s event is a
+        // third of the gap. Asking for 40/min was giving 27.
+        nextAt = clock + Math.max(nextInterval(cfg.rate), endsAt - clock);
+        const h = THREE.MathUtils.clamp(cfg.originHeight, 0, 1);
+        const altitude = deck.baseAltitude + (deck.topAltitude - deck.baseAltitude) * h;
+        placeInView(position, camera, altitude, Math.max(cfg.spread, 1000));
+    };
+    return {
+        update(dt, deck, cfg, camera) {
+            if (!cfg.enabled) {
+                strokes = [];
+                seeded = false;
+                state.intensity = 0;
+                state.active = false;
+                return state;
+            }
+            // Don't fire the instant the user ticks the box — that reads as a bug.
+            if (!seeded) {
+                seeded = true;
+                clock = 0;
+                nextAt = nextInterval(cfg.rate);
+            }
+            clock += dt;
+            if (strokes.length === 0 && clock >= nextAt)
+                spawn(deck, cfg, camera);
+            let sum = 0;
+            if (strokes.length > 0) {
+                // Fast attack, exponential decay. tau a third of the stroke so it has
+                // visibly fallen off by the time the next one lands.
+                const tau = Math.max(cfg.strokeDuration, 0.005) / 3;
+                for (const s of strokes) {
+                    const age = clock - s.start;
+                    if (age < 0 || age > cfg.strokeDuration * 6)
+                        continue;
+                    sum += s.peak * Math.exp(-age / tau);
+                }
+                if (clock >= endsAt)
+                    strokes = [];
+            }
+            state.intensity = sum * cfg.intensity;
+            state.active = sum > 0.002;
+            return state;
+        },
+    };
+}
+/** One driver per mounted pass, stable across renders. */
+export function useThunder() {
+    const ref = useRef(null);
+    return useMemo(() => {
+        if (!ref.current)
+            ref.current = createThunderDriver();
+        return ref.current;
+    }, []);
+}
+export default useThunder;

package/dist/index.d.ts

@@ -28,7 +28,7 @@ export { buildTextureArray, decodeHeightmap, loadImage } from './utils/landscape
 export type { DecodedHeightmap } from './utils/landscapeTextures';
 export { applyOceanUniforms, buildWaveTable, seaState } from './utils/oceanUniforms';
 export type { WaveTable } from './utils/oceanUniforms';
-export { applyCameraUniforms, applyCirrusUniforms, applyDeckUniforms, applySunUniforms, } from './utils/cloudUniforms';
+export { applyCameraUniforms, applyCirrusUniforms, applyDeckUniforms, applySunUniforms, applyThunderUniforms, } from './utils/cloudUniforms';
 export { applyCloudsKeyframeAnimations, applyCloudsMouseMove, resolveDeckConfig, } from './utils/handleCloudsAnimations';
 export { volumetricCloudPresets, cirrusPresets, getCloudPresetsForType, getCloudPresetByName, getCirrusPresetByName, searchCloudPresetsByTags, } from './presets/volumetricCloudPresets';
 export type { VolumetricCloudPreset, CirrusPreset } from './presets/volumetricCloudPresets';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -24,7 +24,7 @@ export { buildLandscapeGeometry, rtinTileFor, setLandscapeBounds } from './utils
 export { Rtin, RtinTile } from './utils/rtin.js';
 export { buildTextureArray, decodeHeightmap, loadImage } from './utils/landscapeTextures.js';
 export { applyOceanUniforms, buildWaveTable, seaState } from './utils/oceanUniforms.js';
-export { applyCameraUniforms, applyCirrusUniforms, applyDeckUniforms, applySunUniforms, } from './utils/cloudUniforms.js';
+export { applyCameraUniforms, applyCirrusUniforms, applyDeckUniforms, applySunUniforms, applyThunderUniforms, } from './utils/cloudUniforms.js';
 export { applyCloudsKeyframeAnimations, applyCloudsMouseMove, resolveDeckConfig, } from './utils/handleCloudsAnimations.js';
 // Presets
 export { volumetricCloudPresets, cirrusPresets, getCloudPresetsForType, getCloudPresetByName, getCirrusPresetByName, searchCloudPresetsByTags, } from './presets/volumetricCloudPresets.js';

package/dist/shaders/clouds/CloudShadowMaterial.d.ts

@@ -0,0 +1,52 @@
+import * as THREE from 'three';
+import { type ThreeElement } from '@react-three/fiber';
+export declare const CloudShadowMaterial: import("@react-three/fiber").ConstructorRepresentation<THREE.ShaderMaterial & {
+    u_shadowInverse: THREE.Matrix4;
+    u_shadowDir: THREE.Vector3;
+    u_shadowSteps: number;
+    u_base: any;
+    u_detail: any;
+    u_weather: any;
+    u_curl: any;
+    u_coverage: number;
+    u_density: number;
+    u_cloudType: number;
+    u_baseScale: number;
+    u_detailScale: number;
+    u_detailStrength: number;
+    u_curlStrength: number;
+    u_layerBottom: number;
+    u_layerTop: number;
+    u_shear: number;
+    u_anvil: number;
+    u_precip: number;
+    u_weatherScale: number;
+    u_evolution: number;
+    u_windDir: THREE.Vector2;
+    u_windSpeed: number;
+    u_rise: number;
+    u_churn: number;
+    u_sigmaT: number;
+    u_time: number;
+    u_host: number;
+    u_center: THREE.Vector3;
+    u_radius: number;
+    u_curvature: number;
+    u_sunDir: THREE.Vector3;
+    u_sunColor: THREE.Color;
+    u_sunIntensity: number;
+    u_turbidity: number;
+    u_rayleigh: number;
+    u_mieCoefficient: number;
+    u_mieG: number;
+    u_skyAmbient: THREE.Color;
+    u_groundAmbient: THREE.Color;
+}> & {
+    key: string;
+};
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        cloudShadowMaterial: ThreeElement<typeof CloudShadowMaterial>;
+    }
+}
+//# sourceMappingURL=CloudShadowMaterial.d.ts.map

package/dist/shaders/clouds/CloudShadowMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudShadowMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/clouds/CloudShadowMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAkE9D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkD/B,CAAA;AAID,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,mBAAmB,EAAE,YAAY,CAAC,OAAO,mBAAmB,CAAC,CAAA;KAC9D;CACF"}

package/dist/shaders/clouds/CloudShadowMaterial.js

@@ -0,0 +1,110 @@
+import * as THREE from 'three';
+import { shaderMaterial } from '@react-three/drei';
+import { extend } from '@react-three/fiber';
+import { cloudField } from '../glsl/cloudCore.glsl.js';
+/**
+ * Cloud shadows, rendered once per frame instead of once per ground fragment.
+ *
+ * Each texel of this map is one ray fired along the sun vector through the deck,
+ * returning the transmittance that reaches the ground beneath it. Surface materials
+ * then sample it with a single fetch — the whole point, since the previous design
+ * (`cloudField`, a six-sample march pasted into every surface shader) was expensive
+ * enough that nothing ever adopted it.
+ *
+ * Cheap on purpose. It uses `cloudDensityCheap`, so no detail-noise erosion: at the
+ * scale a shadow lands on terrain, the high-frequency worley octaves are far below a
+ * texel and would only alias. Shape and coverage are what cast a recognisable shadow.
+ */
+const vertex = /* glsl */ `
+out vec2 vUv;
+void main(){ vUv = uv; gl_Position = vec4(position.xy, 0.0, 1.0); }
+`;
+const fragment = /* glsl */ `
+${cloudField}
+
+in vec2 vUv;
+out vec4 outColor;
+
+/** Shadow clip space -> world. */
+uniform mat4  u_shadowInverse;
+uniform vec3  u_shadowDir;   // sun -> ground, i.e. -sunDir
+uniform int   u_shadowSteps;
+
+#define MAX_SHADOW_STEPS 24
+
+void main(){
+  // Near plane of the shadow camera, which sits above any cloud top.
+  vec4 wp = u_shadowInverse * vec4(vUv * 2.0 - 1.0, -1.0, 1.0);
+  vec3 ro = wp.xyz / wp.w;
+  vec3 rd = normalize(u_shadowDir);
+
+  float t0, t1;
+  if (!layerRange(ro, rd, u_layerBottom, u_layerTop, t0, t1)) {
+    outColor = vec4(1.0);
+    return;
+  }
+
+  // Curvature is deliberately not applied here (heightAt with t = 0). The shadow
+  // camera is orthographic along the sun, so its rays are parallel and there is no
+  // single "distance from viewer" that the bend is defined against.
+  float dt = (t1 - t0) / float(u_shadowSteps);
+  float acc = 0.0;
+  for (int i = 0; i < MAX_SHADOW_STEPS; i++){
+    if (i >= u_shadowSteps) break;
+    vec3 p = ro + rd * (t0 + dt * (float(i) + 0.5));
+    acc += cloudDensityCheap(p, heightAt(p, 0.0)) * dt;
+  }
+
+  // Shadows that reach zero read as holes cut in the ground. Real cloud shadow is
+  // lifted by light scattered in from the surrounding sky, so it floors well above
+  // black; the surface material's own ambient cannot recover it once it is gone.
+  float transmittance = max(exp(-acc * u_sigmaT), 0.12);
+  outColor = vec4(transmittance, transmittance, transmittance, 1.0);
+}
+`;
+export const CloudShadowMaterial = shaderMaterial({
+    u_shadowInverse: new THREE.Matrix4(),
+    u_shadowDir: new THREE.Vector3(0, -1, 0),
+    u_shadowSteps: 12,
+    // The cloudField subset of the deck uniforms. Pushed by applyDeckUniforms, the
+    // same call the volume material takes, so the shadow can never drift from the
+    // cloud casting it.
+    u_base: null,
+    u_detail: null,
+    u_weather: null,
+    u_curl: null,
+    u_coverage: 0.52,
+    u_density: 2.6,
+    u_cloudType: 0.5,
+    u_baseScale: 1 / 2600,
+    u_detailScale: 1 / 420,
+    u_detailStrength: 0.42,
+    u_curlStrength: 0.55,
+    u_layerBottom: 1500,
+    u_layerTop: 3400,
+    u_shear: 0.08,
+    u_anvil: 0,
+    u_precip: 0,
+    u_weatherScale: 1 / 24000,
+    u_evolution: 0.45,
+    u_windDir: new THREE.Vector2(1, 0.22).normalize(),
+    u_windSpeed: 6,
+    u_rise: 1.4,
+    u_churn: 4.5,
+    u_sigmaT: 0.013,
+    u_time: 0,
+    u_host: 0,
+    u_center: new THREE.Vector3(0, 620, 0),
+    u_radius: 520,
+    u_curvature: 1 / (2 * 6371000),
+    u_sunDir: new THREE.Vector3(0.35, 0.42, 0.84).normalize(),
+    u_sunColor: new THREE.Color(1, 1, 1),
+    u_sunIntensity: 1,
+    u_turbidity: 0.7,
+    u_rayleigh: 0.54,
+    u_mieCoefficient: 0.005,
+    u_mieG: 0.7,
+    u_skyAmbient: new THREE.Color(0.35, 0.48, 0.72),
+    u_groundAmbient: new THREE.Color(0.28, 0.26, 0.22),
+}, vertex, fragment);
+extend({ CloudShadowMaterial });

package/dist/shaders/clouds/CloudVolumeMaterial.d.ts

@@ -54,6 +54,11 @@ export declare const cloudVolumeDefaults: {
     u_stepGrowth: number;
     u_maxSpan: number;
     u_detailFade: number;
+    u_flash: number;
+    u_flashPos: THREE.Vector3;
+    u_flashColor: THREE.Color;
+    u_flashRadius: number;
+    u_flashScatter: number;
     u_host: number;
     u_center: THREE.Vector3;
     u_radius: number;
@@ -119,6 +124,11 @@ export declare const CloudVolumeMaterial: import("@react-three/fiber").Construct
     u_stepGrowth: number;
     u_maxSpan: number;
     u_detailFade: number;
+    u_flash: number;
+    u_flashPos: THREE.Vector3;
+    u_flashColor: THREE.Color;
+    u_flashRadius: number;
+    u_flashScatter: number;
     u_host: number;
     u_center: THREE.Vector3;
     u_radius: number;

package/dist/shaders/clouds/CloudVolumeMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CloudVolumeMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/clouds/CloudVolumeMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAwL9D,MAAM,WAAW,0BAA0B;IACzC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuE/B,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA;AAIxF,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,mBAAmB,EAAE,YAAY,CAAC,OAAO,mBAAmB,CAAC,CAAA;KAC9D;CACF"}
+{"version":3,"file":"CloudVolumeMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/clouds/CloudVolumeMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAuN9D,MAAM,WAAW,0BAA0B;IACzC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6E/B,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwD,CAAA;AAIxF,OAAO,QAAQ,oBAAoB,CAAC;IAClC,UAAU,aAAa;QACrB,mBAAmB,EAAE,YAAY,CAAC,OAAO,mBAAmB,CAAC,CAAA;KAC9D;CACF"}

package/dist/shaders/clouds/CloudVolumeMaterial.js

@@ -41,6 +41,15 @@ uniform int   u_steps;
 uniform float u_stepGrowth, u_maxSpan, u_fogDensity, u_detailFade;
 uniform float u_screenSpace;
 
+// Lightning. Declared here rather than in the shared cloudUniforms chunk so the
+// exported cloudField, which host apps pull into their own surface materials for
+// cloud shadows, keeps exactly the uniform set it has today.
+uniform float u_flash;        // 0 when dark
+uniform vec3  u_flashPos;     // bolt, world space
+uniform vec3  u_flashColor;
+uniform float u_flashRadius;  // softens the inverse square
+uniform float u_flashScatter; // multiplies extinction between bolt and sample
+
 #define MAX_STEPS 256
 
 /** Interleaved gradient noise. Cheap, and it decorrelates well under a golden-ratio
@@ -122,7 +131,12 @@ void main(){
           continue;
         }
 
-        float d = cloudDensity(p, h, saturate(1.0 - t * u_detailFade));
+        // One weather sample per shaded point, shared by the density evaluation and by
+        // every tap of the light march below. Previously each of the seven light taps
+        // re-sampled it (two 2D fetches apiece) and re-derived the coverage window.
+        CloudWeather cw = cloudWeatherAt(p);
+
+        float d = cloudDensityW(p, h, saturate(1.0 - t * u_detailFade), cw);
         if (d <= 0.0){
           empty++;
           if (empty > 8){ inside = false; empty = 0; }
@@ -132,7 +146,7 @@ void main(){
         empty = 0;
 
         float sigmaE = d * u_sigmaT;
-        float lightD = lightMarch(p, t);
+        float lightD = lightMarch(p, t, cw);
 
         vec3 amb = (u_skyAmbient * pow(saturate(h), 0.7)
                   + u_groundAmbient * pow(saturate(1.0 - h), 0.9) * 0.5)
@@ -147,6 +161,23 @@ void main(){
                   * scatterEnergy(lightD, mu) * pw * cloudAlbedo(h)
                   + amb) * sigmaE;
 
+        // Lightning: a point source buried in the volume, so the cloud lights from
+        // the inside out. Two falloffs, and both matter — inverse square alone gives
+        // a glowing ball that ignores the cloud it is inside, and extinction alone
+        // gives a flat wash. Together the near cell blows out and the next one over
+        // is merely lit, which is what a real flash does.
+        //
+        // The extinction term is analytic rather than a second light march toward the
+        // bolt: that would double the cost of the whole pass for one frame in a
+        // hundred. Deliberate approximation — no texture fetches, pure ALU, and the
+        // branch is uniform so it costs nothing while the sky is dark.
+        if (u_flash > 0.0){
+          float fd = length(u_flashPos - p);
+          float att = exp(-fd * u_sigmaT * u_flashScatter)
+                    / (1.0 + (fd * fd) / (u_flashRadius * u_flashRadius));
+          S += u_flashColor * (u_flash * att) * sigmaE;
+        }
+
         // Hillaire's energy-conserving integration, not S * dt * T.
         float trs = exp(-sigmaE * dt);
         scattering += transmittance * ((S - S * trs) / max(sigmaE, 1e-6));
@@ -231,6 +262,11 @@ export const cloudVolumeDefaults = {
     u_stepGrowth: 0.0045,
     u_maxSpan: 120000,
     u_detailFade: 1 / 16000,
+    u_flash: 0,
+    u_flashPos: new THREE.Vector3(0, 2000, 0),
+    u_flashColor: new THREE.Color('#cfe0ff'),
+    u_flashRadius: 900,
+    u_flashScatter: 0.35,
     u_host: 0,
     u_center: new THREE.Vector3(0, 620, 0),
     u_radius: 520,

package/dist/shaders/glsl/cloudCore.glsl.d.ts

@@ -12,11 +12,11 @@ export declare const cloudCommon = "\n#define PI 3.14159265359\n#define saturate
 /** Analytic single-scattering sky. Also supplies the clouds' ambient and aerial perspective. */
 export declare const skyLib = "\nuniform vec3  u_sunDir;\nuniform vec3  u_sunColor;\nuniform float u_sunIntensity;\n\n// The four Preetham parameters, taken straight from SkySettings so the clouds are\n// lit by the same atmosphere SkyController draws. Hardcoding them here is exactly\n// what makes cloud lighting drift away from the sky behind it.\nuniform float u_turbidity;\nuniform float u_rayleigh;\nuniform float u_mieCoefficient;\nuniform float u_mieG;\n\n/** Sun radiance in the same units skyRadiance() returns. Phase functions integrate to 1\n *  over the sphere, so they return ~1/4pi; without a real radiance the clouds render black. */\nconst float SUN_RADIANCE = 22.0;\n\nfloat rayleighPhase(float mu){ return (3.0 / (16.0 * PI)) * (1.0 + mu * mu); }\nfloat miePhaseHG(float mu, float g){\n  float g2 = g * g;\n  return (1.0 - g2) / (4.0 * PI * pow(max(1.0 + g2 - 2.0 * g * mu, 1e-4), 1.5));\n}\n/** Kasten-Young relative air mass. */\nfloat airMass(float cy){\n  float z = degrees(acos(clamp(cy, -1.0, 1.0)));\n  return min(1.0 / (max(cy, 0.0) + 0.15 * pow(max(93.885 - z, 0.5), -1.253)), 40.0);\n}\n\nvec3 skyRadiance(vec3 rd){\n  float mu = dot(rd, u_sunDir);\n  float up = rd.y;\n  float am = airMass(max(up, -0.02));\n\n  vec3  bR = vec3(0.0487, 0.1130, 0.2780) * u_turbidity * u_rayleigh;\n  float bM = u_mieCoefficient * u_turbidity * 4.25;\n  vec3  ext = bR * am + vec3(bM * am * 1.2);\n\n  // A single-scattering model that applies the full reddened beam everywhere turns the\n  // zenith teal at low sun. Most zenith light is in reality multiply scattered, so the\n  // Rayleigh term sees a partly whitened sun; only the Mie glow keeps the full depth.\n  vec3 rayCol = mix(u_sunColor, vec3(1.0), 0.60);\n  vec3 insR = bR * am * rayleighPhase(mu) * rayCol;\n  vec3 insM = vec3(bM * am * miePhaseHG(mu, u_mieG) * 1.3) * u_sunColor;\n\n  vec3 col = ((insR + insM) / max(ext, vec3(1e-4))) * (1.0 - exp(-ext)) * 26.0;\n\n  float below = saturate(-up * 14.0);\n  vec3 groundCol = vec3(0.055, 0.052, 0.048) * u_sunColor * (0.25 + 0.75 * saturate(u_sunDir.y));\n  return mix(col, groundCol, below);\n}\n\nvec3 sunDisc(vec3 rd){\n  float mu = dot(rd, u_sunDir);\n  float d = smoothstep(0.99976, 0.99992, mu);\n  float limb = 1.0 - 0.42 * saturate((0.99992 - mu) / 0.00016);\n  return u_sunColor * u_sunIntensity * d * limb * 42.0;\n}\n";
 /** Every uniform the density field reads. Include before cloudDensity. */
-export declare const cloudUniforms = "\nprecision highp float;\nprecision highp sampler3D;\nprecision highp sampler2D;\n\nuniform sampler3D u_base;\nuniform sampler3D u_detail;\nuniform sampler2D u_weather;\nuniform sampler2D u_curl;\nuniform float u_time;\n\nuniform float u_coverage, u_density, u_cloudType;\nuniform float u_baseScale, u_detailScale, u_detailStrength, u_curlStrength;\nuniform float u_layerBottom, u_layerTop, u_shear, u_anvil, u_precip;\nuniform float u_weatherScale, u_evolution;\nuniform vec2  u_windDir;\nuniform float u_windSpeed, u_rise, u_churn;\nuniform float u_host, u_radius, u_curvature;\nuniform vec3  u_center;\n";
-export declare const cloudDensity = "\n/**\n * Height fraction inside the cloud body.\n * In layer mode the ray is bent by planetary curvature (t^2 / 2R) so the deck meets a\n * real horizon instead of running to infinity as a flat slab would. Bending the ray is\n * equivalent to raising the sample's altitude and keeps coordinates small, which a\n * literal 6371 km sphere does not.\n */\nfloat heightAt(vec3 p, float t){\n  if (u_host < 0.5){\n    return saturate((p.y - (u_center.y - u_radius)) / max(2.0 * u_radius, 1.0));\n  }\n  float y = p.y + t * t * u_curvature;\n  return saturate((y - u_layerBottom) / max(u_layerTop - u_layerBottom, 1.0));\n}\n\n/** Two scales scrolling at different rates: coverage evolves rather than slides past. */\nvec4 sampleWeather(vec3 p){\n  vec2 b = p.xz * u_weatherScale;\n  vec2 drift = u_windDir * (u_time * u_windSpeed * 0.16) * u_weatherScale;\n  vec4 a = texture(u_weather, b + drift);\n  vec4 c = texture(u_weather, b * 2.17 - drift * 1.63 + vec2(0.31, 0.73));\n  return mix(a, c, 0.36);\n}\n\n/**\n * Three archetypal vertical profiles, blended by type. This is what makes the four\n * models genuinely different shapes rather than one shape with different noise.\n *   0.0  stratus       thin, bottom-weighted, flat top\n *   0.5  cumulus       flat base, bulge in the upper middle, eroded cauliflower top\n *   1.0  cumulonimbus  holds density to the tropopause, then spreads\n */\nfloat heightGradient(float h, float ty){\n  float stratus = saturate(remap(h, 0.00, 0.06, 0.0, 1.0)) * saturate(remap(h, 0.20, 0.36, 1.0, 0.0));\n  float cumulus = saturate(remap(h, 0.02, 0.20, 0.0, 1.0)) * saturate(remap(h, 0.56, 0.96, 1.0, 0.0));\n  float cumulon = saturate(remap(h, 0.01, 0.09, 0.0, 1.0)) * saturate(remap(h, 0.82, 1.00, 1.0, 0.0));\n  return mix(mix(stratus, cumulus, saturate(ty * 2.0)), cumulon, saturate((ty - 0.5) * 2.0));\n}\n\n/**\n * @param detail 0..1 \u2014 fades high-frequency erosion out with distance. Without it the\n *        finest worley octave beats against the step size and the far field speckles.\n */\nfloat cloudDensity(vec3 p, float h, float detail){\n  if (h <= 0.001 || h >= 0.999) return 0.0;\n\n  vec4 w = sampleWeather(p);\n  float ty = saturate(u_cloudType + (w.b - 0.5) * 0.30);\n\n  float cov = mix(w.r, w.g, 0.40);\n  // Slow formation and decay: the coverage threshold itself breathes.\n  cov += sin(u_time * 0.041 + w.b * 12.6) * 0.5 * u_evolution * 0.16;\n\n  // The window slides AND narrows with coverage. Remapping to a fixed upper bound of 1.0\n  // caps effective coverage near the weather map's median (~0.5), so overcast is\n  // unreachable no matter how high the slider goes.\n  cov = saturate(remap(cov, 1.0 - u_coverage, 1.0 - u_coverage * 0.35, 0.0, 1.0));\n  if (cov <= 0.0) return 0.0;\n\n  // Anvil: above the equilibrium level a storm spreads laterally. Gated on type so a\n  // fair-weather cumulus never grows one.\n  float anvil = saturate(remap(h, 0.70, 1.0, 0.0, 1.0)) * u_anvil * saturate((ty - 0.5) * 2.0);\n  cov = saturate(mix(cov, cov * 1.9, anvil));\n\n  // Object host: fade coverage toward the bounding sphere so the volume is not sliced\n  // flat by its own container. Through coverage, not final density, so the detail\n  // erosion still bites into the boundary and the silhouette stays ragged.\n  if (u_host < 0.5){\n    float rad = length(p - u_center) / max(u_radius, 1.0);\n    cov *= saturate(remap(rad, 0.50, 0.97, 1.0, 0.0));\n    if (cov <= 0.0) return 0.0;\n  }\n\n  // Wind shear tilts the column with altitude; then advection; then convective rise.\n  // Three decoupled timescales is what reads as delicate rather than scrolling.\n  vec3 sp = p;\n  float thick = (u_host < 0.5) ? (2.0 * u_radius) : max(u_layerTop - u_layerBottom, 1.0);\n  sp.xz += u_windDir * (h * u_shear * thick);\n  sp.xz += u_windDir * (u_time * u_windSpeed);\n  sp.y  -= u_time * u_rise;\n\n  vec4 b = texture(u_base, sp * u_baseScale);\n  float lowFbm = b.g * 0.625 + b.b * 0.25 + b.a * 0.125;\n  float shape  = saturate(remap(b.r, lowFbm - 1.0, 1.0, 0.0, 1.0));\n  shape *= heightGradient(h, ty);\n\n  float d = saturate(remap(shape, 1.0 - cov, 1.0, 0.0, 1.0)) * cov;\n  if (d <= 0.0) return 0.0;\n\n  if (detail > 0.01){\n    vec2 curl = texture(u_curl, sp.xz * u_baseScale * 2.4).rg * 2.0 - 1.0;\n    vec3 dp = sp;\n    // Curl warp is strongest at the base, where a cloud shears out into wisps.\n    dp.xz += curl * u_curlStrength * (1.0 - h) * 260.0;\n    dp.y  -= u_time * u_churn;\n    vec3 dn = texture(u_detail, dp * u_detailScale).rgb;\n    float dFbm = dn.r * 0.625 + dn.g * 0.25 + dn.b * 0.125;\n    // Wispy erosion low down, billowy erosion up top.\n    float m = mix(1.0 - dFbm, dFbm, saturate(h * 3.2));\n    d = saturate(remap(d, m * u_detailStrength * detail, 1.0, 0.0, 1.0));\n  }\n\n  return d * u_density;\n}\n\n/**\n * Scattering albedo. Rain-bearing cloud base holds large drops, which absorb far more\n * than the small droplets higher up \u2014 this is why a storm base is charcoal while its\n * top is brilliant white, and it is not something extinction alone reproduces.\n */\nfloat cloudAlbedo(float h){\n  return mix(1.0, 0.22, u_precip * saturate(remap(h, 0.30, 0.02, 0.0, 1.0)));\n}\n\nfloat cloudDensityCheap(vec3 p, float h){ return cloudDensity(p, h, 0.0); }\n";
+export declare const cloudUniforms = "\nprecision highp float;\nprecision highp sampler3D;\nprecision highp sampler2D;\n\n/** Extinction. Declared with the density uniforms rather than the scattering ones\n *  because cloudField \u2014 the subset exported for surface materials that want cloud\n *  shadows \u2014 needs it to turn accumulated density into transmittance, and does not\n *  compile on its own without it. */\nuniform float u_sigmaT;\n\nuniform sampler3D u_base;\nuniform sampler3D u_detail;\nuniform sampler2D u_weather;\nuniform sampler2D u_curl;\nuniform float u_time;\n\nuniform float u_coverage, u_density, u_cloudType;\nuniform float u_baseScale, u_detailScale, u_detailStrength, u_curlStrength;\nuniform float u_layerBottom, u_layerTop, u_shear, u_anvil, u_precip;\nuniform float u_weatherScale, u_evolution;\nuniform vec2  u_windDir;\nuniform float u_windSpeed, u_rise, u_churn;\nuniform float u_host, u_radius, u_curvature;\nuniform vec3  u_center;\n";
+export declare const cloudDensity = "\n/**\n * Height fraction inside the cloud body.\n * In layer mode the ray is bent by planetary curvature (t^2 / 2R) so the deck meets a\n * real horizon instead of running to infinity as a flat slab would. Bending the ray is\n * equivalent to raising the sample's altitude and keeps coordinates small, which a\n * literal 6371 km sphere does not.\n */\nfloat heightAt(vec3 p, float t){\n  if (u_host < 0.5){\n    return saturate((p.y - (u_center.y - u_radius)) / max(2.0 * u_radius, 1.0));\n  }\n  float y = p.y + t * t * u_curvature;\n  return saturate((y - u_layerBottom) / max(u_layerTop - u_layerBottom, 1.0));\n}\n\n/** Two scales scrolling at different rates: coverage evolves rather than slides past. */\nvec4 sampleWeather(vec3 p){\n  vec2 b = p.xz * u_weatherScale;\n  vec2 drift = u_windDir * (u_time * u_windSpeed * 0.16) * u_weatherScale;\n  vec4 a = texture(u_weather, b + drift);\n  vec4 c = texture(u_weather, b * 2.17 - drift * 1.63 + vec2(0.31, 0.73));\n  return mix(a, c, 0.36);\n}\n\n/**\n * Three archetypal vertical profiles, blended by type. This is what makes the four\n * models genuinely different shapes rather than one shape with different noise.\n *   0.0  stratus       thin, bottom-weighted, flat top\n *   0.5  cumulus       flat base, bulge in the upper middle, eroded cauliflower top\n *   1.0  cumulonimbus  holds density to the tropopause, then spreads\n */\nfloat heightGradient(float h, float ty){\n  float stratus = saturate(remap(h, 0.00, 0.06, 0.0, 1.0)) * saturate(remap(h, 0.20, 0.36, 1.0, 0.0));\n  float cumulus = saturate(remap(h, 0.02, 0.20, 0.0, 1.0)) * saturate(remap(h, 0.56, 0.96, 1.0, 0.0));\n  float cumulon = saturate(remap(h, 0.01, 0.09, 0.0, 1.0)) * saturate(remap(h, 0.82, 1.00, 1.0, 0.0));\n  return mix(mix(stratus, cumulus, saturate(ty * 2.0)), cumulon, saturate((ty - 0.5) * 2.0));\n}\n\n/**\n * The weather-derived terms, separated from the rest of the density evaluation.\n *\n * These are a function of horizontal position only, and the weather map's smallest\n * feature is a ~7 km cell (weatherCellSize / 2.17). A sun ray inside the cloud travels\n * a few hundred metres for a stratocumulus deck; over that distance these values do not\n * meaningfully change. Sampling them once per shaded point and reusing them for the\n * light march removes two texture fetches and a sin() from every one of its taps \u2014\n * which is most of the frame, since lighting is roughly 80% of the sample cost.\n *\n * This is the standard separation (Schneider does the same in Horizon): the light\n * march's job is to find how much *shape* is between here and the sun, and the shape\n * comes from the 3D noise, which is still evaluated per tap.\n */\nstruct CloudWeather {\n  float ty;   // blended cloud type\n  float cov;  // coverage BEFORE the height-dependent anvil term\n};\n\nCloudWeather cloudWeatherAt(vec3 p){\n  vec4 w = sampleWeather(p);\n  CloudWeather cw;\n  cw.ty = saturate(u_cloudType + (w.b - 0.5) * 0.30);\n\n  float cov = mix(w.r, w.g, 0.40);\n  // Slow formation and decay: the coverage threshold itself breathes.\n  cov += sin(u_time * 0.041 + w.b * 12.6) * 0.5 * u_evolution * 0.16;\n\n  // The window slides AND narrows with coverage. Remapping to a fixed upper bound of 1.0\n  // caps effective coverage near the weather map's median (~0.5), so overcast is\n  // unreachable no matter how high the slider goes.\n  cw.cov = saturate(remap(cov, 1.0 - u_coverage, 1.0 - u_coverage * 0.35, 0.0, 1.0));\n  return cw;\n}\n\n/**\n * @param detail 0..1 \u2014 fades high-frequency erosion out with distance. Without it the\n *        finest worley octave beats against the step size and the far field speckles.\n * @param cw     weather at this column, from cloudWeatherAt().\n */\nfloat cloudDensityW(vec3 p, float h, float detail, CloudWeather cw){\n  if (h <= 0.001 || h >= 0.999) return 0.0;\n\n  float ty  = cw.ty;\n  float cov = cw.cov;\n  if (cov <= 0.0) return 0.0;\n\n  // Anvil: above the equilibrium level a storm spreads laterally. Gated on type so a\n  // fair-weather cumulus never grows one.\n  float anvil = saturate(remap(h, 0.70, 1.0, 0.0, 1.0)) * u_anvil * saturate((ty - 0.5) * 2.0);\n  cov = saturate(mix(cov, cov * 1.9, anvil));\n\n  // Object host: fade coverage toward the bounding sphere so the volume is not sliced\n  // flat by its own container. Through coverage, not final density, so the detail\n  // erosion still bites into the boundary and the silhouette stays ragged.\n  if (u_host < 0.5){\n    float rad = length(p - u_center) / max(u_radius, 1.0);\n    cov *= saturate(remap(rad, 0.50, 0.97, 1.0, 0.0));\n    if (cov <= 0.0) return 0.0;\n  }\n\n  // Wind shear tilts the column with altitude; then advection; then convective rise.\n  // Three decoupled timescales is what reads as delicate rather than scrolling.\n  vec3 sp = p;\n  float thick = (u_host < 0.5) ? (2.0 * u_radius) : max(u_layerTop - u_layerBottom, 1.0);\n  sp.xz += u_windDir * (h * u_shear * thick);\n  sp.xz += u_windDir * (u_time * u_windSpeed);\n  sp.y  -= u_time * u_rise;\n\n  vec4 b = texture(u_base, sp * u_baseScale);\n  float lowFbm = b.g * 0.625 + b.b * 0.25 + b.a * 0.125;\n  float shape  = saturate(remap(b.r, lowFbm - 1.0, 1.0, 0.0, 1.0));\n  shape *= heightGradient(h, ty);\n\n  float d = saturate(remap(shape, 1.0 - cov, 1.0, 0.0, 1.0)) * cov;\n  if (d <= 0.0) return 0.0;\n\n  if (detail > 0.01){\n    vec2 curl = texture(u_curl, sp.xz * u_baseScale * 2.4).rg * 2.0 - 1.0;\n    vec3 dp = sp;\n    // Curl warp is strongest at the base, where a cloud shears out into wisps.\n    dp.xz += curl * u_curlStrength * (1.0 - h) * 260.0;\n    dp.y  -= u_time * u_churn;\n    vec3 dn = texture(u_detail, dp * u_detailScale).rgb;\n    float dFbm = dn.r * 0.625 + dn.g * 0.25 + dn.b * 0.125;\n    // Wispy erosion low down, billowy erosion up top.\n    float m = mix(1.0 - dFbm, dFbm, saturate(h * 3.2));\n    d = saturate(remap(d, m * u_detailStrength * detail, 1.0, 0.0, 1.0));\n  }\n\n  return d * u_density;\n}\n\n/**\n * Scattering albedo. Rain-bearing cloud base holds large drops, which absorb far more\n * than the small droplets higher up \u2014 this is why a storm base is charcoal while its\n * top is brilliant white, and it is not something extinction alone reproduces.\n */\nfloat cloudAlbedo(float h){\n  return mix(1.0, 0.22, u_precip * saturate(remap(h, 0.30, 0.02, 0.0, 1.0)));\n}\n\n/** Samples its own weather. Keeps the original signature for every existing caller,\n *  including the cloudField surface-shadow path. */\nfloat cloudDensity(vec3 p, float h, float detail){\n  return cloudDensityW(p, h, detail, cloudWeatherAt(p));\n}\n\nfloat cloudDensityCheap(vec3 p, float h){ return cloudDensity(p, h, 0.0); }\n\n/** Shape only, against weather already sampled at the shaded point. The light march\n *  and the empty-space skip both want this. */\nfloat cloudDensityCheapW(vec3 p, float h, CloudWeather cw){\n  return cloudDensityW(p, h, 0.0, cw);\n}\n";
 /** Ray/layer and ray/sphere intersection. */
 export declare const cloudGeometry = "\n/**\n * Roots of a*t^2 + rd.y*t + (ro.y - h) = 0 with a = 1/(2R).\n * The naive quadratic formula cancels catastrophically here: a is ~1e-7, so\n * (-b + sqrt(b*b - 4ac)) / 2a returns noise for steep rays and the deck vanishes\n * directly overhead. The stable form below is not optional.\n */\nint layerRoots(vec3 ro, vec3 rd, float h, out float r1, out float r2){\n  float a = u_curvature, b = rd.y, c = ro.y - h;\n  r1 = 1e20; r2 = 1e20;\n  if (a < 1e-12){\n    if (abs(b) < 1e-7) return 0;\n    float t = -c / b;\n    if (t > 0.0){ r1 = t; return 1; }\n    return 0;\n  }\n  float disc = b * b - 4.0 * a * c;\n  if (disc < 0.0) return 0;\n  float sq = sqrt(disc);\n  float q  = -0.5 * (b + (b >= 0.0 ? sq : -sq));\n  if (abs(q) < 1e-20) return 0;\n  float ta = q / a;\n  float tb = c / q;\n  float lo = min(ta, tb), hi = max(ta, tb);\n  int n = 0;\n  if (lo > 0.0){ r1 = lo; n = 1; }\n  if (hi > 0.0){ if (n == 0){ r1 = hi; n = 1; } else { r2 = hi; n = 2; } }\n  return n;\n}\n\nbool layerRange(vec3 ro, vec3 rd, float hb, float ht, out float t0, out float t1){\n  float b1, b2, c1, c2;\n  int nb = layerRoots(ro, rd, hb, b1, b2);\n  int nt = layerRoots(ro, rd, ht, c1, c2);\n  float ts[4]; int n = 0;\n  if (nb > 0){ ts[n] = b1; n++; }\n  if (nb > 1){ ts[n] = b2; n++; }\n  if (nt > 0){ ts[n] = c1; n++; }\n  if (nt > 1){ ts[n] = c2; n++; }\n  if (n == 0){\n    if (ro.y > hb && ro.y < ht){ t0 = 0.0; t1 = 120000.0; return true; }\n    return false;\n  }\n  for (int i = 0; i < 4; i++)\n  for (int j = i + 1; j < 4; j++){\n    if (j < n && ts[j] < ts[i]){ float tmp = ts[i]; ts[i] = ts[j]; ts[j] = tmp; }\n  }\n  bool inside = (ro.y > hb && ro.y < ht);\n  if (inside){ t0 = 0.0; t1 = ts[0]; }\n  else { t0 = ts[0]; t1 = (n > 1) ? ts[n - 1] : ts[0] + 6000.0; }\n  return t1 > t0;\n}\n\nbool sphereRange(vec3 ro, vec3 rd, vec3 c, float r, out float t0, out float t1){\n  vec3 oc = ro - c;\n  float b = dot(oc, rd);\n  float cc = dot(oc, oc) - r * r;\n  float disc = b * b - cc;\n  if (disc < 0.0) return false;\n  float sq = sqrt(disc);\n  t0 = max(-b - sq, 0.0);\n  t1 = -b + sq;\n  return t1 > t0;\n}\n";
-export declare const cloudLighting = "\nuniform float u_sigmaT, u_g1, u_g2;\nuniform float u_msExtinction, u_msEnergy, u_msPhase;\nuniform float u_powder, u_silver, u_ambient;\nuniform vec3  u_skyAmbient, u_groundAmbient;\nuniform int   u_lightSteps;\nuniform float u_lightStep;\n\nfloat hg(float mu, float g){\n  float g2 = g * g;\n  return (1.0 - g2) / (4.0 * PI * pow(max(1.0 + g2 - 2.0 * g * mu, 1e-4), 1.5));\n}\n/** Forward lobe carries the silver lining; the small backward lobe is the glow you get\n *  when the sun is behind you. A single lobe cannot do both. */\nfloat dualLobe(float mu, float g1, float g2){\n  return mix(hg(mu, g1), hg(mu, -abs(g2)), 0.42);\n}\n\nconst vec3 kCone[6] = vec3[6](\n  vec3( 0.38, 0.35, 0.14), vec3(-0.20, 0.60,-0.30), vec3(-0.50,-0.20, 0.40),\n  vec3( 0.10,-0.55,-0.35), vec3( 0.55, 0.10,-0.55), vec3(-0.15, 0.25, 0.62)\n);\n\n/**\n * Six exponentially growing samples toward the sun, spread inside a cone so the\n * self-shadow is soft instead of banded, plus one long-range probe for distant occluders.\n * The step is a FRACTION of cloud depth, not metres: the same absolute value is wrong\n * for an 800 m deck and an 8 km tower.\n */\nfloat lightMarch(vec3 p, float rayT){\n  float thick = (u_host < 0.5) ? (2.0 * u_radius) : max(u_layerTop - u_layerBottom, 1.0);\n  float st = u_lightStep * thick;\n  float acc = 0.0;\n  float t = 0.0;\n  for (int i = 0; i < 6; i++){\n    if (i >= u_lightSteps) break;\n    vec3 sp = p + u_sunDir * (t + st * 0.5) + kCone[i] * (t * 0.38);\n    acc += cloudDensityCheap(sp, heightAt(sp, rayT)) * st;\n    t += st;\n    st *= 1.62;\n  }\n  vec3 fp = p + u_sunDir * (t * 2.6);\n  acc += cloudDensityCheap(fp, heightAt(fp, rayT)) * st * 2.0;\n  return acc;\n}\n\n/**\n * Wrenninge / Hillaire multiple-scattering octaves: each octave scales extinction,\n * energy and phase anisotropy down. A real cumulus has optical depth 5-40 and stays\n * white only because photons scatter hundreds of times; first-order exp(-tau) alone\n * renders it black. This approximation is the single biggest difference between a\n * physically-grounded cloud and a generic one.\n */\nvec3 scatterEnergy(float lightD, float mu){\n  vec3 L = vec3(0.0);\n  float a = 1.0, b = 1.0, c = 1.0;\n  for (int n = 0; n < 3; n++){\n    float ph = dualLobe(mu, u_g1 * c, u_g2 * c);\n    L += vec3(b * ph * exp(-lightD * u_sigmaT * a));\n    a *= u_msExtinction; b *= u_msEnergy; c *= u_msPhase;\n  }\n  L += vec3(u_silver * pow(saturate(mu), 8.0) * exp(-lightD * u_sigmaT * 0.35));\n  return L;\n}\n";
+export declare const cloudLighting = "\nuniform float u_g1, u_g2;\nuniform float u_msExtinction, u_msEnergy, u_msPhase;\nuniform float u_powder, u_silver, u_ambient;\nuniform vec3  u_skyAmbient, u_groundAmbient;\nuniform int   u_lightSteps;\nuniform float u_lightStep;\n\nfloat hg(float mu, float g){\n  float g2 = g * g;\n  return (1.0 - g2) / (4.0 * PI * pow(max(1.0 + g2 - 2.0 * g * mu, 1e-4), 1.5));\n}\n/** Forward lobe carries the silver lining; the small backward lobe is the glow you get\n *  when the sun is behind you. A single lobe cannot do both. */\nfloat dualLobe(float mu, float g1, float g2){\n  return mix(hg(mu, g1), hg(mu, -abs(g2)), 0.42);\n}\n\nconst vec3 kCone[6] = vec3[6](\n  vec3( 0.38, 0.35, 0.14), vec3(-0.20, 0.60,-0.30), vec3(-0.50,-0.20, 0.40),\n  vec3( 0.10,-0.55,-0.35), vec3( 0.55, 0.10,-0.55), vec3(-0.15, 0.25, 0.62)\n);\n\n/**\n * Six exponentially growing samples toward the sun, spread inside a cone so the\n * self-shadow is soft instead of banded, plus one long-range probe for distant occluders.\n * The step is a FRACTION of cloud depth, not metres: the same absolute value is wrong\n * for an 800 m deck and an 8 km tower.\n */\n/**\n * How far a light tap may travel, as a fraction of a weather cell, before it stops\n * reusing the shaded point's weather and samples its own.\n *\n * The steps grow 1.62x, so the last two taps cover most of the distance and carry\n * nearly all of the error \u2014 sharing weather across all six is fine for a 800 m\n * stratocumulus deck and badly wrong for a 8.4 km cumulonimbus, where the cone reaches\n * 5.5 km. Measured against the real baked weather map (p95 absolute coverage error):\n *\n *   share all 6   strato 0.115  cumulus 0.173  Cb 0.408   <- too much on the big types\n *   0.0012 (here) strato 0.074  cumulus 0.106  Cb 0.115\n *   0.0008        strato 0.039  cumulus 0.057  Cb 0.053   <- if a storm looks wrong\n *\n * A distance rule rather than a fixed tap count because it self-tunes: thickness and\n * weatherCellSize are both user-facing sliders, and their ratio is what decides how\n * many taps are safe. It costs nothing in divergence either \u2014 the condition is built\n * from uniforms alone, so every fragment in the draw takes the same branch.\n */\n#define LIGHT_WEATHER_REUSE 0.0012\n\nfloat lightMarch(vec3 p, float rayT, CloudWeather cw){\n  float thick = (u_host < 0.5) ? (2.0 * u_radius) : max(u_layerTop - u_layerBottom, 1.0);\n  float st = u_lightStep * thick;\n  float acc = 0.0;\n  float t = 0.0;\n  for (int i = 0; i < 6; i++){\n    if (i >= u_lightSteps) break;\n    vec3 sp = p + u_sunDir * (t + st * 0.5) + kCone[i] * (t * 0.38);\n    float sh = heightAt(sp, rayT);\n    // Near taps reuse the shaded point's weather; far ones sample their own. What every\n    // tap still fetches per-sample is the 3D shape, which is what forms the shadow.\n    acc += ((t * u_weatherScale < LIGHT_WEATHER_REUSE)\n              ? cloudDensityCheapW(sp, sh, cw)\n              : cloudDensityCheap(sp, sh)) * st;\n    t += st;\n    st *= 1.62;\n  }\n  // The long probe always samples its own: at 2.6x the accumulated distance it can be\n  // 9 km out on a cumulonimbus, well outside the cell the shaded point sits in.\n  vec3 fp = p + u_sunDir * (t * 2.6);\n  acc += cloudDensityCheap(fp, heightAt(fp, rayT)) * st * 2.0;\n  return acc;\n}\n\n/**\n * Wrenninge / Hillaire multiple-scattering octaves: each octave scales extinction,\n * energy and phase anisotropy down. A real cumulus has optical depth 5-40 and stays\n * white only because photons scatter hundreds of times; first-order exp(-tau) alone\n * renders it black. This approximation is the single biggest difference between a\n * physically-grounded cloud and a generic one.\n */\nvec3 scatterEnergy(float lightD, float mu){\n  vec3 L = vec3(0.0);\n  float a = 1.0, b = 1.0, c = 1.0;\n  for (int n = 0; n < 3; n++){\n    float ph = dualLobe(mu, u_g1 * c, u_g2 * c);\n    L += vec3(b * ph * exp(-lightD * u_sigmaT * a));\n    a *= u_msExtinction; b *= u_msEnergy; c *= u_msPhase;\n  }\n  L += vec3(u_silver * pow(saturate(mu), 8.0) * exp(-lightD * u_sigmaT * 0.35));\n  return L;\n}\n";
 /** Everything a fragment shader needs to evaluate the density field. */
 export declare const cloudField: string;
 /** The full model, including scattering. */

package/dist/shaders/glsl/cloudCore.glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloudCore.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/glsl/cloudCore.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,eAAO,MAAM,WAAW,2LAMvB,CAAA;AAED,gGAAgG;AAChG,eAAO,MAAM,MAAM,qxEAyDlB,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,aAAa,mmBAmBzB,CAAA;AAED,eAAO,MAAM,YAAY,spKAmHxB,CAAA;AAED,6CAA6C;AAC7C,eAAO,MAAM,aAAa,kkEAgEzB,CAAA;AAED,eAAO,MAAM,aAAa,88EAgEzB,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,UAAU,QAA+E,CAAA;AAEtG,4CAA4C;AAC5C,eAAO,MAAM,SAAS,QAAyC,CAAA"}
+{"version":3,"file":"cloudCore.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/glsl/cloudCore.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,eAAO,MAAM,WAAW,2LAMvB,CAAA;AAED,gGAAgG;AAChG,eAAO,MAAM,MAAM,qxEAyDlB,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,aAAa,46BAyBzB,CAAA;AAED,eAAO,MAAM,YAAY,+yNA0JxB,CAAA;AAED,6CAA6C;AAC7C,eAAO,MAAM,aAAa,kkEAgEzB,CAAA;AAED,eAAO,MAAM,aAAa,whIA2FzB,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,UAAU,QAA+E,CAAA;AAEtG,4CAA4C;AAC5C,eAAO,MAAM,SAAS,QAAyC,CAAA"}