sindicate 0.1.0 → 0.4.0

package/src/world/weather.js

@@ -0,0 +1,312 @@
+// Dynamic weather: a slow state machine (clear → overcast → rain → storm) sets a global precipitation
+// intensity; the TYPE is local — warm ground falls as rain (fast streaks + rain/thunder audio), cold/
+// high ground as snow (slow drifting flakes, silent). Precipitation is ONE resident InstancedMesh of
+// camera-following billboarded quads (NOT points — WebGPU point sprites compile pointUV→gl_PointCoord
+// which doesn't exist in WGSL, so they render invisible & are locked to 1px). All motion is shader math
+// off uTime/aSeed (no per-frame buffer churn). An `exposure` factor (0 underground/sheltered → 1 open
+// sky) zeroes it in dungeons + muffles it indoors. Audio loops gaplessly via Web Audio (HTMLAudio loop
+// gaps on AAC padding). Runs AFTER Sky.update so it overlays the time-of-day sky/fog.
+//   Design spec: webgpu-rain-research workflow (2026-06-21) — toneMapped:false (ACESFilmic else greys
+//   the streaks), manual linear fog in opacityNode (custom view-space vertexNode bypasses built-in fog).
+import * as THREE from 'three/webgpu';
+import { uniform, float, vec2, vec3, vec4, attribute, positionGeometry, modelViewMatrix, cameraProjectionMatrix, uv, smoothstep, oneMinus, abs, mod, floor, sin, cos, fract, length, mix, clamp, step, varying } from 'three/tsl';
+import { uWet, uCover, uCloudiness, uRainT, uRain, uWindDir, uWindStr } from './weatherUniforms.js';
+
+const COUNT = 10000;       // instanced quads — density is what makes rain read
+const BOX = 28;            // disk radius around the player (m)
+const TOP = 18, BOT = 5;   // column extent above / below the player (drops pass through eye level)
+const SPAN = TOP + BOT;
+const FALL = 30;           // rain fall speed (m/s); snow is ~7× slower
+const SNOWLINE = 500;      // terrain height (m) where precipitation turns to snow — above every mesa: it never snows on Dustwater
+const STORM_GREY = new THREE.Color(0x4a4f57);
+
+export class Weather {
+  constructor(scene, { shelterObjects = null, indoorAt = null } = {}) {
+    this._shelterObjects = shelterObjects; this._indoorAt = indoorAt;
+    this.scene = scene;
+    this.intensity = 0;          // 0 clear … 1 storm (smoothed)
+    this.target = 0;
+    this.exposure = 1;           // 0 underground/sheltered … 1 open sky (smoothed)
+    this._expTarget = 1;
+    this._snow = 0;              // 0 rain … 1 snow (smoothed by ground coldness)
+    this._snowForce = null;
+    this._time = 0;
+    this._stateT = 0;
+    this._rollT = 0;
+    this._flash = 0;
+    this._nextBolt = 8;
+    this._thunderIn = -1;
+    this._boom = 0;
+    this._wet = 0;               // ground wetness (rain) — eased, drives uWet
+    this._cover = 0;             // ground snow cover — eased, drives uCover
+    this._forced = false;
+    this._muted = false;  // weather SFX (rain/thunder) on with the audio pass; follows the master audio toggle (setMuted)
+    this._ray = new THREE.Raycaster(); this._ray.far = 14;
+    this._up = new THREE.Vector3(0, 1, 0);
+    this._origin = new THREE.Vector3();
+
+    this.uCenter = uniform(new THREE.Vector3());
+    this.uTime = uniform(0);
+    this.uAmount = uniform(0);    // precipitation visual amount = intensity * exposure
+    this.uSnow = uniform(0);      // 0 rain … 1 snow
+    this.uFogNear = uniform(60);  // fed from scene.fog each frame so drops fade into the haze
+    this.uFogFar = uniform(240);
+    this.uRainSize = uniform(1);  // live size multipliers (tunable via console)
+    this.uSnowSize = uniform(1);
+
+    this._buildPrecip();
+    this._buildAudio();
+    this._roll(true);
+  }
+
+  _buildPrecip() {
+    const geo = new THREE.PlaneGeometry(1, 1); // unit quad: positionGeometry ±0.5, uv 0..1
+    const seed = new Float32Array(COUNT * 4);  // (offsetX, phase 0-1, offsetZ, rnd 0-1)
+    for (let i = 0; i < COUNT; i++) {
+      seed[i * 4] = (Math.random() * 2 - 1) * BOX;
+      seed[i * 4 + 1] = Math.random();
+      seed[i * 4 + 2] = (Math.random() * 2 - 1) * BOX;
+      seed[i * 4 + 3] = Math.random();
+    }
+    geo.setAttribute('aSeed', new THREE.InstancedBufferAttribute(seed, 4));
+    const mat = new THREE.MeshBasicNodeMaterial({
+      transparent: true, depthWrite: false, depthTest: true, side: THREE.DoubleSide,
+      forceSinglePass: true, fog: false, toneMapped: false,
+    });
+    const snow = this.uSnow;
+    const s = attribute('aSeed', 'vec4');
+    const rnd = s.w;
+    const near = step(rnd, float(0.5)); // 1 = near drop (rnd ≤ 0.5): tighter, faster, bigger, brighter
+
+    // fall: snow ~7× slower; per-drop jitter; near drops a touch faster. Wraps over the column.
+    const fall = float(FALL).mul(oneMinus(snow.mul(0.86))).mul(float(0.75).add(rnd.mul(0.5))).mul(mix(float(1.0), float(1.15), near));
+    const tt = this.uTime.mul(fall).add(s.y.mul(SPAN));
+    const cyc = floor(tt.div(float(SPAN)));
+    const yLocal = float(TOP).sub(tt.sub(cyc.mul(float(SPAN)))); // = TOP - mod(tt, SPAN)
+    // each fall cycle the drop reappears at a FRESH random spot in the disk, so rain doesn't fall in
+    // fixed vertical lines (the same column repeating). Hash the cycle number with the drop's seed.
+    const jx = fract(sin(cyc.mul(12.9898).add(s.x.mul(4.7)).add(s.z.mul(7.3))).mul(43758.5453)).mul(2.0).sub(1.0).mul(float(BOX));
+    const jz = fract(sin(cyc.mul(78.233).add(s.z.mul(3.1)).add(s.x.mul(2.6))).mul(43758.5453)).mul(2.0).sub(1.0).mul(float(BOX));
+    const wSlant = mix(uWindStr.mul(0.5).add(0.05), float(0.0), snow);                 // rain leans ON THE WIND; snow flutters
+    const driftX = sin(this.uTime.add(s.y.mul(6.283))).mul(mix(float(0.0), float(1.6), snow));
+    const driftZ = cos(this.uTime.mul(0.7).add(s.x.mul(0.3))).mul(mix(float(0.0), float(1.2), snow));
+    const radial = mix(float(1.0), float(0.55), near);
+    const worldPos = this.uCenter.add(vec3(
+      jx.mul(radial).add(yLocal.mul(uWindDir.x).mul(wSlant)).add(driftX),   // streak leans the way the wind blows (XZ)
+      yLocal,
+      jz.mul(radial).add(yLocal.mul(uWindDir.y).mul(wSlant)).add(driftZ),
+    ));
+    // view-space billboard (mesh at origin → modelViewMatrix == view)
+    const viewCenter = modelViewMatrix.mul(vec4(worldPos, 1.0)).xyz;
+    const upView = modelViewMatrix.mul(vec4(0.0, 1.0, 0.0, 0.0)).xyz.normalize(); // world-up in view space
+    const pitch = abs(upView.z);                                                   // 0 level … 1 looking up/down
+    const fore = oneMinus(pitch.mul(0.85));                                        // foreshorten steep streaks
+    const baseW = mix(float(0.028).mul(this.uRainSize), float(0.032).mul(this.uSnowSize), snow);
+    const baseH = mix(float(0.42).mul(this.uRainSize), float(0.036).mul(this.uSnowSize), snow);
+    const sizeMul = mix(float(0.85), float(1.12), near).mul(float(0.8).add(rnd.mul(0.4)));
+    const W = baseW.mul(sizeMul);
+    const H = baseH.mul(sizeMul).mul(mix(fore, float(1.0), snow));
+    const longAxis = mix(vec3(0.0, 1.0, 0.0), upView, pitch.mul(0.6).mul(oneMinus(snow))); // rotate toward up when steep
+    const viewPos = viewCenter.add(vec3(positionGeometry.x.mul(W), float(0), float(0))).add(longAxis.mul(positionGeometry.y).mul(H));
+    mat.vertexNode = cameraProjectionMatrix.mul(vec4(viewPos, 1.0));
+
+    // carry per-drop scalars + camera distance to the fragment
+    const vCamDist = varying(length(viewCenter));
+    const vNear = varying(near);
+    const vRnd = varying(rnd);
+    // fade drops as they reach the ground (yLocal≈0 is the player's feet) so they LAND instead of
+    // punching through the terrain + flickering among the grass blades
+    const vGround = varying(smoothstep(float(-1.5), float(0.8), yLocal));
+
+    const u = uv();
+    // rain streak: thin core, soft tail, bright droplet head
+    const core = oneMinus(smoothstep(0.0, 0.5, abs(u.x.sub(0.5))));
+    const tail = smoothstep(0.0, 0.25, u.y).mul(oneMinus(smoothstep(0.55, 1.0, u.y)));
+    const head = smoothstep(0.7, 1.0, u.y);
+    const streak = core.mul(tail.add(head.mul(1.6)));
+    const flake = oneMinus(smoothstep(0.12, 0.5, length(u.sub(vec2(0.5)))));
+    const shape = mix(streak, flake, snow);
+    const tint = mix(vec3(0.78, 0.86, 1.0), vec3(0.95, 0.97, 1.0), snow);
+    const bright = mix(float(0.9), float(1.35), vNear).mul(float(0.7).add(vRnd.mul(0.6)));
+    // manual linear fog (custom vertexNode bypasses built-in fog): fade drops into the haze, don't paint over it
+    const fogged = oneMinus(smoothstep(this.uFogNear, this.uFogFar, vCamDist));
+    const nearFade = smoothstep(this.uFogNear.mul(0.04), this.uFogNear.mul(0.25), vCamDist); // no lens-plastered drops
+    const density = step(fract(vRnd.mul(11.3)), clamp(this.uAmount.mul(1.3), float(0.15), float(1.0))); // drizzle = fewer drops
+    mat.colorNode = tint.mul(bright);
+    mat.opacityNode = shape.mul(this.uAmount).mul(fogged).mul(nearFade).mul(density).mul(vGround).mul(mix(float(0.55), float(0.9), snow)).clamp(0.0, 1.0);
+
+    const precip = new THREE.InstancedMesh(geo, mat, COUNT);
+    const I = new THREE.Matrix4();
+    for (let i = 0; i < COUNT; i++) precip.setMatrixAt(i, I); // identity — positions come from the shader
+    precip.instanceMatrix.needsUpdate = true;
+    precip.frustumCulled = false;
+    precip.renderOrder = 10; // after opaque world
+    this.scene.add(precip);
+    this.precip = precip;
+  }
+
+  // ---- gapless audio via Web Audio (decoded buffers loop without the AAC padding gap) ----
+  _buildAudio() {
+    this._buf = {}; this._src = {}; this._gain = {}; this._actx = null;
+    this._load('rain', '/assets/audio/weather/rain.m4a');
+    this._load('thunder', '/assets/audio/weather/thunder.m4a');
+    const unlock = () => { if (this._actx?.state === 'suspended') this._actx.resume(); };
+    addEventListener('pointerdown', unlock); addEventListener('keydown', unlock);
+  }
+  _ctx() { if (!this._actx) this._actx = new (window.AudioContext || window.webkitAudioContext)(); return this._actx; }
+  async _load(key, url) {
+    try { const r = await fetch(url); this._buf[key] = await this._ctx().decodeAudioData(await r.arrayBuffer()); } catch (e) { /* leave silent */ }
+  }
+  _vol(key, vol) {
+    if (this._muted) vol = 0;
+    vol *= 0.28;   // master weather volume cap — rain/thunder at full gain (1.0) was ear-splitting
+    const buf = this._buf[key]; if (!buf) return;
+    if (vol > 0.002) {
+      if (!this._src[key]) {
+        const ctx = this._ctx(); if (ctx.state === 'suspended') ctx.resume();
+        const src = ctx.createBufferSource(); src.buffer = buf; src.loop = true;
+        const g = ctx.createGain(); g.gain.value = 0;
+        src.connect(g).connect(ctx.destination); src.start();
+        this._src[key] = src; this._gain[key] = g;
+      }
+      this._gain[key].gain.setTargetAtTime(Math.min(1, vol), this._actx.currentTime, 0.3); // smooth, no clicks
+    } else if (this._src[key]) {
+      try { this._src[key].stop(); } catch (e) {}
+      this._src[key] = null; this._gain[key] = null;
+    }
+  }
+
+  // A DISCRETE thunderclap fired on each bolt — a one-shot with a sharp attack + rolling decay.
+  // (The old scheme looped thunder as a bed and nudged its volume, but _vol's 0.3s smoothing
+  // smeared every clap into an inaudible swell, and the low rumble is sub-bass laptop speakers
+  // barely reproduce. A punchy transient reads as thunder on any speaker.)
+  _thunderClap(vol) {
+    const buf = this._buf.thunder; if (!buf || this._muted) return;
+    const ctx = this._ctx(); if (ctx.state === 'suspended') ctx.resume();
+    const src = ctx.createBufferSource(); src.buffer = buf; src.loop = false;
+    const off = Math.random() * Math.max(0, buf.duration - 5);   // vary which part of the sample
+    const g = ctx.createGain(); const t = ctx.currentTime;
+    const peak = Math.min(0.6, vol);
+    g.gain.setValueAtTime(0.0001, t);
+    g.gain.exponentialRampToValueAtTime(peak, t + 0.03);         // sharp crack
+    g.gain.exponentialRampToValueAtTime(0.0001, t + 4.0);        // rolling boom decay
+    src.connect(g).connect(ctx.destination);
+    src.start(t, off, 4.2); try { src.stop(t + 4.3); } catch (e) {}
+  }
+
+  _roll(initial) {
+    if (initial) this.target = 0;
+    else { const r = Math.random(); this.target = r < 0.42 ? 0 : r < 0.68 ? 0.18 : r < 0.9 ? 0.55 : 1.0; }
+    this._stateT = 90 + Math.random() * 150;
+  }
+
+  // Debug: pin the weather (intensity 0-1, snow 0|1). Pass null to resume the natural cycle.
+  force(intensity, snow = null) {
+    if (intensity == null) { this._forced = false; this._snowForce = null; return; }
+    this._forced = true; this.target = intensity; this.intensity = intensity;
+    this._snowForce = snow;
+  }
+
+  update(dt, playerPos, sky, world) {
+    this._time += dt;
+    this.uTime.value = this._time;
+    this.uCenter.value.copy(playerPos);
+
+    if (!this._forced) {
+      if ((this._stateT -= dt) <= 0) this._roll(false);
+      this.intensity += (this.target - this.intensity) * Math.min(1, dt * 0.4);
+    }
+
+    if ((this._rollT -= dt) <= 0) {
+      this._rollT = 0.3;
+      if (this._indoorAt?.(playerPos)) this._expTarget = 0;   // generic indoor-volume interface — no precipitation inside
+      // A ROOF IS A ROOF. This used to leave 0.18 of the rain falling indoors, which reads as rain
+      // coming through the ceiling — and now that every door in the county opens, you are inside far
+      // more often and you see it. Nothing falls under a roof.
+      // ...and a MOVING roof is a roof too: the shelter ray tests the building BVHs, which a train
+      // carriage or a coach cab is not in. shelterHook (main.js) answers for the vehicles.
+      else { this._roofed = (this.shelterHook?.() ?? false) || this._sheltered(playerPos, world); this._expTarget = this._roofed ? 0 : 1; }
+    }
+    this.exposure += (this._expTarget - this.exposure) * Math.min(1, dt * 2.5);
+
+    const cold = this._snowForce != null ? this._snowForce
+      : world?.groundAt ? THREE.MathUtils.smoothstep(world.groundAt(playerPos.x, playerPos.z), SNOWLINE - 8, SNOWLINE + 8) : 0;
+    this._snow += (cold - this._snow) * Math.min(1, dt * 0.5);
+    this.uSnow.value = this._snow;
+    // cloud deck LEADS precipitation: full-heavy while rain is still building (x1.75), lingers
+    // as it eases off — the sky visibly thickens before the rain/snow starts and clears after
+    uCloudiness.value = Math.min(1, this.intensity * 1.75);
+
+    // ground accumulation: rain wets the ground (fast), snow covers it (slow). Uses the player's local
+    // snow factor (visible ground is near the player); eases so it soaks/dries + builds/melts gradually.
+    this._wet += (this.intensity * (1 - this._snow) - this._wet) * Math.min(1, dt * 0.18);
+    this._cover += (this.intensity * this._snow - this._cover) * Math.min(1, dt * 0.07);
+    uWet.value = this._wet;
+    uRainT.value = this._time;      // the ground's clock (splashes and rings)
+    uRain.value = this.intensity * (1 - this._snow);   // what is falling NOW — snow does not splash
+    uCover.value = this._cover;
+
+    this.uAmount.value = this.intensity * this.exposure;
+
+    const k = this.intensity; // darken the sky even when sheltered — it's overcast outside
+    sky.sun.intensity *= 1 - k * 0.55;
+    sky.hemi.intensity *= 1 - k * 0.42;
+    // Fog responds to weather: clear/sunny pushes the far haze WAY back (the quality preset pulls fog in
+    // hard for perf — fogScale 0.45 → far ~144m, which reads as "very close"); storms pull it back in.
+    // Capped at 330m so we never reveal un-streamed terrain past the ~360m tile ring, whatever the preset.
+    sky.scene.fog.near *= 1.5 - k * 0.8;                              // clear ×1.5 … storm ×0.7
+    sky.scene.fog.far = Math.min(sky.scene.fog.far * (2.3 - k * 1.7), 330); // clear → ~330m … storm → in close
+    if (k > 0.01) sky.scene.fog.color.lerp(STORM_GREY, k * 0.5);
+    this.uFogNear.value = sky.scene.fog.near;
+    this.uFogFar.value = sky.scene.fog.far * 0.75; // rain fades a touch before the world far plane
+
+    this._lightning(dt, sky);
+    // ...but you still HEAR it. Under a roof the drops stop and the sound does not: it drums on the
+    // shingles above you, muffled. Silence indoors during a downpour is as wrong as rain through the
+    // ceiling. (Underground is a different matter — there `exposure` is zeroed without `_roofed`.)
+    this._audio(this.intensity * (this._roofed ? 0.35 : this.exposure));
+  }
+
+  // IS THERE A ROOF OVER HIM? Look up, and ask the same solid world the player collides with.
+  //
+  // This used to raycast `buildingObjects`, and that array is EMPTY by the time anyone plays:
+  // world.js takes a copy of it to bake the building BVH, and the region streamer splices it as it
+  // goes, so the county's 121 buildings are in the BVH and not in the list. Measured in the running
+  // game: buildingObjects.length === 0 while the scene holds 121 `bld:` meshes. The test could
+  // therefore never find a roof, and the rain fell indoors everywhere, in every building, always.
+  // Ask the BVH — it is the thing that actually knows where the walls and roofs are.
+  _sheltered(p, world) {
+    this._ray.set(this._origin.set(p.x, p.y + 1.2, p.z), this._up);
+    const bvh = world?.buildingBVH;
+    if (bvh?.raycastFirst) {
+      try { if (bvh.raycastFirst(this._ray.ray, THREE.DoubleSide)) return true; } catch (e) { /* a bad BVH is not worth a stack trace every 0.3s */ }
+    }
+    for (const b of world?.sideBVHs ?? []) {          // ...and the settlements streamed in during play
+      try { if (b.raycastFirst?.(this._ray.ray, THREE.DoubleSide)) return true; } catch (e) { /* ditto */ }
+    }
+    const objs = this._shelterObjects?.() ?? [];
+    return objs.length > 0 && this._ray.intersectObjects(objs, true).length > 0;
+  }
+
+  _lightning(dt, sky) {
+    if (this.intensity > 0.72 && this.exposure > 0.4 && this._snow < 0.5) {
+      if ((this._nextBolt -= dt) <= 0) { this._flash = 1; this._nextBolt = 5 + Math.random() * 14; this._thunderIn = 1.2 + Math.random() * 2.5; }
+    }
+    if (this._flash > 0) {
+      this._flash = Math.max(0, this._flash - dt * 3.2);
+      sky.hemi.intensity += this._flash * this._flash * 1.8;
+      sky.sun.intensity += this._flash * this._flash * 0.9;
+    }
+    if (this._thunderIn > 0 && (this._thunderIn -= dt) <= 0) this._thunderClap(0.42 + Math.random() * 0.18);
+  }
+
+  _audio(amount) {
+    const dry = 1 - this._snow; // snow is silent
+    this._vol('rain', THREE.MathUtils.clamp((amount - 0.15) / 0.5, 0, 1) * 0.6 * dry);
+    // thunder is discrete claps synced to the bolts now (see _thunderClap / _lightning), not a
+    // continuous bed — so stop any lingering thunder loop.
+    this._vol('thunder', 0);
+  }
+
+  setMuted(on) { this._muted = on; }
+}