@jgengine/shell 0.5.0 → 0.7.0

package/dist/vision/HiddenStateProbeHud.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { probeHiddenState } from "@jgengine/core/sensor/hiddenStateProbe";
+/** Reads a hidden zone/entity state variable in range (EMF / thermometer / geiger style sensor verb, #116). */
+export function useHiddenStateProbe(origin, sources, options) {
+    return probeHiddenState(origin, sources, options);
+}
+/** A handheld-sensor readout: needle strength bar + the raw reading, or a "no signal" idle state. */
+export function SensorReadoutMeter({ label, reading, className }) {
+    const percent = reading === null ? 0 : Math.round(reading.strength * 100);
+    return (_jsxs("div", { className: className ?? "w-44 rounded border border-emerald-400/30 bg-black/70 p-2 text-xs text-emerald-200 shadow-lg", children: [_jsxs("div", { className: "mb-1 flex items-center justify-between uppercase tracking-wide", children: [_jsx("span", { children: label }), _jsx("span", { className: "tabular-nums", children: reading === null ? "—" : `${percent}%` })] }), _jsx("div", { className: "h-1.5 overflow-hidden rounded bg-white/10", children: _jsx("div", { className: "h-full bg-emerald-400 transition-[width]", style: { width: `${percent}%` } }) }), _jsx("div", { className: "mt-1 text-[10px] text-emerald-300/70", children: reading === null ? "no signal" : String(reading.value) })] }));
+}

package/dist/vision/RevealVision.d.ts

@@ -0,0 +1,28 @@
+import { type RevealHit } from "@jgengine/core/sensor/revealQuery";
+import type { SceneEntity } from "@jgengine/core/scene/entityStore";
+export interface RevealVisionOptions {
+    originEntityId?: string;
+    radius: number;
+    tags: readonly string[];
+    resolveTags: (entity: SceneEntity) => readonly string[];
+}
+/** Occlusion-ignoring tagged-entity radius query (#115), bound to the live scene. */
+export declare function useRevealHits(options: RevealVisionOptions): readonly RevealHit[];
+export interface RevealHighlightsProps extends RevealVisionOptions {
+    enabled: boolean;
+    color?: string;
+}
+/**
+ * Screen-space reveal effect (#115) — highlights tagged entities through
+ * occluders (Dark Sight / detective-vision / wallhack style). Renders with
+ * `depthTest: false` so the highlight draws over any wall standing between
+ * the origin and the revealed entity, rather than the usual depth-sorted scene.
+ */
+export declare function RevealHighlights(props: RevealHighlightsProps): import("react").JSX.Element | null;
+export interface RevealScreenTintProps {
+    enabled: boolean;
+    color?: string;
+    className?: string;
+}
+/** Full-screen desaturating tint that reads as "vision mode is on" (Dark Sight / thermal / detective vision). */
+export declare function RevealScreenTint({ enabled, color, className }: RevealScreenTintProps): import("react").JSX.Element | null;

package/dist/vision/RevealVision.js

