@jgengine/shell 0.4.0 → 0.6.0

package/dist/water/OceanMaterial.d.ts

@@ -0,0 +1,54 @@
+import * as THREE from "three";
+import { type ResolvedOceanConfig } from "./OceanConfig.js";
+export interface OceanMaterialUniforms {
+    uTime: {
+        value: number;
+    };
+    uWaveDirections: {
+        value: THREE.Vector2[];
+    };
+    uWaveParams: {
+        value: THREE.Vector4[];
+    };
+    uChoppiness: {
+        value: number;
+    };
+    uShallowColor: {
+        value: THREE.Color;
+    };
+    uDeepColor: {
+        value: THREE.Color;
+    };
+    uCrestColor: {
+        value: THREE.Color;
+    };
+    uFoamColor: {
+        value: THREE.Color;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uFresnelStrength: {
+        value: number;
+    };
+    uHorizonBlend: {
+        value: number;
+    };
+    uFoamThreshold: {
+        value: number;
+    };
+    uFoamSoftness: {
+        value: number;
+    };
+    uFoamIntensity: {
+        value: number;
+    };
+    uFoamCoverage: {
+        value: number;
+    };
+}
+export type OceanShaderMaterial = THREE.ShaderMaterial & {
+    uniforms: OceanMaterialUniforms;
+};
+export declare function createOceanMaterial(config: ResolvedOceanConfig): OceanShaderMaterial;
+export declare function syncOceanMaterial(material: OceanShaderMaterial, config: ResolvedOceanConfig, elapsedSeconds: number): void;

package/dist/water/OceanMaterial.js

@@ -0,0 +1,51 @@
+import * as THREE from "three";
+import { buildOceanWaveUniforms } from "./OceanConfig.js";
+import { oceanFragmentShader, oceanVertexShader } from "./OceanShader.js";
+export function createOceanMaterial(config) {
+    const material = new THREE.ShaderMaterial({
+        vertexShader: oceanVertexShader,
+        fragmentShader: oceanFragmentShader,
+        side: THREE.DoubleSide,
+        transparent: config.color.opacity < 1,
+        depthWrite: config.color.opacity >= 0.98,
+        uniforms: {
+            uTime: { value: 0 },
+            uWaveDirections: { value: [] },
+            uWaveParams: { value: [] },
+            uChoppiness: { value: config.choppiness },
+            uShallowColor: { value: new THREE.Color(config.color.shallow) },
+            uDeepColor: { value: new THREE.Color(config.color.deep) },
+            uCrestColor: { value: new THREE.Color(config.color.crest) },
+            uFoamColor: { value: new THREE.Color(config.color.foam) },
+            uOpacity: { value: config.color.opacity },
+            uFresnelStrength: { value: config.color.fresnelStrength },
+            uHorizonBlend: { value: config.color.horizonBlend },
+            uFoamThreshold: { value: config.foam.crestThreshold },
+            uFoamSoftness: { value: config.foam.softness },
+            uFoamIntensity: { value: config.foam.intensity },
+            uFoamCoverage: { value: config.foam.coverage },
+        },
+    });
+    syncOceanMaterial(material, config, 0);
+    return material;
+}
+export function syncOceanMaterial(material, config, elapsedSeconds) {
+    const waveUniforms = buildOceanWaveUniforms(config);
+    material.uniforms.uTime.value = elapsedSeconds;
+    material.uniforms.uWaveDirections.value = waveUniforms.directions;
+    material.uniforms.uWaveParams.value = waveUniforms.params;
+    material.uniforms.uChoppiness.value = config.choppiness;
+    material.uniforms.uShallowColor.value.set(config.color.shallow);
+    material.uniforms.uDeepColor.value.set(config.color.deep);
+    material.uniforms.uCrestColor.value.set(config.color.crest);
+    material.uniforms.uFoamColor.value.set(config.color.foam);
+    material.uniforms.uOpacity.value = config.color.opacity;
+    material.uniforms.uFresnelStrength.value = config.color.fresnelStrength;
+    material.uniforms.uHorizonBlend.value = config.color.horizonBlend;
+    material.uniforms.uFoamThreshold.value = config.foam.crestThreshold;
+    material.uniforms.uFoamSoftness.value = config.foam.softness;
+    material.uniforms.uFoamIntensity.value = config.foam.intensity;
+    material.uniforms.uFoamCoverage.value = config.foam.coverage;
+    material.transparent = config.color.opacity < 1;
+    material.depthWrite = config.color.opacity >= 0.98;
+}

package/dist/water/OceanShader.d.ts

@@ -0,0 +1,2 @@
+export declare const oceanVertexShader = "\nuniform float uTime;\nuniform vec2 uWaveDirections[6];\nuniform vec4 uWaveParams[6];\nuniform float uChoppiness;\nuniform float uFoamThreshold;\nuniform float uFoamSoftness;\nuniform float uFoamCoverage;\n\nvarying vec3 vWorldPosition;\nvarying vec3 vNormal;\nvarying float vCrest;\nvarying float vWaveHeight;\n\nvoid main() {\n  vec3 displaced = position;\n  vec3 tangent = vec3(1.0, 0.0, 0.0);\n  vec3 bitangent = vec3(0.0, 0.0, 1.0);\n  float crest = 0.0;\n\n  for (int i = 0; i < 6; i++) {\n    vec2 direction = normalize(uWaveDirections[i]);\n    vec4 wave = uWaveParams[i];\n    float k = wave.x;\n    float amplitude = wave.y;\n    float steepness = wave.z;\n    float omega = wave.w;\n    float phase = k * dot(direction, position.xz) - omega * uTime;\n    float sine = sin(phase);\n    float cosine = cos(phase);\n    float horizontal = steepness * amplitude * uChoppiness;\n    displaced.x += horizontal * direction.x * cosine;\n    displaced.z += horizontal * direction.y * cosine;\n    displaced.y += amplitude * sine;\n    float common = horizontal * k * sine;\n    tangent += vec3(-common * direction.x * direction.x, amplitude * k * direction.x * cosine, -common * direction.x * direction.y);\n    bitangent += vec3(-common * direction.x * direction.y, amplitude * k * direction.y * cosine, -common * direction.y * direction.y);\n    crest = max(crest, smoothstep(uFoamThreshold, uFoamThreshold + uFoamSoftness, sine * steepness + uFoamCoverage * 0.35));\n  }\n\n  vNormal = normalize(cross(bitangent, tangent));\n  vCrest = crest;\n  vWaveHeight = displaced.y;\n  vec4 worldPosition = modelMatrix * vec4(displaced, 1.0);\n  vWorldPosition = worldPosition.xyz;\n  gl_Position = projectionMatrix * viewMatrix * worldPosition;\n}\n";
+export declare const oceanFragmentShader = "\nuniform vec3 uShallowColor;\nuniform vec3 uDeepColor;\nuniform vec3 uCrestColor;\nuniform vec3 uFoamColor;\nuniform float uOpacity;\nuniform float uFresnelStrength;\nuniform float uHorizonBlend;\nuniform float uFoamIntensity;\n\nvarying vec3 vWorldPosition;\nvarying vec3 vNormal;\nvarying float vCrest;\nvarying float vWaveHeight;\n\nvoid main() {\n  vec3 normal = normalize(vNormal);\n  vec3 viewDirection = normalize(cameraPosition - vWorldPosition);\n  float fresnel = pow(1.0 - max(dot(normal, viewDirection), 0.0), 4.5);\n  float depthMix = smoothstep(-1.8, 1.6, vWaveHeight);\n  vec3 waterColor = mix(uDeepColor, uShallowColor, depthMix);\n  waterColor = mix(waterColor, uCrestColor, smoothstep(0.15, 1.2, vWaveHeight) * 0.28);\n  waterColor = mix(waterColor, vec3(0.86, 0.95, 1.0), fresnel * uFresnelStrength);\n  float horizon = smoothstep(0.0, 1.0, 1.0 - abs(normal.y));\n  waterColor = mix(waterColor, uShallowColor, horizon * uHorizonBlend);\n  float foam = clamp(vCrest * uFoamIntensity, 0.0, 1.0);\n  vec3 color = mix(waterColor, uFoamColor, foam);\n  gl_FragColor = vec4(color, uOpacity);\n}\n";

package/dist/water/OceanShader.js

@@ -0,0 +1,78 @@
+export const oceanVertexShader = `
+uniform float uTime;
+uniform vec2 uWaveDirections[6];
+uniform vec4 uWaveParams[6];
+uniform float uChoppiness;
+uniform float uFoamThreshold;
+uniform float uFoamSoftness;
+uniform float uFoamCoverage;
+
+varying vec3 vWorldPosition;
+varying vec3 vNormal;
+varying float vCrest;
+varying float vWaveHeight;
+
+void main() {
+  vec3 displaced = position;
+  vec3 tangent = vec3(1.0, 0.0, 0.0);
+  vec3 bitangent = vec3(0.0, 0.0, 1.0);
+  float crest = 0.0;
+
+  for (int i = 0; i < 6; i++) {
+    vec2 direction = normalize(uWaveDirections[i]);
+    vec4 wave = uWaveParams[i];
+    float k = wave.x;
+    float amplitude = wave.y;
+    float steepness = wave.z;
+    float omega = wave.w;
+    float phase = k * dot(direction, position.xz) - omega * uTime;
+    float sine = sin(phase);
+    float cosine = cos(phase);
+    float horizontal = steepness * amplitude * uChoppiness;
+    displaced.x += horizontal * direction.x * cosine;
+    displaced.z += horizontal * direction.y * cosine;
+    displaced.y += amplitude * sine;
+    float common = horizontal * k * sine;
+    tangent += vec3(-common * direction.x * direction.x, amplitude * k * direction.x * cosine, -common * direction.x * direction.y);
+    bitangent += vec3(-common * direction.x * direction.y, amplitude * k * direction.y * cosine, -common * direction.y * direction.y);
+    crest = max(crest, smoothstep(uFoamThreshold, uFoamThreshold + uFoamSoftness, sine * steepness + uFoamCoverage * 0.35));
+  }
+
+  vNormal = normalize(cross(bitangent, tangent));
+  vCrest = crest;
+  vWaveHeight = displaced.y;
+  vec4 worldPosition = modelMatrix * vec4(displaced, 1.0);
+  vWorldPosition = worldPosition.xyz;
+  gl_Position = projectionMatrix * viewMatrix * worldPosition;
+}
+`;
+export const oceanFragmentShader = `
+uniform vec3 uShallowColor;
+uniform vec3 uDeepColor;
+uniform vec3 uCrestColor;
+uniform vec3 uFoamColor;
+uniform float uOpacity;
+uniform float uFresnelStrength;
+uniform float uHorizonBlend;
+uniform float uFoamIntensity;
+
+varying vec3 vWorldPosition;
+varying vec3 vNormal;
+varying float vCrest;
+varying float vWaveHeight;
+
+void main() {
+  vec3 normal = normalize(vNormal);
+  vec3 viewDirection = normalize(cameraPosition - vWorldPosition);
+  float fresnel = pow(1.0 - max(dot(normal, viewDirection), 0.0), 4.5);
+  float depthMix = smoothstep(-1.8, 1.6, vWaveHeight);
+  vec3 waterColor = mix(uDeepColor, uShallowColor, depthMix);
+  waterColor = mix(waterColor, uCrestColor, smoothstep(0.15, 1.2, vWaveHeight) * 0.28);
+  waterColor = mix(waterColor, vec3(0.86, 0.95, 1.0), fresnel * uFresnelStrength);
+  float horizon = smoothstep(0.0, 1.0, 1.0 - abs(normal.y));
+  waterColor = mix(waterColor, uShallowColor, horizon * uHorizonBlend);
+  float foam = clamp(vCrest * uFoamIntensity, 0.0, 1.0);
+  vec3 color = mix(waterColor, uFoamColor, foam);
+  gl_FragColor = vec4(color, uOpacity);
+}
+`;

package/dist/water/index.d.ts

@@ -0,0 +1,3 @@
+export { Ocean, type OceanProps } from "./Ocean.js";
+export { DEFAULT_OCEAN_CONFIG, MAX_OCEAN_WAVES, OCEAN_QUALITY_PRESETS, buildOceanWaveUniforms, createOceanConfig, type OceanColorConfig, type OceanConfig, type OceanDirectionVector, type OceanFoamConfig, type OceanQualityPreset, type OceanWaveConfig, type OceanWaveDirection, type ResolvedOceanColorConfig, type ResolvedOceanConfig, type ResolvedOceanFoamConfig, type ResolvedOceanWaveConfig, } from "./OceanConfig.js";
+export { createOceanMaterial, syncOceanMaterial, type OceanMaterialUniforms, type OceanShaderMaterial, } from "./OceanMaterial.js";

package/dist/water/index.js

@@ -0,0 +1,3 @@
+export { Ocean } from "./Ocean.js";
+export { DEFAULT_OCEAN_CONFIG, MAX_OCEAN_WAVES, OCEAN_QUALITY_PRESETS, buildOceanWaveUniforms, createOceanConfig, } from "./OceanConfig.js";
+export { createOceanMaterial, syncOceanMaterial, } from "./OceanMaterial.js";

package/dist/water.d.ts

@@ -0,0 +1 @@
+export * from "./water/index.js";

package/dist/water.js

@@ -0,0 +1 @@
+export * from "./water/index.js";

package/dist/weather/LightningStrike.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from "three";
+import type { WeatherVector } from "./weatherUniforms.js";
+export interface LightningStrikeProps {
+    origin: WeatherVector;
+    target: WeatherVector;
+    strikeKey?: string | number;
+    seed?: number;
+    visible?: boolean;
+    duration?: number;
+    color?: THREE.ColorRepresentation;
+    glow?: number;
+    branches?: number;
+    jaggedness?: number;
+    impactLight?: number;
+    renderOrder?: number;
+}
+export declare function LightningStrike({ origin, target, strikeKey, seed, visible, duration, color, glow, branches, jaggedness, impactLight, renderOrder, }: LightningStrikeProps): import("react").JSX.Element;

package/dist/weather/LightningStrike.js

@@ -0,0 +1,130 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from "react";
+import { useFrame } from "@react-three/fiber";
+import * as THREE from "three";
+const DEFAULT_COLOR = "#bdd4ff";
+function createRandom(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state * 1664525 + 1013904223) >>> 0;
+        return state / 4294967296;
+    };
+}
+function hashStrikeKey(value) {
+    const text = String(value);
+    let hash = 2166136261;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0;
+}
+function vectorFromTuple(value) {
+    return new THREE.Vector3(value[0], value[1], value[2]);
+}
+function perpendicularVector(direction, random) {
+    const axis = Math.abs(direction.y) > 0.82 ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 1, 0);
+    return new THREE.Vector3().crossVectors(direction, axis).normalize().applyAxisAngle(direction, random() * Math.PI * 2);
+}
+function createLightningSegments(origin, target, seed, branches, jaggedness) {
+    const random = createRandom(seed);
+    const start = vectorFromTuple(origin);
+    const end = vectorFromTuple(target);
+    const direction = new THREE.Vector3().subVectors(end, start).normalize();
+    const length = start.distanceTo(end);
+    const points = [];
+    const pointCount = 14;
+    for (let index = 0; index < pointCount; index += 1) {
+        const ratio = index / (pointCount - 1);
+        const point = start.clone().lerp(end, ratio);
+        if (index > 0 && index < pointCount - 1) {
+            point.addScaledVector(perpendicularVector(direction, random), (random() - 0.5) * jaggedness * length);
+        }
+        points.push(point);
+    }
+    const segments = [];
+    for (let index = 0; index < points.length - 1; index += 1) {
+        segments.push({ from: points[index], to: points[index + 1] });
+    }
+    const branchCount = Math.max(0, Math.floor(branches));
+    for (let index = 0; index < branchCount; index += 1) {
+        const sourceIndex = 2 + Math.floor(random() * Math.max(1, points.length - 5));
+        const source = points[sourceIndex];
+        const branchDirection = direction
+            .clone()
+            .addScaledVector(perpendicularVector(direction, random), 0.75 + random() * 0.8)
+            .normalize();
+        const branchLength = length * (0.1 + random() * 0.22);
+        const middle = source.clone().addScaledVector(branchDirection, branchLength * 0.48);
+        const tip = source.clone().addScaledVector(branchDirection, branchLength);
+        middle.addScaledVector(perpendicularVector(branchDirection, random), (random() - 0.5) * jaggedness * length * 0.35);
+        segments.push({ from: source.clone(), to: middle });
+        segments.push({ from: middle, to: tip });
+    }
+    return segments;
+}
+function writeLightningGeometry(geometry, segments) {
+    const positions = new Float32Array(segments.length * 6);
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        positions[index * 6] = segment.from.x;
+        positions[index * 6 + 1] = segment.from.y;
+        positions[index * 6 + 2] = segment.from.z;
+        positions[index * 6 + 3] = segment.to.x;
+        positions[index * 6 + 4] = segment.to.y;
+        positions[index * 6 + 5] = segment.to.z;
+    }
+    geometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
+    geometry.computeBoundingSphere();
+}
+export function LightningStrike({ origin, target, strikeKey = 0, seed = 451, visible = true, duration = 0.18, color = DEFAULT_COLOR, glow = 2.4, branches = 5, jaggedness = 0.08, impactLight = 26, renderOrder = 20, }) {
+    const lifeRef = useRef(0);
+    const lightRef = useRef(null);
+    const geometry = useMemo(() => new THREE.BufferGeometry(), []);
+    const material = useMemo(() => new THREE.LineBasicMaterial({
+        color,
+        transparent: true,
+        opacity: 0,
+        blending: THREE.AdditiveBlending,
+        depthWrite: false,
+    }), [color]);
+    const line = useMemo(() => {
+        const next = new THREE.LineSegments(geometry, material);
+        next.frustumCulled = false;
+        next.renderOrder = renderOrder;
+        return next;
+    }, [geometry, material, renderOrder]);
+    useEffect(() => {
+        material.color.set(color);
+    }, [color, material]);
+    useEffect(() => {
+        if (!visible) {
+            lifeRef.current = 0;
+            material.opacity = 0;
+            if (lightRef.current !== null)
+                lightRef.current.intensity = 0;
+            return;
+        }
+        writeLightningGeometry(geometry, createLightningSegments(origin, target, seed ^ hashStrikeKey(strikeKey), branches, jaggedness));
+        lifeRef.current = duration;
+    }, [branches, duration, geometry, jaggedness, material, origin, seed, strikeKey, target, visible]);
+    useFrame((_state, delta) => {
+        if (!visible || lifeRef.current <= 0) {
+            material.opacity = 0;
+            if (lightRef.current !== null)
+                lightRef.current.intensity = 0;
+            return;
+        }
+        lifeRef.current = Math.max(0, lifeRef.current - delta);
+        const amount = duration <= 0 ? 0 : lifeRef.current / duration;
+        const flicker = 0.62 + Math.random() * 0.38;
+        material.opacity = amount * glow * flicker;
+        if (lightRef.current !== null)
+            lightRef.current.intensity = amount * impactLight * flicker;
+    });
+    useEffect(() => () => {
+        geometry.dispose();
+        material.dispose();
+    }, [geometry, material]);
+    return (_jsxs(_Fragment, { children: [_jsx("primitive", { object: line }), _jsx("pointLight", { ref: lightRef, position: [target[0], target[1], target[2]], color: color, intensity: 0, distance: 56, decay: 2 })] }));
+}

