incanto 0.7.1 → 0.8.0

package/dist/particle-sim-CyUU7HVU.js

@@ -0,0 +1,281 @@
+import { n as jsonEquals } from "./json-BLk7H2Qa.js";
+//#region src/core/order-groups.ts
+const ORDER_GROUP_BASE = {
+	background: -2e3,
+	terrain: -1e3,
+	default: 0,
+	characters: 1e3,
+	effects: 2e3,
+	overlay: 3e3
+};
+/** base + fine offset (unknown group names fall back to `default`). */
+function effectiveOrder(group, renderOrder) {
+	return (ORDER_GROUP_BASE[group] ?? 0) + renderOrder;
+}
+//#endregion
+//#region src/core/particle-presets.ts
+const PARTICLE_PRESETS = {
+	fire: {
+		rate: 60,
+		lifetime: [.4, .9],
+		speed: [30, 70],
+		directionDeg: -90,
+		spreadDeg: 35,
+		gravity: [0, -30],
+		sizeStart: 14,
+		sizeEnd: 3,
+		colorStart: "#ffcf5a",
+		colorEnd: "#e8401f",
+		alphaStart: .9,
+		alphaEnd: 0,
+		blend: "add"
+	},
+	smoke: {
+		rate: 20,
+		lifetime: [1.5, 2.5],
+		speed: [10, 25],
+		directionDeg: -90,
+		spreadDeg: 40,
+		gravity: [0, -12],
+		sizeStart: 10,
+		sizeEnd: 26,
+		colorStart: "#8a8a8a",
+		colorEnd: "#3a3a3a",
+		alphaStart: .35,
+		alphaEnd: 0,
+		blend: "normal"
+	},
+	sparks: {
+		rate: 80,
+		lifetime: [.3, .7],
+		speed: [120, 260],
+		spreadDeg: 360,
+		gravity: [0, 240],
+		drag: 1,
+		sizeStart: 4,
+		sizeEnd: 1,
+		colorStart: "#fff3b0",
+		colorEnd: "#ff9d2e",
+		blend: "add"
+	},
+	fireworks: {
+		rate: 0,
+		burst: 120,
+		lifetime: [.8, 1.6],
+		speed: [80, 240],
+		spreadDeg: 360,
+		gravity: [0, 90],
+		drag: .6,
+		sizeStart: 5,
+		sizeEnd: 1,
+		colorStart: "#9ad8ff",
+		colorEnd: "#ff5ad8",
+		blend: "add"
+	},
+	explosion: {
+		rate: 0,
+		burst: 60,
+		lifetime: [.25, .6],
+		speed: [150, 420],
+		spreadDeg: 360,
+		drag: 3,
+		sizeStart: 16,
+		sizeEnd: 2,
+		colorStart: "#ffe08a",
+		colorEnd: "#ff3b1f",
+		blend: "add"
+	},
+	flash: {
+		rate: 0,
+		burst: 8,
+		lifetime: [.08, .16],
+		speed: [0, 30],
+		spreadDeg: 360,
+		sizeStart: 64,
+		sizeEnd: 96,
+		colorStart: "#ffffff",
+		colorEnd: "#ffffff",
+		alphaStart: 1,
+		alphaEnd: 0,
+		blend: "add"
+	},
+	lightning: {
+		rate: 90,
+		lifetime: [.05, .12],
+		speed: [400, 900],
+		directionDeg: -90,
+		spreadDeg: 14,
+		sizeStart: 6,
+		sizeEnd: 2,
+		colorStart: "#eaf2ff",
+		colorEnd: "#7fb4ff",
+		blend: "add"
+	},
+	rain: {
+		rate: 160,
+		lifetime: [.8, 1.2],
+		speed: [300, 420],
+		directionDeg: 90,
+		spreadDeg: 6,
+		sizeStart: 3,
+		sizeEnd: 3,
+		colorStart: "#9ec8ff",
+		colorEnd: "#9ec8ff",
+		alphaStart: .5,
+		alphaEnd: .2,
+		blend: "normal"
+	},
+	snow: {
+		rate: 40,
+		lifetime: [3, 5],
+		speed: [20, 50],
+		directionDeg: 90,
+		spreadDeg: 30,
+		drag: .2,
+		sizeStart: 5,
+		sizeEnd: 4,
+		colorStart: "#ffffff",
+		colorEnd: "#ffffff",
+		alphaStart: .9,
+		alphaEnd: .6,
+		blend: "normal"
+	},
+	magic: {
+		rate: 50,
+		lifetime: [.6, 1.4],
+		speed: [20, 80],
+		spreadDeg: 360,
+		gravity: [0, -20],
+		sizeStart: 7,
+		sizeEnd: 1,
+		colorStart: "#9dffe8",
+		colorEnd: "#7a5cff",
+		blend: "add"
+	}
+};
+const PARTICLE_PRESET_NAMES = Object.keys(PARTICLE_PRESETS);
+/**
+* Apply the delta rule across three layers: schema default < preset < the
+* scene's explicit props. A prop still equal to its SCHEMA default is
+* considered "unset" and takes the preset value.
+*/
+function applyParticlePreset(target, presetName, schema) {
+	if (presetName === "custom") return;
+	const preset = PARTICLE_PRESETS[presetName];
+	if (!preset) return;
+	for (const [key, presetValue] of Object.entries(preset)) {
+		const def = schema[key]?.default;
+		const current = target[key];
+		if (def !== void 0 && jsonEquals(current, def)) target[key] = Array.isArray(presetValue) ? [...presetValue] : presetValue;
+	}
+}
+//#endregion
+//#region src/core/particle-sim.ts
+const FIELDS = 9;
+var ParticleSim = class {
+	config;
+	rng;
+	data;
+	alive = 0;
+	spawnAccumulator = 0;
+	everSpawned = false;
+	constructor(config, rng) {
+		this.config = config;
+		this.rng = rng;
+		this.data = new Float64Array(Math.max(1, config.maxParticles) * FIELDS);
+	}
+	/** Change the emission rate LIVE (particles/sec; 0 pauses emission) — lets an
+	* emitter toggle on/off at runtime (drift smoke, throttle flames). */
+	setRate(rate) {
+		this.config.rate = rate;
+		if (rate <= 0) this.spawnAccumulator = 0;
+	}
+	get count() {
+		return this.alive;
+	}
+	/** True when nothing is alive and at least one particle has ever spawned. */
+	get done() {
+		return this.everSpawned && this.alive === 0;
+	}
+	/** Spawn n particles immediately (fireworks, explosions, flashes). */
+	burst(n) {
+		for (let i = 0; i < n; i++) this.spawn();
+	}
+	update(dt) {
+		if (this.config.rate > 0) {
+			this.spawnAccumulator += this.config.rate * dt;
+			while (this.spawnAccumulator >= 1) {
+				this.spawnAccumulator -= 1;
+				this.spawn();
+			}
+		}
+		const d = this.data;
+		const [gx, gy, gz] = this.config.gravity;
+		const damp = this.config.drag > 0 ? Math.exp(-this.config.drag * dt) : 1;
+		let i = 0;
+		while (i < this.alive) {
+			const base = i * FIELDS;
+			const age = d[base + 6] + dt;
+			if (age >= d[base + 7]) {
+				this.kill(i);
+				continue;
+			}
+			d[base + 6] = age;
+			d[base + 3] = (d[base + 3] + gx * dt) * damp;
+			d[base + 4] = (d[base + 4] + gy * dt) * damp;
+			d[base + 5] = (d[base + 5] + gz * dt) * damp;
+			d[base + 0] = d[base + 0] + d[base + 3] * dt;
+			d[base + 1] = d[base + 1] + d[base + 4] * dt;
+			d[base + 2] = d[base + 2] + d[base + 5] * dt;
+			i += 1;
+		}
+	}
+	forEach(fn) {
+		const d = this.data;
+		for (let i = 0; i < this.alive; i++) {
+			const base = i * FIELDS;
+			const age = d[base + 6];
+			const life = d[base + 7];
+			fn({
+				x: d[base + 0],
+				y: d[base + 1],
+				z: d[base + 2],
+				vx: d[base + 3],
+				vy: d[base + 4],
+				vz: d[base + 5],
+				age,
+				life,
+				t: life > 0 ? age / life : 1,
+				seed: d[base + 8]
+			});
+		}
+	}
+	spawn() {
+		if (this.alive >= this.config.maxParticles) return;
+		const base = this.alive * FIELDS;
+		const d = this.data;
+		const c = this.config;
+		const angle = (c.directionDeg + (this.rng.next() - .5) * c.spreadDeg) * Math.PI / 180;
+		const speed = c.speed[0] + this.rng.next() * (c.speed[1] - c.speed[0]);
+		const zTilt = c.spreadZ ? (this.rng.next() - .5) * (c.spreadDeg * Math.PI / 180) : 0;
+		const planar = Math.cos(zTilt);
+		d[base + 0] = 0;
+		d[base + 1] = 0;
+		d[base + 2] = 0;
+		d[base + 3] = Math.cos(angle) * speed * planar;
+		d[base + 4] = Math.sin(angle) * speed * planar;
+		d[base + 5] = Math.sin(zTilt) * speed;
+		d[base + 6] = 0;
+		d[base + 7] = c.lifetime[0] + this.rng.next() * (c.lifetime[1] - c.lifetime[0]);
+		d[base + 8] = this.rng.next();
+		this.alive += 1;
+		this.everSpawned = true;
+	}
+	kill(index) {
+		const last = this.alive - 1;
+		if (index !== last) this.data.copyWithin(index * FIELDS, last * FIELDS, last * FIELDS + FIELDS);
+		this.alive = last;
+	}
+};
+//#endregion
+export { ORDER_GROUP_BASE as a, applyParticlePreset as i, PARTICLE_PRESETS as n, effectiveOrder as o, PARTICLE_PRESET_NAMES as r, ParticleSim as t };