@@ -0,0 +1,53 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { DoubleSide } from "three";
+import { createRevealQuery } from "@jgengine/core/sensor/revealQuery";
+import { usePlayer, useSceneEntities } from "@jgengine/react/hooks";
+/** Occlusion-ignoring tagged-entity radius query (#115), bound to the live scene. */
+export function useRevealHits(options) {
+    const entities = useSceneEntities();
+    const player = usePlayer();
+    const originId = options.originEntityId ?? player.userId;
+    const tagsKey = options.tags.join("|");
+    return useMemo(() => {
+        const byId = new Map(entities.map((entity) => [entity.id, entity]));
+        const query = createRevealQuery({
+            resolvePosition: (id) => byId.get(id)?.position,
+            resolveTags: (id) => {
+                const entity = byId.get(id);
+                return entity === undefined ? [] : options.resolveTags(entity);
+            },
+            candidates: () => entities.map((entity) => entity.id),
+        });
+        return query.inRadius(originId, options.radius, options.tags);
+    }, [entities, originId, options.radius, tagsKey, options.tags, options.resolveTags]);
+}
+/**
+ * Screen-space reveal effect (#115) — highlights tagged entities through
+ * occluders (Dark Sight / detective-vision / wallhack style). Renders with
+ * `depthTest: false` so the highlight draws over any wall standing between
+ * the origin and the revealed entity, rather than the usual depth-sorted scene.
+ */
+export function RevealHighlights(props) {
+    const { enabled, color = "#7dd3fc" } = props;
+    const hits = useRevealHits(props);
+    const entities = useSceneEntities();
+    if (!enabled)
+        return null;
+    return (_jsx(_Fragment, { children: hits.map((hit) => {
+            const entity = entities.find((candidate) => candidate.id === hit.instanceId);
+            if (entity === undefined)
+                return null;
+            const pulse = Math.max(0.25, 1 - hit.distance / Math.max(props.radius, 1));
+            return (_jsxs("group", { position: [entity.position[0], entity.position[1], entity.position[2]], children: [_jsxs("mesh", { "position-y": 0.95, renderOrder: 999, children: [_jsx("capsuleGeometry", { args: [0.42, 1.2, 6, 14] }), _jsx("meshBasicMaterial", { color: color, transparent: true, opacity: 0.55 + pulse * 0.35, depthTest: false })] }), _jsxs("mesh", { "position-y": 2.6, renderOrder: 999, children: [_jsx("coneGeometry", { args: [0.14, 0.3, 12] }), _jsx("meshBasicMaterial", { color: color, transparent: true, opacity: 0.85, depthTest: false })] }), _jsxs("mesh", { "rotation-x": -Math.PI / 2, "position-y": 0.04, renderOrder: 999, children: [_jsx("ringGeometry", { args: [0.55, 0.85, 32] }), _jsx("meshBasicMaterial", { color: color, transparent: true, opacity: 0.9, depthTest: false, side: DoubleSide })] })] }, hit.instanceId));
+        }) }));
+}
+/** Full-screen desaturating tint that reads as "vision mode is on" (Dark Sight / thermal / detective vision). */
+export function RevealScreenTint({ enabled, color = "rgba(56, 189, 248, 0.16)", className }) {
+    if (!enabled)
+        return null;
+    return (_jsx("div", { className: className ?? "pointer-events-none absolute inset-0 z-10 mix-blend-screen", style: {
+            background: `radial-gradient(circle at 50% 50%, transparent 25%, ${color} 100%)`,
+            filter: "saturate(0.55) contrast(1.15) brightness(0.92)",
+        } }));
+}

package/dist/water/Ocean.d.ts

@@ -0,0 +1,6 @@
+import { type ThreeElements } from "@react-three/fiber";
+import { type OceanConfig } from "./OceanConfig.js";
+export interface OceanProps extends Omit<ThreeElements["mesh"], "args" | "children" | "geometry" | "material"> {
+    config?: OceanConfig;
+}
+export declare function Ocean({ config, ...meshProps }: OceanProps): import("react").JSX.Element;

package/dist/water/Ocean.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useFrame } from "@react-three/fiber";
+import { useEffect, useMemo, useRef } from "react";
+import * as THREE from "three";
+import { createOceanConfig } from "./OceanConfig.js";
+import { createOceanMaterial, syncOceanMaterial } from "./OceanMaterial.js";
+function createOceanGeometry(config) {
+    const geometry = new THREE.PlaneGeometry(config.size, config.size, config.resolution, config.resolution);
+    geometry.rotateX(-Math.PI / 2);
+    geometry.computeBoundingSphere();
+    return geometry;
+}
+export function Ocean({ config, ...meshProps }) {
+    const resolved = useMemo(() => createOceanConfig(config), [config]);
+    const elapsedRef = useRef(0);
+    const geometry = useMemo(() => createOceanGeometry(resolved), [resolved]);
+    const material = useMemo(() => createOceanMaterial(resolved), [resolved]);
+    useEffect(() => {
+        return () => geometry.dispose();
+    }, [geometry]);
+    useEffect(() => {
+        elapsedRef.current = 0;
+        return () => material.dispose();
+    }, [material]);
+    useFrame((_, delta) => {
+        elapsedRef.current += delta * resolved.timeScale;
+        syncOceanMaterial(material, resolved, elapsedRef.current);
+    });
+    return _jsx("mesh", { ...meshProps, geometry: geometry, material: material });
+}