package/dist/weather/RainField.d.ts

@@ -0,0 +1,20 @@
+import * as THREE from "three";
+import { type WeatherVector } from "./weatherUniforms.js";
+export interface RainFieldProps {
+    count?: number;
+    density?: number;
+    volume?: WeatherVector;
+    wind?: WeatherVector;
+    origin?: WeatherVector;
+    followCamera?: boolean;
+    speed?: number;
+    length?: number;
+    width?: number;
+    opacity?: number;
+    color?: THREE.ColorRepresentation;
+    lightning?: number;
+    timeScale?: number;
+    seed?: number;
+    renderOrder?: number;
+}
+export declare function RainField({ count, density, volume, wind, origin, followCamera, speed, length, width, opacity, color, lightning, timeScale, seed, renderOrder, }: RainFieldProps): import("react").JSX.Element;

package/dist/weather/RainField.js

@@ -0,0 +1,107 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo } from "react";
+import { useFrame, useThree } from "@react-three/fiber";
+import * as THREE from "three";
+import { createWeatherQuadGeometry } from "./weatherGeometry.js";
+import { resolveWeatherInstanceCount } from "./weatherMath.js";
+import { useWeatherUniformSet } from "./weatherUniforms.js";
+const DEFAULT_VOLUME = [56, 42, 56];
+const DEFAULT_ORIGIN = [0, 0, 0];
+const DEFAULT_RAIN_COLOR = "#b8c4d8";
+export function RainField({ count = 8000, density = 0.45, volume = DEFAULT_VOLUME, wind, origin = DEFAULT_ORIGIN, followCamera = true, speed = 22, length = 1.35, width = 0.018, opacity = 0.48, color = DEFAULT_RAIN_COLOR, lightning, timeScale, seed = 11939, renderOrder = 10, }) {
+    const { camera } = useThree();
+    const shared = useWeatherUniformSet({ wind, lightning, timeScale });
+    const geometry = useMemo(() => createWeatherQuadGeometry(count, seed), [count, seed]);
+    const material = useMemo(() => {
+        const uniforms = {
+            uTime: shared.time,
+            uWind: shared.wind,
+            uLightning: shared.lightning,
+            uAnchor: { value: new THREE.Vector3() },
+            uVolume: { value: new THREE.Vector3() },
+            uSpeed: { value: speed },
+            uLength: { value: length },
+            uWidth: { value: width },
+            uOpacity: { value: opacity },
+            uColor: { value: new THREE.Color(color) },
+        };
+        return new THREE.ShaderMaterial({
+            uniforms,
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.NormalBlending,
+            vertexShader: `
+        uniform float uTime;
+        uniform vec3 uWind;
+        uniform vec3 uAnchor;
+        uniform vec3 uVolume;
+        uniform float uSpeed;
+        uniform float uLength;
+        uniform float uWidth;
+
+        attribute vec3 aSpawn;
+        attribute float aDrift;
+
+        varying vec2 vUv;
+        varying float vDrift;
+
+        void main() {
+          vUv = uv;
+          vDrift = aDrift;
+
+          vec3 origin = uAnchor - vec3(uVolume.x * 0.5, uVolume.y * 0.85, uVolume.z * 0.5);
+          float speed = uSpeed * (0.72 + 0.56 * aDrift);
+          vec3 velocity = vec3(uWind.x, -speed, uWind.z);
+          vec3 local = aSpawn * uVolume + velocity * uTime;
+          vec3 worldCenter = mod(local - origin, uVolume) + origin;
+          vec3 direction = normalize(velocity);
+          vec3 cameraRay = normalize(cameraPosition - worldCenter);
+          vec3 sideRaw = cross(direction, cameraRay);
+          vec3 side = length(sideRaw) < 0.001 ? vec3(1.0, 0.0, 0.0) : normalize(sideRaw);
+          float streak = uLength * (0.68 + 0.64 * aDrift);
+          vec3 world = worldCenter + side * position.x * uWidth + direction * position.y * streak;
+
+          gl_Position = projectionMatrix * viewMatrix * vec4(world, 1.0);
+        }
+      `,
+            fragmentShader: `
+        uniform float uOpacity;
+        uniform vec3 uColor;
+        uniform float uLightning;
+
+        varying vec2 vUv;
+        varying float vDrift;
+
+        void main() {
+          float across = smoothstep(0.0, 0.45, vUv.x) * smoothstep(1.0, 0.55, vUv.x);
+          float along = smoothstep(0.0, 0.28, vUv.y) * smoothstep(1.0, 0.58, vUv.y);
+          float alpha = across * along * uOpacity * (0.55 + 0.45 * vDrift);
+          if (alpha < 0.001) discard;
+          vec3 litColor = uColor * (1.0 + uLightning * 2.25);
+          gl_FragColor = vec4(litColor, alpha);
+        }
+      `,
+        });
+    }, [color, length, opacity, shared, speed, width]);
+    useFrame(() => {
+        const anchor = followCamera ? camera.position : null;
+        const uniforms = material.uniforms;
+        const target = uniforms.uAnchor.value;
+        if (anchor !== null)
+            target.copy(anchor);
+        else
+            target.set(origin[0], origin[1], origin[2]);
+        uniforms.uVolume.value.set(volume[0], volume[1], volume[2]);
+        uniforms.uSpeed.value = speed;
+        uniforms.uLength.value = length;
+        uniforms.uWidth.value = width;
+        uniforms.uOpacity.value = opacity;
+        uniforms.uColor.value.set(color);
+        geometry.instanceCount = resolveWeatherInstanceCount(count, density);
+    });
+    useEffect(() => () => {
+        geometry.dispose();
+        material.dispose();
+    }, [geometry, material]);
+    return _jsx("mesh", { geometry: geometry, material: material, frustumCulled: false, renderOrder: renderOrder });
+}