package/dist/{physics-2d-CZM5Y90X.js → physics-2d-q2N362ph.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { _ as validateCollider2D, d as Area2D, f as CharacterBody2D, g as Node2D, m as RigidBody2D, p as PhysicsBody2D, u as Joint2D } from "./register-Cl3pAxX-.js";
+import { _ as RigidBody2D, b as validateCollider2D, g as PhysicsBody2D, h as CharacterBody2D, m as Area2D, p as Joint2D, y as Node2D } from "./register-Cqjxrfq0.js";
 import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
 //#region src/2d/physics/physics-2d.ts
 var physics_2d_exports = /* @__PURE__ */ __exportAll({
@@ -110,11 +110,27 @@ var Physics2D = class {
 		if (node.snapToGround && vy >= 0) this.kcc.enableSnapToGround(.05);
 		else this.kcc.disableSnapToGround();
 		this.kcc.setMaxSlopeClimbAngle(node.slopeLimitDeg * DEG);
+		let carryX = 0;
+		let carryY = 0;
+		if (e.ground && e.ground._physics === this) {
+			const [gx, gy] = worldPosition2D(e.ground);
+			carryX = gx - (e.groundX ?? gx);
+			carryY = gy - (e.groundY ?? gy);
+		} else e.ground = null;
 		const desired = {
-			x: (node.velocity[0] ?? 0) * this.lastDt / SCALE,
-			y: vy * this.lastDt / SCALE
+			x: ((node.velocity[0] ?? 0) * this.lastDt + carryX) / SCALE * 1,
+			y: (vy * this.lastDt + carryY) / SCALE * 1
 		};
-		this.kcc.computeColliderMovement(e.collider, desired, this.R.QueryFilterFlags.EXCLUDE_SENSORS);
+		const charBottomPx = e.body.translation().y * SCALE + charHalfHeight(node);
+		const predicate = (collider) => {
+			const other = this.byColliderHandle.get(collider.handle);
+			if (other && other !== node && other.collider.oneWay === true) {
+				if (vy < 0) return false;
+				if (charBottomPx > platformTopPx(other) + ONE_WAY_TOLERANCE_PX) return false;
+			}
+			return true;
+		};
+		this.kcc.computeColliderMovement(e.collider, desired, this.R.QueryFilterFlags.EXCLUDE_SENSORS, void 0, predicate);
 		const corrected = this.kcc.computedMovement();
 		const t = e.body.translation();
 		e.body.setNextKinematicTranslation({
@@ -122,6 +138,17 @@ var Physics2D = class {
 			y: t.y + corrected.y
 		});
 		node._grounded = this.kcc.computedGrounded();
+		if (node._grounded) {
+			const footX = (t.x + corrected.x) * SCALE;
+			const footY = (t.y + corrected.y) * SCALE + charHalfHeight(node) - 2;
+			const hit = this.castRay([footX, footY], [0, 1], 8, node);
+			if (hit?.node && !(hit.node instanceof CharacterBody2D)) {
+				e.ground = hit.node;
+				const [gx, gy] = worldPosition2D(hit.node);
+				e.groundX = gx;
+				e.groundY = gy;
+			} else e.ground = null;
+		} else e.ground = null;
 	}
 	/** Rapier debug segments, scaled back to pixels. Null while debugDraw is off. */
 	debugLines() {
@@ -327,6 +354,20 @@ function collectBodies(node, out) {
 * Composed world position (translation only — ancestor rotation/scale are NOT
 * supported for physics bodies; keep body ancestors untransformed or offset-only).
 */
+const ONE_WAY_TOLERANCE_PX = 4;
+/** Distance from a body's center to its lowest point, px. */
+function charHalfHeight(node) {
+	const c = node.collider;
+	if (c.shape === "rect") return (c.size?.[1] ?? 32) / 2;
+	if (c.shape === "capsule") return (c.height ?? 32) / 2 + (c.radius ?? 8);
+	return c.radius ?? 16;
+}
+/** The stand-on surface of a platform (y-down: its SMALLEST y), px. */
+function platformTopPx(node) {
+	const [, wy] = worldPosition2D(node);
+	const c = node.collider;
+	return wy - (c.shape === "rect" ? (c.size?.[1] ?? 32) / 2 : c.shape === "capsule" ? (c.height ?? 32) / 2 + (c.radius ?? 8) : c.radius ?? 16);
+}
 function worldPosition2D(node) {
 	let x = 0;
 	let y = 0;

package/dist/{physics-3d-DT5e8izo.js → physics-3d-CvHr31d4.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
-import { D as CharacterBody3D, E as Area3D, M as validateCollider3D, O as PhysicsBody3D, T as Joint3D, j as Node3D, k as RigidBody3D, x as Terrain3D } from "./register-CpXcMiEk.js";
+import { A as RigidBody3D, D as Area3D, E as Joint3D, M as Node3D, N as validateCollider3D, O as CharacterBody3D, S as Terrain3D, k as PhysicsBody3D } from "./register-Cbs7QxoV.js";
 import { Euler, Quaternion } from "three";
 //#region src/3d/physics/physics-3d.ts
 var physics_3d_exports = /* @__PURE__ */ __exportAll({

package/dist/react.d.ts

@@ -1,5 +1,5 @@
 import { c as JsonValue } from "./schema-CcoWb32N.js";
-import { n as BehaviorCtor, v as Engine, w as Scene } from "./behavior-q3cejJgs.js";
+import { n as BehaviorCtor, v as Engine, w as Scene } from "./behavior-Bod1AyJS.js";
 import { CSSProperties, ReactNode } from "react";
 
 //#region src/react/index.d.ts

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-rFulaS3s.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-DuDkqnjl.js").then((n) => n.n)).createGame2D(o)))(opts);
+			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-66c4iYJE.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-BNDSbhy-.js").then((n) => n.n)).createGame2D(o)))(opts);
 			if (disposed) {
 				next.dispose();
 				return;

package/dist/{register-CpXcMiEk.js → register-Cbs7QxoV.js}

@@ -1,10 +1,10 @@
 import { f as Node } from "./loader-B4OEXDZ8.js";
-import { i as applyParticlePreset, o as effectiveOrder, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-m3CdTGSl.js";
+import { t as registerCoreNodes } from "./register-DRPIjrKG.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
-import { t as registerCoreNodes } from "./register-Dl_ixIJe.js";
 import { i as getNodeSchema, l as registerNode } from "./registry-BVJ2HbCn.js";
 import { t as createNoise2D } from "./noise-CGUMx44x.js";
+import { i as applyParticlePreset, o as effectiveOrder, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-CyUU7HVU.js";
 import { n as splatWeights, t as buildHeightmap } from "./heightmap-CroQPEER.js";
 import { AdditiveBlending, AnimationClip, AnimationMixer, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CapsuleGeometry, Color, ConeGeometry, CubeCamera, CylinderGeometry, DataTexture, DepthTexture, DirectionalLight, DoubleSide, Euler, FloatType, Frustum, Group, HalfFloatType, IcosahedronGeometry, ImageBitmapLoader, InstancedBufferAttribute, InstancedMesh, LinearFilter, LinearMipmapLinearFilter, LoopOnce, LoopRepeat, MathUtils, Matrix4, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshPhysicalMaterial, MeshStandardMaterial, NearestFilter, NoBlending, NormalBlending, Object3D, PerspectiveCamera, Plane, PlaneGeometry, PointLight, Points, PointsMaterial, Quaternion, QuaternionKeyframeTrack, RGBADepthPacking, RGBAFormat, RepeatWrapping, SRGBColorSpace, ShaderChunk, ShaderMaterial, Sphere, SphereGeometry, Texture, TextureLoader, UniformsLib, UniformsUtils, Vector2, Vector3, Vector4, VectorKeyframeTrack, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
 import { clone } from "three/addons/utils/SkeletonUtils.js";
@@ -1996,7 +1996,8 @@ var CharacterController3D = class extends Node3D {
 		jumpAction: { default: "jump" },
 		sprintAction: { default: "sprint" },
 		skinPath: { default: "../Skin" },
-		skinYawOffset: { default: 0 }
+		skinYawOffset: { default: 0 },
+		animations: { default: {} }
 	};
 	view = "free";
 	camDistance = 4;
@@ -2027,6 +2028,13 @@ var CharacterController3D = class extends Node3D {
 	* character facing away from the camera until it first moves).
 	*/
 	skinYawOffset = 0;
+	/**
+	* Movement-state → animation asset map, applied to the `skinPath` model
+	* directly — no CharacterAnimator behavior needed:
+	*   "animations": { "idle": "$idle", "run": "$run", "fastRun": "$sprint",
+	*                   "walk": "$walk", "airborne": "$jump" }
+	*/
+	animations = {};
 	/** Camera yaw/pitch in radians (mouse look mutates these). */
 	yaw = 0;
 	pitch = 0;
@@ -2147,6 +2155,11 @@ var CharacterController3D = class extends Node3D {
 		const next = movementState(this.grounded, moving ? intensity : 0);
 		if (next !== this.state) {
 			this.state = next;
+			const clip = this.animations[next];
+			if (clip && this.skinPath !== "") {
+				const skin = this.getNodeOrNull(this.skinPath);
+				if (skin && "animation" in skin) skin.animation = clip;
+			}
 			this.emit("movementStateChanged", next);
 		}
 		if (moving && this.skinPath !== "") {
@@ -6108,6 +6121,127 @@ function softSprite() {
 	return tex;
 }
 //#endregion
+//#region src/3d/nodes/trail-3d.ts
+const MAX_POINTS = 128;
+/**
+* A fading ribbon behind whatever this node is parented to — wingtip trails,
+* sword arcs, tyre streaks. Records the node's world position over `seconds`
+* and renders a camera-facing strip that tapers and fades to the tail.
+*
+*   { "name": "WingTrail", "type": "Trail3D",
+*     "props": { "width": 0.4, "color": "#dddddd", "seconds": 0.8 } }
+*
+* `emitting: false` stops laying new ribbon (the old tail still fades out).
+*/
+var Trail3D = class extends Node3D {
+	static typeName = "Trail3D";
+	static props = {
+		width: { default: .3 },
+		color: { default: "#ffffff" },
+		opacity: { default: .8 },
+		seconds: { default: .6 },
+		emitting: { default: true },
+		additive: { default: false },
+		/** Min world distance between recorded points (jitter filter). */
+		minDistance: { default: .05 }
+	};
+	width = .3;
+	color = "#ffffff";
+	opacity = .8;
+	seconds = .6;
+	emitting = true;
+	additive = false;
+	minDistance = .05;
+	points = [];
+	clock = 0;
+	mesh = null;
+	lastColor = "";
+	_createObject3D() {
+		const group = new Group();
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new BufferAttribute(new Float32Array(MAX_POINTS * 2 * 3), 3));
+		const material = new MeshBasicMaterial({
+			color: this.color,
+			transparent: true,
+			opacity: this.opacity,
+			side: DoubleSide,
+			depthWrite: false,
+			blending: this.additive ? AdditiveBlending : NormalBlending
+		});
+		this.mesh = new Mesh(geometry, material);
+		this.mesh.frustumCulled = false;
+		this.mesh.matrixAutoUpdate = false;
+		group.add(this.mesh);
+		return group;
+	}
+	update(dt) {
+		this.clock += dt;
+		while (this.points.length > 0 && this.clock - this.points[0].t > this.seconds) this.points.shift();
+	}
+	_onRender3D(ctx) {
+		const obj = this._ensureObject3D();
+		if (this.emitting) {
+			obj.getWorldPosition(worldScratch);
+			const last = this.points[this.points.length - 1];
+			if (!last || (last.x - worldScratch.x) ** 2 + (last.y - worldScratch.y) ** 2 + (last.z - worldScratch.z) ** 2 > this.minDistance * this.minDistance) {
+				this.points.push({
+					x: worldScratch.x,
+					y: worldScratch.y,
+					z: worldScratch.z,
+					t: this.clock
+				});
+				if (this.points.length > MAX_POINTS) this.points.shift();
+			}
+		}
+		const mesh = this.mesh;
+		if (!mesh) return;
+		mesh.matrixWorld.identity();
+		const mat = mesh.material;
+		if (this.color !== this.lastColor) {
+			this.lastColor = this.color;
+			mat.color = new Color(this.color);
+		}
+		mat.opacity = this.opacity;
+		const n = this.points.length;
+		const geometry = mesh.geometry;
+		const pos = geometry.getAttribute("position");
+		if (n < 2) {
+			geometry.setDrawRange(0, 0);
+			return;
+		}
+		for (let i = 0; i < n; i++) {
+			const p = this.points[i];
+			const q = this.points[Math.min(i + 1, n - 1)] ?? p;
+			dirScratch.set(q.x - p.x, q.y - p.y, q.z - p.z);
+			if (dirScratch.lengthSq() < 1e-8) dirScratch.set(0, 1, 0);
+			camScratch.set(ctx.camera.position.x - p.x, ctx.camera.position.y - p.y, ctx.camera.position.z - p.z);
+			sideScratch.crossVectors(dirScratch, camScratch).normalize();
+			const age = (this.clock - p.t) / this.seconds;
+			const half = this.width / 2 * Math.max(0, 1 - age);
+			pos.setXYZ(i * 2, p.x + sideScratch.x * half, p.y + sideScratch.y * half, p.z + sideScratch.z * half);
+			pos.setXYZ(i * 2 + 1, p.x - sideScratch.x * half, p.y - sideScratch.y * half, p.z - sideScratch.z * half);
+		}
+		pos.needsUpdate = true;
+		if (!geometry.index || geometry.index.count < (MAX_POINTS - 1) * 6) {
+			const indices = [];
+			for (let i = 0; i < MAX_POINTS - 1; i++) {
+				const a = i * 2;
+				indices.push(a, a + 1, a + 2, a + 1, a + 3, a + 2);
+			}
+			geometry.setIndex(indices);
+		}
+		geometry.setDrawRange(0, (n - 1) * 6);
+	}
+	/** Test hook: recorded point count. */
+	get pointCount() {
+		return this.points.length;
+	}
+};
+const worldScratch = new Vector3();
+const dirScratch = new Vector3();
+const camScratch = new Vector3();
+const sideScratch = new Vector3();
+//#endregion
 //#region src/3d/vegetation/eztree/options.ts
 /**
 * Predict the EXACT triangle count `buildEzTreeGeometry` will emit for these
@@ -11481,6 +11615,7 @@ function registerNodes3D() {
 	registerNode(CharacterController3D);
 	registerNode(VoxelGrid3D);
 	registerNode(Joint3D);
+	registerNode(Trail3D);
 	registerNode(Terrain3D);
 	registerNode(Water3D);
 	registerNode(Foliage3D);
@@ -11496,4 +11631,4 @@ function registerNodes3D() {
 	registerNode(CharacterBody3D);
 }
 //#endregion
-export { StaticBody3D as A, TERRAIN_THEMES as C, CharacterBody3D as D, Area3D as E, keyboardIntensity as F, movementState as I, rigPose as L, validateCollider3D as M, QUARTER_PITCH as N, PhysicsBody3D as O, cameraRelative as P, DEFAULT_TERRAIN_TEXTURE_BASE as S, Joint3D as T, FLOWER_VARIETIES as _, VoxelGrid3D as a, Billboard3D as b, ModelInstance3D as c, DirectionalLight3D as d, OmniLight3D as f, resolveFlowerDensity as g, Flowers3D as h, VOXEL_PALETTE as i, Node3D as j, RigidBody3D as k, LoftMesh3D as l, DENSITY_PRESETS as m, Water3D as n, Tree3D as o, Foliage3D as p, WATER_MAX_RIPPLES as r, Particles3D as s, registerNodes3D as t, MeshInstance3D as u, CharacterController3D as v, terrainThemeLayers as w, Terrain3D as x, Camera3D as y };
+export { RigidBody3D as A, DEFAULT_TERRAIN_TEXTURE_BASE as C, Area3D as D, Joint3D as E, cameraRelative as F, keyboardIntensity as I, movementState as L, Node3D as M, validateCollider3D as N, CharacterBody3D as O, QUARTER_PITCH as P, rigPose as R, Terrain3D as S, terrainThemeLayers as T, resolveFlowerDensity as _, VoxelGrid3D as a, Camera3D as b, Particles3D as c, MeshInstance3D as d, DirectionalLight3D as f, Flowers3D as g, DENSITY_PRESETS as h, VOXEL_PALETTE as i, StaticBody3D as j, PhysicsBody3D as k, ModelInstance3D as l, Foliage3D as m, Water3D as n, Tree3D as o, OmniLight3D as p, WATER_MAX_RIPPLES as r, Trail3D as s, registerNodes3D as t, LoftMesh3D as u, FLOWER_VARIETIES as v, TERRAIN_THEMES as w, Billboard3D as x, CharacterController3D as y };