@scenography/plugin-water 0.2.0

package/dist/data-BI-VQXjw.cjs

@@ -0,0 +1,42 @@
+let _scenography_scene = require("@scenography/scene");
+//#region src/data/validate.ts
+const validateWater = (water) => (0, _scenography_scene.validate)([
+	(0, _scenography_scene.existsProp)("size", "Water is missing a size."),
+	(0, _scenography_scene.propIs)("size", _scenography_scene.isVec2, "size must be [width, depth]."),
+	(0, _scenography_scene.propIs)("center", _scenography_scene.isVec2, "center must be [x, z]."),
+	(0, _scenography_scene.propIs)("level", _scenography_scene.isFiniteNumber, "level must be a finite number."),
+	...[
+		"waveHeight",
+		"waveScale",
+		"waveSpeed"
+	].map((key) => (0, _scenography_scene.propIs)(key, _scenography_scene.isNonNegativeNumber, `${key} must be a non-negative number.`)),
+	(0, _scenography_scene.propIs)("depthScale", _scenography_scene.isPositiveNumber, "depthScale must be a positive number."),
+	(0, _scenography_scene.propIs)("foam", _scenography_scene.isNonNegativeNumber, "foam must be a non-negative number.")
+])(water);
+//#endregion
+//#region src/data/plugin.ts
+/**
+* The data half of the water plugin: owns the `water` scene key (a singleton)
+* and validates it. Pure — no three.js; pass it to `defineScene` so scenes
+* using water validate without loading the runtime.
+*/
+const waterData = {
+	kind: "water",
+	cardinality: "single",
+	validate: (water) => validateWater(water)
+};
+//#endregion
+Object.defineProperty(exports, "validateWater", {
+	enumerable: true,
+	get: function() {
+		return validateWater;
+	}
+});
+Object.defineProperty(exports, "waterData", {
+	enumerable: true,
+	get: function() {
+		return waterData;
+	}
+});
+
+//# sourceMappingURL=data-BI-VQXjw.cjs.map

package/dist/data-BI-VQXjw.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-BI-VQXjw.cjs","names":["isVec2","isFiniteNumber","isNonNegativeNumber","isPositiveNumber"],"sources":["../src/data/validate.ts","../src/data/plugin.ts"],"sourcesContent":["import {\n  existsProp,\n  isFiniteNumber,\n  isNonNegativeNumber,\n  isPositiveNumber,\n  isVec2,\n  propIs,\n  validate,\n  type ValidationResult,\n} from \"@scenography/scene\";\n\nimport type { Water } from \"./water\";\n\nexport const validateWater = (water: Water): ValidationResult =>\n  validate<Water>([\n    existsProp(\"size\", \"Water is missing a size.\"),\n    propIs(\"size\", isVec2, \"size must be [width, depth].\"),\n    propIs(\"center\", isVec2, \"center must be [x, z].\"),\n    propIs(\"level\", isFiniteNumber, \"level must be a finite number.\"),\n    ...([\"waveHeight\", \"waveScale\", \"waveSpeed\"] as const).map((key) =>\n      propIs(key, isNonNegativeNumber, `${key} must be a non-negative number.`),\n    ),\n    propIs(\"depthScale\", isPositiveNumber, \"depthScale must be a positive number.\"),\n    propIs(\"foam\", isNonNegativeNumber, \"foam must be a non-negative number.\"),\n  ])(water);\n","import type { DataPlugin } from \"@scenography/scene\";\n\nimport { validateWater } from \"./validate\";\nimport type { Water } from \"./water\";\n\n/**\n * The data half of the water plugin: owns the `water` scene key (a singleton)\n * and validates it. Pure — no three.js; pass it to `defineScene` so scenes\n * using water validate without loading the runtime.\n */\nexport const waterData: DataPlugin<Water> = {\n  kind: \"water\",\n  cardinality: \"single\",\n  validate: (water) => validateWater(water),\n};\n"],"mappings":";;AAaA,MAAa,iBAAiB,WAAA,GAAA,mBAAA,SAAA,CACZ;oCACH,QAAQ,0BAA0B;gCACtC,QAAQA,mBAAAA,QAAQ,8BAA8B;gCAC9C,UAAUA,mBAAAA,QAAQ,wBAAwB;gCAC1C,SAASC,mBAAAA,gBAAgB,gCAAgC;CAChE,GAAI;EAAC;EAAc;EAAa;CAAW,CAAC,CAAW,KAAK,SAAA,GAAA,mBAAA,OAAA,CACnD,KAAKC,mBAAAA,qBAAqB,GAAG,IAAI,gCAAgC,CAC1E;gCACO,cAAcC,mBAAAA,kBAAkB,uCAAuC;gCACvE,QAAQD,mBAAAA,qBAAqB,qCAAqC;AAC3E,CAAC,CAAC,CAAC,KAAK;;;;;;;;ACdV,MAAa,YAA+B;CAC1C,MAAM;CACN,aAAa;CACb,WAAW,UAAU,cAAc,KAAK;AAC1C"}

package/dist/data-CAd_goXP.mjs

@@ -0,0 +1,31 @@
+import { existsProp, isFiniteNumber, isNonNegativeNumber, isPositiveNumber, isVec2, propIs, validate } from "@scenography/scene";
+//#region src/data/validate.ts
+const validateWater = (water) => validate([
+	existsProp("size", "Water is missing a size."),
+	propIs("size", isVec2, "size must be [width, depth]."),
+	propIs("center", isVec2, "center must be [x, z]."),
+	propIs("level", isFiniteNumber, "level must be a finite number."),
+	...[
+		"waveHeight",
+		"waveScale",
+		"waveSpeed"
+	].map((key) => propIs(key, isNonNegativeNumber, `${key} must be a non-negative number.`)),
+	propIs("depthScale", isPositiveNumber, "depthScale must be a positive number."),
+	propIs("foam", isNonNegativeNumber, "foam must be a non-negative number.")
+])(water);
+//#endregion
+//#region src/data/plugin.ts
+/**
+* The data half of the water plugin: owns the `water` scene key (a singleton)
+* and validates it. Pure — no three.js; pass it to `defineScene` so scenes
+* using water validate without loading the runtime.
+*/
+const waterData = {
+	kind: "water",
+	cardinality: "single",
+	validate: (water) => validateWater(water)
+};
+//#endregion
+export { validateWater as n, waterData as t };
+
+//# sourceMappingURL=data-CAd_goXP.mjs.map

package/dist/data-CAd_goXP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-CAd_goXP.mjs","names":[],"sources":["../src/data/validate.ts","../src/data/plugin.ts"],"sourcesContent":["import {\n  existsProp,\n  isFiniteNumber,\n  isNonNegativeNumber,\n  isPositiveNumber,\n  isVec2,\n  propIs,\n  validate,\n  type ValidationResult,\n} from \"@scenography/scene\";\n\nimport type { Water } from \"./water\";\n\nexport const validateWater = (water: Water): ValidationResult =>\n  validate<Water>([\n    existsProp(\"size\", \"Water is missing a size.\"),\n    propIs(\"size\", isVec2, \"size must be [width, depth].\"),\n    propIs(\"center\", isVec2, \"center must be [x, z].\"),\n    propIs(\"level\", isFiniteNumber, \"level must be a finite number.\"),\n    ...([\"waveHeight\", \"waveScale\", \"waveSpeed\"] as const).map((key) =>\n      propIs(key, isNonNegativeNumber, `${key} must be a non-negative number.`),\n    ),\n    propIs(\"depthScale\", isPositiveNumber, \"depthScale must be a positive number.\"),\n    propIs(\"foam\", isNonNegativeNumber, \"foam must be a non-negative number.\"),\n  ])(water);\n","import type { DataPlugin } from \"@scenography/scene\";\n\nimport { validateWater } from \"./validate\";\nimport type { Water } from \"./water\";\n\n/**\n * The data half of the water plugin: owns the `water` scene key (a singleton)\n * and validates it. Pure — no three.js; pass it to `defineScene` so scenes\n * using water validate without loading the runtime.\n */\nexport const waterData: DataPlugin<Water> = {\n  kind: \"water\",\n  cardinality: \"single\",\n  validate: (water) => validateWater(water),\n};\n"],"mappings":";;AAaA,MAAa,iBAAiB,UAC5B,SAAgB;CACd,WAAW,QAAQ,0BAA0B;CAC7C,OAAO,QAAQ,QAAQ,8BAA8B;CACrD,OAAO,UAAU,QAAQ,wBAAwB;CACjD,OAAO,SAAS,gBAAgB,gCAAgC;CAChE,GAAI;EAAC;EAAc;EAAa;CAAW,CAAC,CAAW,KAAK,QAC1D,OAAO,KAAK,qBAAqB,GAAG,IAAI,gCAAgC,CAC1E;CACA,OAAO,cAAc,kBAAkB,uCAAuC;CAC9E,OAAO,QAAQ,qBAAqB,qCAAqC;AAC3E,CAAC,CAAC,CAAC,KAAK;;;;;;;;ACdV,MAAa,YAA+B;CAC1C,MAAM;CACN,aAAa;CACb,WAAW,UAAU,cAAc,KAAK;AAC1C"}

package/dist/data.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_data = require("./data-BI-VQXjw.cjs");
+exports.validateWater = require_data.validateWater;
+exports.waterData = require_data.waterData;

package/dist/data.d.cts

@@ -0,0 +1,2 @@
+import { n as validateWater, r as Water, t as waterData } from "./index-BLdh03xr.cjs";
+export { type Water, validateWater, waterData };

package/dist/data.d.mts

@@ -0,0 +1,2 @@
+import { n as validateWater, r as Water, t as waterData } from "./index-BLdh03xr.mjs";
+export { type Water, validateWater, waterData };

package/dist/data.mjs

@@ -0,0 +1,2 @@
+import { n as validateWater, t as waterData } from "./data-CAd_goXP.mjs";
+export { validateWater, waterData };

package/dist/index-BLdh03xr.d.cts