package/dist/weather/SnowField.d.ts

@@ -0,0 +1,19 @@
+import * as THREE from "three";
+import { type WeatherVector } from "./weatherUniforms.js";
+export interface SnowFieldProps {
+    count?: number;
+    density?: number;
+    volume?: WeatherVector;
+    wind?: WeatherVector;
+    origin?: WeatherVector;
+    followCamera?: boolean;
+    speed?: number;
+    size?: number;
+    sway?: number;
+    opacity?: number;
+    color?: THREE.ColorRepresentation;
+    timeScale?: number;
+    seed?: number;
+    renderOrder?: number;
+}
+export declare function SnowField({ count, density, volume, wind, origin, followCamera, speed, size, sway, opacity, color, timeScale, seed, renderOrder, }: SnowFieldProps): import("react").JSX.Element;

package/dist/weather/SnowField.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo } from "react";
+import { useFrame, useThree } from "@react-three/fiber";
+import * as THREE from "three";
+import { createWeatherQuadGeometry } from "./weatherGeometry.js";
+import { resolveWeatherInstanceCount } from "./weatherMath.js";
+import { useWeatherUniformSet } from "./weatherUniforms.js";
+const DEFAULT_VOLUME = [52, 38, 52];
+const DEFAULT_ORIGIN = [0, 0, 0];
+const DEFAULT_SNOW_COLOR = "#ffffff";
+export function SnowField({ count = 6000, density = 0.5, volume = DEFAULT_VOLUME, wind, origin = DEFAULT_ORIGIN, followCamera = true, speed = 3.2, size = 0.11, sway = 0.62, opacity = 0.86, color = DEFAULT_SNOW_COLOR, timeScale, seed = 72931, renderOrder = 11, }) {
+    const { camera } = useThree();
+    const shared = useWeatherUniformSet({ wind, timeScale });
+    const geometry = useMemo(() => createWeatherQuadGeometry(count, seed), [count, seed]);
+    const material = useMemo(() => {
+        const uniforms = {
+            uTime: shared.time,
+            uWind: shared.wind,
+            uAnchor: { value: new THREE.Vector3() },
+            uVolume: { value: new THREE.Vector3() },
+            uSpeed: { value: speed },
+            uSize: { value: size },
+            uSway: { value: sway },
+            uOpacity: { value: opacity },
+            uColor: { value: new THREE.Color(color) },
+        };
+        return new THREE.ShaderMaterial({
+            uniforms,
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.NormalBlending,
+            vertexShader: `
+        uniform float uTime;
+        uniform vec3 uWind;
+        uniform vec3 uAnchor;
+        uniform vec3 uVolume;
+        uniform float uSpeed;
+        uniform float uSize;
+        uniform float uSway;
+
+        attribute vec3 aSpawn;
+        attribute float aDrift;
+
+        varying vec2 vUv;
+        varying float vDrift;
+
+        void main() {
+          vUv = uv;
+          vDrift = aDrift;
+
+          vec3 origin = uAnchor - vec3(uVolume.x * 0.5, uVolume.y * 0.42, uVolume.z * 0.5);
+          float phase = aDrift * 6.28318530718;
+          float fallSpeed = uSpeed * (0.62 + 0.76 * aDrift);
+          vec3 wander = vec3(
+            sin(uTime * 0.72 + phase) + sin(uTime * 1.53 + phase * 1.7) * 0.32,
+            0.0,
+            cos(uTime * 0.61 + phase) + cos(uTime * 1.27 + phase * 1.3) * 0.32
+          ) * uSway * (0.45 + 0.55 * aDrift);
+          vec3 local = aSpawn * uVolume + vec3(uWind.x, -fallSpeed, uWind.z) * uTime + wander;
+          vec3 worldCenter = mod(local - origin, uVolume) + origin;
+          float flakeSize = uSize * (0.48 + 1.08 * aDrift);
+          vec3 right = vec3(viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0]);
+          vec3 up = vec3(viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1]);
+          vec3 world = worldCenter + right * position.x * flakeSize + up * position.y * flakeSize;
+
+          gl_Position = projectionMatrix * viewMatrix * vec4(world, 1.0);
+        }
+      `,
+            fragmentShader: `
+        uniform float uOpacity;
+        uniform vec3 uColor;
+
+        varying vec2 vUv;
+        varying float vDrift;
+
+        void main() {
+          float distanceFromCenter = length(vUv - 0.5) * 2.0;
+          float disc = smoothstep(1.0, 0.12, distanceFromCenter);
+          float core = smoothstep(0.54, 0.0, distanceFromCenter) * 0.42;
+          float alpha = (disc + core) * uOpacity * (0.56 + 0.44 * vDrift);
+          if (alpha < 0.001) discard;
+          gl_FragColor = vec4(uColor, alpha);
+        }
+      `,
+        });
+    }, [color, opacity, shared, size, speed, sway]);
+    useFrame(() => {
+        const anchor = followCamera ? camera.position : null;
+        const uniforms = material.uniforms;
+        const target = uniforms.uAnchor.value;
+        if (anchor !== null)
+            target.copy(anchor);
+        else
+            target.set(origin[0], origin[1], origin[2]);
+        uniforms.uVolume.value.set(volume[0], volume[1], volume[2]);
+        uniforms.uSpeed.value = speed;
+        uniforms.uSize.value = size;
+        uniforms.uSway.value = sway;
+        uniforms.uOpacity.value = opacity;
+        uniforms.uColor.value.set(color);
+        geometry.instanceCount = resolveWeatherInstanceCount(count, density);
+    });
+    useEffect(() => () => {
+        geometry.dispose();
+        material.dispose();
+    }, [geometry, material]);
+    return _jsx("mesh", { geometry: geometry, material: material, frustumCulled: false, renderOrder: renderOrder });
+}

