@adatechnology/game-weather-three 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anderson Fernandes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,49 @@
-# Temporary Holding Version
+# @adatechnology/game-weather-three
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The three.js picture of [`@adatechnology/game-weather`](../game-weather): the rain, fog, sky, lightning, headlights and heat of the weather that a
+`createWeather` world samples. It reads `weather.sample()` once a frame and draws it; it never advances the weather.
+
+| Part | What it draws | Where it comes from |
+|---|---|---|
+| **Rain curtain** (`createRainCurtain`) | 14 000 GPU points in a 70 m x 25 m box that follows the camera, falling 13 m/s; shader texts character for character; sized by the weather's `drops` (the whole curtain at 4 000, the storm) and by the profile (`low` 0.35, `medium` 0.7, `high` 1) | game `jogo.js`, `const RAIN = 14000` |
+| **Near rain** (`createNearRain`) | the Workshop's streaks (`engine.rain`, up to 4 000, slanted by the wind), the splashes on the `normal` sprite pool and the rings (only where `puddleAt` says there is a puddle, within `12 / (1 + quality)` m); `game-vfx-three` draws them | Workshop W313-331 |
+| **Mist and ash** (`emitAirborne`) | `mistPerSecond` puffs of low mist and `ashPerSecond` flakes of falling ash a second around the camera, into the same pool | Workshop `neblina`, W1085-1086 |
+| **Fog** (`createFog`, `fogOf`) | linear fog (near 25 m, far from the weather: 220 clear, 140 rain) or exponential-squared fog where the weather has a density (`fog` 0.075), and the zone fog (colour, far, weight; near 4 m at full weight) | game `skyUpdate` and `ZONA_NEBLINA` |
+| **Sky** (`createSky`) | night colour `0x0b0f18` to day `0x8796a6` by `sample.sun`, times `sample.skyScale` (the page's 0.8 in rain), pulled to the zone colour; it also gives the fog its colour | game `skyUpdate` |
+| **Lightning** (`createLightning`) | the double flash of `sample.flash`: hemisphere light `+ 3.2 I`, background `+ I * (.25, .27, .32)`, screen white `I * .12` | Workshop `chuva`, W1068-1072 |
+| **Headlights** (`createHeadlights`) | two spot lights and two additive beam cones on any `Object3D`, lit at night, in rain or in fog, real light only within 40 m of the camera, and rain that glows inside the beam (up to 600 lit drops a second) | Workshop `farol`, W101-103 and W1161-1170 |
+| **Heat haze** (`createHeatHaze`) | warm bands that rise over the lower half of the view, by `sample.haze` | SDK-made: no team delivered it |
+
+`createWeatherRenderer(THREE, { scene, camera, weather, vfx, profile, zone, puddles, puddleAt, headlights, layers })` puts them together:
+`update(dt)` each frame, `setLayer(id, on)` for `far_rain`, `near_rain`, `mist`, `fog`, `sky`, `lightning`, `headlights` and `haze`, `setZoneFog`,
+`setProfile`, `headlights.attach(car, lensMaterial)`. Without `vfx` only the curtain, fog, sky, lightning light, headlights and haze are drawn.
+
+```ts
+import * as THREE from 'three'
+import { createWeather } from '@adatechnology/game-weather'
+import { createWeatherRenderer } from '@adatechnology/game-weather-three'
+
+const weather = createWeather({ seed: 1, start: 'storm' })
+const picture = createWeatherRenderer(THREE, { scene, camera, weather, vfx })
+// every frame
+weather.advance(dt)
+picture.update(dt)
+```
+
+## Bench
+
+`createWeatherTestModule({ visual: createWeatherVisual({ vfx: room.vfx }) })` (the module of `game-weather`) adds the picture to the weather bench: seven layers
+(rain curtain, near rain and splashes, mist and ash, sky, lightning, headlights, heat haze; names in pt-BR and en), and a lamp rig (two lamps on a block, the
+Workshop's `hlMat` lenses) in front of the camera to show the headlights. `layers: { sky: false }` keeps a room's own sky; the bench's own `fog` layer reaches the
+renderer too. The fog layer gives back the fog the host had when it is switched off.
+
+## Proof
+
+- `tools/golden/bin/record-weather-visual.mjs` cuts the rain block of `jogo.js` (`const RAIN = 14000` to `skyUpdate`) and runs it in a vm with three.js stubs under a
+  seeded `Math.random`; the fixture `tools/golden/fixtures/weather/game-rain-curtain.json` keeps the SHA-256 of the 42 000 floats, the shader texts and the sky, zone and
+  fog lines of the page. `tests/rain-curtain-golden.test.ts` compares the points bit for bit, the shaders character for character and the numbers of sky, fog, lightning,
+  headlights, mist and ash against the page text.
+- The Workshop's `chuva` (three intensities), `neblina` and `farol` run in `game-vfx` as effects (`rain_and_puddles`, `fog_and_ash`, `headlights_in_rain`), with their own
+  golden of the events and the pools (`vfx-workshop-weather.json`).
+
+No game content here: no names of a city or a faction. Peer dependency: `three` ^0.160.

package/dist/index.d.ts

@@ -0,0 +1,331 @@
+import * as THREE_NS from 'three';
+import { WorkshopEngine, VfxWorld, Puddle } from '@adatechnology/game-vfx';
+import { WeatherSample, WeatherVisualFactory } from '@adatechnology/game-weather';
+
+/** The only three.js members the renderer needs at runtime. Pass your own `THREE` instance (the whole namespace works). */
+type ThreeLib = Pick<typeof THREE_NS, 'AdditiveBlending' | 'BoxGeometry' | 'BufferAttribute' | 'BufferGeometry' | 'Color' | 'ConeGeometry' | 'DoubleSide' | 'Fog' | 'FogExp2' | 'Group' | 'HemisphereLight' | 'Mesh' | 'MeshBasicMaterial' | 'Object3D' | 'PlaneGeometry' | 'Points' | 'ShaderMaterial' | 'SpotLight' | 'Vector3'>;
+/** What the renderer reads of a weather world: its sample. A `createWeather` world fits. */
+type WeatherSource = {
+    sample(): WeatherSample;
+};
+/** The quality names of game-vfx; they size the rain curtain. */
+type WeatherProfileName = 'low' | 'medium' | 'high';
+/** Zone fog (the game's `ZONA_NEBLINA`): colour, far distance in metres and weight 0..1. */
+type ZoneFog = {
+    readonly color?: number;
+    readonly far?: number;
+    readonly weight: number;
+};
+type Vec3 = readonly [number, number, number];
+
+/** The page's linear fog starts at 25 m and, in the zone, at 4 m (`scene.fog.near = lerp(25, 4, weight)`). */
+declare const FOG_NEAR = 25;
+declare const FOG_ZONE_NEAR = 4;
+/** Below this exponential-squared density the weather uses the linear fog (the clear weathers have 0). */
+declare const FOG_EXP_FROM = 0.0005;
+/** exp2 density that sees as far as a linear fog of `far` metres (2 % left): used to blend the zone fog in the exponential case. */
+declare const densityForFar: (far: number) => number;
+type FogValues = {
+    readonly mode: 'linear';
+    readonly near: number;
+    readonly far: number;
+} | {
+    readonly mode: 'exp2';
+    readonly density: number;
+};
+/** The fog the weather and the zone ask for. Pure. */
+declare function fogOf(sample: WeatherSample, zone?: ZoneFog, expFrom?: number): FogValues;
+type Fog = {
+    /** Puts the weather's fog on the scene (the page's `fog.far` and `fog.near`, or the exponential-squared one) with the sky's colour. */
+    update(sample: WeatherSample, sky: THREE_NS.Color, zone?: ZoneFog): void;
+    /** Takes the fog off the scene (a layer switched off). */
+    clear(): void;
+};
+declare function createFog(THREE: ThreeLib, scene: {
+    fog: unknown;
+}, options?: {
+    readonly expFrom?: number;
+}): Fog;
+/** The Workshop's mist (W1073: low, slow, 3 to 5 m wide) and ash (fine, falling in a spiral), in a box that follows the camera. */
+declare const MIST: {
+    readonly box: {
+        readonly x: readonly [-14, 10];
+        readonly y: readonly [0.2, 1.1];
+        readonly z: readonly [-3, 8];
+    };
+    readonly drift: readonly [0.15, 0.35];
+    readonly life: readonly [9, 13];
+    readonly size: readonly [3, 5];
+    readonly grow: 1.4;
+    readonly color: 8227488;
+    readonly alpha: 0.13;
+    readonly fadeIn: 0.35;
+};
+declare const ASH: {
+    readonly box: {
+        readonly x: readonly [-10, 8];
+        readonly y: readonly [4, 6];
+        readonly z: readonly [-3, 7];
+    };
+    readonly fall: -0.35;
+    readonly life: readonly [8, 12];
+    readonly size: readonly [0.025, 0.04];
+    readonly color: 10525328;
+    readonly alpha: 0.75;
+    readonly fadeIn: 0.1;
+};
+/**
+ * Feeds the `normal` sprite pool of the Workshop with `mistPerSecond` puffs of mist and `ashPerSecond` flakes of ash a second (the page's `emit('fog', ...)`
+ * and `emit('ash', ...)`, at the weather's rate instead of 5 and 14), around `camera`. The renderer of game-vfx-three draws them.
+ */
+declare function emitAirborne(engine: WorkshopEngine, sample: WeatherSample, dt: number, camera: Vec3): void;
+
+/** The Workshop's car lamps (W101-103) and the rain that glows inside their beam (W1161-1170). */
+declare const HEADLIGHTS: {
+    readonly spot: {
+        readonly color: 16773584;
+        readonly intensity: 2.4;
+        readonly distance: 26;
+        readonly angle: 0.33;
+        readonly penumbra: 0.5;
+        readonly decay: 1.6;
+    };
+    /** Lamp position on the car (x is mirrored), where the spot points, and the cone drawn in the air. */
+    readonly lamp: readonly [0.65, 0.74, 2.15];
+    readonly aim: readonly [0.65, 0.2, 12];
+    readonly cone: {
+        readonly radius: 2.4;
+        readonly length: 9;
+        readonly segments: 18;
+        readonly color: 16773584;
+        readonly opacity: 0.06;
+    };
+    readonly lens: {
+        readonly on: 16773584;
+        readonly off: 3815988;
+    };
+    /** Lit drops a second, thrown into the beam 1 to 13 m ahead (W1176). */
+    readonly lit: {
+        readonly rate: 600;
+        readonly depth: readonly [1, 13];
+        readonly spread: 0.33;
+        readonly color: 13622512;
+        readonly alpha: 0.9;
+        readonly life: 0.06;
+        readonly len: 0.035;
+        readonly velocity: readonly [0.8, -14, 0];
+    };
+    /** Beyond this many metres a car keeps only the cone: no real light (W-b text of `farol`). */
+    readonly lightRange: 40;
+};
+type HeadlightRules = {
+    /** Whether the lamps are lit in this weather and light (default: night, rain or fog). */
+    readonly lit?: (sample: WeatherSample) => boolean;
+    readonly lightRange?: number;
+};
+/** Night (the sun below the page's 0.3 night factor), rain or fog make a driver turn the lamps on. */
+declare const defaultHeadlightRule: (sample: WeatherSample) => boolean;
+type Headlights = {
+    /** Gives `car` its two spot lights and two beam cones (`lens`, when given, is the material of the lamp glass, lit with them). Returns the function that takes them off. */
+    attach(car: THREE_NS.Object3D, lens?: THREE_NS.MeshBasicMaterial): () => void;
+    /** Lights the lamps of the cars attached, the real light only within range of `camera`; throws the lit drops of the beams into the Workshop's streak pool. */
+    update(sample: WeatherSample, dt: number, camera: Vec3, engine?: WorkshopEngine, enabled?: boolean): void;
+    count(): number;
+    dispose(): void;
+};
+declare function createHeadlights(THREE: ThreeLib, rules?: HeadlightRules): Headlights;
+
+/** Peak opacity of the shimmer at full haze, and how fast the bands rise (SDK-made: no team delivered heat haze, see the open question). */
+declare const HEAT_HAZE: {
+    readonly opacity: 0.09;
+    readonly bands: 38;
+    readonly rise: 1.4;
+    readonly color: readonly [1, 0.93, 0.82];
+};
+declare const HEAT_HAZE_VERTEX = "varying vec2 vUv; void main(){ vUv = uv; gl_Position = vec4(position.xy, 0., 1.); }";
+declare const 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); }";
+type HeatHaze = {
+    readonly object: THREE_NS.Mesh;
+    update(sample: WeatherSample, time: number): void;
+    dispose(): void;
+};
+/**
+ * The heat shimmer of `extreme_heat` (`WeatherSample.haze`, 0..1): a screen-space layer of warm bands that rise over the lower half of the view. It is a layer, not a
+ * distortion of the picture, because bending the picture needs a render target that only the host owns.
+ */
+declare function createHeatHaze(THREE: ThreeLib): HeatHaze;
+
+/**
+ * What the Workshop's double flash does to the scene (W1072): the hemisphere light gains `I * 3.2`, the background gains `I * (.25, .27, .32)` and the screen goes
+ * white by `I * .12`, where `I` is the flash the weather samples (1, then .2, then .8 for 0.26 s).
+ */
+declare const LIGHTNING: {
+    readonly light: 3.2;
+    readonly background: readonly [0.25, 0.27, 0.32];
+    readonly white: 0.12;
+    readonly skyColor: 3820650;
+    readonly groundColor: 723724;
+};
+type Lightning = {
+    readonly light: THREE_NS.HemisphereLight;
+    /**
+     * Lights the scene with the flash of `sample`. `background`, when given, is the sky just written for this frame (the renderer passes it only when it owns the sky),
+     * and gains the flash; a background the host keeps for itself is left alone.
+     */
+    update(sample: WeatherSample, background?: THREE_NS.Color): void;
+    dispose(): void;
+};
+declare function createLightning(THREE: ThreeLib, scene: {
+    add(object: THREE_NS.Object3D): unknown;
+    remove(object: THREE_NS.Object3D): unknown;
+}, vfx?: VfxWorld): Lightning;
+
+/** The rain (mm/h) from which a drop that lands splashes (the Workshop's garoa, 2.5, does not; its chuva, 15, does). */
+declare const SPLASH_FROM_MM = 5;
+type NearRainOptions = {
+    /** Ground ellipses where a drop leaves a ring (the Workshop's four dark puddles; a game has its own). None by default. */
+    readonly puddles?: readonly Puddle[];
+    /** Replaces the puddle test. */
+    readonly puddleAt?: (x: number, z: number) => boolean;
+    readonly splashFrom?: number;
+};
+type NearRain = {
+    update(sample: WeatherSample, dt: number, camera: Vec3): void;
+    /** Streaks alive. */
+    count(): number;
+    clear(): void;
+};
+/**
+ * The Workshop's near rain (W313-331) driven by the weather: the streaks live in the world's Workshop engine (`engine.rain`), game-vfx-three draws them, and the
+ * splashes and rings they leave go to the `normal` sprite pool and the rings. `drops` (900 garoa, 2 200 chuva, 4 000 temporal) and the wind along x are the Workshop's own
+ * numbers for its three intensities.
+ */
+declare function createNearRain(vfx: VfxWorld | undefined, options?: NearRainOptions): NearRain;
+
+/**
+ * The game's rain curtain (jogo.js `const RAIN = 14000`): a box of points that follows the camera, 70 m wide and 25 m high, falling 13 m/s. The shader texts and the
+ * numbers are the page's, character for character (a golden cuts them from the page and compares).
+ */
+declare const RAIN_CURTAIN: {
+    readonly count: 14000;
+    readonly width: 70;
+    readonly height: 25;
+    readonly speed: 13;
+    readonly pointSize: 1.6;
+};
+declare const 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; }";
+declare const RAIN_CURTAIN_FRAGMENT = "uniform float uDay; void main(){ gl_FragColor = vec4(vec3(.68,.72,.78)*(0.25+0.75*uDay), .22+.1*uDay); }";
+/** The share of the 14 000 points each quality draws. */
+declare const RAIN_CURTAIN_PROFILES: Readonly<Record<WeatherProfileName, number>>;
+/** The weather's `drops` at which the whole curtain is drawn (the storm's 4 000). */
+declare const RAIN_CURTAIN_FULL_AT = 4000;
+/** The page's loop: x and z in -35..35, y in 0..25, three draws a point in that order, stored as Float32. */
+declare function rainCurtainPositions(random?: () => number, count?: number): Float32Array;
+type RainCurtainOptions = {
+    readonly random?: () => number;
+    readonly profile?: WeatherProfileName;
+    /** Drops (`WeatherSample.drops`) that draw the whole curtain. */
+    readonly fullAt?: number;
+    readonly count?: number;
+};
+type RainCurtain = {
+    readonly object: THREE_NS.Points;
+    /** Draws `sample.drops` of the curtain around `camera`; `daylight` is the game's `s` (0 night, 1 day). */
+    update(sample: WeatherSample, camera: {
+        readonly x: number;
+        readonly y: number;
+        readonly z: number;
+    }, time: number, daylight: number): void;
+    setProfile(profile: WeatherProfileName): void;
+    /** How many points are drawn now. */
+    drawn(): number;
+    dispose(): void;
+};
+declare function createRainCurtain(THREE: ThreeLib, options?: RainCurtainOptions): RainCurtain;
+
+/** The colours of the game's `skyUpdate` (jogo.js `_skyN` and `_skyD`): the sky goes from the night one to the day one with the sun height. */
+declare const SKY_NIGHT = 724760;
+declare const SKY_DAY = 8885926;
+/** The zone fog colour is lit by `0.35 + 0.65 s` (the page's `ZONA_NEBLINA` blend). */
+declare const ZONE_LIGHT: {
+    readonly base: 0.35;
+    readonly sun: 0.65;
+};
+/** The page's zone fog (`ZONA_NEBLINA`): colour and far distance; its weight is the game's to set. */
+declare const ZONE_FOG_DEFAULTS: {
+    readonly color: 3820090;
+    readonly far: 60;
+};
+type Sky = {
+    /** The sky colour for this weather: night to day by `sample.sun`, dimmed by `sample.skyScale` (the page's 0.8 in rain), pulled to the zone colour by its weight. */
+    update(sample: WeatherSample, zone?: ZoneFog): THREE_NS.Color;
+    readonly color: THREE_NS.Color;
+};
+/** Writes the sky into `scene.background` (a `Color`; made when the scene has none) and hands the colour to the fog. */
+declare function createSky(THREE: ThreeLib, scene: {
+    background: unknown;
+}): Sky;
+
+/** The parts the renderer draws, each of which a layer switches. */
+declare const WEATHER_LAYERS: readonly ["far_rain", "near_rain", "mist", "fog", "sky", "lightning", "headlights", "haze"];
+type WeatherLayerId = (typeof WEATHER_LAYERS)[number];
+type WeatherRendererOptions = {
+    readonly scene: THREE_NS.Scene;
+    readonly camera: THREE_NS.Camera;
+    readonly weather: WeatherSource;
+    /** The effects world: near rain, splashes, mist, ash, the white of lightning and the lit drops of headlights live in its Workshop pools (game-vfx-three draws them). */
+    readonly vfx?: VfxWorld;
+    readonly profile?: WeatherProfileName;
+    /** Seeds the rain curtain (default `Math.random`). */
+    readonly random?: () => number;
+    readonly zone?: ZoneFog;
+    readonly puddles?: readonly Puddle[];
+    readonly puddleAt?: (x: number, z: number) => boolean;
+    readonly headlights?: HeadlightRules;
+    readonly layers?: Partial<Record<WeatherLayerId, boolean>>;
+};
+type WeatherRenderer = {
+    readonly curtain: RainCurtain;
+    readonly nearRain: NearRain;
+    readonly fog: Fog;
+    readonly sky: Sky;
+    readonly lightning: Lightning;
+    readonly headlights: Headlights;
+    readonly haze: HeatHaze;
+    /** Draws the weather of the source for a frame of `dt` seconds. Call once per frame, after the weather advanced. */
+    update(dt: number): void;
+    setLayer(id: WeatherLayerId, on: boolean): void;
+    layer(id: WeatherLayerId): boolean;
+    setZoneFog(zone: ZoneFog | undefined): void;
+    setProfile(profile: WeatherProfileName): void;
+    stats(): {
+        readonly rainCurtain: number;
+        readonly rainNear: number;
+        readonly cars: number;
+    };
+    dispose(): void;
+};
+/** The whole weather picture: rain curtain, near rain with splashes, mist and ash, fog, sky, lightning, headlights and heat haze, from one `WeatherSource`. */
+declare function createWeatherRenderer(THREE: ThreeLib, options: WeatherRendererOptions): WeatherRenderer;
+
+type WeatherVisualOptions = Pick<WeatherRendererOptions, 'profile' | 'random' | 'zone' | 'puddles' | 'puddleAt' | 'headlights'> & {
+    /** The effects world of the room (`room.vfx`); without it the near rain, mist, ash, white flash and lit drops are left out. */
+    readonly vfx?: VfxWorld;
+    /** Where the lamp rig stands (the two headlights of the Workshop's car, to see the beams); `false` leaves it out. Default 2.5 m ahead of the test room camera, lamps toward it. */
+    readonly rig?: readonly [x: number, z: number, turn: number] | false;
+    /** Which layers start on (all do by default); the room that is not about weather starts the sky and the fog off to keep its own look. */
+    readonly layers?: Partial<Record<WeatherLayerId, boolean>>;
+};
+/**
+ * The picture of the weather for the weather bench: `createWeatherTestModule({ visual: createWeatherVisual({ vfx: room.vfx }) })`. It draws the weather the bench shows with
+ * `createWeatherRenderer` on the room's scene and camera, switches each part with the bench layers and puts a lamp rig in front of the camera for the headlights.
+ */
+declare function createWeatherVisual(options?: WeatherVisualOptions): WeatherVisualFactory;
+
+/** The names of the visual layers in the bench; any other locale falls back to English. */
+type WeatherVisualText = {
+    readonly layers: Readonly<Record<Exclude<WeatherLayerId, 'fog'>, string>>;
+};
+declare const weatherVisualTextOf: (locale: string) => WeatherVisualText;
+
+export { ASH, FOG_EXP_FROM, FOG_NEAR, FOG_ZONE_NEAR, type Fog, type FogValues, HEADLIGHTS, HEAT_HAZE, HEAT_HAZE_FRAGMENT, HEAT_HAZE_VERTEX, type HeadlightRules, type Headlights, type HeatHaze, LIGHTNING, type Lightning, MIST, type NearRain, type NearRainOptions, RAIN_CURTAIN, RAIN_CURTAIN_FRAGMENT, RAIN_CURTAIN_FULL_AT, RAIN_CURTAIN_PROFILES, RAIN_CURTAIN_VERTEX, type RainCurtain, type RainCurtainOptions, SKY_DAY, SKY_NIGHT, SPLASH_FROM_MM, type Sky, type ThreeLib, type Vec3, WEATHER_LAYERS, type WeatherLayerId, type WeatherProfileName, type WeatherRenderer, type WeatherRendererOptions, type WeatherSource, type WeatherVisualOptions, type WeatherVisualText, ZONE_FOG_DEFAULTS, ZONE_LIGHT, type ZoneFog, createFog, createHeadlights, createHeatHaze, createLightning, createNearRain, createRainCurtain, createSky, createWeatherRenderer, createWeatherVisual, defaultHeadlightRule, densityForFar, emitAirborne, fogOf, rainCurtainPositions, weatherVisualTextOf };