@@ -0,0 +1,59 @@
+import { DataPlugin, ValidationResult, Vec2 } from "@scenography/scene";
+
+//#region src/data/water.d.ts
+/**
+ * A flat body of water — a transparent surface that refracts whatever opaque
+ * geometry sits below it (so the sea floor shows through). Pure data: the plane,
+ * its level, a color the water tints toward, and an optional ripple. The runtime
+ * builds it with a physically-based transmissive material.
+ */
+interface Water {
+  /** Plane extent `[width (x), depth (z)]` in world units. */
+  size: Vec2;
+  /** Center on the ground plane `[x, z]`. Defaults to `[0, 0]`. */
+  center?: Vec2;
+  /** Surface level (world Y). Defaults to `0`. */
+  level?: number;
+  /** Color the water tints toward (CSS). Defaults to a sea green-blue. */
+  color?: string;
+  /** Animate the surface with FBM waves (evolving normals, not a scrolling map). Defaults to `true`. */
+  ripple?: boolean;
+  /** Wave amplitude — how bumpy the surface normals get. Default `6`. */
+  waveHeight?: number;
+  /** Wave spatial frequency — higher is choppier/smaller waves. Default `0.02`. */
+  waveScale?: number;
+  /** Wave animation speed. Default `0.6`. */
+  waveSpeed?: number;
+  /**
+   * Deep-water tint (CSS). The surface leans toward it with depth (depth is read
+   * from the floor below — its base `y` plus heightmap relief). Defaults to a
+   * deep teal.
+   */
+  depthColor?: string;
+  /** Depth (world units) over which color approaches `depthColor`. Default `100`. */
+  depthScale?: number;
+  /** Shoreline foam band width (world units of depth). `0` = none. Default `12`. */
+  foam?: number;
+  /** Foam color (CSS). Default white. */
+  foamColor?: string;
+}
+declare module "@scenography/scene" {
+  interface Scene {
+    /** A body of water (sea, pool…) — provided by `@scenography/plugin-water`. */
+    water?: Water;
+  }
+}
+//#endregion
+//#region src/data/validate.d.ts
+declare const validateWater: (water: Water) => ValidationResult;
+//#endregion
+//#region src/data/plugin.d.ts
+/**
+ * The data half of the water plugin: owns the `water` scene key (a singleton)
+ * and validates it. Pure — no three.js; pass it to `defineScene` so scenes
+ * using water validate without loading the runtime.
+ */
+declare const waterData: DataPlugin<Water>;
+//#endregion
+export { validateWater as n, Water as r, waterData as t };
+//# sourceMappingURL=index-BLdh03xr.d.cts.map

package/dist/index-BLdh03xr.d.mts

@@ -0,0 +1,59 @@
+import { DataPlugin, ValidationResult, Vec2 } from "@scenography/scene";
+
+//#region src/data/water.d.ts
+/**
+ * A flat body of water — a transparent surface that refracts whatever opaque
+ * geometry sits below it (so the sea floor shows through). Pure data: the plane,
+ * its level, a color the water tints toward, and an optional ripple. The runtime
+ * builds it with a physically-based transmissive material.
+ */
+interface Water {
+  /** Plane extent `[width (x), depth (z)]` in world units. */
+  size: Vec2;
+  /** Center on the ground plane `[x, z]`. Defaults to `[0, 0]`. */
+  center?: Vec2;
+  /** Surface level (world Y). Defaults to `0`. */
+  level?: number;
+  /** Color the water tints toward (CSS). Defaults to a sea green-blue. */
+  color?: string;
+  /** Animate the surface with FBM waves (evolving normals, not a scrolling map). Defaults to `true`. */
+  ripple?: boolean;
+  /** Wave amplitude — how bumpy the surface normals get. Default `6`. */
+  waveHeight?: number;
+  /** Wave spatial frequency — higher is choppier/smaller waves. Default `0.02`. */
+  waveScale?: number;
+  /** Wave animation speed. Default `0.6`. */
+  waveSpeed?: number;
+  /**
+   * Deep-water tint (CSS). The surface leans toward it with depth (depth is read
+   * from the floor below — its base `y` plus heightmap relief). Defaults to a
+   * deep teal.
+   */
+  depthColor?: string;
+  /** Depth (world units) over which color approaches `depthColor`. Default `100`. */
+  depthScale?: number;
+  /** Shoreline foam band width (world units of depth). `0` = none. Default `12`. */
+  foam?: number;
+  /** Foam color (CSS). Default white. */
+  foamColor?: string;
+}
+declare module "@scenography/scene" {
+  interface Scene {
+    /** A body of water (sea, pool…) — provided by `@scenography/plugin-water`. */
+    water?: Water;
+  }
+}
+//#endregion
+//#region src/data/validate.d.ts
+declare const validateWater: (water: Water) => ValidationResult;
+//#endregion
+//#region src/data/plugin.d.ts
+/**
+ * The data half of the water plugin: owns the `water` scene key (a singleton)
+ * and validates it. Pure — no three.js; pass it to `defineScene` so scenes
+ * using water validate without loading the runtime.
+ */
+declare const waterData: DataPlugin<Water>;
+//#endregion
+export { validateWater as n, Water as r, waterData as t };
+//# sourceMappingURL=index-BLdh03xr.d.mts.map

package/dist/index.cjs