package/dist/water/OceanConfig.d.ts

@@ -0,0 +1,90 @@
+import * as THREE from "three";
+export declare const MAX_OCEAN_WAVES = 6;
+export type OceanQualityPreset = "low" | "medium" | "high" | "ultra";
+export interface OceanDirectionVector {
+    x: number;
+    z: number;
+}
+export type OceanWaveDirection = number | OceanDirectionVector;
+export interface OceanWaveConfig {
+    amplitude?: number;
+    wavelength?: number;
+    speed?: number;
+    direction?: OceanWaveDirection;
+    steepness?: number;
+}
+export interface OceanColorConfig {
+    shallow?: THREE.ColorRepresentation;
+    deep?: THREE.ColorRepresentation;
+    crest?: THREE.ColorRepresentation;
+    foam?: THREE.ColorRepresentation;
+    opacity?: number;
+    fresnelStrength?: number;
+    horizonBlend?: number;
+}
+export interface OceanFoamConfig {
+    crestThreshold?: number;
+    softness?: number;
+    intensity?: number;
+    coverage?: number;
+}
+export interface OceanConfig {
+    quality?: OceanQualityPreset;
+    size?: number;
+    resolution?: number;
+    amplitude?: number;
+    speed?: number;
+    direction?: OceanWaveDirection;
+    choppiness?: number;
+    steepness?: number;
+    timeScale?: number;
+    color?: OceanColorConfig;
+    foam?: OceanFoamConfig;
+    waves?: readonly OceanWaveConfig[];
+}
+export interface ResolvedOceanColorConfig {
+    shallow: THREE.ColorRepresentation;
+    deep: THREE.ColorRepresentation;
+    crest: THREE.ColorRepresentation;
+    foam: THREE.ColorRepresentation;
+    opacity: number;
+    fresnelStrength: number;
+    horizonBlend: number;
+}
+export interface ResolvedOceanFoamConfig {
+    crestThreshold: number;
+    softness: number;
+    intensity: number;
+    coverage: number;
+}
+export interface ResolvedOceanWaveConfig {
+    amplitude: number;
+    wavelength: number;
+    speed: number;
+    direction: OceanDirectionVector;
+    steepness: number;
+}
+export interface ResolvedOceanConfig {
+    quality: OceanQualityPreset;
+    size: number;
+    resolution: number;
+    amplitude: number;
+    speed: number;
+    direction: OceanDirectionVector;
+    choppiness: number;
+    steepness: number;
+    timeScale: number;
+    color: ResolvedOceanColorConfig;
+    foam: ResolvedOceanFoamConfig;
+    waves: readonly ResolvedOceanWaveConfig[];
+}
+export declare const OCEAN_QUALITY_PRESETS: Record<OceanQualityPreset, {
+    size: number;
+    resolution: number;
+}>;
+export declare const DEFAULT_OCEAN_CONFIG: ResolvedOceanConfig;
+export declare function createOceanConfig(patch?: OceanConfig): ResolvedOceanConfig;
+export declare function buildOceanWaveUniforms(config: ResolvedOceanConfig): {
+    directions: THREE.Vector2[];
+    params: THREE.Vector4[];
+};

package/dist/water/OceanConfig.js

