@adatechnology/game-weather 0.1.1 → 0.2.0

package/dist/index.js

@@ -771,6 +771,177 @@ function createTimeline(options) {
   };
 }
 
+// src/audio/recipes.ts
+import { sceneNoise, sceneTone } from "@adatechnology/game-audio";
+var RAIN_LOOP = {
+  id: "rain_loop",
+  bus: "weather",
+  order: "chain_loop",
+  source: { kind: "noise", loop: true },
+  filters: {
+    mode: "serial",
+    bank: [
+      { type: "highpass", frequency: { set: 600 } },
+      { type: "lowpass", frequency: { set: 6e3 } }
+    ]
+  },
+  sources: ["cena:L1314"]
+};
+var WIND_LOOP = {
+  id: "wind_loop",
+  bus: "weather",
+  order: "chain_loop",
+  source: { kind: "noise", loop: true },
+  filters: { mode: "serial", bank: [{ type: "lowpass", frequency: { set: 320 } }] },
+  modulators: [{ target: "gain", rate: 0.07, depth: 0.035 }],
+  sources: ["cena:L1315"]
+};
+var RAIN_HISS_GAME = {
+  id: "rain_hiss_game",
+  bus: "weather",
+  order: "game_loop",
+  source: { kind: "noise", loop: true },
+  filters: { mode: "serial", bank: [{ type: "highpass", frequency: { set: 2500 } }] },
+  sources: ["jogo:L62116 chuva"]
+};
+var THUNDER = {
+  id: "thunder",
+  bus: "weather",
+  pan: true,
+  layers: [sceneTone({ f: 70, f2: 28, d: 1.2, vol: 1 }), sceneNoise({ f: 260, f2: 50, d: 3.2, vol: 0.9, wet: 0.8 })],
+  falloff: { model: "inverse_square", k: 1e-5, scale: 1.4 },
+  sources: ["jogo:L68278-68285 boom", "sdk: rumble and falloff"]
+};
+var WEATHER_BANK = { id: "weather", sounds: [THUNDER], loops: [RAIN_LOOP, WIND_LOOP, RAIN_HISS_GAME] };
+var WEATHER_SOUNDS = WEATHER_BANK.sounds ?? [];
+var WEATHER_LOOPS = WEATHER_BANK.loops ?? [];
+
+// src/audio/sound.ts
+var DEFAULT_RAIN_SOUND = { light: 0.035, heavy: 0.06, lightAt: 2.5, heavyAt: 15 };
+var DEFAULT_WIND_SOUND = { base: 0.05, referenceSpeed: 3.8, max: 0.12 };
+function rainVolume(rain, options = {}) {
+  if (!(rain > 0)) return 0;
+  const { light, heavy, lightAt, heavyAt } = { ...DEFAULT_RAIN_SOUND, ...options };
+  if (heavyAt <= lightAt) return rain >= heavyAt ? heavy : light;
+  const t = Math.min(1, Math.max(0, (rain - lightAt) / (heavyAt - lightAt)));
+  return light + (heavy - light) * t;
+}
+function windVolume(speed, options = {}) {
+  const { base, referenceSpeed, max } = { ...DEFAULT_WIND_SOUND, ...options };
+  return Math.min(max, base * Math.max(0, speed) / referenceSpeed);
+}
+function strikePosition(strike, origin = [0, 0, 0]) {
+  const angle = strike.bearing * Math.PI / 180;
+  return [origin[0] + Math.sin(angle) * strike.distance, origin[1], origin[2] - Math.cos(angle) * strike.distance];
+}
+function createWeatherSound(sink, options = {}) {
+  if (sink && options.register !== false) sink.register?.(WEATHER_BANK);
+  const rainSound = options.style === "game" ? "rain_hiss_game" : "rain_loop";
+  const loops = /* @__PURE__ */ new Map();
+  const set = (id, volume) => {
+    let loop = loops.get(id);
+    if (!loop) {
+      if (!(volume > 0) || !sink?.loop) return;
+      loop = sink.loop(id);
+      loops.set(id, loop);
+    }
+    loop.set({ volume });
+  };
+  return {
+    update(sample) {
+      set(rainSound, rainVolume(sample.rain, options.rain));
+      set("wind_loop", windVolume(sample.windSpeed, options.wind));
+    },
+    thunder(strike) {
+      sink?.play({ sound: "thunder", position: strikePosition(strike, options.listener?.()), ...options.thunderVolume === void 0 ? {} : { volume: options.thunderVolume } });
+    },
+    dispose() {
+      for (const loop of loops.values()) loop.stop();
+      loops.clear();
+    }
+  };
+}
+
+// src/bridges.ts
+var DEFAULT_BRIDGE_RULES = { filmRainFullAt: 2.5, washFrom: 15, washBelow: 0.5, washEvery: 1, windFull: 20 };
+function environmentOf(sample) {
+  return {
+    rain: sample.rain,
+    windX: sample.windX,
+    windZ: sample.windZ,
+    windSpeed: sample.windSpeed,
+    gust: sample.gust,
+    fogFar: sample.fogFar,
+    visibility: sample.effects.visibility,
+    nightFactor: sample.nightFactor,
+    temperatureC: sample.temperatureC,
+    wetness: sample.groundWetness
+  };
+}
+function createWeatherBridges(targets, options = {}) {
+  const rules = { ...DEFAULT_BRIDGE_RULES, ...options };
+  const sound = options.sound === false || !targets.audio ? void 0 : createWeatherSound(targets.audio, options.sound ?? {});
+  let weather;
+  let offThunder;
+  let sinceWash = 0;
+  let last = {};
+  const push = () => {
+    if (!weather) return;
+    const sample = weather.sample();
+    const { film, interactables, vegetation, vfx, environment } = targets;
+    environment?.set(environmentOf(sample));
+    if (film) {
+      const rain = Math.min(1, Math.max(0, sample.rain / rules.filmRainFullAt));
+      const drying = sample.effects.dryingScale;
+      if (rain !== last.filmRain || drying !== last.drying) film.setWeather({ rain, drying });
+      last.filmRain = rain;
+      last.drying = drying;
+    }
+    if (interactables && sample.rain !== last.rain) interactables.water.setRain(sample.rain);
+    const windChanged = sample.windX !== last.windX || sample.windZ !== last.windZ;
+    if (windChanged) {
+      interactables?.setWind(sample.windX, sample.windZ);
+      vfx?.setWind([sample.windX, 0, sample.windZ]);
+      if (vegetation) {
+        const wind = { strength: Math.min(1, sample.windSpeed / rules.windFull), gust: Math.min(1, sample.gust / rules.windFull) };
+        vegetation.setWind(sample.windSpeed > 1e-6 ? { direction: [sample.windX, sample.windZ], ...wind } : wind);
+      }
+    }
+    last = { ...last, rain: sample.rain, windX: sample.windX, windZ: sample.windZ };
+    sound?.update(sample);
+  };
+  const onThunder = (strike) => sound?.thunder(strike);
+  return {
+    bind(next) {
+      offThunder?.();
+      weather = next;
+      offThunder = next.on("thunder", onThunder);
+      last = {};
+      sinceWash = 0;
+      push();
+    },
+    update(dt) {
+      push();
+      if (!weather || !targets.film?.wash) return;
+      if (weather.sample().rain < rules.washFrom) {
+        sinceWash = 0;
+        return;
+      }
+      sinceWash += dt;
+      if (sinceWash >= rules.washEvery) {
+        sinceWash = 0;
+        targets.film.wash(rules.washBelow);
+      }
+    },
+    dispose() {
+      offThunder?.();
+      offThunder = void 0;
+      weather = void 0;
+      sound?.dispose();
+    }
+  };
+}
+
 // src/bench/locale.ts
 var EN = {
   group: "Weather",
@@ -873,9 +1044,12 @@ var FOG_NEAR = 1;
 function createWeatherTestModule(options = {}) {
   const locale = options.locale ?? "pt-BR";
   const text = weatherBenchTextOf(locale);
-  const { locale: _locale, translate, weather: given, fog: _fog, ...weatherOptions } = options;
+  const { locale: _locale, translate, weather: given, fog: _fog, targets: _targets, sound: _sound, visual: _visual, ...weatherOptions } = options;
   void _locale;
   void _fog;
+  void _targets;
+  void _sound;
+  void _visual;
   const state = {
     seed: options.seed ?? 1,
     hour: options.startHour ?? 8,
@@ -887,6 +1061,8 @@ function createWeatherTestModule(options = {}) {
   let host = null;
   let strikes = 0;
   let offStrike;
+  let bridges;
+  let visual;
   let weather = given ?? createWeather({ ...weatherOptions, autoSchedule: state.auto, ...state.auto ? { timeScale: FAST_SCALE } : {} });
   const watch = () => {
     offStrike?.();
@@ -899,19 +1075,8 @@ function createWeatherTestModule(options = {}) {
     weather = createWeather({ ...weatherOptions, seed: state.seed, start: current, startHour: state.hour, autoSchedule: state.auto, timeScale: state.auto ? FAST_SCALE : NORMAL_SCALE });
     strikes = 0;
     watch();
+    bridges?.bind(weather);
   };
-  const toEnvironment = (sample) => ({
-    rain: sample.rain,
-    windX: sample.windX,
-    windZ: sample.windZ,
-    windSpeed: sample.windSpeed,
-    gust: sample.gust,
-    fogFar: sample.fogFar,
-    visibility: sample.effects.visibility,
-    nightFactor: sample.nightFactor,
-    temperatureC: sample.temperatureC,
-    wetness: sample.groundWetness
-  });
   const applyFog = (far) => {
     const scene = host?.scene;
     const Fog = host?.THREE?.Fog;
@@ -922,12 +1087,13 @@ function createWeatherTestModule(options = {}) {
   };
   const publish = () => {
     const sample = weather.sample();
-    if (state.environment) host?.environment?.set(toEnvironment(sample));
-    if (state.fog) applyFog(sample.fogFar);
+    if (state.environment) host?.environment?.set(environmentOf(sample));
+    if (state.fog && !visual) applyFog(sample.fogFar);
   };
   const onChange = (change) => {
     if (change.kind === "layer") {
       if (change.id === "environment" || change.id === "fog") state[change.id] = change.on;
+      visual?.setLayer(change.id, change.on);
       return;
     }
     if (change.kind === "action") return;
@@ -965,7 +1131,8 @@ function createWeatherTestModule(options = {}) {
   ];
   const layers = () => [
     { id: "environment", name: text.layers.environment },
-    { id: "fog", name: text.layers.fog, default: state.fog }
+    { id: "fog", name: text.layers.fog, default: state.fog },
+    ...options.visual?.layers(locale) ?? []
   ];
   const metrics = () => [
     { id: "current_state", name: text.metrics.state, read: () => nameOf(weather.state()) },
@@ -1054,14 +1221,24 @@ function createWeatherTestModule(options = {}) {
     attach(lent) {
       host = lent;
       const off = lent.bench?.onChange(onChange);
+      bridges = createWeatherBridges({ ...options.targets, ...lent.audio ? { audio: lent.audio } : {} }, { sound: options.sound ?? {} });
+      bridges.bind(weather);
+      visual = options.visual?.create({ host: lent, locale, weather: { sample: () => weather.sample() } });
+      if (visual && !state.fog) visual.setLayer("fog", false);
       publish();
       const offFrame = lent.onFrame((dt) => {
         weather.advance(dt);
         publish();
+        bridges?.update(dt);
+        visual?.update(dt);
       });
       return () => {
+        visual?.dispose();
+        visual = void 0;
         off?.();
         offFrame();
+        bridges?.dispose();
+        bridges = void 0;
         host = null;
       };
     }
@@ -1071,17 +1248,27 @@ function createWeatherTestModule(options = {}) {
 export {
   CLIMATES,
   DAY_REAL_SECONDS,
+  DEFAULT_BRIDGE_RULES,
   DEFAULT_DRY_OUT_SECONDS,
+  DEFAULT_RAIN_SOUND,
   DEFAULT_START_HOUR,
   DEFAULT_TIME_SCALE,
   DEFAULT_WET_RISE_SECONDS,
+  DEFAULT_WIND_SOUND,
   DRY_VISIBILITY_METERS,
   FLASH_END_SECONDS,
   GAME_DAY_SECONDS,
   NIGHT_SIGHT_LOSS,
+  RAIN_HISS_GAME,
+  RAIN_LOOP,
   SPEED_OF_SOUND,
   STATE_VALUE_KEYS,
+  THUNDER,
+  WEATHER_BANK,
+  WEATHER_LOOPS,
+  WEATHER_SOUNDS,
   WEATHER_STATES,
+  WIND_LOOP,
   blendValues,
   createLightningStream,
   createRng,
@@ -1089,18 +1276,24 @@ export {
   createStream,
   createTimeline,
   createWeather,
+  createWeatherBridges,
   createWeatherRegistry,
+  createWeatherSound,
   createWeatherTestModule,
   createWetness,
   dayFractionAt,
   daylight,
   deriveEffects,
+  environmentOf,
   flashIntensity,
   heatIndexC,
   heatStress,
+  rainVolume,
   streamSeed,
+  strikePosition,
   thunderDelay,
   valuesOf,
-  weatherBenchTextOf
+  weatherBenchTextOf,
+  windVolume
 };
 //# sourceMappingURL=index.js.map