@adatechnology/game-weather-three 0.4.3 → 0.5.1

package/dist/chunk-SOEOSGSU.js

@@ -0,0 +1,621 @@
+// src/bench/visual.ts
+import { isLightBudget } from "@adatechnology/game-render-three";
+import { footprintBlocker } from "@adatechnology/game-contracts";
+
+// src/headlights.ts
+import { LIGHT_PRIORITY } from "@adatechnology/game-render-three";
+var HEADLIGHTS = {
+  spot: { color: 16773584, intensity: 2.4, distance: 26, angle: 0.33, penumbra: 0.5, decay: 1.6 },
+  /** Lamp position on the car (x is mirrored), where the spot points, and the cone drawn in the air. */
+  lamp: [0.65, 0.74, 2.15],
+  aim: [0.65, 0.2, 12],
+  cone: { radius: 2.4, length: 9, segments: 18, color: 16773584, opacity: 0.06 },
+  lens: { on: 16773584, off: 3815988 },
+  /** Lit drops a second, thrown into the beam 1 to 13 m ahead (W1176). */
+  lit: { rate: 600, depth: [1, 13], spread: 0.33, color: 13622512, alpha: 0.9, life: 0.06, len: 0.035, velocity: [0.8, -14, 0] },
+  /** Beyond this many metres a car keeps only the cone: no real light (W-b text of `farol`). */
+  lightRange: 40
+};
+var defaultHeadlightRule = (sample) => sample.nightFactor > 0.3 || sample.rain > 0 || sample.fogDensity > 0.02 || sample.visibility < 150;
+function createHeadlights(THREE, rules = {}) {
+  const rigs = /* @__PURE__ */ new Set();
+  const cone = HEADLIGHTS.cone;
+  const lampWorld = new THREE.Vector3();
+  const aimWorld = new THREE.Vector3();
+  const forward = new THREE.Vector3();
+  const rule = rules.lit ?? defaultHeadlightRule;
+  const range = rules.lightRange ?? HEADLIGHTS.lightRange;
+  const lights = rules.lights;
+  const forwardAxis = new THREE.Vector3(0, 0, -1);
+  function lampSource(side, car, targets) {
+    const lamp = new THREE.Object3D();
+    lamp.position.set(side * HEADLIGHTS.lamp[0], HEADLIGHTS.lamp[1], HEADLIGHTS.lamp[2]);
+    const aim = new THREE.Vector3(side * HEADLIGHTS.aim[0], HEADLIGHTS.aim[1], HEADLIGHTS.aim[2]).sub(lamp.position).normalize();
+    lamp.quaternion.setFromUnitVectors(forwardAxis, aim);
+    car.add(lamp);
+    targets.push(lamp);
+    const spot = HEADLIGHTS.spot;
+    return lights.addSource({ owner: "weather.headlight", kind: "spot", priority: LIGHT_PRIORITY.headlight, color: spot.color, intensity: 0, distance: spot.distance, decay: spot.decay, angle: spot.angle, penumbra: spot.penumbra, position: [0, 0, 0], follow: lamp });
+  }
+  function legacySpot(side, car, targets) {
+    const spot = new THREE.SpotLight(HEADLIGHTS.spot.color, 0, HEADLIGHTS.spot.distance, HEADLIGHTS.spot.angle, HEADLIGHTS.spot.penumbra, HEADLIGHTS.spot.decay);
+    spot.position.set(side * HEADLIGHTS.lamp[0], HEADLIGHTS.lamp[1], HEADLIGHTS.lamp[2]);
+    const target = new THREE.Object3D();
+    target.position.set(side * HEADLIGHTS.aim[0], HEADLIGHTS.aim[1], HEADLIGHTS.aim[2]);
+    car.add(spot, target);
+    spot.target = target;
+    targets.push(target);
+    return spot;
+  }
+  function attach(car, lens) {
+    const spots = [];
+    const cones = [];
+    const targets = [];
+    const sources = [];
+    for (const side of [-1, 1]) {
+      if (lights) sources.push(lampSource(side, car, targets));
+      else spots.push(legacySpot(side, car, targets));
+      const geometry = new THREE.ConeGeometry(cone.radius, cone.length, cone.segments, 1, true);
+      geometry.translate(0, -cone.length / 2, 0);
+      geometry.rotateX(-Math.PI / 2);
+      const material = new THREE.MeshBasicMaterial({ color: cone.color, transparent: true, opacity: cone.opacity, blending: THREE.AdditiveBlending, depthWrite: false, side: THREE.DoubleSide, fog: false });
+      const beam = new THREE.Mesh(geometry, material);
+      beam.position.set(side * HEADLIGHTS.lamp[0], HEADLIGHTS.lamp[1], HEADLIGHTS.lamp[2]);
+      beam.visible = false;
+      car.add(beam);
+      cones.push(beam);
+    }
+    const rig = { car, spots, sources, cones, lens, targets };
+    rigs.add(rig);
+    return () => {
+      rigs.delete(rig);
+      for (const object of [...spots, ...cones, ...targets]) car.remove(object);
+      for (const beam of cones) {
+        beam.geometry.dispose();
+        beam.material.dispose();
+      }
+      for (const spot of spots) spot.dispose();
+      for (const source of sources) source.remove();
+      lens?.color.setHex(HEADLIGHTS.lens.off);
+    };
+  }
+  return {
+    attach,
+    update(sample, dt, camera, engine, enabled = true) {
+      const on = enabled && rule(sample);
+      let index = 0;
+      for (const rig of rigs) {
+        rig.car.updateWorldMatrix(true, false);
+        lampWorld.set(0, HEADLIGHTS.lamp[1], HEADLIGHTS.lamp[2]).applyMatrix4(rig.car.matrixWorld);
+        const near = Math.hypot(lampWorld.x - camera[0], lampWorld.z - camera[2]) <= range;
+        for (const spot of rig.spots) spot.intensity = on && near ? HEADLIGHTS.spot.intensity : 0;
+        for (const source of rig.sources) source.update({ intensity: on && near ? HEADLIGHTS.spot.intensity : 0 });
+        for (const beam of rig.cones) beam.visible = on;
+        rig.lens?.color.setHex(on ? HEADLIGHTS.lens.on : HEADLIGHTS.lens.off);
+        if (!on || !engine || sample.rain <= 0 || !near) {
+          index++;
+          continue;
+        }
+        aimWorld.set(0, HEADLIGHTS.lamp[1], HEADLIGHTS.lamp[2] + 1).applyMatrix4(rig.car.matrixWorld);
+        forward.copy(aimWorld).sub(lampWorld).normalize();
+        const side = [forward.z, -forward.x];
+        const { random } = engine;
+        const lit = HEADLIGHTS.lit;
+        engine.emit(`weather-lit-${index}`, "streak", lit.rate, dt, () => {
+          const depth = random.between(lit.depth[0], lit.depth[1]);
+          const spread = depth * lit.spread * Math.sqrt(random.next());
+          const turn = random.between(0, 6.283);
+          return {
+            p: [lampWorld.x + forward.x * depth + side[0] * Math.cos(turn) * spread, lampWorld.y + forward.y * depth + Math.sin(turn) * spread * 0.6, lampWorld.z + forward.z * depth + side[1] * Math.cos(turn) * spread],
+            v: lit.velocity,
+            sp: 0,
+            life: lit.life,
+            len: lit.len,
+            c0: lit.color,
+            a: lit.alpha
+          };
+        });
+        index++;
+      }
+    },
+    count: () => rigs.size,
+    dispose() {
+      for (const rig of [...rigs]) {
+        rigs.delete(rig);
+        for (const object of [...rig.spots, ...rig.cones, ...rig.targets]) rig.car.remove(object);
+        for (const source of rig.sources) source.remove();
+      }
+    }
+  };
+}
+
+// src/fog.ts
+import { createFog as createStableFog } from "@adatechnology/game-render-three";
+
+// src/sky.ts
+var SKY_NIGHT = 724760;
+var SKY_DAY = 8885926;
+var ZONE_LIGHT = { base: 0.35, sun: 0.65 };
+var ZONE_FOG_DEFAULTS = { color: 3820090, far: 60 };
+function createSky(THREE, scene) {
+  const night = new THREE.Color(SKY_NIGHT);
+  const day = new THREE.Color(SKY_DAY);
+  const zoneColor = new THREE.Color(ZONE_FOG_DEFAULTS.color);
+  const tint = new THREE.Color();
+  const color = new THREE.Color();
+  return {
+    color,
+    update(sample, zone) {
+      color.lerpColors(night, day, sample.sun);
+      color.multiplyScalar(sample.skyScale);
+      if (zone && zone.weight > 0) {
+        zoneColor.setHex(zone.color ?? ZONE_FOG_DEFAULTS.color);
+        color.lerp(tint.copy(zoneColor).multiplyScalar(ZONE_LIGHT.base + sample.sun * ZONE_LIGHT.sun), zone.weight);
+      }
+      const background = scene.background;
+      if (background && background.isColor) background.copy(color);
+      else scene.background = color.clone();
+      return color;
+    }
+  };
+}
+
+// src/fog.ts
+var FOG_NEAR = 25;
+var FOG_ZONE_NEAR = 4;
+var FOG_EXP_FROM = 5e-4;
+var densityForFar = (far) => Math.sqrt(Math.log(50)) / far;
+function fogOf(sample, zone, expFrom = FOG_EXP_FROM) {
+  const weight = zone?.weight ?? 0;
+  const zoneFar = zone?.far ?? ZONE_FOG_DEFAULTS.far;
+  if (sample.fogDensity >= expFrom) return { mode: "exp2", density: sample.fogDensity + (densityForFar(zoneFar) - sample.fogDensity) * weight };
+  return { mode: "linear", near: FOG_NEAR + (FOG_ZONE_NEAR - FOG_NEAR) * weight, far: sample.fogFar + (zoneFar - sample.fogFar) * weight };
+}
+function createFog(THREE, scene, options = {}) {
+  if (options.stable) return stableFog(THREE, scene, options);
+  const original = scene.fog;
+  const kept = original && original.isFog ? original.clone() : original;
+  return {
+    update(sample, sky, zone) {
+      const values = fogOf(sample, zone, options.expFrom);
+      const current = scene.fog;
+      if (values.mode === "linear") {
+        if (current?.isFog) {
+          current.color.copy(sky);
+          current.near = values.near;
+          current.far = values.far;
+        } else scene.fog = new THREE.Fog(sky.getHex(), values.near, values.far);
+      } else if (current?.isFogExp2) {
+        current.color.copy(sky);
+        current.density = values.density;
+      } else scene.fog = new THREE.FogExp2(sky.getHex(), values.density);
+      const fog = scene.fog;
+      fog.color.copy(sky);
+    },
+    clear() {
+      scene.fog = kept && kept.isFog ? kept.clone() : kept ?? null;
+    }
+  };
+}
+function stableFog(THREE, scene, options) {
+  const controller = createStableFog(THREE, scene, { stable: true });
+  return {
+    update(sample, sky, zone) {
+      const values = fogOf(sample, zone, options.expFrom);
+      if (values.mode === "linear") controller.useLinear(sky.getHex(), values.near, values.far);
+      else controller.useExp2(sky.getHex(), values.density);
+      scene.fog.color.copy(sky);
+    },
+    clear: () => controller.clear()
+  };
+}
+var MIST = { box: { x: [-14, 10], y: [0.2, 1.1], z: [-3, 8] }, drift: [0.15, 0.35], life: [9, 13], size: [3, 5], grow: 1.4, color: 8227488, alpha: 0.13, fadeIn: 0.35 };
+var ASH = { box: { x: [-10, 8], y: [4, 6], z: [-3, 7] }, fall: -0.35, life: [8, 12], size: [0.025, 0.04], color: 10525328, alpha: 0.75, fadeIn: 0.1 };
+function emitAirborne(engine, sample, dt, camera) {
+  const { random } = engine;
+  const around = (box) => [
+    camera[0] + random.between(box.x[0], box.x[1]),
+    random.between(box.y[0], box.y[1]),
+    camera[2] + random.between(box.z[0], box.z[1])
+  ];
+  if (sample.mistPerSecond > 0) {
+    engine.emit("weather-mist", "normal", sample.mistPerSecond, dt, () => ({
+      p: around(MIST.box),
+      v: [random.between(MIST.drift[0], MIST.drift[1]), 0, random.between(-0.05, 0.05)],
+      sp: 0,
+      life: MIST.life,
+      size: MIST.size,
+      grow: MIST.grow,
+      c0: MIST.color,
+      a: MIST.alpha,
+      fi: MIST.fadeIn
+    }));
+  }
+  if (sample.ashPerSecond > 0) {
+    engine.emit("weather-ash", "normal", sample.ashPerSecond, dt, () => ({
+      p: around(ASH.box),
+      v: [random.between(0.1, 0.4), ASH.fall, random.between(-0.1, 0.1)],
+      sp: [0.05, 0.15],
+      life: ASH.life,
+      size: ASH.size,
+      c0: ASH.color,
+      a: ASH.alpha,
+      fi: ASH.fadeIn,
+      gnd: 1
+    }));
+  }
+}
+
+// src/heat-haze.ts
+var HEAT_HAZE = { opacity: 0.09, bands: 38, rise: 1.4, color: [1, 0.93, 0.82] };
+var HEAT_HAZE_VERTEX = "varying vec2 vUv; void main(){ vUv = uv; gl_Position = vec4(position.xy, 0., 1.); }";
+var HEAT_HAZE_FRAGMENT = "uniform float uTime; uniform float uHaze; uniform vec3 uColor; varying vec2 vUv; void main(){ float low = 1. - smoothstep(0.15, 0.7, vUv.y); float wave = sin(vUv.y*38. - uTime*1.4 + sin(vUv.x*11. + uTime*.7)*2.2) * .5 + .5; gl_FragColor = vec4(uColor, uHaze*low*wave*.09); }";
+function createHeatHaze(THREE) {
+  const uniforms = { uTime: { value: 0 }, uHaze: { value: 0 }, uColor: { value: new THREE.Vector3(...HEAT_HAZE.color) } };
+  const material = new THREE.ShaderMaterial({ uniforms, vertexShader: HEAT_HAZE_VERTEX, fragmentShader: HEAT_HAZE_FRAGMENT, transparent: true, depthTest: false, depthWrite: false });
+  const object = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), material);
+  object.frustumCulled = false;
+  object.renderOrder = 999;
+  object.name = "weather-heat-haze";
+  object.visible = false;
+  return {
+    object,
+    update(sample, time) {
+      uniforms.uHaze.value = sample.haze;
+      uniforms.uTime.value = time;
+      object.visible = sample.haze > 0;
+    },
+    dispose() {
+      object.geometry.dispose();
+      material.dispose();
+    }
+  };
+}
+
+// src/lightning.ts
+var LIGHTNING = { light: 3.2, background: [0.25, 0.27, 0.32], white: 0.12, skyColor: 3820650, groundColor: 723724 };
+function createLightning(THREE, scene, vfx, options = {}) {
+  const leased = options.lights?.leaseHemisphere("weather.lightning") ?? null;
+  const light = leased ?? new THREE.HemisphereLight(LIGHTNING.skyColor, LIGHTNING.groundColor, 0);
+  light.name = "weather-lightning";
+  light.color.setHex(LIGHTNING.skyColor);
+  light.groundColor.setHex(LIGHTNING.groundColor);
+  if (!options.lights) scene.add(light);
+  return {
+    light,
+    update(sample, background) {
+      const flash = sample.flash;
+      light.intensity = flash * LIGHTNING.light;
+      if (flash <= 0) return;
+      if (background) {
+        background.r += flash * LIGHTNING.background[0];
+        background.g += flash * LIGHTNING.background[1];
+        background.b += flash * LIGHTNING.background[2];
+      }
+      const screen = vfx?.workshop().screen;
+      if (screen) screen.white = Math.max(screen.white, flash * LIGHTNING.white);
+    },
+    dispose() {
+      light.intensity = 0;
+      if (options.lights) return;
+      scene.remove(light);
+      light.dispose();
+    }
+  };
+}
+
+// src/rain-near.ts
+import { inPuddle } from "@adatechnology/game-vfx";
+var SPLASH_FROM_MM = 5;
+function createNearRain(vfx, options = {}) {
+  const puddles = options.puddles ?? [];
+  return {
+    update(sample, dt, camera) {
+      const raining = sample.rain > 0;
+      const engine = raining ? vfx?.workshop() : vfx?.peekWorkshop();
+      if (!engine) return;
+      const field = engine.rain;
+      if (!raining) {
+        if (field.on) field.clear();
+        return;
+      }
+      field.puddleAt = options.puddleAt ?? ((x, z) => inPuddle(puddles, x, z));
+      field.drive(sample.drops, sample.windX, camera[0], camera[2]);
+      field.update(dt, sample.rain >= (options.splashFrom ?? SPLASH_FROM_MM), camera);
+    },
+    count: () => vfx?.peekWorkshop()?.rain.count ?? 0,
+    clear() {
+      vfx?.peekWorkshop()?.rain.clear();
+    }
+  };
+}
+
+// src/rain-curtain.ts
+var RAIN_CURTAIN = { count: 14e3, width: 70, height: 25, speed: 13, pointSize: 1.6 };
+var RAIN_CURTAIN_VERTEX = "uniform float uTime; uniform vec3 uCam; void main(){ vec3 p = position; p.y = mod(p.y - uTime*13., 25.); p.xz = uCam.xz + mod(p.xz - uCam.xz + 35., 70.) - 35.; gl_Position = projectionMatrix*viewMatrix*vec4(p,1.); gl_PointSize = 1.6; }";
+var RAIN_CURTAIN_FRAGMENT = "uniform float uDay; void main(){ gl_FragColor = vec4(vec3(.68,.72,.78)*(0.25+0.75*uDay), .22+.1*uDay); }";
+var RAIN_CURTAIN_PROFILES = { low: 0.35, medium: 0.7, high: 1 };
+var RAIN_CURTAIN_FULL_AT = 4e3;
+function rainCurtainPositions(random = Math.random, count = RAIN_CURTAIN.count) {
+  const positions = new Float32Array(count * 3);
+  for (let index = 0; index < count; index++) {
+    positions[index * 3] = (random() - 0.5) * RAIN_CURTAIN.width;
+    positions[index * 3 + 1] = random() * RAIN_CURTAIN.height;
+    positions[index * 3 + 2] = (random() - 0.5) * RAIN_CURTAIN.width;
+  }
+  return positions;
+}
+function createRainCurtain(THREE, options = {}) {
+  const count = options.count ?? RAIN_CURTAIN.count;
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute("position", new THREE.BufferAttribute(rainCurtainPositions(options.random, count), 3));
+  const uniforms = { uTime: { value: 0 }, uCam: { value: new THREE.Vector3() }, uDay: { value: 1 } };
+  const material = new THREE.ShaderMaterial({ uniforms, transparent: true, depthWrite: false, vertexShader: RAIN_CURTAIN_VERTEX, fragmentShader: RAIN_CURTAIN_FRAGMENT });
+  const object = new THREE.Points(geometry, material);
+  object.frustumCulled = false;
+  object.name = "weather-rain-curtain";
+  object.visible = false;
+  let share = RAIN_CURTAIN_PROFILES[options.profile ?? "high"];
+  let drawn = 0;
+  return {
+    object,
+    update(sample, camera, time, daylight) {
+      const fullAt = options.fullAt ?? RAIN_CURTAIN_FULL_AT;
+      drawn = sample.rain > 0 ? Math.round(count * share * Math.min(1, sample.drops / fullAt)) : 0;
+      object.visible = drawn > 0;
+      geometry.setDrawRange(0, drawn);
+      uniforms.uTime.value = time;
+      uniforms.uDay.value = daylight;
+      uniforms.uCam.value.set(camera.x, camera.y, camera.z);
+    },
+    setProfile(profile) {
+      share = RAIN_CURTAIN_PROFILES[profile];
+    },
+    drawn: () => drawn,
+    dispose() {
+      geometry.dispose();
+      material.dispose();
+    }
+  };
+}
+
+// src/renderer.ts
+var WEATHER_LAYERS = ["far_rain", "near_rain", "mist", "fog", "sky", "lightning", "headlights", "haze"];
+function createWeatherRenderer(THREE, options) {
+  const { scene, camera, weather, vfx } = options;
+  const group = new THREE.Group();
+  group.name = "weather";
+  scene.add(group);
+  const curtain = createRainCurtain(THREE, { ...options.random ? { random: options.random } : {}, ...options.profile ? { profile: options.profile } : {} });
+  const haze = createHeatHaze(THREE);
+  group.add(curtain.object, haze.object);
+  const sky = createSky(THREE, scene);
+  const fog = createFog(THREE, scene, { stable: options.lights !== void 0 });
+  const lightning = createLightning(THREE, scene, vfx, options.lights ? { lights: options.lights } : {});
+  const headlights = createHeadlights(THREE, options.lights ? { ...options.headlights, lights: options.lights } : options.headlights);
+  const nearRain = createNearRain(vfx, { ...options.puddles ? { puddles: options.puddles } : {}, ...options.puddleAt ? { puddleAt: options.puddleAt } : {} });
+  const on = new Map(WEATHER_LAYERS.map((id) => [id, options.layers?.[id] ?? true]));
+  let zone = options.zone;
+  let time = 0;
+  const eye = { x: 0, y: 0, z: 0 };
+  const switchedOff = (id) => {
+    if (id === "far_rain") curtain.object.visible = false;
+    else if (id === "near_rain") nearRain.clear();
+    else if (id === "fog") fog.clear();
+    else if (id === "lightning") lightning.light.intensity = 0;
+    else if (id === "haze") haze.object.visible = false;
+  };
+  return {
+    curtain,
+    nearRain,
+    fog,
+    sky,
+    lightning,
+    headlights,
+    haze,
+    update(dt) {
+      time += dt;
+      const sample = weather.sample();
+      const position = camera.position;
+      eye.x = position.x;
+      eye.y = position.y;
+      eye.z = position.z;
+      const where = [eye.x, eye.y, eye.z];
+      const background = scene.background ?? void 0;
+      const ownSky = on.get("sky") === true;
+      const color = ownSky ? sky.update(sample, zone) : background && background.isColor ? background : sky.color;
+      if (on.get("fog")) fog.update(sample, color, zone);
+      if (on.get("lightning")) lightning.update(sample, ownSky ? scene.background : void 0);
+      if (on.get("far_rain")) curtain.update(sample, eye, time, sample.sun);
+      if (on.get("haze")) haze.update(sample, time);
+      if (vfx) {
+        if (on.get("near_rain")) nearRain.update(sample, dt, where);
+        if (on.get("mist")) emitAirborne(vfx.workshop(), sample, dt, where);
+      }
+      headlights.update(sample, dt, where, vfx && sample.rain > 0 ? vfx.workshop() : void 0, on.get("headlights"));
+    },
+    setLayer(id, value) {
+      on.set(id, value);
+      if (!value) switchedOff(id);
+    },
+    layer: (id) => on.get(id) === true,
+    setZoneFog(next) {
+      zone = next;
+    },
+    setProfile(profile) {
+      curtain.setProfile(profile);
+    },
+    stats: () => ({ rainCurtain: curtain.drawn(), rainNear: nearRain.count(), cars: headlights.count() }),
+    dispose() {
+      scene.remove(group);
+      curtain.dispose();
+      haze.dispose();
+      lightning.dispose();
+      headlights.dispose();
+      nearRain.clear();
+    }
+  };
+}
+
+// src/bench/text.ts
+var TEXTS = {
+  en: { layers: { far_rain: "Rain curtain", near_rain: "Near rain and splashes", mist: "Mist and ash", sky: "Sky", lightning: "Lightning", headlights: "Headlights", haze: "Heat haze" } },
+  "pt-BR": { layers: { far_rain: "Cortina de chuva", near_rain: "Chuva perto e respingos", mist: "N\xE9voa e cinza", sky: "C\xE9u", lightning: "Rel\xE2mpago", headlights: "Far\xF3is", haze: "N\xE9voa de calor" } }
+};
+var weatherVisualTextOf = (locale) => TEXTS[locale] ?? TEXTS[locale.split("-")[0] ?? "en"] ?? TEXTS.en;
+
+// src/bench/visual.ts
+var RIG_VEHICLE = "midsize_sedan";
+var LAYER_ORDER = ["far_rain", "near_rain", "mist", "sky", "lightning", "headlights", "haze"];
+var RIG_DEFAULT = [1.6, -2.5, 0];
+function buildRig(THREE, vehicles, key) {
+  const group = new THREE.Group();
+  group.name = "weather-lamp-rig";
+  const car = vehicles?.build(key, { quality: "lite" });
+  if (car) {
+    car.group.position.z = HEADLIGHTS.lamp[2] + 0.1 - car.length / 2;
+    group.add(car.group);
+  }
+  const footprint = car ? footprintOf(car) : void 0;
+  return {
+    group,
+    ...footprint ? { footprint } : {},
+    dispose() {
+      car?.dispose();
+    }
+  };
+}
+function createWeatherVisual(options = {}) {
+  return {
+    layers(locale) {
+      const text = weatherVisualTextOf(locale);
+      return LAYER_ORDER.map((id) => ({ id, name: text.layers[id], default: options.layers?.[id] ?? true }));
+    },
+    create({ host, weather }) {
+      const THREE = host.THREE;
+      const renderer = createWeatherRenderer(THREE, {
+        scene: host.scene,
+        camera: host.camera,
+        weather,
+        ...options.vfx ? { vfx: options.vfx } : {},
+        ...options.profile ? { profile: options.profile } : {},
+        ...options.random ? { random: options.random } : {},
+        ...options.zone ? { zone: options.zone } : {},
+        ...options.puddles ? { puddles: options.puddles } : {},
+        ...options.puddleAt ? { puddleAt: options.puddleAt } : {},
+        ...options.headlights ? { headlights: options.headlights } : {},
+        ...options.layers ? { layers: options.layers } : {},
+        ...isLightBudget(host.lights) ? { lights: host.lights } : {}
+      });
+      const item = options.rigItem && host.addObject ? options.rigItem : void 0;
+      return attachRig(THREE, host, renderer, options.rig === void 0 ? RIG_DEFAULT : options.rig, item ? void 0 : options.vehicles?.(THREE), options.rigVehicle ?? RIG_VEHICLE, item);
+    }
+  };
+}
+function footprintOf(car) {
+  if (!car.width) return void 0;
+  const z = car.group.position.z;
+  return { minX: -car.width / 2, maxX: car.width / 2, minZ: z - car.length / 2, maxZ: z + car.length / 2 };
+}
+function lengthOf(THREE, root) {
+  root.updateMatrixWorld(true);
+  const inverse = new THREE.Matrix4().copy(root.matrixWorld).invert();
+  const box = new THREE.Box3();
+  const piece = new THREE.Box3();
+  const matrix = new THREE.Matrix4();
+  root.traverse((mesh) => {
+    const m = mesh;
+    if (!m.isMesh || !m.geometry) return;
+    if (!m.geometry.boundingBox) m.geometry.computeBoundingBox();
+    piece.copy(m.geometry.boundingBox).applyMatrix4(matrix.multiplyMatrices(inverse, m.matrixWorld));
+    box.union(piece);
+  });
+  return box.isEmpty() ? 0 : box.max.z - box.min.z;
+}
+function attachRig(THREE, host, renderer, place, vehicles, key, item) {
+  const scene = host.scene;
+  const rig = place === false ? void 0 : buildRig(THREE, vehicles, key);
+  let detach;
+  let unblock;
+  if (rig && place) {
+    rig.group.position.set(place[0], 0, place[1]);
+    rig.group.rotation.y = place[2];
+    scene.add(rig.group);
+    detach = renderer.headlights.attach(rig.group);
+    if (rig.footprint) unblock = host.addBlocker?.(footprintBlocker(rig.group, rig.footprint));
+  }
+  let car = null;
+  let stopWaiting;
+  if (item && place) {
+    const tryPlace = () => {
+      if (car || !host.addObject) return;
+      const placed = host.addObject(item, { position: [place[0], 0, place[1]], rotationY: place[2] });
+      if (!placed) return;
+      car = placed;
+      stopWaiting?.();
+      stopWaiting = void 0;
+      const ahead = lengthOf(THREE, placed.root) / 2 - HEADLIGHTS.lamp[2] - 0.1;
+      rig.group.position.set(place[0] + Math.sin(place[2]) * ahead, 0, place[1] + Math.cos(place[2]) * ahead);
+    };
+    tryPlace();
+    if (!car) stopWaiting = host.onFrame(tryPlace);
+  }
+  return {
+    update: (dt) => renderer.update(dt),
+    setLayer(id, on) {
+      if (WEATHER_IDS.includes(id)) renderer.setLayer(id, on);
+    },
+    dispose() {
+      detach?.();
+      unblock?.();
+      stopWaiting?.();
+      car?.remove();
+      if (rig) {
+        scene.remove(rig.group);
+        rig.dispose();
+      }
+      renderer.dispose();
+    }
+  };
+}
+var WEATHER_IDS = ["far_rain", "near_rain", "mist", "fog", "sky", "lightning", "headlights", "haze"];
+
+export {
+  SKY_NIGHT,
+  SKY_DAY,
+  ZONE_LIGHT,
+  ZONE_FOG_DEFAULTS,
+  createSky,
+  FOG_NEAR,
+  FOG_ZONE_NEAR,
+  FOG_EXP_FROM,
+  densityForFar,
+  fogOf,
+  createFog,
+  MIST,
+  ASH,
+  emitAirborne,
+  HEADLIGHTS,
+  defaultHeadlightRule,
+  createHeadlights,
+  HEAT_HAZE,
+  HEAT_HAZE_VERTEX,
+  HEAT_HAZE_FRAGMENT,
+  createHeatHaze,
+  LIGHTNING,
+  createLightning,
+  SPLASH_FROM_MM,
+  createNearRain,
+  RAIN_CURTAIN,
+  RAIN_CURTAIN_VERTEX,
+  RAIN_CURTAIN_FRAGMENT,
+  RAIN_CURTAIN_PROFILES,
+  RAIN_CURTAIN_FULL_AT,
+  rainCurtainPositions,
+  createRainCurtain,
+  WEATHER_LAYERS,
+  createWeatherRenderer,
+  weatherVisualTextOf,
+  createWeatherVisual
+};
+//# sourceMappingURL=chunk-SOEOSGSU.js.map