@@ -0,0 +1,244 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_data = require("./data-BI-VQXjw.cjs");
+let _scenography_engine = require("@scenography/engine");
+let three = require("three");
+//#region src/buildWater.ts
+const WAVE_GLSL = `
+  varying vec3 vWaterWorld;
+  uniform float uTime, uWaterLevel, uFloorY, uFloorHeightScale, uDepthScale, uFoam;
+  uniform float uWaveHeight, uWaveScale, uWaveSpeed;
+  uniform vec2 uFloorCenter, uFloorSize;
+  uniform sampler2D uFloorHeightmap;
+  uniform vec3 uDepthColor, uFoamColor;
+
+  float wHash(vec2 p){ float h = dot(p, vec2(127.1, 311.7)); return fract(sin(h) * 43758.5453123); }
+  float wNoise(vec2 p){
+    vec2 i = floor(p), f = fract(p);
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return -1.0 + 2.0 * mix(mix(wHash(i + vec2(0.0,0.0)), wHash(i + vec2(1.0,0.0)), u.x),
+                            mix(wHash(i + vec2(0.0,1.0)), wHash(i + vec2(1.0,1.0)), u.x), u.y);
+  }
+  float seaOctave(vec2 uv, float choppy){
+    uv += wNoise(uv);
+    vec2 wv = 1.0 - abs(sin(uv));
+    vec2 swv = abs(cos(uv));
+    wv = mix(wv, swv, wv);
+    return pow(1.0 - pow(wv.x * wv.y, 0.65), choppy);
+  }
+  float waveHeight(vec2 p){
+    float t = uTime * uWaveSpeed;
+    vec2 uv = p * uWaveScale; uv.x *= 0.75;
+    float freq = 1.0, amp = 1.0, choppy = 4.0, h = 0.0;
+    mat2 m = mat2(1.6, 1.2, -1.2, 1.6);
+    for(int i = 0; i < 3; i++){
+      float d = seaOctave((uv + t) * freq, choppy) + seaOctave((uv - t) * freq, choppy);
+      h += d * amp;
+      uv = m * uv; freq *= 1.9; amp *= 0.22; choppy = mix(choppy, 1.0, 0.2);
+    }
+    return h * uWaveHeight;
+  }
+`;
+/**
+* Build a `Water` surface: a horizontal plane with a transmissive physical
+* material (refracts the sea floor so the pebbles show through), upgraded with a
+* custom shader that (1) ripples the surface normal with FBM waves that evolve in
+* place, (2) tints by depth (the bottom is read from the `floor`'s base `y` plus
+* its heightmap relief — no depth prepass), and (3) paints an irregular,
+* advancing/receding shoreline foam line. Set
+* `ripple: false` for a still, glassy surface.
+*/
+function buildWater(water, floor) {
+	const [width, depth] = water.size;
+	const [cx, cz] = water.center ?? [0, 0];
+	const level = water.level ?? 0;
+	const rippleOn = water.ripple !== false;
+	const material = new three.MeshPhysicalMaterial({
+		color: "#ffffff",
+		roughness: .12,
+		metalness: 0,
+		transmission: 1,
+		ior: 1.33,
+		thickness: 100,
+		attenuationColor: new three.Color(water.color ?? "#3b7d78"),
+		attenuationDistance: 400
+	});
+	const [fcx, fcz] = floor?.center ?? [0, 0];
+	const [fw, fd] = floor?.size ?? [1, 1];
+	const floorHeightScale = floor?.heightmap ? floor.heightScale ?? 0 : 0;
+	let bottomMap;
+	if (floor?.heightmap && floorHeightScale !== 0) bottomMap = new three.TextureLoader().load(floor.heightmap);
+	else {
+		bottomMap = new three.DataTexture(new Uint8Array([
+			0,
+			0,
+			0,
+			255
+		]), 1, 1);
+		bottomMap.needsUpdate = true;
+	}
+	const reflectionTarget = new three.WebGLRenderTarget(1, 1);
+	const uniforms = {
+		uTime: { value: 0 },
+		uWaterLevel: { value: level },
+		uFloorY: { value: floor?.y ?? 0 },
+		uFloorCenter: { value: new three.Vector2(fcx, fcz) },
+		uFloorSize: { value: new three.Vector2(fw, fd) },
+		uFloorHeightmap: { value: bottomMap },
+		uFloorHeightScale: { value: floorHeightScale },
+		uDepthColor: { value: new three.Color(water.depthColor ?? "#0d3b40") },
+		uDepthScale: { value: water.depthScale ?? 100 },
+		uFoam: { value: water.foam ?? 12 },
+		uFoamColor: { value: new three.Color(water.foamColor ?? "#eaf6f6") },
+		uWaveHeight: { value: rippleOn ? water.waveHeight ?? 6 : 0 },
+		uWaveScale: { value: water.waveScale ?? .02 },
+		uWaveSpeed: { value: water.waveSpeed ?? .6 },
+		uReflection: { value: reflectionTarget.texture },
+		uReflectionMatrix: { value: new three.Matrix4() }
+	};
+	material.onBeforeCompile = (shader) => {
+		Object.assign(shader.uniforms, uniforms);
+		shader.vertexShader = shader.vertexShader.replace("#include <common>", "#include <common>\nvarying vec3 vWaterWorld;\nvarying vec4 vReflectCoord;\nuniform mat4 uReflectionMatrix;").replace("#include <begin_vertex>", `#include <begin_vertex>
+        vWaterWorld = (modelMatrix * vec4(transformed, 1.0)).xyz;
+        vReflectCoord = uReflectionMatrix * vec4(transformed, 1.0);`);
+		shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>\n${WAVE_GLSL}\nvarying vec4 vReflectCoord;\nuniform sampler2D uReflection;\nvec2 gWaveSlope = vec2(0.0);`).replace("#include <normal_fragment_maps>", `#include <normal_fragment_maps>
+        if (uWaveHeight > 0.0) {
+          vec2 wp = vWaterWorld.xz;
+          float e = 2.0;
+          float hC = waveHeight(wp);
+          float dhdx = (waveHeight(wp + vec2(e, 0.0)) - hC) / e;
+          float dhdz = (waveHeight(wp + vec2(0.0, e)) - hC) / e;
+          vec3 wn = normalize(vec3(-dhdx, 1.0, -dhdz));
+          normal = normalize((viewMatrix * vec4(wn, 0.0)).xyz);
+          gWaveSlope = vec2(dhdx, dhdz); // fed to the reflection for ripples
+        }`).replace("#include <opaque_fragment>", `#include <opaque_fragment>
+        {
+          // Floor world (x, z) → heightmap UV. Matches the floor builder's
+          // mapping; v is flipped because three.js textures flip Y on upload.
+          vec2 huv = clamp((vWaterWorld.xz - uFloorCenter) / uFloorSize + 0.5, 0.0, 1.0);
+          float bottom = uFloorY + texture2D(uFloorHeightmap, huv).r * uFloorHeightScale;
+          float wdepth = max(uWaterLevel - bottom, 0.0);
+          float deep = 1.0 - exp(-wdepth / uDepthScale);
+          gl_FragColor.rgb = mix(gl_FragColor.rgb, uDepthColor, deep);
+          // Planar reflection: the mirrored scene (walls occlude the sky) sampled
+          // at this fragment's projected position, rippled by the wave slope and
+          // Fresnel-weighted so it dominates at grazing angles. This replaces the
+          // sky-only environment reflection, so the glint respects the walls.
+          vec2 rUv = vReflectCoord.xy / vReflectCoord.w + gWaveSlope * 0.06;
+          vec3 reflColor = texture2D(uReflection, rUv).rgb;
+          float fres = clamp(pow(1.0 - abs(dot(normalize(vViewPosition), normal)), 5.0), 0.0, 1.0);
+          gl_FragColor.rgb = mix(gl_FragColor.rgb, reflColor, mix(0.15, 0.95, fres));
+          float foam = 0.0;
+          if (uFoam > 0.0) {
+            // A thin lacy band hugging the waterline (depth 0..uFoam), not a wash
+            // across open water. A little noise wiggles its inner edge so the
+            // straight plane cut reads as an irregular shoreline; marching sine
+            // fronts add waves running up the shore.
+            float wiggle = wNoise(vWaterWorld.xz * 0.03 + uTime * 0.1) * 0.5 + 0.5;
+            float wd = max(wdepth + (wiggle - 0.5) * uFoam * 0.6, 0.0);
+            float band = 1.0 - smoothstep(0.0, uFoam, wd);
+            float lace = 0.5 + 0.5 * wNoise(vWaterWorld.xz * 0.1 - uTime * 0.25);
+            float fronts = 0.5 + 0.5 * sin(wd * 0.2 - uTime * 1.5);
+            foam = smoothstep(0.12, 0.5, band * band * lace * fronts);
+            gl_FragColor.rgb = mix(gl_FragColor.rgb, uFoamColor, foam);
+          }
+          gl_FragColor.a = max(gl_FragColor.a, max(deep * 0.7, foam));
+        }`);
+	};
+	material.customProgramCacheKey = () => "scenography-water";
+	const mesh = new three.Mesh(new three.PlaneGeometry(width, depth), material);
+	mesh.rotation.x = -Math.PI / 2;
+	mesh.position.set(cx, level, cz);
+	mesh.name = "water";
+	mesh.receiveShadow = true;
+	const update = (deltaMs) => {
+		uniforms.uTime.value += deltaMs / 1e3;
+	};
+	const reflectionCamera = new three.PerspectiveCamera();
+	const reflectorNormal = new three.Vector3(0, 1, 0);
+	const reflectorPos = new three.Vector3(cx, level, cz);
+	const reflectorPlane = new three.Plane();
+	const camPos = new three.Vector3();
+	const rot = new three.Matrix4();
+	const view = new three.Vector3();
+	const lookAt = new three.Vector3();
+	const target = new three.Vector3();
+	const clip = new three.Vector4();
+	const q = new three.Vector4();
+	const size = new three.Vector2();
+	const beforeRender = (renderer, scene, camera) => {
+		renderer.getDrawingBufferSize(size);
+		if (reflectionTarget.width !== size.x || reflectionTarget.height !== size.y) reflectionTarget.setSize(Math.max(1, size.x), Math.max(1, size.y));
+		camera.updateMatrixWorld();
+		mesh.updateMatrixWorld();
+		camPos.setFromMatrixPosition(camera.matrixWorld);
+		view.subVectors(reflectorPos, camPos);
+		if (view.dot(reflectorNormal) > 0) return;
+		view.reflect(reflectorNormal).negate().add(reflectorPos);
+		rot.extractRotation(camera.matrixWorld);
+		lookAt.set(0, 0, -1).applyMatrix4(rot).add(camPos);
+		target.subVectors(reflectorPos, lookAt).reflect(reflectorNormal).negate().add(reflectorPos);
+		reflectionCamera.position.copy(view);
+		reflectionCamera.up.set(0, 1, 0).applyMatrix4(rot).reflect(reflectorNormal);
+		reflectionCamera.lookAt(target);
+		reflectionCamera.far = camera.far;
+		reflectionCamera.updateMatrixWorld();
+		reflectionCamera.projectionMatrix.copy(camera.projectionMatrix);
+		const m = uniforms.uReflectionMatrix.value;
+		m.set(.5, 0, 0, .5, 0, .5, 0, .5, 0, 0, .5, .5, 0, 0, 0, 1);
+		m.multiply(reflectionCamera.projectionMatrix);
+		m.multiply(reflectionCamera.matrixWorldInverse);
+		m.multiply(mesh.matrixWorld);
+		reflectorPlane.setFromNormalAndCoplanarPoint(reflectorNormal, reflectorPos);
+		reflectorPlane.applyMatrix4(reflectionCamera.matrixWorldInverse);
+		clip.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant);
+		const e = reflectionCamera.projectionMatrix.elements;
+		q.set((Math.sign(clip.x) + e[8]) / e[0], (Math.sign(clip.y) + e[9]) / e[5], -1, (1 + e[10]) / e[14]);
+		clip.multiplyScalar(2 / clip.dot(q));
+		e[2] = clip.x;
+		e[6] = clip.y;
+		e[10] = clip.z + 1;
+		e[14] = clip.w;
+		const prevTarget = renderer.getRenderTarget();
+		const prevShadowAuto = renderer.shadowMap.autoUpdate;
+		mesh.visible = false;
+		renderer.shadowMap.autoUpdate = false;
+		renderer.setRenderTarget(reflectionTarget);
+		renderer.clear();
+		renderer.render(scene, reflectionCamera);
+		renderer.setRenderTarget(prevTarget);
+		renderer.shadowMap.autoUpdate = prevShadowAuto;
+		mesh.visible = true;
+	};
+	const dispose = () => {
+		reflectionTarget.dispose();
+	};
+	return {
+		object: mesh,
+		update,
+		beforeRender,
+		dispose
+	};
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* The water plugin: materializes the `water` scene key as a transparent,
+* depth-tinted surface with FBM waves and shoreline foam. Consumes the
+* `terrain` capability (published by the floor) so the depth/foam shader can
+* sample the same heightmap the ground is displaced by — and rebuilds when the
+* floor changes (`dependsOn`).
+*/
+const water = () => ({
+	data: require_data.waterData,
+	dependsOn: [_scenography_engine.TERRAIN],
+	build: (definition, ctx) => {
+		return buildWater(definition, ctx.capabilities.get(_scenography_engine.TERRAIN)?.definition);
+	}
+});
+//#endregion
+exports.buildWater = buildWater;
+exports.validateWater = require_data.validateWater;
+exports.water = water;
+exports.waterData = require_data.waterData;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["MeshPhysicalMaterial","Color","TextureLoader","DataTexture","WebGLRenderTarget","Vector2","Matrix4","Mesh","PlaneGeometry","PerspectiveCamera","Vector3","Plane","Vector4","waterData","TERRAIN"],"sources":["../src/buildWater.ts","../src/plugin.ts"],"sourcesContent":["import {\n  Color,\n  DataTexture,\n  Matrix4,\n  Mesh,\n  MeshPhysicalMaterial,\n  PerspectiveCamera,\n  Plane,\n  PlaneGeometry,\n  TextureLoader,\n  Vector2,\n  Vector3,\n  Vector4,\n  WebGLRenderTarget,\n  type Object3D,\n  type PerspectiveCamera as PerspectiveCameraType,\n  type Scene as ThreeScene,\n  type WebGLRenderer,\n  type WebGLProgramParametersWithUniforms,\n} from \"three\";\nimport type { TerrainDefinition } from \"@scenography/engine\";\n\nimport type { Water } from \"./data\";\n\n/** A built water surface: the mesh plus its per-frame update and reflection pass. */\nexport interface BuiltWater {\n  object: Object3D;\n  update: (deltaMs: number) => void;\n  beforeRender: (renderer: WebGLRenderer, scene: ThreeScene, camera: PerspectiveCameraType) => void;\n  dispose: () => void;\n}\n\n// FBM wave + noise helpers, borrowed from \"Seascape\" by Alexander Alekseev (TDM,\n// CC BY-NC-SA 3.0): waves evolve in place (not a scrolling texture) so the calm\n// surface doesn't look like a repeating slide. Injected into the fragment shader.\nconst WAVE_GLSL = /* glsl */ `\n  varying vec3 vWaterWorld;\n  uniform float uTime, uWaterLevel, uFloorY, uFloorHeightScale, uDepthScale, uFoam;\n  uniform float uWaveHeight, uWaveScale, uWaveSpeed;\n  uniform vec2 uFloorCenter, uFloorSize;\n  uniform sampler2D uFloorHeightmap;\n  uniform vec3 uDepthColor, uFoamColor;\n\n  float wHash(vec2 p){ float h = dot(p, vec2(127.1, 311.7)); return fract(sin(h) * 43758.5453123); }\n  float wNoise(vec2 p){\n    vec2 i = floor(p), f = fract(p);\n    vec2 u = f * f * (3.0 - 2.0 * f);\n    return -1.0 + 2.0 * mix(mix(wHash(i + vec2(0.0,0.0)), wHash(i + vec2(1.0,0.0)), u.x),\n                            mix(wHash(i + vec2(0.0,1.0)), wHash(i + vec2(1.0,1.0)), u.x), u.y);\n  }\n  float seaOctave(vec2 uv, float choppy){\n    uv += wNoise(uv);\n    vec2 wv = 1.0 - abs(sin(uv));\n    vec2 swv = abs(cos(uv));\n    wv = mix(wv, swv, wv);\n    return pow(1.0 - pow(wv.x * wv.y, 0.65), choppy);\n  }\n  float waveHeight(vec2 p){\n    float t = uTime * uWaveSpeed;\n    vec2 uv = p * uWaveScale; uv.x *= 0.75;\n    float freq = 1.0, amp = 1.0, choppy = 4.0, h = 0.0;\n    mat2 m = mat2(1.6, 1.2, -1.2, 1.6);\n    for(int i = 0; i < 3; i++){\n      float d = seaOctave((uv + t) * freq, choppy) + seaOctave((uv - t) * freq, choppy);\n      h += d * amp;\n      uv = m * uv; freq *= 1.9; amp *= 0.22; choppy = mix(choppy, 1.0, 0.2);\n    }\n    return h * uWaveHeight;\n  }\n`;\n\n/**\n * Build a `Water` surface: a horizontal plane with a transmissive physical\n * material (refracts the sea floor so the pebbles show through), upgraded with a\n * custom shader that (1) ripples the surface normal with FBM waves that evolve in\n * place, (2) tints by depth (the bottom is read from the `floor`'s base `y` plus\n * its heightmap relief — no depth prepass), and (3) paints an irregular,\n * advancing/receding shoreline foam line. Set\n * `ripple: false` for a still, glassy surface.\n */\nexport function buildWater(water: Water, floor?: TerrainDefinition): BuiltWater {\n  const [width, depth] = water.size;\n  const [cx, cz] = water.center ?? [0, 0];\n  const level = water.level ?? 0;\n  const rippleOn = water.ripple !== false;\n\n  const material = new MeshPhysicalMaterial({\n    color: \"#ffffff\",\n    roughness: 0.12,\n    metalness: 0,\n    transmission: 1,\n    ior: 1.33,\n    thickness: 100,\n    attenuationColor: new Color(water.color ?? \"#3b7d78\"),\n    attenuationDistance: 400,\n  });\n\n  // The depth/foam shader samples the floor's heightmap to know the bottom under\n  // each fragment (there is no depth prepass). A 1×1 black texture keeps the\n  // sampler bound when the floor is flat (bottom = uFloorY everywhere).\n  const [fcx, fcz] = floor?.center ?? [0, 0];\n  const [fw, fd] = floor?.size ?? [1, 1];\n  const floorHeightScale = floor?.heightmap ? floor.heightScale ?? 0 : 0;\n  let bottomMap;\n  if (floor?.heightmap && floorHeightScale !== 0) {\n    bottomMap = new TextureLoader().load(floor.heightmap);\n  } else {\n    bottomMap = new DataTexture(new Uint8Array([0, 0, 0, 255]), 1, 1);\n    bottomMap.needsUpdate = true;\n  }\n  // Planar reflection: the scene rendered mirrored across the water plane, so\n  // walls (and everything else) occlude the sky in the reflection.\n  const reflectionTarget = new WebGLRenderTarget(1, 1);\n  const uniforms = {\n    uTime: { value: 0 },\n    uWaterLevel: { value: level },\n    uFloorY: { value: floor?.y ?? 0 },\n    uFloorCenter: { value: new Vector2(fcx, fcz) },\n    uFloorSize: { value: new Vector2(fw, fd) },\n    uFloorHeightmap: { value: bottomMap },\n    uFloorHeightScale: { value: floorHeightScale },\n    uDepthColor: { value: new Color(water.depthColor ?? \"#0d3b40\") },\n    uDepthScale: { value: water.depthScale ?? 100 },\n    uFoam: { value: water.foam ?? 12 },\n    uFoamColor: { value: new Color(water.foamColor ?? \"#eaf6f6\") },\n    uWaveHeight: { value: rippleOn ? water.waveHeight ?? 6 : 0 },\n    uWaveScale: { value: water.waveScale ?? 0.02 },\n    uWaveSpeed: { value: water.waveSpeed ?? 0.6 },\n    uReflection: { value: reflectionTarget.texture },\n    uReflectionMatrix: { value: new Matrix4() },\n  };\n\n  material.onBeforeCompile = (shader: WebGLProgramParametersWithUniforms): void => {\n    Object.assign(shader.uniforms, uniforms);\n\n    shader.vertexShader = shader.vertexShader\n      .replace(\n        \"#include <common>\",\n        \"#include <common>\\nvarying vec3 vWaterWorld;\\nvarying vec4 vReflectCoord;\\nuniform mat4 uReflectionMatrix;\",\n      )\n      .replace(\n        \"#include <begin_vertex>\",\n        `#include <begin_vertex>\n        vWaterWorld = (modelMatrix * vec4(transformed, 1.0)).xyz;\n        vReflectCoord = uReflectionMatrix * vec4(transformed, 1.0);`,\n      );\n\n    shader.fragmentShader = shader.fragmentShader\n      .replace(\n        \"#include <common>\",\n        `#include <common>\\n${WAVE_GLSL}\\nvarying vec4 vReflectCoord;\\nuniform sampler2D uReflection;\\nvec2 gWaveSlope = vec2(0.0);`,\n      )\n      // Replace the flat surface normal with the FBM wave normal (world → view),\n      // so refraction and sun glints move organically. Runs after the map normals.\n      .replace(\n        \"#include <normal_fragment_maps>\",\n        `#include <normal_fragment_maps>\n        if (uWaveHeight > 0.0) {\n          vec2 wp = vWaterWorld.xz;\n          float e = 2.0;\n          float hC = waveHeight(wp);\n          float dhdx = (waveHeight(wp + vec2(e, 0.0)) - hC) / e;\n          float dhdz = (waveHeight(wp + vec2(0.0, e)) - hC) / e;\n          vec3 wn = normalize(vec3(-dhdx, 1.0, -dhdz));\n          normal = normalize((viewMatrix * vec4(wn, 0.0)).xyz);\n          gWaveSlope = vec2(dhdx, dhdz); // fed to the reflection for ripples\n        }`,\n      )\n      // Depth tint + irregular, breathing shoreline foam, after the final color.\n      .replace(\n        \"#include <opaque_fragment>\",\n        `#include <opaque_fragment>\n        {\n          // Floor world (x, z) → heightmap UV. Matches the floor builder's\n          // mapping; v is flipped because three.js textures flip Y on upload.\n          vec2 huv = clamp((vWaterWorld.xz - uFloorCenter) / uFloorSize + 0.5, 0.0, 1.0);\n          float bottom = uFloorY + texture2D(uFloorHeightmap, huv).r * uFloorHeightScale;\n          float wdepth = max(uWaterLevel - bottom, 0.0);\n          float deep = 1.0 - exp(-wdepth / uDepthScale);\n          gl_FragColor.rgb = mix(gl_FragColor.rgb, uDepthColor, deep);\n          // Planar reflection: the mirrored scene (walls occlude the sky) sampled\n          // at this fragment's projected position, rippled by the wave slope and\n          // Fresnel-weighted so it dominates at grazing angles. This replaces the\n          // sky-only environment reflection, so the glint respects the walls.\n          vec2 rUv = vReflectCoord.xy / vReflectCoord.w + gWaveSlope * 0.06;\n          vec3 reflColor = texture2D(uReflection, rUv).rgb;\n          float fres = clamp(pow(1.0 - abs(dot(normalize(vViewPosition), normal)), 5.0), 0.0, 1.0);\n          gl_FragColor.rgb = mix(gl_FragColor.rgb, reflColor, mix(0.15, 0.95, fres));\n          float foam = 0.0;\n          if (uFoam > 0.0) {\n            // A thin lacy band hugging the waterline (depth 0..uFoam), not a wash\n            // across open water. A little noise wiggles its inner edge so the\n            // straight plane cut reads as an irregular shoreline; marching sine\n            // fronts add waves running up the shore.\n            float wiggle = wNoise(vWaterWorld.xz * 0.03 + uTime * 0.1) * 0.5 + 0.5;\n            float wd = max(wdepth + (wiggle - 0.5) * uFoam * 0.6, 0.0);\n            float band = 1.0 - smoothstep(0.0, uFoam, wd);\n            float lace = 0.5 + 0.5 * wNoise(vWaterWorld.xz * 0.1 - uTime * 0.25);\n            float fronts = 0.5 + 0.5 * sin(wd * 0.2 - uTime * 1.5);\n            foam = smoothstep(0.12, 0.5, band * band * lace * fronts);\n            gl_FragColor.rgb = mix(gl_FragColor.rgb, uFoamColor, foam);\n          }\n          gl_FragColor.a = max(gl_FragColor.a, max(deep * 0.7, foam));\n        }`,\n      );\n  };\n  // Keep this material's program separate from other physical materials'.\n  material.customProgramCacheKey = (): string => \"scenography-water\";\n\n  const mesh = new Mesh(new PlaneGeometry(width, depth), material);\n  // PlaneGeometry faces +Z; lay it flat at the water level.\n  mesh.rotation.x = -Math.PI / 2;\n  mesh.position.set(cx, level, cz);\n  mesh.name = \"water\";\n  // Receive shadows so the sun's specular glint is cut where something (a wall)\n  // casts a shadow onto the surface, instead of shining through it.\n  mesh.receiveShadow = true;\n\n  const update = (deltaMs: number): void => {\n    uniforms.uTime.value += deltaMs / 1000;\n  };\n\n  // Reusable objects for the per-frame reflection pass (mirror the main camera\n  // across the water plane, then render the scene into `reflectionTarget`).\n  const reflectionCamera = new PerspectiveCamera();\n  const reflectorNormal = new Vector3(0, 1, 0);\n  const reflectorPos = new Vector3(cx, level, cz);\n  const reflectorPlane = new Plane();\n  const camPos = new Vector3();\n  const rot = new Matrix4();\n  const view = new Vector3();\n  const lookAt = new Vector3();\n  const target = new Vector3();\n  const clip = new Vector4();\n  const q = new Vector4();\n  const size = new Vector2();\n\n  const beforeRender = (\n    renderer: WebGLRenderer,\n    scene: ThreeScene,\n    camera: PerspectiveCameraType,\n  ): void => {\n    renderer.getDrawingBufferSize(size);\n    if (reflectionTarget.width !== size.x || reflectionTarget.height !== size.y) {\n      reflectionTarget.setSize(Math.max(1, size.x), Math.max(1, size.y));\n    }\n    camera.updateMatrixWorld();\n    mesh.updateMatrixWorld();\n    camPos.setFromMatrixPosition(camera.matrixWorld);\n    view.subVectors(reflectorPos, camPos);\n    if (view.dot(reflectorNormal) > 0) return; // camera below the surface — skip\n    view.reflect(reflectorNormal).negate().add(reflectorPos);\n    rot.extractRotation(camera.matrixWorld);\n    lookAt.set(0, 0, -1).applyMatrix4(rot).add(camPos);\n    target.subVectors(reflectorPos, lookAt).reflect(reflectorNormal).negate().add(reflectorPos);\n    reflectionCamera.position.copy(view);\n    reflectionCamera.up.set(0, 1, 0).applyMatrix4(rot).reflect(reflectorNormal);\n    reflectionCamera.lookAt(target);\n    reflectionCamera.far = camera.far;\n    reflectionCamera.updateMatrixWorld();\n    reflectionCamera.projectionMatrix.copy(camera.projectionMatrix);\n\n    // Texture matrix: bias · proj · viewInv · meshWorld → sample by fragment.\n    const m = uniforms.uReflectionMatrix.value;\n    m.set(0.5, 0, 0, 0.5, 0, 0.5, 0, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0, 1);\n    m.multiply(reflectionCamera.projectionMatrix);\n    m.multiply(reflectionCamera.matrixWorldInverse);\n    m.multiply(mesh.matrixWorld);\n\n    // Oblique near-plane clip at the water surface, so geometry below it isn't\n    // mirrored into the reflection (standard Reflector trick).\n    reflectorPlane.setFromNormalAndCoplanarPoint(reflectorNormal, reflectorPos);\n    reflectorPlane.applyMatrix4(reflectionCamera.matrixWorldInverse);\n    clip.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant);\n    const e = reflectionCamera.projectionMatrix.elements;\n    q.set((Math.sign(clip.x) + e[8]!) / e[0]!, (Math.sign(clip.y) + e[9]!) / e[5]!, -1, (1 + e[10]!) / e[14]!);\n    clip.multiplyScalar(2 / clip.dot(q));\n    e[2] = clip.x;\n    e[6] = clip.y;\n    e[10] = clip.z + 1;\n    e[14] = clip.w;\n\n    const prevTarget = renderer.getRenderTarget();\n    const prevShadowAuto = renderer.shadowMap.autoUpdate;\n    mesh.visible = false; // don't mirror the water into itself\n    renderer.shadowMap.autoUpdate = false; // reuse the main shadow map\n    renderer.setRenderTarget(reflectionTarget);\n    renderer.clear();\n    renderer.render(scene, reflectionCamera);\n    renderer.setRenderTarget(prevTarget);\n    renderer.shadowMap.autoUpdate = prevShadowAuto;\n    mesh.visible = true;\n  };\n\n  const dispose = (): void => {\n    reflectionTarget.dispose();\n  };\n\n  return { object: mesh, update, beforeRender, dispose };\n}\n","import { TERRAIN, type EnginePlugin, type TerrainCapability } from \"@scenography/engine\";\n\nimport { buildWater } from \"./buildWater\";\nimport { waterData } from \"./data\";\nimport type { Water } from \"./data\";\n\n/**\n * The water plugin: materializes the `water` scene key as a transparent,\n * depth-tinted surface with FBM waves and shoreline foam. Consumes the\n * `terrain` capability (published by the floor) so the depth/foam shader can\n * sample the same heightmap the ground is displaced by — and rebuilds when the\n * floor changes (`dependsOn`).\n */\nexport const water = (): EnginePlugin<Water> => ({\n  data: waterData,\n  dependsOn: [TERRAIN],\n  build: (definition, ctx) => {\n    const terrain = ctx.capabilities.get<TerrainCapability>(TERRAIN);\n    return buildWater(definition, terrain?.definition);\n  },\n});\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -0,0 +1,35 @@
+import { n as validateWater, r as Water, t as waterData } from "./index-BLdh03xr.cjs";
+import { EnginePlugin, TerrainDefinition } from "@scenography/engine";
+import { Object3D, PerspectiveCamera, Scene, WebGLRenderer } from "three";
+
+//#region src/plugin.d.ts
+/**
+ * The water plugin: materializes the `water` scene key as a transparent,
+ * depth-tinted surface with FBM waves and shoreline foam. Consumes the
+ * `terrain` capability (published by the floor) so the depth/foam shader can
+ * sample the same heightmap the ground is displaced by — and rebuilds when the
+ * floor changes (`dependsOn`).
+ */
+declare const water: () => EnginePlugin<Water>;
+//#endregion
+//#region src/buildWater.d.ts
+/** A built water surface: the mesh plus its per-frame update and reflection pass. */
+interface BuiltWater {
+  object: Object3D;
+  update: (deltaMs: number) => void;
+  beforeRender: (renderer: WebGLRenderer, scene: Scene, camera: PerspectiveCamera) => void;
+  dispose: () => void;
+}
+/**
+ * Build a `Water` surface: a horizontal plane with a transmissive physical
+ * material (refracts the sea floor so the pebbles show through), upgraded with a
+ * custom shader that (1) ripples the surface normal with FBM waves that evolve in
+ * place, (2) tints by depth (the bottom is read from the `floor`'s base `y` plus
+ * its heightmap relief — no depth prepass), and (3) paints an irregular,
+ * advancing/receding shoreline foam line. Set
+ * `ripple: false` for a still, glassy surface.
+ */
+declare function buildWater(water: Water, floor?: TerrainDefinition): BuiltWater;
+//#endregion
+export { type BuiltWater, type Water, buildWater, validateWater, water, waterData };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -0,0 +1,35 @@
+import { n as validateWater, r as Water, t as waterData } from "./index-BLdh03xr.mjs";
+import { EnginePlugin, TerrainDefinition } from "@scenography/engine";
+import { Object3D, PerspectiveCamera, Scene, WebGLRenderer } from "three";
+
+//#region src/plugin.d.ts
+/**
+ * The water plugin: materializes the `water` scene key as a transparent,
+ * depth-tinted surface with FBM waves and shoreline foam. Consumes the
+ * `terrain` capability (published by the floor) so the depth/foam shader can
+ * sample the same heightmap the ground is displaced by — and rebuilds when the
+ * floor changes (`dependsOn`).
+ */
+declare const water: () => EnginePlugin<Water>;
+//#endregion
+//#region src/buildWater.d.ts
+/** A built water surface: the mesh plus its per-frame update and reflection pass. */
+interface BuiltWater {
+  object: Object3D;
+  update: (deltaMs: number) => void;
+  beforeRender: (renderer: WebGLRenderer, scene: Scene, camera: PerspectiveCamera) => void;
+  dispose: () => void;
+}
+/**
+ * Build a `Water` surface: a horizontal plane with a transmissive physical
+ * material (refracts the sea floor so the pebbles show through), upgraded with a
+ * custom shader that (1) ripples the surface normal with FBM waves that evolve in
+ * place, (2) tints by depth (the bottom is read from the `floor`'s base `y` plus
+ * its heightmap relief — no depth prepass), and (3) paints an irregular,
+ * advancing/receding shoreline foam line. Set
+ * `ripple: false` for a still, glassy surface.
+ */
+declare function buildWater(water: Water, floor?: TerrainDefinition): BuiltWater;
+//#endregion
+export { type BuiltWater, type Water, buildWater, validateWater, water, waterData };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,240 @@
+import { n as validateWater, t as waterData } from "./data-CAd_goXP.mjs";
+import { TERRAIN } from "@scenography/engine";
+import { Color, DataTexture, Matrix4, Mesh, MeshPhysicalMaterial, PerspectiveCamera, Plane, PlaneGeometry, TextureLoader, Vector2, Vector3, Vector4, WebGLRenderTarget } from "three";
+//#region src/buildWater.ts
+const WAVE_GLSL = `
+  varying vec3 vWaterWorld;
+  uniform float uTime, uWaterLevel, uFloorY, uFloorHeightScale, uDepthScale, uFoam;
+  uniform float uWaveHeight, uWaveScale, uWaveSpeed;
+  uniform vec2 uFloorCenter, uFloorSize;
+  uniform sampler2D uFloorHeightmap;
+  uniform vec3 uDepthColor, uFoamColor;
+
+  float wHash(vec2 p){ float h = dot(p, vec2(127.1, 311.7)); return fract(sin(h) * 43758.5453123); }
+  float wNoise(vec2 p){
+    vec2 i = floor(p), f = fract(p);
+    vec2 u = f * f * (3.0 - 2.0 * f);
+    return -1.0 + 2.0 * mix(mix(wHash(i + vec2(0.0,0.0)), wHash(i + vec2(1.0,0.0)), u.x),
+                            mix(wHash(i + vec2(0.0,1.0)), wHash(i + vec2(1.0,1.0)), u.x), u.y);
+  }
+  float seaOctave(vec2 uv, float choppy){
+    uv += wNoise(uv);
+    vec2 wv = 1.0 - abs(sin(uv));
+    vec2 swv = abs(cos(uv));
+    wv = mix(wv, swv, wv);
+    return pow(1.0 - pow(wv.x * wv.y, 0.65), choppy);
+  }
+  float waveHeight(vec2 p){
+    float t = uTime * uWaveSpeed;
+    vec2 uv = p * uWaveScale; uv.x *= 0.75;
+    float freq = 1.0, amp = 1.0, choppy = 4.0, h = 0.0;
+    mat2 m = mat2(1.6, 1.2, -1.2, 1.6);
+    for(int i = 0; i < 3; i++){
+      float d = seaOctave((uv + t) * freq, choppy) + seaOctave((uv - t) * freq, choppy);
+      h += d * amp;
+      uv = m * uv; freq *= 1.9; amp *= 0.22; choppy = mix(choppy, 1.0, 0.2);
+    }
+    return h * uWaveHeight;
+  }
+`;
+/**
+* Build a `Water` surface: a horizontal plane with a transmissive physical
+* material (refracts the sea floor so the pebbles show through), upgraded with a
+* custom shader that (1) ripples the surface normal with FBM waves that evolve in
+* place, (2) tints by depth (the bottom is read from the `floor`'s base `y` plus
+* its heightmap relief — no depth prepass), and (3) paints an irregular,
+* advancing/receding shoreline foam line. Set
+* `ripple: false` for a still, glassy surface.
+*/
+function buildWater(water, floor) {
+	const [width, depth] = water.size;
+	const [cx, cz] = water.center ?? [0, 0];
+	const level = water.level ?? 0;
+	const rippleOn = water.ripple !== false;
+	const material = new MeshPhysicalMaterial({
+		color: "#ffffff",
+		roughness: .12,
+		metalness: 0,
+		transmission: 1,
+		ior: 1.33,
+		thickness: 100,
+		attenuationColor: new Color(water.color ?? "#3b7d78"),
+		attenuationDistance: 400
+	});
+	const [fcx, fcz] = floor?.center ?? [0, 0];
+	const [fw, fd] = floor?.size ?? [1, 1];
+	const floorHeightScale = floor?.heightmap ? floor.heightScale ?? 0 : 0;
+	let bottomMap;
+	if (floor?.heightmap && floorHeightScale !== 0) bottomMap = new TextureLoader().load(floor.heightmap);
+	else {
+		bottomMap = new DataTexture(new Uint8Array([
+			0,
+			0,
+			0,
+			255
+		]), 1, 1);
+		bottomMap.needsUpdate = true;
+	}
+	const reflectionTarget = new WebGLRenderTarget(1, 1);
+	const uniforms = {
+		uTime: { value: 0 },
+		uWaterLevel: { value: level },
+		uFloorY: { value: floor?.y ?? 0 },
+		uFloorCenter: { value: new Vector2(fcx, fcz) },
+		uFloorSize: { value: new Vector2(fw, fd) },
+		uFloorHeightmap: { value: bottomMap },
+		uFloorHeightScale: { value: floorHeightScale },
+		uDepthColor: { value: new Color(water.depthColor ?? "#0d3b40") },
+		uDepthScale: { value: water.depthScale ?? 100 },
+		uFoam: { value: water.foam ?? 12 },
+		uFoamColor: { value: new Color(water.foamColor ?? "#eaf6f6") },
+		uWaveHeight: { value: rippleOn ? water.waveHeight ?? 6 : 0 },
+		uWaveScale: { value: water.waveScale ?? .02 },
+		uWaveSpeed: { value: water.waveSpeed ?? .6 },
+		uReflection: { value: reflectionTarget.texture },
+		uReflectionMatrix: { value: new Matrix4() }
+	};
+	material.onBeforeCompile = (shader) => {
+		Object.assign(shader.uniforms, uniforms);
+		shader.vertexShader = shader.vertexShader.replace("#include <common>", "#include <common>\nvarying vec3 vWaterWorld;\nvarying vec4 vReflectCoord;\nuniform mat4 uReflectionMatrix;").replace("#include <begin_vertex>", `#include <begin_vertex>
+        vWaterWorld = (modelMatrix * vec4(transformed, 1.0)).xyz;
+        vReflectCoord = uReflectionMatrix * vec4(transformed, 1.0);`);
+		shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>\n${WAVE_GLSL}\nvarying vec4 vReflectCoord;\nuniform sampler2D uReflection;\nvec2 gWaveSlope = vec2(0.0);`).replace("#include <normal_fragment_maps>", `#include <normal_fragment_maps>
+        if (uWaveHeight > 0.0) {
+          vec2 wp = vWaterWorld.xz;
+          float e = 2.0;
+          float hC = waveHeight(wp);
+          float dhdx = (waveHeight(wp + vec2(e, 0.0)) - hC) / e;
+          float dhdz = (waveHeight(wp + vec2(0.0, e)) - hC) / e;
+          vec3 wn = normalize(vec3(-dhdx, 1.0, -dhdz));
+          normal = normalize((viewMatrix * vec4(wn, 0.0)).xyz);
+          gWaveSlope = vec2(dhdx, dhdz); // fed to the reflection for ripples
+        }`).replace("#include <opaque_fragment>", `#include <opaque_fragment>
+        {
+          // Floor world (x, z) → heightmap UV. Matches the floor builder's
+          // mapping; v is flipped because three.js textures flip Y on upload.
+          vec2 huv = clamp((vWaterWorld.xz - uFloorCenter) / uFloorSize + 0.5, 0.0, 1.0);
+          float bottom = uFloorY + texture2D(uFloorHeightmap, huv).r * uFloorHeightScale;
+          float wdepth = max(uWaterLevel - bottom, 0.0);
+          float deep = 1.0 - exp(-wdepth / uDepthScale);
+          gl_FragColor.rgb = mix(gl_FragColor.rgb, uDepthColor, deep);
+          // Planar reflection: the mirrored scene (walls occlude the sky) sampled
+          // at this fragment's projected position, rippled by the wave slope and
+          // Fresnel-weighted so it dominates at grazing angles. This replaces the
+          // sky-only environment reflection, so the glint respects the walls.
+          vec2 rUv = vReflectCoord.xy / vReflectCoord.w + gWaveSlope * 0.06;
+          vec3 reflColor = texture2D(uReflection, rUv).rgb;
+          float fres = clamp(pow(1.0 - abs(dot(normalize(vViewPosition), normal)), 5.0), 0.0, 1.0);
+          gl_FragColor.rgb = mix(gl_FragColor.rgb, reflColor, mix(0.15, 0.95, fres));
+          float foam = 0.0;
+          if (uFoam > 0.0) {
+            // A thin lacy band hugging the waterline (depth 0..uFoam), not a wash
+            // across open water. A little noise wiggles its inner edge so the
+            // straight plane cut reads as an irregular shoreline; marching sine
+            // fronts add waves running up the shore.
+            float wiggle = wNoise(vWaterWorld.xz * 0.03 + uTime * 0.1) * 0.5 + 0.5;
+            float wd = max(wdepth + (wiggle - 0.5) * uFoam * 0.6, 0.0);
+            float band = 1.0 - smoothstep(0.0, uFoam, wd);
+            float lace = 0.5 + 0.5 * wNoise(vWaterWorld.xz * 0.1 - uTime * 0.25);
+            float fronts = 0.5 + 0.5 * sin(wd * 0.2 - uTime * 1.5);
+            foam = smoothstep(0.12, 0.5, band * band * lace * fronts);
+            gl_FragColor.rgb = mix(gl_FragColor.rgb, uFoamColor, foam);
+          }
+          gl_FragColor.a = max(gl_FragColor.a, max(deep * 0.7, foam));
+        }`);
+	};
+	material.customProgramCacheKey = () => "scenography-water";
+	const mesh = new Mesh(new PlaneGeometry(width, depth), material);
+	mesh.rotation.x = -Math.PI / 2;
+	mesh.position.set(cx, level, cz);
+	mesh.name = "water";
+	mesh.receiveShadow = true;
+	const update = (deltaMs) => {
+		uniforms.uTime.value += deltaMs / 1e3;
+	};
+	const reflectionCamera = new PerspectiveCamera();
+	const reflectorNormal = new Vector3(0, 1, 0);
+	const reflectorPos = new Vector3(cx, level, cz);
+	const reflectorPlane = new Plane();
+	const camPos = new Vector3();
+	const rot = new Matrix4();
+	const view = new Vector3();
+	const lookAt = new Vector3();
+	const target = new Vector3();
+	const clip = new Vector4();
+	const q = new Vector4();
+	const size = new Vector2();
+	const beforeRender = (renderer, scene, camera) => {
+		renderer.getDrawingBufferSize(size);
+		if (reflectionTarget.width !== size.x || reflectionTarget.height !== size.y) reflectionTarget.setSize(Math.max(1, size.x), Math.max(1, size.y));
+		camera.updateMatrixWorld();
+		mesh.updateMatrixWorld();
+		camPos.setFromMatrixPosition(camera.matrixWorld);
+		view.subVectors(reflectorPos, camPos);
+		if (view.dot(reflectorNormal) > 0) return;
+		view.reflect(reflectorNormal).negate().add(reflectorPos);
+		rot.extractRotation(camera.matrixWorld);
+		lookAt.set(0, 0, -1).applyMatrix4(rot).add(camPos);
+		target.subVectors(reflectorPos, lookAt).reflect(reflectorNormal).negate().add(reflectorPos);
+		reflectionCamera.position.copy(view);
+		reflectionCamera.up.set(0, 1, 0).applyMatrix4(rot).reflect(reflectorNormal);
+		reflectionCamera.lookAt(target);
+		reflectionCamera.far = camera.far;
+		reflectionCamera.updateMatrixWorld();
+		reflectionCamera.projectionMatrix.copy(camera.projectionMatrix);
+		const m = uniforms.uReflectionMatrix.value;
+		m.set(.5, 0, 0, .5, 0, .5, 0, .5, 0, 0, .5, .5, 0, 0, 0, 1);
+		m.multiply(reflectionCamera.projectionMatrix);
+		m.multiply(reflectionCamera.matrixWorldInverse);
+		m.multiply(mesh.matrixWorld);
+		reflectorPlane.setFromNormalAndCoplanarPoint(reflectorNormal, reflectorPos);
+		reflectorPlane.applyMatrix4(reflectionCamera.matrixWorldInverse);
+		clip.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant);
+		const e = reflectionCamera.projectionMatrix.elements;
+		q.set((Math.sign(clip.x) + e[8]) / e[0], (Math.sign(clip.y) + e[9]) / e[5], -1, (1 + e[10]) / e[14]);
+		clip.multiplyScalar(2 / clip.dot(q));
+		e[2] = clip.x;
+		e[6] = clip.y;
+		e[10] = clip.z + 1;
+		e[14] = clip.w;
+		const prevTarget = renderer.getRenderTarget();
+		const prevShadowAuto = renderer.shadowMap.autoUpdate;
+		mesh.visible = false;
+		renderer.shadowMap.autoUpdate = false;
+		renderer.setRenderTarget(reflectionTarget);
+		renderer.clear();
+		renderer.render(scene, reflectionCamera);
+		renderer.setRenderTarget(prevTarget);
+		renderer.shadowMap.autoUpdate = prevShadowAuto;
+		mesh.visible = true;
+	};
+	const dispose = () => {
+		reflectionTarget.dispose();
+	};
+	return {
+		object: mesh,
+		update,
+		beforeRender,
+		dispose
+	};
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* The water plugin: materializes the `water` scene key as a transparent,
+* depth-tinted surface with FBM waves and shoreline foam. Consumes the
+* `terrain` capability (published by the floor) so the depth/foam shader can
+* sample the same heightmap the ground is displaced by — and rebuilds when the
+* floor changes (`dependsOn`).
+*/
+const water = () => ({
+	data: waterData,
+	dependsOn: [TERRAIN],
+	build: (definition, ctx) => {
+		return buildWater(definition, ctx.capabilities.get(TERRAIN)?.definition);
+	}
+});
+//#endregion
+export { buildWater, validateWater, water, waterData };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/buildWater.ts","../src/plugin.ts"],"sourcesContent":["import {\n  Color,\n  DataTexture,\n  Matrix4,\n  Mesh,\n  MeshPhysicalMaterial,\n  PerspectiveCamera,\n  Plane,\n  PlaneGeometry,\n  TextureLoader,\n  Vector2,\n  Vector3,\n  Vector4,\n  WebGLRenderTarget,\n  type Object3D,\n  type PerspectiveCamera as PerspectiveCameraType,\n  type Scene as ThreeScene,\n  type WebGLRenderer,\n  type WebGLProgramParametersWithUniforms,\n} from \"three\";\nimport type { TerrainDefinition } from \"@scenography/engine\";\n\nimport type { Water } from \"./data\";\n\n/** A built water surface: the mesh plus its per-frame update and reflection pass. */\nexport interface BuiltWater {\n  object: Object3D;\n  update: (deltaMs: number) => void;\n  beforeRender: (renderer: WebGLRenderer, scene: ThreeScene, camera: PerspectiveCameraType) => void;\n  dispose: () => void;\n}\n\n// FBM wave + noise helpers, borrowed from \"Seascape\" by Alexander Alekseev (TDM,\n// CC BY-NC-SA 3.0): waves evolve in place (not a scrolling texture) so the calm\n// surface doesn't look like a repeating slide. Injected into the fragment shader.\nconst WAVE_GLSL = /* glsl */ `\n  varying vec3 vWaterWorld;\n  uniform float uTime, uWaterLevel, uFloorY, uFloorHeightScale, uDepthScale, uFoam;\n  uniform float uWaveHeight, uWaveScale, uWaveSpeed;\n  uniform vec2 uFloorCenter, uFloorSize;\n  uniform sampler2D uFloorHeightmap;\n  uniform vec3 uDepthColor, uFoamColor;\n\n  float wHash(vec2 p){ float h = dot(p, vec2(127.1, 311.7)); return fract(sin(h) * 43758.5453123); }\n  float wNoise(vec2 p){\n    vec2 i = floor(p), f = fract(p);\n    vec2 u = f * f * (3.0 - 2.0 * f);\n    return -1.0 + 2.0 * mix(mix(wHash(i + vec2(0.0,0.0)), wHash(i + vec2(1.0,0.0)), u.x),\n                            mix(wHash(i + vec2(0.0,1.0)), wHash(i + vec2(1.0,1.0)), u.x), u.y);\n  }\n  float seaOctave(vec2 uv, float choppy){\n    uv += wNoise(uv);\n    vec2 wv = 1.0 - abs(sin(uv));\n    vec2 swv = abs(cos(uv));\n    wv = mix(wv, swv, wv);\n    return pow(1.0 - pow(wv.x * wv.y, 0.65), choppy);\n  }\n  float waveHeight(vec2 p){\n    float t = uTime * uWaveSpeed;\n    vec2 uv = p * uWaveScale; uv.x *= 0.75;\n    float freq = 1.0, amp = 1.0, choppy = 4.0, h = 0.0;\n    mat2 m = mat2(1.6, 1.2, -1.2, 1.6);\n    for(int i = 0; i < 3; i++){\n      float d = seaOctave((uv + t) * freq, choppy) + seaOctave((uv - t) * freq, choppy);\n      h += d * amp;\n      uv = m * uv; freq *= 1.9; amp *= 0.22; choppy = mix(choppy, 1.0, 0.2);\n    }\n    return h * uWaveHeight;\n  }\n`;\n\n/**\n * Build a `Water` surface: a horizontal plane with a transmissive physical\n * material (refracts the sea floor so the pebbles show through), upgraded with a\n * custom shader that (1) ripples the surface normal with FBM waves that evolve in\n * place, (2) tints by depth (the bottom is read from the `floor`'s base `y` plus\n * its heightmap relief — no depth prepass), and (3) paints an irregular,\n * advancing/receding shoreline foam line. Set\n * `ripple: false` for a still, glassy surface.\n */\nexport function buildWater(water: Water, floor?: TerrainDefinition): BuiltWater {\n  const [width, depth] = water.size;\n  const [cx, cz] = water.center ?? [0, 0];\n  const level = water.level ?? 0;\n  const rippleOn = water.ripple !== false;\n\n  const material = new MeshPhysicalMaterial({\n    color: \"#ffffff\",\n    roughness: 0.12,\n    metalness: 0,\n    transmission: 1,\n    ior: 1.33,\n    thickness: 100,\n    attenuationColor: new Color(water.color ?? \"#3b7d78\"),\n    attenuationDistance: 400,\n  });\n\n  // The depth/foam shader samples the floor's heightmap to know the bottom under\n  // each fragment (there is no depth prepass). A 1×1 black texture keeps the\n  // sampler bound when the floor is flat (bottom = uFloorY everywhere).\n  const [fcx, fcz] = floor?.center ?? [0, 0];\n  const [fw, fd] = floor?.size ?? [1, 1];\n  const floorHeightScale = floor?.heightmap ? floor.heightScale ?? 0 : 0;\n  let bottomMap;\n  if (floor?.heightmap && floorHeightScale !== 0) {\n    bottomMap = new TextureLoader().load(floor.heightmap);\n  } else {\n    bottomMap = new DataTexture(new Uint8Array([0, 0, 0, 255]), 1, 1);\n    bottomMap.needsUpdate = true;\n  }\n  // Planar reflection: the scene rendered mirrored across the water plane, so\n  // walls (and everything else) occlude the sky in the reflection.\n  const reflectionTarget = new WebGLRenderTarget(1, 1);\n  const uniforms = {\n    uTime: { value: 0 },\n    uWaterLevel: { value: level },\n    uFloorY: { value: floor?.y ?? 0 },\n    uFloorCenter: { value: new Vector2(fcx, fcz) },\n    uFloorSize: { value: new Vector2(fw, fd) },\n    uFloorHeightmap: { value: bottomMap },\n    uFloorHeightScale: { value: floorHeightScale },\n    uDepthColor: { value: new Color(water.depthColor ?? \"#0d3b40\") },\n    uDepthScale: { value: water.depthScale ?? 100 },\n    uFoam: { value: water.foam ?? 12 },\n    uFoamColor: { value: new Color(water.foamColor ?? \"#eaf6f6\") },\n    uWaveHeight: { value: rippleOn ? water.waveHeight ?? 6 : 0 },\n    uWaveScale: { value: water.waveScale ?? 0.02 },\n    uWaveSpeed: { value: water.waveSpeed ?? 0.6 },\n    uReflection: { value: reflectionTarget.texture },\n    uReflectionMatrix: { value: new Matrix4() },\n  };\n\n  material.onBeforeCompile = (shader: WebGLProgramParametersWithUniforms): void => {\n    Object.assign(shader.uniforms, uniforms);\n\n    shader.vertexShader = shader.vertexShader\n      .replace(\n        \"#include <common>\",\n        \"#include <common>\\nvarying vec3 vWaterWorld;\\nvarying vec4 vReflectCoord;\\nuniform mat4 uReflectionMatrix;\",\n      )\n      .replace(\n        \"#include <begin_vertex>\",\n        `#include <begin_vertex>\n        vWaterWorld = (modelMatrix * vec4(transformed, 1.0)).xyz;\n        vReflectCoord = uReflectionMatrix * vec4(transformed, 1.0);`,\n      );\n\n    shader.fragmentShader = shader.fragmentShader\n      .replace(\n        \"#include <common>\",\n        `#include <common>\\n${WAVE_GLSL}\\nvarying vec4 vReflectCoord;\\nuniform sampler2D uReflection;\\nvec2 gWaveSlope = vec2(0.0);`,\n      )\n      // Replace the flat surface normal with the FBM wave normal (world → view),\n      // so refraction and sun glints move organically. Runs after the map normals.\n      .replace(\n        \"#include <normal_fragment_maps>\",\n        `#include <normal_fragment_maps>\n        if (uWaveHeight > 0.0) {\n          vec2 wp = vWaterWorld.xz;\n          float e = 2.0;\n          float hC = waveHeight(wp);\n          float dhdx = (waveHeight(wp + vec2(e, 0.0)) - hC) / e;\n          float dhdz = (waveHeight(wp + vec2(0.0, e)) - hC) / e;\n          vec3 wn = normalize(vec3(-dhdx, 1.0, -dhdz));\n          normal = normalize((viewMatrix * vec4(wn, 0.0)).xyz);\n          gWaveSlope = vec2(dhdx, dhdz); // fed to the reflection for ripples\n        }`,\n      )\n      // Depth tint + irregular, breathing shoreline foam, after the final color.\n      .replace(\n        \"#include <opaque_fragment>\",\n        `#include <opaque_fragment>\n        {\n          // Floor world (x, z) → heightmap UV. Matches the floor builder's\n          // mapping; v is flipped because three.js textures flip Y on upload.\n          vec2 huv = clamp((vWaterWorld.xz - uFloorCenter) / uFloorSize + 0.5, 0.0, 1.0);\n          float bottom = uFloorY + texture2D(uFloorHeightmap, huv).r * uFloorHeightScale;\n          float wdepth = max(uWaterLevel - bottom, 0.0);\n          float deep = 1.0 - exp(-wdepth / uDepthScale);\n          gl_FragColor.rgb = mix(gl_FragColor.rgb, uDepthColor, deep);\n          // Planar reflection: the mirrored scene (walls occlude the sky) sampled\n          // at this fragment's projected position, rippled by the wave slope and\n          // Fresnel-weighted so it dominates at grazing angles. This replaces the\n          // sky-only environment reflection, so the glint respects the walls.\n          vec2 rUv = vReflectCoord.xy / vReflectCoord.w + gWaveSlope * 0.06;\n          vec3 reflColor = texture2D(uReflection, rUv).rgb;\n          float fres = clamp(pow(1.0 - abs(dot(normalize(vViewPosition), normal)), 5.0), 0.0, 1.0);\n          gl_FragColor.rgb = mix(gl_FragColor.rgb, reflColor, mix(0.15, 0.95, fres));\n          float foam = 0.0;\n          if (uFoam > 0.0) {\n            // A thin lacy band hugging the waterline (depth 0..uFoam), not a wash\n            // across open water. A little noise wiggles its inner edge so the\n            // straight plane cut reads as an irregular shoreline; marching sine\n            // fronts add waves running up the shore.\n            float wiggle = wNoise(vWaterWorld.xz * 0.03 + uTime * 0.1) * 0.5 + 0.5;\n            float wd = max(wdepth + (wiggle - 0.5) * uFoam * 0.6, 0.0);\n            float band = 1.0 - smoothstep(0.0, uFoam, wd);\n            float lace = 0.5 + 0.5 * wNoise(vWaterWorld.xz * 0.1 - uTime * 0.25);\n            float fronts = 0.5 + 0.5 * sin(wd * 0.2 - uTime * 1.5);\n            foam = smoothstep(0.12, 0.5, band * band * lace * fronts);\n            gl_FragColor.rgb = mix(gl_FragColor.rgb, uFoamColor, foam);\n          }\n          gl_FragColor.a = max(gl_FragColor.a, max(deep * 0.7, foam));\n        }`,\n      );\n  };\n  // Keep this material's program separate from other physical materials'.\n  material.customProgramCacheKey = (): string => \"scenography-water\";\n\n  const mesh = new Mesh(new PlaneGeometry(width, depth), material);\n  // PlaneGeometry faces +Z; lay it flat at the water level.\n  mesh.rotation.x = -Math.PI / 2;\n  mesh.position.set(cx, level, cz);\n  mesh.name = \"water\";\n  // Receive shadows so the sun's specular glint is cut where something (a wall)\n  // casts a shadow onto the surface, instead of shining through it.\n  mesh.receiveShadow = true;\n\n  const update = (deltaMs: number): void => {\n    uniforms.uTime.value += deltaMs / 1000;\n  };\n\n  // Reusable objects for the per-frame reflection pass (mirror the main camera\n  // across the water plane, then render the scene into `reflectionTarget`).\n  const reflectionCamera = new PerspectiveCamera();\n  const reflectorNormal = new Vector3(0, 1, 0);\n  const reflectorPos = new Vector3(cx, level, cz);\n  const reflectorPlane = new Plane();\n  const camPos = new Vector3();\n  const rot = new Matrix4();\n  const view = new Vector3();\n  const lookAt = new Vector3();\n  const target = new Vector3();\n  const clip = new Vector4();\n  const q = new Vector4();\n  const size = new Vector2();\n\n  const beforeRender = (\n    renderer: WebGLRenderer,\n    scene: ThreeScene,\n    camera: PerspectiveCameraType,\n  ): void => {\n    renderer.getDrawingBufferSize(size);\n    if (reflectionTarget.width !== size.x || reflectionTarget.height !== size.y) {\n      reflectionTarget.setSize(Math.max(1, size.x), Math.max(1, size.y));\n    }\n    camera.updateMatrixWorld();\n    mesh.updateMatrixWorld();\n    camPos.setFromMatrixPosition(camera.matrixWorld);\n    view.subVectors(reflectorPos, camPos);\n    if (view.dot(reflectorNormal) > 0) return; // camera below the surface — skip\n    view.reflect(reflectorNormal).negate().add(reflectorPos);\n    rot.extractRotation(camera.matrixWorld);\n    lookAt.set(0, 0, -1).applyMatrix4(rot).add(camPos);\n    target.subVectors(reflectorPos, lookAt).reflect(reflectorNormal).negate().add(reflectorPos);\n    reflectionCamera.position.copy(view);\n    reflectionCamera.up.set(0, 1, 0).applyMatrix4(rot).reflect(reflectorNormal);\n    reflectionCamera.lookAt(target);\n    reflectionCamera.far = camera.far;\n    reflectionCamera.updateMatrixWorld();\n    reflectionCamera.projectionMatrix.copy(camera.projectionMatrix);\n\n    // Texture matrix: bias · proj · viewInv · meshWorld → sample by fragment.\n    const m = uniforms.uReflectionMatrix.value;\n    m.set(0.5, 0, 0, 0.5, 0, 0.5, 0, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0, 1);\n    m.multiply(reflectionCamera.projectionMatrix);\n    m.multiply(reflectionCamera.matrixWorldInverse);\n    m.multiply(mesh.matrixWorld);\n\n    // Oblique near-plane clip at the water surface, so geometry below it isn't\n    // mirrored into the reflection (standard Reflector trick).\n    reflectorPlane.setFromNormalAndCoplanarPoint(reflectorNormal, reflectorPos);\n    reflectorPlane.applyMatrix4(reflectionCamera.matrixWorldInverse);\n    clip.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant);\n    const e = reflectionCamera.projectionMatrix.elements;\n    q.set((Math.sign(clip.x) + e[8]!) / e[0]!, (Math.sign(clip.y) + e[9]!) / e[5]!, -1, (1 + e[10]!) / e[14]!);\n    clip.multiplyScalar(2 / clip.dot(q));\n    e[2] = clip.x;\n    e[6] = clip.y;\n    e[10] = clip.z + 1;\n    e[14] = clip.w;\n\n    const prevTarget = renderer.getRenderTarget();\n    const prevShadowAuto = renderer.shadowMap.autoUpdate;\n    mesh.visible = false; // don't mirror the water into itself\n    renderer.shadowMap.autoUpdate = false; // reuse the main shadow map\n    renderer.setRenderTarget(reflectionTarget);\n    renderer.clear();\n    renderer.render(scene, reflectionCamera);\n    renderer.setRenderTarget(prevTarget);\n    renderer.shadowMap.autoUpdate = prevShadowAuto;\n    mesh.visible = true;\n  };\n\n  const dispose = (): void => {\n    reflectionTarget.dispose();\n  };\n\n  return { object: mesh, update, beforeRender, dispose };\n}\n","import { TERRAIN, type EnginePlugin, type TerrainCapability } from \"@scenography/engine\";\n\nimport { buildWater } from \"./buildWater\";\nimport { waterData } from \"./data\";\nimport type { Water } from \"./data\";\n\n/**\n * The water plugin: materializes the `water` scene key as a transparent,\n * depth-tinted surface with FBM waves and shoreline foam. Consumes the\n * `terrain` capability (published by the floor) so the depth/foam shader can\n * sample the same heightmap the ground is displaced by — and rebuilds when the\n * floor changes (`dependsOn`).\n */\nexport const water = (): EnginePlugin<Water> => ({\n  data: waterData,\n  dependsOn: [TERRAIN],\n  build: (definition, ctx) => {\n    const terrain = ctx.capabilities.get<TerrainCapability>(TERRAIN);\n    return buildWater(definition, terrain?.definition);\n  },\n});\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@scenography/plugin-water",
+  "version": "0.2.0",
+  "description": "Water plugin for scenography: a transparent, depth-tinted sea/pool surface with FBM waves and shoreline foam. Data half importable without three.js.",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./data": {
+      "import": {
+        "types": "./dist/data.d.mts",
+        "default": "./dist/data.mjs"
+      },
+      "require": {
+        "types": "./dist/data.d.cts",
+        "default": "./dist/data.cjs"
+      }
+    }
+  },
+  "dependencies": {
+    "@scenography/scene": "0.2.0"
+  },
+  "devDependencies": {
+    "@types/three": "^0.160.0",
+    "three": "^0.160.0",
+    "@scenography/engine": "0.2.0"
+  },
+  "peerDependencies": {
+    "three": ">=0.160.0",
+    "@scenography/engine": "0.2.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}