package/dist/weather/WeatherLayer.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from "react";
+import { type RainFieldProps } from "./RainField.js";
+import { type SnowFieldProps } from "./SnowField.js";
+import { type WeatherVector } from "./weatherUniforms.js";
+export type WeatherLayerMode = "clear" | "rain" | "snow" | "mixed";
+export interface WeatherLayerProps {
+    mode?: WeatherLayerMode;
+    intensity?: number;
+    wind?: WeatherVector;
+    lightning?: number;
+    timeScale?: number;
+    rain?: Omit<RainFieldProps, "wind" | "lightning" | "timeScale"> | false;
+    snow?: Omit<SnowFieldProps, "wind" | "timeScale"> | false;
+    enabled?: boolean;
+    children?: ReactNode;
+}
+export declare function WeatherLayer({ mode, intensity, wind, lightning, timeScale, rain, snow, enabled, children, }: WeatherLayerProps): import("react").JSX.Element | null;

package/dist/weather/WeatherLayer.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { RainField } from "./RainField.js";
+import { SnowField } from "./SnowField.js";
+import { WeatherUniformProvider } from "./weatherUniforms.js";
+function resolveLayerDensity(value, fallback, intensity) {
+    return (value ?? fallback) * intensity;
+}
+export function WeatherLayer({ mode = "clear", intensity = 1, wind, lightning, timeScale, rain, snow, enabled = true, children, }) {
+    if (!enabled)
+        return null;
+    const rainProps = rain === false ? null : (rain ?? {});
+    const snowProps = snow === false ? null : (snow ?? {});
+    const showRain = rainProps !== null && (mode === "rain" || mode === "mixed");
+    const showSnow = snowProps !== null && (mode === "snow" || mode === "mixed");
+    return (_jsxs(WeatherUniformProvider, { wind: wind, lightning: lightning, timeScale: timeScale, children: [showRain ? (_jsx(RainField, { ...rainProps, density: resolveLayerDensity(rainProps.density, 0.45, intensity) })) : null, showSnow ? (_jsx(SnowField, { ...snowProps, density: resolveLayerDensity(snowProps.density, 0.5, intensity) })) : null, children] }));
+}

package/dist/weather/index.d.ts

@@ -0,0 +1,5 @@
+export { LightningStrike, type LightningStrikeProps } from "./LightningStrike.js";
+export { RainField, type RainFieldProps } from "./RainField.js";
+export { SnowField, type SnowFieldProps } from "./SnowField.js";
+export { WeatherLayer, type WeatherLayerMode, type WeatherLayerProps } from "./WeatherLayer.js";
+export { createWeatherUniformSet, WeatherUniformProvider, useWeatherUniformSet, type WeatherUniformOptions, type WeatherUniformSet, type WeatherVector, } from "./weatherUniforms.js";

package/dist/weather/index.js

@@ -0,0 +1,5 @@
+export { LightningStrike } from "./LightningStrike.js";
+export { RainField } from "./RainField.js";
+export { SnowField } from "./SnowField.js";
+export { WeatherLayer } from "./WeatherLayer.js";
+export { createWeatherUniformSet, WeatherUniformProvider, useWeatherUniformSet, } from "./weatherUniforms.js";

package/dist/weather/weatherGeometry.d.ts

@@ -0,0 +1,2 @@
+import * as THREE from "three";
+export declare function createWeatherQuadGeometry(maxCount: number, seed: number): THREE.InstancedBufferGeometry;