incanto 0.22.0 → 0.24.0

package/dist/2d.js

@@ -1,5 +1,5 @@
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { a as AssetStore2D, i as syncTree2D, r as Renderer2D, t as createGame2D } from "./create-game-B-M1zune.js";
+import { a as AssetStore2D, i as syncTree2D, r as Renderer2D, t as createGame2D } from "./create-game-DrcEgRup.js";
 import { _ as RigidBody2D, a as parseCells, c as ColorRect2D, d as AnimatedSprite2D, f as Sprite2D, g as PhysicsBody2D, h as CharacterBody2D, i as mergeSolidRects, l as CharacterController2D, m as Area2D, n as UILayer, o as Particles2D, p as Joint2D, r as TileMap2D, s as Label, t as registerNodes2D, u as Camera2D, v as StaticBody2D, y as Node2D } from "./register-CvpSUU3O.js";
 import { n as enablePhysics2D, t as Physics2D } from "./physics-2d-DiVFFlH3.js";
 //#region src/2d/library-sprite.ts

package/dist/3d.d.ts

@@ -377,6 +377,9 @@ interface CreateGame3DOptions {
   seed?: number;
   fixedHz?: number;
   pixelRatio?: number;
+  /** Keep the frame rate by rendering fewer pixels while frames run slow
+  * (default ON). `false` pins the resolution — screenshots, capture, tests. */
+  adaptiveResolution?: boolean;
   resolveScene?: LoadSceneOptions["resolveScene"];
   /** @internal Test seam — replaces the Renderer3D construction. */
   _rendererFactory?: (engine: Engine, canvas: HTMLCanvasElement) => GameRenderer;
@@ -2285,6 +2288,12 @@ declare class Water3D extends Node3D implements RenderHook3D, SunConsumer3D {
   * render per frame, so it is off by default; a still lake earns it.
   */
   mirror: boolean;
+  /**
+  * Milliseconds between planar-mirror re-renders. A reflection seen through a
+  * rippling surface does not need 60 Hz — 33 ms halves the pass's cost and
+  * nobody can tell. 0 re-renders every frame.
+  */
+  mirrorInterval: number;
   /** ms between reflection (and foam depth) re-renders. */
   reflectionInterval: number;
   /** Depth-texture shoreline foam — rides the always-on fancy scene pass. */
@@ -2378,6 +2387,8 @@ declare class Water3D extends Node3D implements RenderHook3D, SunConsumer3D {
   private readonly _scratchA;
   private readonly _scratchB;
   private readonly _bodies;
+  /** Scratch for the side-pass cull (no per-frame allocation). */
+  private readonly _passHidden;
   private cubeTarget;
   private cubeCamera;
   /** Reflection near plane (max half extent) — recreate the camera on resize. */
@@ -2388,6 +2399,7 @@ declare class Water3D extends Node3D implements RenderHook3D, SunConsumer3D {
   private mirrorTarget;
   private readonly mirrorCamera;
   private readonly mirrorMatrix;
+  private lastMirrorAt;
   protected override _createObject3D(): Object3D;
   override update(dt: number): void;
   override _syncObject3D(): void;
@@ -2457,6 +2469,14 @@ interface Renderer3DOptions {
   assets?: AssetStore3D;
   /** Defaults to `window.devicePixelRatio` capped at 2. */
   pixelRatio?: number;
+  /**
+  * Keep the frame rate by rendering at fewer pixels when frames run slow, and
+  * hand them back when they recover (default ON). A retina display asks for
+  * 4× the pixels; shaded water is fragment-heavy; the honest answer is fewer
+  * pixels of the same world, only while it is actually needed. `false` pins
+  * the resolution — for screenshots, video capture and pixel-diff tests.
+  */
+  adaptiveResolution?: boolean;
 }
 /**
 * WebGL presentation layer: subscribes to `engine.updated`, mirrors the active
@@ -2524,10 +2544,22 @@ declare class Renderer3D {
   private bloomCompositeScene;
   private bloomCompositeUniforms;
   constructor(opts: Renderer3DOptions);
+  /** The pixel ratio the scene ASKED for — the governor scales this, never replaces it. */
+  private readonly basePixelRatio;
+  private readonly adaptive;
+  private lastFrameAt;
   private readonly debugLines;
   private readonly selectionLines;
   private syncSelectionOutline;
   private syncDebugLines;
+  /**
+  * Frame-rate governor: measure the frame, and when the median of a window is
+  * slow, render the same world at fewer pixels (and hand them back when it
+  * recovers). Resizing the drawing buffer is all it takes — every render
+  * target in the pipeline is keyed off `getDrawingBufferSize`, so the water
+  * grab, the mirror and the bloom chain follow automatically.
+  */
+  private governResolution;
   private render;
   /**
   * Bloom post pass (only when `environment.bloom` is declared). LDR and safe:

package/dist/3d.js

@@ -1,9 +1,9 @@
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { A as Water3D, F as StaticBody3D, I as Node3D, M as CharacterBody3D, N as PhysicsBody3D, P as RigidBody3D, j as Area3D, z as WATER_MAX_RIPPLES } from "./gameplay-Dib5mNFD.js";
-import { a as Environment3D, c as sunDirectionFromElevationAzimuth, i as syncTree, l as sunDirectionFromSky, o as horizonColorFromSky, r as Renderer3D, s as parseEnvironment3D, t as createGame3D, u as AssetStore3D } from "./create-game-C3uiw80V.js";
-import { A as QUARTER_PITCH, C as BoneAttachment3D, D as TERRAIN_THEMES, E as DEFAULT_TERRAIN_TEXTURE_BASE, M as keyboardIntensity, N as movementState, O as terrainThemeLayers, P as rigPose, S as BoneLookAt3D, T as Terrain3D, _ as Flowers3D, a as Trail3D, b as CharacterController3D, c as Particles3D, d as DirectionalLight3D, f as OmniLight3D, g as DENSITY_PRESETS, h as Foliage3D, i as Tree3D, j as cameraRelative, k as Joint3D, l as ModelInstance3D, m as MeshInstance3D, n as VOXEL_PALETTE, o as River3D, p as InstancedMesh3D, r as VoxelGrid3D, s as traceDownhillPath, t as registerNodes3D, u as LoftMesh3D, v as resolveFlowerDensity, w as Billboard3D, x as Camera3D, y as FLOWER_VARIETIES } from "./register-CHgVdSbp.js";
+import { A as Water3D, F as StaticBody3D, I as Node3D, M as CharacterBody3D, N as PhysicsBody3D, P as RigidBody3D, j as Area3D, z as WATER_MAX_RIPPLES } from "./gameplay-BJ5gXIks.js";
+import { a as Environment3D, c as sunDirectionFromElevationAzimuth, i as syncTree, l as sunDirectionFromSky, o as horizonColorFromSky, r as Renderer3D, s as parseEnvironment3D, t as createGame3D, u as AssetStore3D } from "./create-game-DjWIgtQ_.js";
+import { A as QUARTER_PITCH, C as BoneAttachment3D, D as TERRAIN_THEMES, E as DEFAULT_TERRAIN_TEXTURE_BASE, M as keyboardIntensity, N as movementState, O as terrainThemeLayers, P as rigPose, S as BoneLookAt3D, T as Terrain3D, _ as Flowers3D, a as Trail3D, b as CharacterController3D, c as Particles3D, d as DirectionalLight3D, f as OmniLight3D, g as DENSITY_PRESETS, h as Foliage3D, i as Tree3D, j as cameraRelative, k as Joint3D, l as ModelInstance3D, m as MeshInstance3D, n as VOXEL_PALETTE, o as River3D, p as InstancedMesh3D, r as VoxelGrid3D, s as traceDownhillPath, t as registerNodes3D, u as LoftMesh3D, v as resolveFlowerDensity, w as Billboard3D, x as Camera3D, y as FLOWER_VARIETIES } from "./register-CpJORtm4.js";
 import { n as splatWeights, t as buildHeightmap } from "./heightmap-CRK0M4jT.js";
-import { n as enablePhysics3D, t as Physics3D } from "./physics-3d-DLPPRNu4.js";
+import { n as enablePhysics3D, t as Physics3D } from "./physics-3d-CpIB9C-F.js";
 //#region src/3d/environment-runtime.ts
 /**
 * Live environment editing — the renderer re-applies `scene.environment`

package/dist/{create-game-C3uiw80V.js → create-game-DjWIgtQ_.js}

@@ -3,10 +3,10 @@ import { _ as registerBehavior, n as loadScene } from "./loader-BZqOKfI2.js";
 import { l as AudioPlayer, u as Engine } from "./register-nObreUQR.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-031PxtCR.js";
-import { I as Node3D, N as PhysicsBody3D, R as createCausticsQuad, n as registerGameplayBehaviors } from "./gameplay-Dib5mNFD.js";
+import { I as Node3D, N as PhysicsBody3D, R as createCausticsQuad, n as registerGameplayBehaviors } from "./gameplay-BJ5gXIks.js";
 import { t as debugSources } from "./debug-draw-CZmOYjL2.js";
-import { d as DirectionalLight3D, l as ModelInstance3D, t as registerNodes3D, x as Camera3D } from "./register-CHgVdSbp.js";
-import { n as enablePhysics3D } from "./physics-3d-DLPPRNu4.js";
+import { d as DirectionalLight3D, l as ModelInstance3D, t as registerNodes3D, x as Camera3D } from "./register-CpJORtm4.js";
+import { n as enablePhysics3D } from "./physics-3d-CpIB9C-F.js";
 import { ACESFilmicToneMapping, AmbientLight, Box3, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
 import { VRMLoaderPlugin, VRMUtils } from "@pixiv/three-vrm";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
@@ -126,6 +126,50 @@ var AssetStore3D = class {
 	}
 };
 //#endregion
+//#region src/3d/adaptive-resolution.ts
+const DEFAULTS = {
+	slowMs: 20,
+	fastMs: 13,
+	minScale: .6,
+	step: .15,
+	window: 45
+};
+var AdaptiveResolution = class {
+	opts;
+	samples = [];
+	scale = 1;
+	constructor(options = {}) {
+		this.opts = {
+			...DEFAULTS,
+			...options
+		};
+	}
+	/** The fraction of the requested pixel ratio to render at right now. */
+	current() {
+		return this.scale;
+	}
+	/**
+	* Feed one frame's duration. Returns the new scale when it CHANGED (the
+	* caller then resizes), else null — so a steady frame rate costs nothing.
+	*/
+	push(frameMs) {
+		if (!(frameMs > 0) || !Number.isFinite(frameMs)) return null;
+		this.samples.push(frameMs);
+		if (this.samples.length < this.opts.window) return null;
+		const sorted = [...this.samples].sort((a, b) => a - b);
+		const median = sorted[Math.floor(sorted.length / 2)];
+		this.samples = [];
+		const before = this.scale;
+		if (median > this.opts.slowMs) this.scale = Math.max(this.opts.minScale, this.scale - this.opts.step);
+		else if (median < this.opts.fastMs && this.scale < 1) this.scale = Math.min(1, this.scale + this.opts.step);
+		return this.scale === before ? null : this.scale;
+	}
+	/** Forget the window (a paused or backgrounded game is not "slow"). */
+	reset() {
+		this.samples = [];
+	}
+};
+//#endregion
 //#region src/3d/bloom/bloom-composite.ts
 /**
 * HDR bloom post pass:
@@ -1421,7 +1465,9 @@ var Renderer3D = class {
 			canvas: opts.canvas,
 			antialias: rendering.antialias
 		});
+		this.basePixelRatio = rendering.pixelRatio;
 		this.webgl.setPixelRatio(rendering.pixelRatio);
+		this.adaptive = opts.adaptiveResolution === false ? null : new AdaptiveResolution();
 		this.webgl.shadowMap.enabled = true;
 		this.webgl.shadowMap.type = PCFShadowMap;
 		this.webgl.toneMapping = ACESFilmicToneMapping;
@@ -1445,6 +1491,10 @@ var Renderer3D = class {
 		this.threeScene.add(this.selectionLines);
 		this.disconnect = this.engine.updated.connect(() => this.render());
 	}
+	/** The pixel ratio the scene ASKED for — the governor scales this, never replaces it. */
+	basePixelRatio;
+	adaptive;
+	lastFrameAt = 0;
 	debugLines;
 	selectionLines;
 	syncSelectionOutline() {
@@ -1468,9 +1518,35 @@ var Renderer3D = class {
 		this.debugLines.visible = vertices !== null;
 		if (vertices) this.debugLines.geometry.setAttribute("position", new BufferAttribute(vertices, 3));
 	}
+	/**
+	* Frame-rate governor: measure the frame, and when the median of a window is
+	* slow, render the same world at fewer pixels (and hand them back when it
+	* recovers). Resizing the drawing buffer is all it takes — every render
+	* target in the pipeline is keyed off `getDrawingBufferSize`, so the water
+	* grab, the mirror and the bloom chain follow automatically.
+	*/
+	governResolution() {
+		const gov = this.adaptive;
+		if (!gov) return;
+		const now = globalThis.performance?.now?.() ?? 0;
+		const prev = this.lastFrameAt;
+		this.lastFrameAt = now;
+		if (prev === 0) return;
+		const frameMs = now - prev;
+		if (frameMs > 500) {
+			gov.reset();
+			return;
+		}
+		const scale = gov.push(frameMs);
+		if (scale === null) return;
+		this.webgl.setPixelRatio(this.basePixelRatio * scale);
+		const size = this.lastSize;
+		if (size.w > 0 && size.h > 0) this.webgl.setSize(size.w, size.h, false);
+	}
 	render() {
 		const scene = this.engine.scene;
 		if (!scene) return;
+		this.governResolution();
 		this.syncDebugLines();
 		this.syncSelectionOutline();
 		if (scene.assets && !this.loadedAssetScenes.has(scene)) {
@@ -1937,7 +2013,8 @@ async function createGame3D(opts) {
 	const renderer = opts._rendererFactory ? opts._rendererFactory(engine, opts.canvas) : new Renderer3D({
 		canvas: opts.canvas,
 		engine,
-		...opts.pixelRatio !== void 0 ? { pixelRatio: opts.pixelRatio } : {}
+		...opts.pixelRatio !== void 0 ? { pixelRatio: opts.pixelRatio } : {},
+		...opts.adaptiveResolution !== void 0 ? { adaptiveResolution: opts.adaptiveResolution } : {}
 	});
 	if (opts.debug ?? false) {
 		const host = opts.touchContainer ?? opts.canvas.parentElement ?? (typeof document !== "undefined" ? document.body : null);

package/dist/{create-game-B-M1zune.js → create-game-DrcEgRup.js}

@@ -3,7 +3,7 @@ import { _ as registerBehavior, n as loadScene, o as computeViewport, s as resol
 import { l as AudioPlayer, u as Engine } from "./register-nObreUQR.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-031PxtCR.js";
-import { n as registerGameplayBehaviors } from "./gameplay-Dib5mNFD.js";
+import { n as registerGameplayBehaviors } from "./gameplay-BJ5gXIks.js";
 import { g as PhysicsBody2D, n as UILayer, t as registerNodes2D, u as Camera2D, y as Node2D } from "./register-CvpSUU3O.js";
 import { t as debugSources } from "./debug-draw-CZmOYjL2.js";
 import { n as enablePhysics2D } from "./physics-2d-DiVFFlH3.js";

package/dist/{gameplay-Dib5mNFD.js → gameplay-BJ5gXIks.js}

@@ -398,6 +398,55 @@ void main() {
 }
 `;
 //#endregion
+//#region src/3d/water/pass-cull.ts
+/**
+* What a water side-pass is allowed to skip.
+*
+* Water costs extra SCENE RENDERS — the refraction/depth grab, the planar
+* mirror — and each one re-submits the whole world. On a meadow lake the world
+* is mostly GRASS: tens of thousands of blade triangles that contribute
+* nothing a player can name in a reflection or a depth mask, and everything to
+* the frame budget. These node types are therefore dropped from the side
+* passes; the main render is untouched, so nothing disappears from the scene
+* the player is actually looking at.
+*
+* Foliage/flowers additionally BELONG out of the depth pass: alpha-cutout
+* quads depth-write their full rectangle and wind-displaced blades render
+* unposed, so their depth was always a lie the foam mask had to survive.
+*/
+const SKIPPED_IN_WATER_PASSES = new Set([
+	"Foliage3D",
+	"Flowers3D",
+	"Particles3D",
+	"Trail3D"
+]);
+/**
+* Hide the auxiliary nodes for one pass. Returns the objects that were hidden
+* so the caller can restore them — pass the array to {@link restoreForPass}.
+* Allocation-free in the common case: the caller owns the scratch array.
+*/
+function hideForWaterPass(root, out) {
+	out.length = 0;
+	if (typeof root?.traverse !== "function") return out;
+	root.traverse((obj) => {
+		if (!obj.visible) return;
+		const type = (obj.userData?.incantoNode)?.constructor?.typeName;
+		if (type && SKIPPED_IN_WATER_PASSES.has(type)) {
+			obj.visible = false;
+			out.push(obj);
+		}
+	});
+	return out;
+}
+/** Undo {@link hideForWaterPass}. */
+function restoreForWaterPass(hidden) {
+	for (let i = 0; i < hidden.length; i++) {
+		const obj = hidden[i];
+		if (obj) obj.visible = true;
+	}
+	hidden.length = 0;
+}
+//#endregion
 //#region src/3d/water/caustics.ts
 /**
 * Underwater caustics — the dancing refracted-light pattern the water surface
@@ -1696,8 +1745,26 @@ void main() {
     foamOpacity = max(foamOpacity, mix(baseOpacity, min(baseOpacity + 0.3, 1.0), splashFoam));
   }
 
+  // ── the waterline ───────────────────────────────────────────────────────
+  // Water does not END; it runs out. Without this the surface stays fully
+  // opaque right up to the geometric intersection and the shore reads as a
+  // sheet of vinyl laid on the sand — the single most common tell of game
+  // water. Fade over the last ~18 cm of VERTICAL column (not view depth: at a
+  // grazing angle the view ray is metres long in ankle-deep water), so the
+  // last hand's breadth of wash dissolves into wet ground. Independent of the
+  // foam toggle — a beach without foam still has a waterline.
+  float shoreDissolve = 1.0;
+  if (uUseSceneDepth > 0.5 && waterViewDepth >= 0.0) {
+    float shoreT = camDist * (linearSceneDepth / max(linearWaterDepth, 1e-4));
+    float bedY = cameraPosition.y + viewDirection.y * shoreT;
+    float column = max(uWaterCenter.y - bedY, 0.0);
+    // ragged, so the dissolve edge is a wash line and not a contour
+    float lacy = noise(vWorldPosition.xz * 1.9) * 0.4 + noise(vWorldPosition.xz * 5.3) * 0.2;
+    shoreDissolve = smoothstep(0.0, 0.18 + lacy * 0.12, column);
+  }
+
   // 🔥 Final fundamental solution: Apply depth mask
-  float finalOpacity = foamOpacity * depthMask;
+  float finalOpacity = foamOpacity * depthMask * shoreDissolve;
 
   // ── seen from BELOW ─────────────────────────────────────────────────────
   // The underside of water is not the top with the colours swapped. Light can
@@ -2371,8 +2438,14 @@ const WAVE_WORLD_REF = 128;
 const AMPLITUDE_PER_WAVE_HEIGHT = REFERENCE_AMPLITUDE / REFERENCE_WAVE_HEIGHT;
 /** Cube-map reflection resolution (source: reflectionQuality = 256). */
 const REFLECTION_RESOLUTION = 256;
-/** Planar-mirror target size cap (per side) — half the drawing buffer, clamped. */
-const MIRROR_PASS_MAX = 1024;
+/** Cube-map refresh floor while a planar mirror is on — it is only the
+* off-screen fallback then, so six faces a second is already generous. */
+const MIRRORED_CUBE_INTERVAL = 2e3;
+/** Planar-mirror target: a THIRD of the drawing buffer, capped. A mirror is
+* seen through a rippled surface — the resolution nobody can tell apart from
+* full-res is far lower than the resolution that costs a frame. */
+const MIRROR_PASS_SCALE = 3;
+const MIRROR_PASS_MAX = 640;
 /** How far a wavelet's tilt slides the mirror sample, in UV per unit of normal lean. */
 const MIRROR_DISTORT = .06;
 /** Scene pre-pass (depth for absorption/foam + color grab for refraction):
@@ -2389,9 +2462,9 @@ const SCENE_PASS_MAX = 1024;
 const WATERLINE_CLIP_SLACK = .02;
 /** Fancy vertex density: the FBM displaces per vertex, so density scales with
 * extent (the source's formula degenerated to always-256; ours ramps to it). */
-const FANCY_SEGMENTS_PER_M = 4;
-const FANCY_SEGMENTS_MIN = 32;
-const FANCY_SEGMENTS_MAX = 256;
+const FANCY_SEGMENTS_PER_M = 1.5;
+const FANCY_SEGMENTS_MIN = 24;
+const FANCY_SEGMENTS_MAX = 160;
 /** Simple quality: coarse enough to animate every vertex on the CPU. */
 const SIMPLE_SEGMENTS = 32;
 /** Bodies must rise this far above the waterline to 'exit' (no surface flicker). */
@@ -2461,6 +2534,7 @@ var Water3D = class Water3D extends Node3D {
 		reflection: { default: true },
 		reflectionInterval: { default: 1e3 },
 		mirror: { default: false },
+		mirrorInterval: { default: 33 },
 		swellSteepness: { default: .35 },
 		foam: { default: true },
 		interaction: { default: true },
@@ -2512,6 +2586,12 @@ var Water3D = class Water3D extends Node3D {
 	* render per frame, so it is off by default; a still lake earns it.
 	*/
 	mirror = false;
+	/**
+	* Milliseconds between planar-mirror re-renders. A reflection seen through a
+	* rippling surface does not need 60 Hz — 33 ms halves the pass's cost and
+	* nobody can tell. 0 re-renders every frame.
+	*/
+	mirrorInterval = 33;
 	/** ms between reflection (and foam depth) re-renders. */
 	reflectionInterval = 1e3;
 	/** Depth-texture shoreline foam — rides the always-on fancy scene pass. */
@@ -2671,6 +2751,8 @@ var Water3D = class Water3D extends Node3D {
 		z: 0
 	};
 	_bodies = [];
+	/** Scratch for the side-pass cull (no per-frame allocation). */
+	_passHidden = [];
 	cubeTarget = null;
 	cubeCamera = null;
 	/** Reflection near plane (max half extent) — recreate the camera on resize. */
@@ -2681,6 +2763,7 @@ var Water3D = class Water3D extends Node3D {
 	mirrorTarget = null;
 	mirrorCamera = new PerspectiveCamera();
 	mirrorMatrix = new Matrix4();
+	lastMirrorAt = 0;
 	_createObject3D() {
 		return new Mesh();
 	}
@@ -2736,7 +2819,8 @@ var Water3D = class Water3D extends Node3D {
 				this.cubeCamera = new CubeCamera(near, 1e3, this.cubeTarget);
 				this.lastReflectionAt = 0;
 			}
-			if (this.lastReflectionAt === 0 || now - this.lastReflectionAt >= this.rp("reflectionInterval")) {
+			const cubeInterval = this.mirror ? Math.max(this.rp("reflectionInterval"), MIRRORED_CUBE_INTERVAL) : this.rp("reflectionInterval");
+			if (this.lastReflectionAt === 0 || now - this.lastReflectionAt >= cubeInterval) {
 				this.lastReflectionAt = now;
 				const center = worldTranslationOf(this);
 				const cam = this.cubeCamera;
@@ -2753,8 +2837,8 @@ var Water3D = class Water3D extends Node3D {
 		}
 		if (this.mirror && u.uMirrorMap && u.uMirrorMatrix && u.uUseMirror) {
 			ctx.gl.getDrawingBufferSize(drawingBufferScratch);
-			const mirrorW = Math.max(1, Math.min(Math.round(drawingBufferScratch.x / 2), MIRROR_PASS_MAX));
-			const mirrorH = Math.max(1, Math.min(Math.round(drawingBufferScratch.y / 2), MIRROR_PASS_MAX));
+			const mirrorW = Math.max(1, Math.min(Math.round(drawingBufferScratch.x / MIRROR_PASS_SCALE), MIRROR_PASS_MAX));
+			const mirrorH = Math.max(1, Math.min(Math.round(drawingBufferScratch.y / MIRROR_PASS_SCALE), MIRROR_PASS_MAX));
 			if (this.mirrorTarget && (this.mirrorTarget.width !== mirrorW || this.mirrorTarget.height !== mirrorH)) {
 				this.mirrorTarget.dispose();
 				this.mirrorTarget = null;
@@ -2786,18 +2870,23 @@ var Water3D = class Water3D extends Node3D {
 			this.mirrorMatrix.set(.5, 0, 0, .5, 0, .5, 0, .5, 0, 0, .5, .5, 0, 0, 0, 1);
 			this.mirrorMatrix.multiply(mirrorCam.projectionMatrix);
 			this.mirrorMatrix.multiply(mirrorCam.matrixWorldInverse);
-			const prevMirrorTarget = ctx.gl.getRenderTarget();
-			const prevMirrorClip = ctx.gl.clippingPlanes;
-			const wasMirrorVisible = mesh.visible;
-			mesh.visible = false;
-			mirrorClipPlane.constant = -(surfaceY - WATERLINE_CLIP_SLACK);
-			ctx.gl.clippingPlanes = mirrorClipPlanes;
-			ctx.gl.setRenderTarget(this.mirrorTarget);
-			ctx.gl.clear(true, true, false);
-			ctx.gl.render(ctx.scene, mirrorCam);
-			ctx.gl.setRenderTarget(prevMirrorTarget);
-			ctx.gl.clippingPlanes = prevMirrorClip;
-			mesh.visible = wasMirrorVisible;
+			if (this.lastMirrorAt === 0 || now - this.lastMirrorAt >= this.rp("mirrorInterval")) {
+				this.lastMirrorAt = now;
+				const prevMirrorTarget = ctx.gl.getRenderTarget();
+				const prevMirrorClip = ctx.gl.clippingPlanes;
+				const wasMirrorVisible = mesh.visible;
+				mesh.visible = false;
+				mirrorClipPlane.constant = -(surfaceY - WATERLINE_CLIP_SLACK);
+				ctx.gl.clippingPlanes = mirrorClipPlanes;
+				ctx.gl.setRenderTarget(this.mirrorTarget);
+				ctx.gl.clear(true, true, false);
+				hideForWaterPass(ctx.scene, this._passHidden);
+				ctx.gl.render(ctx.scene, mirrorCam);
+				restoreForWaterPass(this._passHidden);
+				ctx.gl.setRenderTarget(prevMirrorTarget);
+				ctx.gl.clippingPlanes = prevMirrorClip;
+				mesh.visible = wasMirrorVisible;
+			}
 			u.uMirrorMap.value = this.mirrorTarget.texture;
 			u.uMirrorMatrix.value.copy(this.mirrorMatrix);
 			u.uUseMirror.value = 1;
@@ -2840,7 +2929,9 @@ var Water3D = class Water3D extends Node3D {
 		ctx.scene.overrideMaterial = depthOnlyMaterial;
 		ctx.scene.background = null;
 		ctx.gl.autoClear = false;
+		hideForWaterPass(ctx.scene, this._passHidden);
 		ctx.gl.render(ctx.scene, ctx.camera);
+		restoreForWaterPass(this._passHidden);
 		ctx.scene.overrideMaterial = prevOverride;
 		ctx.scene.background = prevBackground;
 		ctx.gl.setRenderTarget(prevTarget);

package/dist/gameplay.js

@@ -1,2 +1,2 @@
-import { C as FollowCamera, D as Health, E as DamageOnContact, O as Collector, S as restartScene, T as phaseOf, _ as hitStop, a as Wander, b as GameFlow, c as Projectile, d as PathFollow, f as Oscillate, g as Cooldown, h as CameraShake, i as WaveSpawner, k as Chase, l as Pickup, m as Lifetime, n as registerGameplayBehaviors, o as Spawner, p as MoveTo, r as ZombieAI, s as ScoreKeeper, t as GAMEPLAY_BEHAVIORS, u as Patrol, v as screenFlash, w as DayNight, x as goToScene, y as Interactable } from "./gameplay-Dib5mNFD.js";
+import { C as FollowCamera, D as Health, E as DamageOnContact, O as Collector, S as restartScene, T as phaseOf, _ as hitStop, a as Wander, b as GameFlow, c as Projectile, d as PathFollow, f as Oscillate, g as Cooldown, h as CameraShake, i as WaveSpawner, k as Chase, l as Pickup, m as Lifetime, n as registerGameplayBehaviors, o as Spawner, p as MoveTo, r as ZombieAI, s as ScoreKeeper, t as GAMEPLAY_BEHAVIORS, u as Patrol, v as screenFlash, w as DayNight, x as goToScene, y as Interactable } from "./gameplay-BJ5gXIks.js";
 export { CameraShake, Chase, Collector, Cooldown, DamageOnContact, DayNight, FollowCamera, GAMEPLAY_BEHAVIORS, GameFlow, Health, Interactable, Lifetime, MoveTo, Oscillate, PathFollow, Patrol, Pickup, Projectile, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, goToScene, hitStop, phaseOf, registerGameplayBehaviors, restartScene, screenFlash };

package/dist/index.js

@@ -295,6 +295,6 @@ function newUid() {
 //#endregion
 //#region src/index.ts
 /** Engine version. Kept in sync with package.json by the release pipeline. */
-const VERSION = "0.22.0";
+const VERSION = "0.24.0";
 //#endregion
 export { AudioBuses, AudioPlayer, Behavior, CONST_REF_KEY, Engine, HudLayer, IncantoError, InputMap, LogManager, MusicManager, Node, ORDER_GROUP_BASE, PARTICLE_PRESETS, PARTICLE_PRESET_NAMES, ParticleSim, ROLLOFF_MODELS, Rng, SCENE_FORMAT, SFX_PRESETS, SFX_PRESET_NAMES, Scene, SceneTree, SfxEngine, Signal, Timer, TouchControls, UiBanner, UiBar, UiButton, UiDialogue, UiText, VERSION, WebAudioMusicBackend, applyParticlePreset, assetUrls, attachTouchControls, auditScene, clearBehaviors, clearRegistry, computeViewport, createNode, createNoise2D, createSaveStore, crossfadeGains, duplicateNode, effectiveOrder, fadeGain, findPath, getBehavior, getNodeSchema, getNodeSignals, getNodeType, gridFromRows, isAudioContextAvailable, isConstRef, joystickVector, jsonClone, jsonEquals, jsonKind, loadScene, mergeStaticSignals, newUid, parseNodePath, preloadUrls, registerBehavior, registerCoreNodes, registerNode, registeredBehaviors, registeredTypes, replay, resolveConstants, resolveRendering, resolveViewport, serializeNode, spatialGain, spatialPan, startRecording, synthSfx };

package/dist/{physics-3d-DLPPRNu4.js → physics-3d-CpIB9C-F.js}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { I as Node3D, L as validateCollider3D, M as CharacterBody3D, N as PhysicsBody3D, P as RigidBody3D, j as Area3D } from "./gameplay-Dib5mNFD.js";
+import { I as Node3D, L as validateCollider3D, M as CharacterBody3D, N as PhysicsBody3D, P as RigidBody3D, j as Area3D } from "./gameplay-BJ5gXIks.js";
 import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
-import { T as Terrain3D, k as Joint3D } from "./register-CHgVdSbp.js";
+import { T as Terrain3D, k as Joint3D } from "./register-CpJORtm4.js";
 import { Euler, Quaternion } from "three";
 //#region src/3d/physics/physics-3d.ts
 var physics_3d_exports = /* @__PURE__ */ __exportAll({

package/dist/react.js

@@ -156,7 +156,7 @@ function IncantoCanvas(props) {
 				pointer: latest.pointer,
 				...keyboard !== void 0 ? { keyboard } : {}
 			};
-			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-C3uiw80V.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-B-M1zune.js").then((n) => n.n)).createGame2D(o)))(opts);
+			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-DjWIgtQ_.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-DrcEgRup.js").then((n) => n.n)).createGame2D(o)))(opts);
 			if (disposed) {
 				next.dispose();
 				return;

package/dist/{register-CHgVdSbp.js → register-CpJORtm4.js}

@@ -4,7 +4,7 @@ import { t as Rng } from "./rng-DP-SR7eg.js";
 import { i as getNodeSchema, l as registerNode } from "./registry-BVJ2HbCn.js";
 import { t as createNoise2D } from "./noise-CGUMx44x.js";
 import { i as applyParticlePreset, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-Bw7hB93B.js";
-import { A as Water3D, B as colliderFootDrop, F as StaticBody3D, I as Node3D, M as CharacterBody3D, N as PhysicsBody3D, P as RigidBody3D, j as Area3D } from "./gameplay-Dib5mNFD.js";
+import { A as Water3D, B as colliderFootDrop, F as StaticBody3D, I as Node3D, M as CharacterBody3D, N as PhysicsBody3D, P as RigidBody3D, j as Area3D } from "./gameplay-BJ5gXIks.js";
 import { n as splatWeights, t as buildHeightmap } from "./heightmap-CRK0M4jT.js";
 import { AdditiveBlending, AnimationClip, AnimationMixer, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CapsuleGeometry, Color, ConeGeometry, CylinderGeometry, DataTexture, DirectionalLight, DoubleSide, DynamicDrawUsage, Euler, Group, IcosahedronGeometry, ImageBitmapLoader, InstancedBufferAttribute, InstancedMesh, LinearFilter, LoopOnce, LoopRepeat, Matrix4, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshPhysicalMaterial, MeshStandardMaterial, NearestFilter, NoBlending, NormalBlending, PerspectiveCamera, PlaneGeometry, PointLight, Points, PointsMaterial, Quaternion, QuaternionKeyframeTrack, RGBADepthPacking, RGBAFormat, RepeatWrapping, SRGBColorSpace, ShaderChunk, ShaderMaterial, SphereGeometry, Texture, TextureLoader, UniformsLib, UniformsUtils, Vector3, Vector4, VectorKeyframeTrack } from "three";
 import { clone } from "three/addons/utils/SkeletonUtils.js";
@@ -7100,7 +7100,11 @@ void main() {
   // ── edges ───────────────────────────────────────────────────────────────
   // the ribbon is built wider than the channel; what makes its outline is the
   // water running out, so bars and boulders cut it exactly like the ground does
-  float edge = smoothstep(0.0, 0.06, column) * (1.0 - smoothstep(0.84, 1.0, abs(across)));
+  // The bank is where the water RUNS OUT, and it runs out over centimetres of
+  // depth spread across metres of ground — a 6 cm ramp cut a hard line that
+  // read as vinyl laid on the grass. Fade over a real wading depth instead, and
+  // let the across-fade start earlier so the ribbon never ends on an edge.
+  float edge = smoothstep(0.0, 0.22, column) * (1.0 - smoothstep(0.7, 1.0, abs(across)));
   float alpha = clamp(max(hide * uOpacity, fresnel * 0.85), 0.0, 1.0);
   alpha = clamp(max(alpha, foam * 0.95) * edge, 0.0, 1.0);
 
@@ -7465,9 +7469,6 @@ var River3D = class River3D extends Node3D {
 			transparent: true,
 			depthTest: true,
 			depthWrite: false,
-			polygonOffset: true,
-			polygonOffsetFactor: -2,
-			polygonOffsetUnits: -4,
 			side: DoubleSide
 		});
 	}

package/dist/test.js

@@ -4,9 +4,9 @@ import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as auditScene } from "./audit-C6rMyict.js";
 import { n as jsonEquals, t as jsonClone } from "./json-BLk7H2Qa.js";
 import { i as getNodeSchema, s as mergeStaticProps } from "./registry-BVJ2HbCn.js";
-import { n as registerGameplayBehaviors } from "./gameplay-Dib5mNFD.js";
+import { n as registerGameplayBehaviors } from "./gameplay-BJ5gXIks.js";
 import { t as registerNodes2D } from "./register-CvpSUU3O.js";
-import { t as registerNodes3D } from "./register-CHgVdSbp.js";
+import { t as registerNodes3D } from "./register-CpJORtm4.js";
 import { t as registerNodesNet } from "./register-BFFE1Mh1.js";
 //#region src/test/index.ts
 /**
@@ -127,7 +127,7 @@ async function runScript(json, opts) {
 		const { enablePhysics2D } = await import("./physics-2d-DiVFFlH3.js").then((n) => n.r);
 		await enablePhysics2D(engine);
 	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
-		const { enablePhysics3D } = await import("./physics-3d-DLPPRNu4.js").then((n) => n.r);
+		const { enablePhysics3D } = await import("./physics-3d-CpIB9C-F.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const failures = [];
@@ -232,7 +232,7 @@ async function createPlaySession(json, opts = {}) {
 		const { enablePhysics2D } = await import("./physics-2d-DiVFFlH3.js").then((n) => n.r);
 		await enablePhysics2D(engine);
 	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
-		const { enablePhysics3D } = await import("./physics-3d-DLPPRNu4.js").then((n) => n.r);
+		const { enablePhysics3D } = await import("./physics-3d-CpIB9C-F.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const stepMs = 1e3 / (opts.fixedHz ?? 60);

package/editor/assets/{agent8-4yMWrtSC.js → agent8-DlMVayXX.js}

@@ -1 +1 @@
-import{t as e}from"./index-DAzNRDSQ.js";async function t(t){return new n((await e(()=>import(`./GameServer-C56iOUgF.js`),[],import.meta.url)).GameServer,t)}var n=class{raw;active=new Map;reconnecting=!1;disposed=!1;constructor(e,t){this.raw=new e({...t})}get account(){return this.raw.account}get connected(){return this.raw.connected}connect(){return this.raw.connected?Promise.resolve(!0):(this.disposed=!1,this.rawConnect())}rawConnect(){return this.raw.connect({onDisconnect:()=>void this.reconnect()})}disconnect(){this.disposed=!0;for(let e of this.active.values())e.off();return this.active.clear(),this.raw.disconnect()}remoteFunction(e,t,n){return this.raw.remoteFunction(e,t,n)}track(e){let t=Symbol(`sub`),n={make:e,off:e()};return this.active.set(t,n),()=>{n.off(),this.active.delete(t)}}async reconnect(){if(!this.disposed&&!this.reconnecting){this.reconnecting=!0;try{await this.rawConnect();for(let e of this.active.values())e.off(),e.off=e.make()}finally{this.reconnecting=!1}}}subscribeRoomState(e,t){return this.track(()=>this.raw.subscribeRoomState(e,t))}subscribeRoomMyState(e,t){return this.track(()=>this.raw.subscribeRoomMyState(e,t))}subscribeRoomAllUserStates(e,t){return this.track(()=>this.raw.subscribeRoomAllUserStates(e,e=>{let n={};for(let t of e??[]){if(!t||typeof t.account!=`string`||t.__leaved)continue;let{account:e,__updated:r,__leaved:i,...a}=t;n[e]=a}t(n)}))}subscribeRoomCollection(e,t,n){return this.track(()=>this.raw.subscribeRoomCollection(e,t,({items:e})=>{let t={};for(let n of e??[])n&&typeof n.__id==`string`&&(t[n.__id]=n);n(t)}))}onRoomMessage(e,t,n){return this.track(()=>this.raw.onRoomMessage(e,t,n))}onRoomUserJoin(e,t){return this.track(()=>this.raw.onRoomUserJoin(e,t))}onRoomUserLeave(e,t){return this.track(()=>this.raw.onRoomUserLeave(e,t))}subscribeGlobalState(e){return this.track(()=>this.raw.subscribeGlobalState(e))}subscribeGlobalMyState(e){return this.track(()=>this.raw.subscribeGlobalMyState(e))}subscribeGlobalUserState(e,t){return this.track(()=>this.raw.subscribeGlobalUserState(e,t))}subscribeGlobalCollection(e,t){return this.track(()=>this.raw.subscribeGlobalCollection(e,({items:e})=>{let n={};for(let t of e??[])t&&typeof t.__id==`string`&&(n[t.__id]=t);t(n)}))}subscribeAsset(e,t){return this.track(()=>this.raw.subscribeAsset(e,t))}onGlobalMessage(e,t){return this.track(()=>this.raw.onGlobalMessage(e,t))}};export{t as createAgent8Server};
+import{t as e}from"./index-B5y_MdYb.js";async function t(t){return new n((await e(()=>import(`./GameServer-C56iOUgF.js`),[],import.meta.url)).GameServer,t)}var n=class{raw;active=new Map;reconnecting=!1;disposed=!1;constructor(e,t){this.raw=new e({...t})}get account(){return this.raw.account}get connected(){return this.raw.connected}connect(){return this.raw.connected?Promise.resolve(!0):(this.disposed=!1,this.rawConnect())}rawConnect(){return this.raw.connect({onDisconnect:()=>void this.reconnect()})}disconnect(){this.disposed=!0;for(let e of this.active.values())e.off();return this.active.clear(),this.raw.disconnect()}remoteFunction(e,t,n){return this.raw.remoteFunction(e,t,n)}track(e){let t=Symbol(`sub`),n={make:e,off:e()};return this.active.set(t,n),()=>{n.off(),this.active.delete(t)}}async reconnect(){if(!this.disposed&&!this.reconnecting){this.reconnecting=!0;try{await this.rawConnect();for(let e of this.active.values())e.off(),e.off=e.make()}finally{this.reconnecting=!1}}}subscribeRoomState(e,t){return this.track(()=>this.raw.subscribeRoomState(e,t))}subscribeRoomMyState(e,t){return this.track(()=>this.raw.subscribeRoomMyState(e,t))}subscribeRoomAllUserStates(e,t){return this.track(()=>this.raw.subscribeRoomAllUserStates(e,e=>{let n={};for(let t of e??[]){if(!t||typeof t.account!=`string`||t.__leaved)continue;let{account:e,__updated:r,__leaved:i,...a}=t;n[e]=a}t(n)}))}subscribeRoomCollection(e,t,n){return this.track(()=>this.raw.subscribeRoomCollection(e,t,({items:e})=>{let t={};for(let n of e??[])n&&typeof n.__id==`string`&&(t[n.__id]=n);n(t)}))}onRoomMessage(e,t,n){return this.track(()=>this.raw.onRoomMessage(e,t,n))}onRoomUserJoin(e,t){return this.track(()=>this.raw.onRoomUserJoin(e,t))}onRoomUserLeave(e,t){return this.track(()=>this.raw.onRoomUserLeave(e,t))}subscribeGlobalState(e){return this.track(()=>this.raw.subscribeGlobalState(e))}subscribeGlobalMyState(e){return this.track(()=>this.raw.subscribeGlobalMyState(e))}subscribeGlobalUserState(e,t){return this.track(()=>this.raw.subscribeGlobalUserState(e,t))}subscribeGlobalCollection(e,t){return this.track(()=>this.raw.subscribeGlobalCollection(e,({items:e})=>{let n={};for(let t of e??[])t&&typeof t.__id==`string`&&(n[t.__id]=t);t(n)}))}subscribeAsset(e,t){return this.track(()=>this.raw.subscribeAsset(e,t))}onGlobalMessage(e,t){return this.track(()=>this.raw.onGlobalMessage(e,t))}};export{t as createAgent8Server};