@@ -0,0 +1,131 @@
+import * as THREE from "three";
+export const MAX_OCEAN_WAVES = 6;
+export const OCEAN_QUALITY_PRESETS = {
+    low: { size: 220, resolution: 80 },
+    medium: { size: 360, resolution: 128 },
+    high: { size: 520, resolution: 192 },
+    ultra: { size: 720, resolution: 256 },
+};
+export const DEFAULT_OCEAN_CONFIG = {
+    quality: "medium",
+    size: OCEAN_QUALITY_PRESETS.medium.size,
+    resolution: OCEAN_QUALITY_PRESETS.medium.resolution,
+    amplitude: 1,
+    speed: 1,
+    direction: { x: 0.78, z: 0.62 },
+    choppiness: 1,
+    steepness: 0.72,
+    timeScale: 1,
+    color: {
+        shallow: "#2dc5d3",
+        deep: "#064468",
+        crest: "#8be9ff",
+        foam: "#f4fbff",
+        opacity: 0.88,
+        fresnelStrength: 0.7,
+        horizonBlend: 0.38,
+    },
+    foam: {
+        crestThreshold: 0.64,
+        softness: 0.22,
+        intensity: 0.8,
+        coverage: 0.45,
+    },
+    waves: [],
+};
+const DEFAULT_WAVE_SHAPE = [
+    { amplitude: 1.15, wavelength: 44, speed: 1, steepness: 0.68 },
+    { amplitude: 0.72, wavelength: 28, speed: 1.08, steepness: 0.58 },
+    { amplitude: 0.44, wavelength: 17, speed: 1.18, steepness: 0.48 },
+    { amplitude: 0.28, wavelength: 10, speed: 1.34, steepness: 0.38 },
+    { amplitude: 0.18, wavelength: 6.5, speed: 1.52, steepness: 0.28 },
+    { amplitude: 0.11, wavelength: 3.8, speed: 1.75, steepness: 0.18 },
+];
+const DEFAULT_DIRECTION_OFFSETS = [-8, 7, 21, -31, 46, -58];
+function finiteOr(value, fallback) {
+    return value === undefined || !Number.isFinite(value) ? fallback : value;
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function directionFromAngle(degrees) {
+    const radians = THREE.MathUtils.degToRad(degrees);
+    return { x: Math.cos(radians), z: Math.sin(radians) };
+}
+function directionAngle(direction) {
+    return THREE.MathUtils.radToDeg(Math.atan2(direction.z, direction.x));
+}
+function normalizeDirection(direction, fallback) {
+    if (direction === undefined)
+        return fallback;
+    if (typeof direction === "number")
+        return directionFromAngle(direction);
+    const length = Math.hypot(direction.x, direction.z);
+    if (length <= 0.0001 || !Number.isFinite(length))
+        return fallback;
+    return { x: direction.x / length, z: direction.z / length };
+}
+function createDefaultWaves(config) {
+    const baseAngle = directionAngle(config.direction);
+    return DEFAULT_WAVE_SHAPE.map((wave, index) => ({
+        amplitude: wave.amplitude,
+        wavelength: wave.wavelength,
+        speed: wave.speed,
+        direction: directionFromAngle(baseAngle + DEFAULT_DIRECTION_OFFSETS[index]),
+        steepness: wave.steepness,
+    }));
+}
+function resolveWave(wave, fallback, config) {
+    return {
+        amplitude: Math.max(0, finiteOr(wave?.amplitude, fallback.amplitude) * config.amplitude),
+        wavelength: Math.max(0.1, finiteOr(wave?.wavelength, fallback.wavelength)),
+        speed: finiteOr(wave?.speed, fallback.speed) * config.speed,
+        direction: normalizeDirection(wave?.direction, fallback.direction),
+        steepness: clamp(finiteOr(wave?.steepness, fallback.steepness) * config.steepness, 0, 1.2),
+    };
+}
+export function createOceanConfig(patch = {}) {
+    const quality = patch.quality ?? DEFAULT_OCEAN_CONFIG.quality;
+    const preset = OCEAN_QUALITY_PRESETS[quality];
+    const withoutWaves = {
+        quality,
+        size: Math.max(1, Math.floor(finiteOr(patch.size, preset.size))),
+        resolution: Math.max(1, Math.floor(finiteOr(patch.resolution, preset.resolution))),
+        amplitude: Math.max(0, finiteOr(patch.amplitude, DEFAULT_OCEAN_CONFIG.amplitude)),
+        speed: finiteOr(patch.speed, DEFAULT_OCEAN_CONFIG.speed),
+        direction: normalizeDirection(patch.direction, DEFAULT_OCEAN_CONFIG.direction),
+        choppiness: Math.max(0, finiteOr(patch.choppiness, DEFAULT_OCEAN_CONFIG.choppiness)),
+        steepness: Math.max(0, finiteOr(patch.steepness, DEFAULT_OCEAN_CONFIG.steepness)),
+        timeScale: finiteOr(patch.timeScale, DEFAULT_OCEAN_CONFIG.timeScale),
+        color: {
+            ...DEFAULT_OCEAN_CONFIG.color,
+            ...patch.color,
+            opacity: clamp(finiteOr(patch.color?.opacity, DEFAULT_OCEAN_CONFIG.color.opacity), 0, 1),
+            fresnelStrength: Math.max(0, finiteOr(patch.color?.fresnelStrength, DEFAULT_OCEAN_CONFIG.color.fresnelStrength)),
+            horizonBlend: clamp(finiteOr(patch.color?.horizonBlend, DEFAULT_OCEAN_CONFIG.color.horizonBlend), 0, 1),
+        },
+        foam: {
+            ...DEFAULT_OCEAN_CONFIG.foam,
+            ...patch.foam,
+            crestThreshold: clamp(finiteOr(patch.foam?.crestThreshold, DEFAULT_OCEAN_CONFIG.foam.crestThreshold), 0, 1),
+            softness: clamp(finiteOr(patch.foam?.softness, DEFAULT_OCEAN_CONFIG.foam.softness), 0.001, 1),
+            intensity: Math.max(0, finiteOr(patch.foam?.intensity, DEFAULT_OCEAN_CONFIG.foam.intensity)),
+            coverage: clamp(finiteOr(patch.foam?.coverage, DEFAULT_OCEAN_CONFIG.foam.coverage), 0, 1),
+        },
+    };
+    const defaultWaves = createDefaultWaves(withoutWaves);
+    const inputWaves = patch.waves ?? defaultWaves;
+    const waves = Array.from({ length: MAX_OCEAN_WAVES }, (_, index) => resolveWave(inputWaves[index], defaultWaves[index], withoutWaves));
+    return { ...withoutWaves, waves };
+}
+export function buildOceanWaveUniforms(config) {
+    const directions = [];
+    const params = [];
+    for (const wave of config.waves) {
+        const waveNumber = (Math.PI * 2) / wave.wavelength;
+        const omega = Math.sqrt(9.81 * waveNumber) * wave.speed;
+        directions.push(new THREE.Vector2(wave.direction.x, wave.direction.z));
+        params.push(new THREE.Vector4(waveNumber, wave.amplitude, wave.steepness, omega));
+    }
+    return { directions, params };
+}

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/FireSpreadLayer.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+import type { FireGrid } from "@jgengine/core/world/weather";
+export interface FireSpreadLayerProps {
+    grid: FireGrid;
+    cellSize: number;
+    origin?: readonly [number, number];
+    /** Sample ground height so flames sit on terrain; defaults to y=0. */
+    heightAt?: (x: number, z: number) => number;
+    /** Flame quad height. Default 1.6. */
+    flameHeight?: number;
+    burningColor?: THREE.ColorRepresentation;
+    emberColor?: THREE.ColorRepresentation;
+}
+export declare function FireSpreadLayer({ grid, cellSize, origin, heightAt, flameHeight, burningColor, emberColor, }: FireSpreadLayerProps): import("react").JSX.Element;

package/dist/weather/FireSpreadLayer.js

@@ -0,0 +1,68 @@
+import { 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 HIDDEN = new THREE.Matrix4().makeScale(0, 0, 0);
+export function FireSpreadLayer({ grid, cellSize, origin = [0, 0], heightAt, flameHeight = 1.6, burningColor = "#ff6a1a", emberColor = "#4a1206", }) {
+    const flames = useRef(null);
+    const scorch = useRef(null);
+    const capacity = grid.cols * grid.rows;
+    const flameGeometry = useMemo(() => new THREE.PlaneGeometry(cellSize * 0.9, flameHeight), [cellSize, flameHeight]);
+    const scorchGeometry = useMemo(() => {
+        const geometry = new THREE.PlaneGeometry(cellSize, cellSize);
+        geometry.rotateX(-Math.PI / 2);
+        return geometry;
+    }, [cellSize]);
+    const flameMaterial = useMemo(() => new THREE.MeshBasicMaterial({ color: burningColor, transparent: true, opacity: 0.85, depthWrite: false, side: THREE.DoubleSide }), [burningColor]);
+    const scorchMaterial = useMemo(() => new THREE.MeshBasicMaterial({ color: emberColor, transparent: true, opacity: 0.7, depthWrite: false }), [emberColor]);
+    useEffect(() => () => {
+        flameGeometry.dispose();
+        scorchGeometry.dispose();
+        flameMaterial.dispose();
+        scorchMaterial.dispose();
+    }, [flameGeometry, scorchGeometry, flameMaterial, scorchMaterial]);
+    const matrix = useMemo(() => new THREE.Matrix4(), []);
+    const position = useMemo(() => new THREE.Vector3(), []);
+    const quaternion = useMemo(() => new THREE.Quaternion(), []);
+    const scale = useMemo(() => new THREE.Vector3(1, 1, 1), []);
+    useFrame((state) => {
+        const flameMesh = flames.current;
+        const scorchMesh = scorch.current;
+        if (flameMesh === null || scorchMesh === null)
+            return;
+        const cells = grid.snapshot();
+        const flicker = 0.85 + 0.15 * Math.sin(state.clock.elapsedTime * 12);
+        let flameIndex = 0;
+        let scorchIndex = 0;
+        for (let row = 0; row < grid.rows; row += 1) {
+            for (let col = 0; col < grid.cols; col += 1) {
+                const cell = cells[row * grid.cols + col];
+                const x = origin[0] + col * cellSize;
+                const z = origin[1] + row * cellSize;
+                const groundY = heightAt?.(x, z) ?? 0;
+                if (cell.state === "burning") {
+                    position.set(x, groundY + flameHeight * 0.5, z);
+                    quaternion.setFromEuler(new THREE.Euler(0, state.camera.rotation.y, 0));
+                    scale.set(1, flicker, 1);
+                    matrix.compose(position, quaternion, scale);
+                    flameMesh.setMatrixAt(flameIndex, matrix);
+                    flameIndex += 1;
+                }
+                else if (cell.state === "burnt") {
+                    position.set(x, groundY + 0.05, z);
+                    scorchMesh.setMatrixAt(scorchIndex, matrix.compose(position, new THREE.Quaternion(), scale.set(1, 1, 1)));
+                    scorchIndex += 1;
+                }
+            }
+        }
+        for (let i = flameIndex; i < capacity; i += 1)
+            flameMesh.setMatrixAt(i, HIDDEN);
+        for (let i = scorchIndex; i < capacity; i += 1)
+            scorchMesh.setMatrixAt(i, HIDDEN);
+        flameMesh.count = capacity;
+        scorchMesh.count = capacity;
+        flameMesh.instanceMatrix.needsUpdate = true;
+        scorchMesh.instanceMatrix.needsUpdate = true;
+    });
+    return (_jsxs("group", { children: [_jsx("instancedMesh", { ref: scorch, args: [scorchGeometry, scorchMaterial, capacity], frustumCulled: false, renderOrder: 5 }), _jsx("instancedMesh", { ref: flames, args: [flameGeometry, flameMaterial, capacity], frustumCulled: false, renderOrder: 11 })] }));
+}