@jgengine/shell 0.5.0 → 0.7.0

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,6 @@
+export { FireSpreadLayer, type FireSpreadLayerProps } from "./FireSpreadLayer.js";
+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,6 @@
+export { FireSpreadLayer } from "./FireSpreadLayer.js";
+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;

package/dist/weather/weatherGeometry.js

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+import { createWeatherSeedAttributes } from "./weatherMath.js";
+export function createWeatherQuadGeometry(maxCount, seed) {
+    const count = Math.max(0, Math.floor(maxCount));
+    const geometry = new THREE.InstancedBufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array([-0.5, -0.5, 0, 0.5, -0.5, 0, 0.5, 0.5, 0, -0.5, 0.5, 0]), 3));
+    geometry.setAttribute("uv", new THREE.BufferAttribute(new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]), 2));
+    geometry.setIndex([0, 1, 2, 0, 2, 3]);
+    const attributes = createWeatherSeedAttributes(count, seed);
+    geometry.setAttribute("aSpawn", new THREE.InstancedBufferAttribute(attributes.spawn, 3));
+    geometry.setAttribute("aDrift", new THREE.InstancedBufferAttribute(attributes.drift, 1));
+    geometry.instanceCount = count;
+    return geometry;
+}

package/dist/weather/weatherMath.d.ts

@@ -0,0 +1,7 @@
+export declare function clampWeatherRatio(value: number): number;
+export declare function resolveWeatherInstanceCount(maxCount: number, density: number): number;
+export interface WeatherSeedAttributes {
+    spawn: Float32Array;
+    drift: Float32Array;
+}
+export declare function createWeatherSeedAttributes(maxCount: number, seed: number): WeatherSeedAttributes;

package/dist/weather/weatherMath.js

@@ -0,0 +1,30 @@
+export function clampWeatherRatio(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    if (value <= 0)
+        return 0;
+    if (value >= 1)
+        return 1;
+    return value;
+}
+export function resolveWeatherInstanceCount(maxCount, density) {
+    const safeMax = Math.max(0, Math.floor(maxCount));
+    return Math.floor(safeMax * clampWeatherRatio(density));
+}
+export function createWeatherSeedAttributes(maxCount, seed) {
+    const count = Math.max(0, Math.floor(maxCount));
+    const spawn = new Float32Array(count * 3);
+    const drift = new Float32Array(count);
+    let state = seed >>> 0;
+    const next = () => {
+        state = (state * 1664525 + 1013904223) >>> 0;
+        return state / 4294967296;
+    };
+    for (let index = 0; index < count; index += 1) {
+        spawn[index * 3] = next();
+        spawn[index * 3 + 1] = next();
+        spawn[index * 3 + 2] = next();
+        drift[index] = next();
+    }
+    return { spawn, drift };
+}

package/dist/weather/weatherUniforms.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from "react";
+import * as THREE from "three";
+export type WeatherVector = readonly [number, number, number];
+export interface WeatherUniformSet {
+    time: THREE.IUniform<number>;
+    wind: THREE.IUniform<THREE.Vector3>;
+    lightning: THREE.IUniform<number>;
+}
+export interface WeatherUniformOptions {
+    wind?: WeatherVector;
+    lightning?: number;
+    timeScale?: number;
+}
+export declare function createWeatherUniformSet(options?: WeatherUniformOptions): WeatherUniformSet;
+export declare function WeatherUniformProvider({ children, ...options }: WeatherUniformOptions & {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useWeatherUniformSet(options?: WeatherUniformOptions): WeatherUniformSet;

package/dist/weather/weatherUniforms.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+import { useFrame } from "@react-three/fiber";
+import * as THREE from "three";
+const WeatherUniformContext = createContext(null);
+export function createWeatherUniformSet(options = {}) {
+    const wind = options.wind ?? [0, 0, 0];
+    return {
+        time: { value: 0 },
+        wind: { value: new THREE.Vector3(wind[0], wind[1], wind[2]) },
+        lightning: { value: options.lightning ?? 0 },
+    };
+}
+function useUniformTicker(uniforms, options, enabled = true) {
+    useFrame((_state, delta) => {
+        if (!enabled)
+            return;
+        const wind = options.wind ?? [0, 0, 0];
+        uniforms.time.value += delta * (options.timeScale ?? 1);
+        uniforms.wind.value.set(wind[0], wind[1], wind[2]);
+        uniforms.lightning.value = options.lightning ?? 0;
+    });
+}
+export function WeatherUniformProvider({ children, ...options }) {
+    const uniforms = useMemo(() => createWeatherUniformSet(options), []);
+    useUniformTicker(uniforms, options);
+    return _jsx(WeatherUniformContext.Provider, { value: uniforms, children: children });
+}
+export function useWeatherUniformSet(options = {}) {
+    const shared = useContext(WeatherUniformContext);
+    const local = useMemo(() => createWeatherUniformSet(options), []);
+    useUniformTicker(local, options, shared === null);
+    return shared ?? local;
+}

package/dist/world/InstancedBodies.d.ts

@@ -0,0 +1,17 @@
+import type { PhysicsWorld } from "@jgengine/core/physics/physicsWorld";
+export interface InstancedBodiesProps {
+    /** Physics world whose SoA buffers are streamed straight into the instance matrix. */
+    world: PhysicsWorld;
+    /** When true, color each instance by simulation state (sleeping / awake / contact) instead of its base color. */
+    debugTint?: boolean;
+    /** Per-body base RGB (length ≥ capacity·3), used when debugTint is off. Defaults to flat gray. */
+    baseColors?: Float32Array;
+    /** Bump to force a color re-upload after the world is rebuilt (e.g. reset). */
+    epoch?: number;
+}
+/**
+ * Renders a PhysicsWorld's box bodies as a single InstancedMesh — one draw call per batch.
+ * Transforms are written directly into `instanceMatrix.array` each frame (bodies never touch
+ * the per-entity React path). Reusable by any game: hand it a physics world and go.
+ */
+export declare function InstancedBodies({ world, debugTint, baseColors, epoch }: InstancedBodiesProps): import("react").JSX.Element;