incanto 0.28.0 → 0.30.0

package/dist/{physics-2d-DiVFFlH3.js → physics-2d-3kOQCtgd.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { _ as RigidBody2D, b as validateCollider2D, g as PhysicsBody2D, h as CharacterBody2D, m as Area2D, p as Joint2D, y as Node2D } from "./register-CvpSUU3O.js";
-import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
+import { _ as RigidBody2D, b as validateCollider2D, g as PhysicsBody2D, h as CharacterBody2D, m as Area2D, p as Joint2D, y as Node2D } from "./register-DWcWq4QG.js";
+import { n as registerDebugSource } from "./debug-draw-BM3DsvtT.js";
 //#region src/2d/physics/physics-2d.ts
 var physics_2d_exports = /* @__PURE__ */ __exportAll({
 	Physics2D: () => Physics2D,
@@ -28,6 +28,8 @@ var Physics2D = class {
 	engine;
 	/** Render collider outlines in the GAME view (renderers pick this up). */
 	debugDraw = false;
+	/** Narrow those outlines to one node's subtree (see DebugLineSource). */
+	debugScope = null;
 	dimension = "2d";
 	unregisterDebug;
 	warnedNoCollider = /* @__PURE__ */ new WeakSet();
@@ -44,6 +46,7 @@ var Physics2D = class {
 		this.R = R;
 		this.engine = engine;
 		this.optsGravity = opts?.gravity;
+		this.simulate = opts?.simulate ?? true;
 		this.lastScene = engine.scene;
 		const declared = engine.scene?.physics?.gravity;
 		const g = opts?.gravity ?? declared ?? [0, 980];
@@ -62,8 +65,15 @@ var Physics2D = class {
 		this.syncBodies();
 	}
 	/** @internal Driven by engine.fixedUpdated. */
+	/** Whether the solver runs at all. False = collider outlines only. */
+	simulate;
 	step(dt) {
 		this.lastDt = dt;
+		if (!this.simulate) {
+			this.syncBodies();
+			this.poseFromTree();
+			return;
+		}
 		if (this.engine.scene !== this.lastScene) {
 			this.lastScene = this.engine.scene;
 			if (!this.optsGravity) {
@@ -157,11 +167,69 @@ var Physics2D = class {
 	/** Rapier debug segments, scaled back to pixels. Null while debugDraw is off. */
 	debugLines() {
 		if (!this.debugDraw) return null;
-		const raw = this.world.debugRender().vertices;
+		const raw = this.debugScope ? this.scopedLines(this.debugScope) : this.world.debugRender().vertices;
 		const px = new Float32Array(raw.length);
 		for (let i = 0; i < raw.length; i++) px[i] = raw[i] * SCALE;
 		return px;
 	}
+	/**
+	* Only the selected node's colliders (meters — the caller scales to pixels).
+	* Rapier draws the whole world or nothing, so a chosen few are outlined from
+	* the same shape data the solver holds. 2D colliders are rect/circle/capsule,
+	* which is the whole switch.
+	*/
+	scopedLines(node) {
+		const out = [];
+		const bodies = [];
+		const collect = (n) => {
+			const entry = this.entries.get(n);
+			if (entry) bodies.push(entry.body);
+			for (const child of n.children) collect(child);
+		};
+		collect(node);
+		for (let p = node.parent; p && bodies.length === 0; p = p.parent) {
+			const entry = this.entries.get(p);
+			if (entry) bodies.push(entry.body);
+		}
+		const RING = 24;
+		for (const body of bodies) for (let i = 0; i < body.numColliders(); i++) {
+			const collider = body.collider(i);
+			if (!collider) continue;
+			const t = collider.translation();
+			const angle = collider.rotation();
+			const cos = Math.cos(angle);
+			const sin = Math.sin(angle);
+			const put = (x, y) => {
+				out.push(t.x + x * cos - y * sin, t.y + x * sin + y * cos);
+			};
+			const seg = (ax, ay, bx, by) => {
+				put(ax, ay);
+				put(bx, by);
+			};
+			const shape = collider.shape;
+			if (shape.halfExtents) {
+				const { x, y } = shape.halfExtents;
+				seg(-x, -y, x, -y);
+				seg(x, -y, x, y);
+				seg(x, y, -x, y);
+				seg(-x, y, -x, -y);
+			} else if (shape.radius !== void 0) {
+				const r = shape.radius;
+				const half = shape.halfHeight ?? 0;
+				for (let k = 0; k < RING; k++) {
+					const a = k / RING * Math.PI * 2;
+					const b = (k + 1) / RING * Math.PI * 2;
+					const lift = (v) => v >= 0 ? half : -half;
+					seg(Math.cos(a) * r, Math.sin(a) * r + lift(Math.sin(a)), Math.cos(b) * r, Math.sin(b) * r + lift(Math.sin(b)));
+				}
+				if (half > 0) {
+					seg(-r, -half, -r, half);
+					seg(r, -half, r, half);
+				}
+			}
+		}
+		return new Float32Array(out);
+	}
 	/** Create newly-arrived joints; tear down departed ones. */
 	syncJoints(structureChanged) {
 		const R = this.R;
@@ -234,6 +302,23 @@ var Physics2D = class {
 	jointSet = /* @__PURE__ */ new Set();
 	joints = /* @__PURE__ */ new Map();
 	bodySet = /* @__PURE__ */ new Set();
+	/**
+	* Move every body to its node's current transform — outline mode only.
+	*
+	* Computed exactly as `ensureEntry` computes a body's first pose, so an
+	* outline drawn in the editor is the outline the running game draws.
+	*/
+	poseFromTree() {
+		for (const [node, e] of this.entries) {
+			const [wx, wy] = worldPosition2D(node);
+			e.body.setTranslation({
+				x: wx / SCALE,
+				y: wy / SCALE
+			}, false);
+			e.body.setRotation(node.rotation * DEG, false);
+		}
+		this.world.propagateModifiedBodyPositionsToColliders();
+	}
 	syncBodies() {
 		const scene = this.engine.scene;
 		if (!scene) return;