@zkmake/three-audit 0.2.1 → 0.3.0

package/dist/audit-scene-CJG1DgRF.js

@@ -0,0 +1,725 @@
+//#region src/scene.ts
+/** The object as three's own type, for the walk. */
+const asObject3D = (object) => object;
+/** Depth-first, in child order. A skipped (or, with `visibleOnly`, hidden) object prunes its subtree. */
+const walk = (root, options, visit) => {
+	const stack = [root];
+	while (stack.length > 0) {
+		const object = stack.pop();
+		if (options.visibleOnly === true && !object.visible || options.skip?.(object) === true) continue;
+		visit(object);
+		for (let i = object.children.length - 1; i >= 0; i -= 1) stack.push(object.children[i]);
+	}
+};
+const isMesh = (object) => object.isMesh === true;
+/** Anything the renderer draws: a mesh, line, point cloud or sprite. */
+const isDrawable = (object) => {
+	const flags = object;
+	return flags.isMesh === true || flags.isLine === true || flags.isPoints === true || flags.isSprite === true;
+};
+const isInstanced = (mesh) => mesh.isInstancedMesh === true;
+const isBatched = (mesh) => mesh.isBatchedMesh === true;
+/** Triangles one draw of this geometry makes: indexed or not, within its draw range. */
+const triangleCount = (geometry) => {
+	const elements = geometry.index?.count ?? geometry.attributes.position?.count ?? 0;
+	const { start, count } = geometry.drawRange;
+	const drawn = Math.min(elements, start + count) - start;
+	return Math.max(0, Math.floor(drawn / 3));
+};
+/**
+* A batch's visible instances by the geometry each draws: how many, and that geometry's triangles
+* (its range in the shared buffer). In first-drawn order.
+*/
+const batchedGeometries = (batch) => {
+	const geometries = /* @__PURE__ */ new Map();
+	for (let id = 0; id < batch.maxInstanceCount; id += 1) {
+		let geometryId;
+		try {
+			if (!batch.getVisibleAt(id)) continue;
+			geometryId = batch.getGeometryIdAt(id);
+		} catch {
+			continue;
+		}
+		const known = geometries.get(geometryId);
+		if (known) {
+			known.instances += 1;
+			continue;
+		}
+		const range = batch.getGeometryRangeAt(geometryId);
+		const elements = range.count ?? (batch.geometry.index ? range.indexCount : range.vertexCount);
+		geometries.set(geometryId, {
+			instances: 1,
+			triangles: Math.floor(elements / 3)
+		});
+	}
+	return geometries;
+};
+/** Triangles a batch draws across its visible instances, and how many instances that is. */
+const batchedTriangles = (batch) => {
+	let triangles = 0;
+	let instances = 0;
+	for (const geometry of batchedGeometries(batch).values()) {
+		triangles += geometry.triangles * geometry.instances;
+		instances += geometry.instances;
+	}
+	return {
+		instances,
+		triangles
+	};
+};
+/** The tag of the nearest tagged ancestor (the object itself included), or `null`. */
+const tagOf = (object, tagKey) => {
+	for (let at = object; at; at = at.parent) {
+		const tag = at.userData[tagKey];
+		if (tag !== void 0 && tag !== null) return String(tag);
+	}
+	return null;
+};
+/**
+* A skip that keeps only what's tagged `tag`: prunes objects tagged otherwise, and meshes outside
+* any object tagged `tag`. Throws when nothing under `root` carries the tag.
+*/
+const onlyTag = (root, tag, tagKey, skip) => {
+	let found = false;
+	walk(root, { skip }, (object) => {
+		const own = object.userData[tagKey];
+		found ||= own !== void 0 && own !== null && String(own) === tag;
+	});
+	if (!found) throw new Error(`three-audit: nothing is tagged userData.${tagKey} = "${tag}"`);
+	return (object) => {
+		if (skip?.(object) === true) return true;
+		const own = object.userData[tagKey];
+		if (own !== void 0 && own !== null && String(own) !== tag) return true;
+		return isDrawable(object) && tagOf(object, tagKey) !== tag;
+	};
+};
+const hasTag = (root, tagKey, skip) => {
+	let found = false;
+	walk(root, { skip }, (object) => {
+		found ||= object.userData[tagKey] !== void 0 && object.userData[tagKey] !== null;
+	});
+	return found;
+};
+const meshName = (mesh) => mesh.name || mesh.geometry.name || mesh.geometry.type;
+/**
+* The named ancestors above an object, outermost first, from `root` (included when named) down:
+* at most the nearest `depth`, with `…` for the rest. An unnamed ancestor carrying `tagKey` goes
+* by its tag.
+*/
+const pathOf = (object, root, tagKey, depth = 3) => {
+	const names = [];
+	for (let at = object.parent; at; at = at === root ? null : at.parent) {
+		const tag = tagKey === void 0 ? void 0 : at.userData[tagKey];
+		const name = at.name || (tag === void 0 || tag === null ? "" : String(tag));
+		if (name) names.unshift(name);
+	}
+	return names.length > depth ? ["…", ...names.slice(-depth)] : names;
+};
+/** `path/to/mesh [material]`: enough to find a mesh in the scene without walking it by hand. */
+const meshLabel = (mesh, root, tagKey) => `${[...pathOf(mesh, root, tagKey), meshName(mesh)].join("/")} [${materialName(mesh)}]`;
+const materialName = (mesh) => {
+	const material = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+	return material ? material.name || material.type : "none";
+};
+/** Adds a property JSON and `console.table` leave out: a live object that would serialise the scene. */
+const withHidden = (row, key, value) => Object.defineProperty(row, key, {
+	value,
+	enumerable: false
+});
+//#endregion
+//#region src/bad-geometry.ts
+const corner = (geometry, k) => geometry.index?.getX(k) ?? k;
+const check = (geometry) => {
+	const position = geometry.attributes.position;
+	const normal = geometry.attributes.normal;
+	const flagged = new Uint8Array(position.count);
+	let nonFinite = 0;
+	let zeroNormals = 0;
+	for (let v = 0; v < position.count; v += 1) if (!(Number.isFinite(position.getX(v)) && Number.isFinite(position.getY(v)) && Number.isFinite(position.getZ(v)) && (!normal || Number.isFinite(normal.getX(v)) && Number.isFinite(normal.getY(v)) && Number.isFinite(normal.getZ(v))))) {
+		flagged[v] = 1;
+		nonFinite += 1;
+	}
+	if (!normal) return {
+		nonFinite,
+		zeroNormals
+	};
+	const corners = geometry.index?.count ?? position.count;
+	for (let k = 0; k + 2 < corners; k += 3) {
+		const a = corner(geometry, k);
+		const b = corner(geometry, k + 1);
+		const c = corner(geometry, k + 2);
+		const ux = position.getX(b) - position.getX(a);
+		const uy = position.getY(b) - position.getY(a);
+		const uz = position.getZ(b) - position.getZ(a);
+		const vx = position.getX(c) - position.getX(a);
+		const vy = position.getY(c) - position.getY(a);
+		const vz = position.getZ(c) - position.getZ(a);
+		if (!(Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx) > 1e-8)) continue;
+		for (const v of [
+			a,
+			b,
+			c
+		]) if (flagged[v] === 0 && Math.hypot(normal.getX(v), normal.getY(v), normal.getZ(v)) < 1e-4) {
+			flagged[v] = 1;
+			zeroNormals += 1;
+		}
+	}
+	return {
+		nonFinite,
+		zeroNormals
+	};
+};
+/** Meshes with geometry that renders NaN, hidden ones included. `[]` is a pass. */
+const findBadGeometry = (root, options = {}) => {
+	const tagKey = options.tagKey ?? "studioObject";
+	const rows = [];
+	walk(asObject3D(root), { skip: options.skip }, (object) => {
+		if (!isMesh(object) || !object.geometry.attributes.position) return;
+		const { nonFinite, zeroNormals } = check(object.geometry);
+		if (nonFinite > 0 || zeroNormals > 0) {
+			const under = tagOf(object, tagKey) ?? object.parent?.name ?? "";
+			rows.push(withHidden({
+				mesh: meshName(object),
+				under,
+				nonFinite,
+				zeroNormals
+			}, "object", object));
+		}
+	});
+	return rows;
+};
+/**
+* Meshes with no vertices, hidden ones included: what a merge of nothing leaves behind. They draw
+* nothing, but each one is still a draw call and a leak to dispose. A draw range of zero doesn't
+* count: that's usually a pool waiting to fill.
+*/
+const findEmptyMeshes = (root, options = {}) => {
+	const scene = asObject3D(root);
+	const rows = [];
+	walk(scene, { skip: options.skip }, (object) => {
+		if (isMesh(object) && (object.geometry.attributes.position?.count ?? 0) === 0) rows.push(withHidden({ mesh: meshLabel(object, scene, options.tagKey ?? "studioObject") }, "object", object));
+	});
+	return rows;
+};
+//#endregion
+//#region src/triangles.ts
+const cost = (mesh) => {
+	if (isBatched(mesh)) return batchedTriangles(mesh);
+	const instances = isInstanced(mesh) ? mesh.count : 1;
+	return {
+		instances,
+		triangles: triangleCount(mesh.geometry) * instances
+	};
+};
+/**
+* Triangles one pass draws: visible meshes, instances counted, no frustum culling. A shadow pass
+* adds roughly as much again for each shadow-casting light.
+*/
+const countTriangles = (root, options = {}) => {
+	let total = 0;
+	walk(asObject3D(root), {
+		skip: options.skip,
+		visibleOnly: true
+	}, (object) => {
+		if (isMesh(object)) total += cost(object).triangles;
+	});
+	return total;
+};
+/** Every visible mesh, most triangles drawn first. */
+const listMeshes = (scene, options = {}) => {
+	const root = asObject3D(scene);
+	const rows = [];
+	walk(root, {
+		skip: options.skip,
+		visibleOnly: true
+	}, (object) => {
+		if (!isMesh(object)) return;
+		const { instances, triangles } = cost(object);
+		const row = {
+			name: [...pathOf(object, root), meshName(object)].join("/"),
+			material: materialName(object),
+			triangles: instances > 0 ? Math.round(triangles / instances) : 0,
+			instances,
+			total: triangles
+		};
+		rows.push(withHidden(row, "mesh", object));
+	});
+	return rows.sort((a, b) => b.total - a.total);
+};
+/**
+* Geometries by triangles drawn, hidden meshes included, most first. Name geometries
+* (`geometry.name`) to make this readable. A batch counts each geometry in it separately, by its
+* visible instances: the row a budget is really spent on.
+*/
+const geometryCensus = (root, options = {}) => {
+	const scene = asObject3D(root);
+	const rows = /* @__PURE__ */ new Map();
+	const add = (key, triangles, uses) => {
+		const row = rows.get(key) ?? {
+			geometry: key,
+			uses: 0,
+			triangles,
+			total: 0,
+			share: 0
+		};
+		row.uses += uses;
+		row.total += triangles * uses;
+		rows.set(key, row);
+	};
+	walk(scene, { skip: options.skip }, (object) => {
+		if (!isMesh(object) || !object.geometry.attributes.position) return;
+		if (isBatched(object)) {
+			const name = [...pathOf(object, scene), meshName(object)].join("/");
+			for (const [id, { instances, triangles }] of batchedGeometries(object)) add(options.label?.(object, id) ?? `${name}#${id}`, triangles, instances);
+			return;
+		}
+		const geometry = object.geometry;
+		add(geometry.name || `${geometry.type}:${geometry.uuid.slice(0, 6)}`, triangleCount(geometry), isInstanced(object) ? object.count : 1);
+	});
+	const all = [...rows.values()];
+	const sum = all.reduce((total, row) => total + row.total, 0);
+	for (const row of all) {
+		row.share = sum > 0 ? Math.round(row.total / sum * 1e3) / 1e3 : 0;
+		if (options.budget !== void 0) row.overBudget = row.total / Math.max(sum, 1) > options.budget;
+	}
+	return all.sort((a, b) => b.total - a.total);
+};
+/**
+* Draw calls one main pass makes: one per visible mesh, line or point cloud, or one per material
+* group for a mesh with several materials. Before frustum culling; each shadow-casting light adds
+* one per caster. `recordDrawLedger` counts the real thing.
+*/
+const countDraws = (root, options = {}) => {
+	let draws = 0;
+	walk(asObject3D(root), {
+		skip: options.skip,
+		visibleOnly: true
+	}, (object) => {
+		if (!isDrawable(object)) return;
+		const drawable = object;
+		const material = drawable.material;
+		if (Array.isArray(material)) {
+			const groups = drawable.geometry?.groups ?? [];
+			draws += groups.filter((group) => material[group.materialIndex ?? 0]?.visible !== false).length;
+		} else if (material?.visible !== false) draws += 1;
+	});
+	return draws;
+};
+//#endregion
+//#region src/z-fighting.ts
+/** Normals quantised to 1/40: neighbouring buckets are searched, so this only sets bucket size. */
+const QUANT = 40;
+/** Normals this aligned count as parallel (about 2.6°). */
+const PARALLEL = .999;
+const round = (value, places = 2) => {
+	const scale = 10 ** places;
+	const rounded = Math.round(value * scale) / scale;
+	return rounded === 0 ? 0 : rounded;
+};
+const labelOf = (part) => {
+	const centre = part.min.map((low, axis) => round((low + part.max[axis]) / 2));
+	return `${part.label} @ (${centre.join(", ")})`;
+};
+const fixed = (value) => round(value, 3).toFixed(3);
+/** `z = -3.000, facing +z` for an axis-aligned plane, `(nx, ny, nz) · p = d` for any other. */
+const planeLabel = (nx, ny, nz, d) => {
+	for (const [axis, value] of [
+		["x", nx],
+		["y", ny],
+		["z", nz]
+	]) if (Math.abs(value) > .9999) return `${axis} = ${fixed(d / value)}, facing ${value > 0 ? "+" : "-"}${axis}`;
+	return `(${fixed(nx)}, ${fixed(ny)}, ${fixed(nz)}) · p = ${fixed(d)}`;
+};
+const materialsOf = (mesh) => (Array.isArray(mesh.material) ? mesh.material : [mesh.material]).filter((material) => material !== void 0 && material !== null);
+/** Whether two parts can fight: one writes depth the other tests, and neither is offset. */
+const canFight = (a, b) => !a.offset && !b.offset && (a.writes && b.tests || b.writes && a.tests);
+/** Pairs of meshes that z-fight, most overlapping triangles first. `[]` is a pass. */
+const findZFighting = (scene, options = {}) => {
+	const root = asObject3D(scene);
+	const gap = options.gap ?? .004;
+	const self = options.self ?? false;
+	const tagKey = options.tagKey ?? "studioObject";
+	const tagged = options.tagged ?? hasTag(root, tagKey, options.skip);
+	root.updateWorldMatrix(true, true);
+	const parts = [];
+	const owner = [];
+	const planes = [];
+	const corners = [];
+	const keys = [];
+	const buckets = /* @__PURE__ */ new Map();
+	const keyOf = (x, y, z, d) => `${x},${y},${z},${d}`;
+	walk(root, {
+		skip: options.skip,
+		visibleOnly: true
+	}, (object) => {
+		if (!isMesh(object) || isInstanced(object) || isBatched(object) || object.geometry.isInstancedBufferGeometry === true || !object.geometry.attributes.position) return;
+		if (tagged && tagOf(object, tagKey) === null) return;
+		const materials = materialsOf(object).filter((material) => material.visible !== false);
+		if (materials.length === 0) return;
+		const part = parts.length;
+		const { index, attributes } = object.geometry;
+		const position = attributes.position;
+		const e = object.matrixWorld.elements;
+		const min = [
+			Infinity,
+			Infinity,
+			Infinity
+		];
+		const max = [
+			-Infinity,
+			-Infinity,
+			-Infinity
+		];
+		const count = index?.count ?? position.count;
+		const world = [
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		];
+		parts.push({
+			mesh: object,
+			label: meshLabel(object, root, tagKey),
+			min,
+			max,
+			writes: materials.some((material) => material.depthWrite !== false),
+			tests: materials.some((material) => material.depthTest !== false),
+			offset: materials.some((material) => material.polygonOffset === true && (material.polygonOffsetFactor !== 0 || material.polygonOffsetUnits !== 0))
+		});
+		for (let k = 0; k + 2 < count; k += 3) {
+			for (let c = 0; c < 3; c += 1) {
+				const v = index?.getX(k + c) ?? k + c;
+				const x = position.getX(v);
+				const y = position.getY(v);
+				const z = position.getZ(v);
+				for (let axis = 0; axis < 3; axis += 1) {
+					const value = e[axis] * x + e[axis + 4] * y + e[axis + 8] * z + e[axis + 12];
+					world[c * 3 + axis] = value;
+					min[axis] = Math.min(min[axis], value);
+					max[axis] = Math.max(max[axis], value);
+				}
+			}
+			const [ax, ay, az, bx, by, bz, cx, cy, cz] = world;
+			const ux = bx - ax;
+			const uy = by - ay;
+			const uz = bz - az;
+			const vx = cx - ax;
+			const vy = cy - ay;
+			const vz = cz - az;
+			let nx = uy * vz - uz * vy;
+			let ny = uz * vx - ux * vz;
+			let nz = ux * vy - uy * vx;
+			const length = Math.hypot(nx, ny, nz);
+			if (!(length / 2 >= 1e-5)) continue;
+			nx /= length;
+			ny /= length;
+			nz /= length;
+			const d = nx * ax + ny * ay + nz * az;
+			const id = owner.length;
+			const key = [
+				Math.round(nx * QUANT),
+				Math.round(ny * QUANT),
+				Math.round(nz * QUANT),
+				Math.round(d / gap)
+			];
+			const bucket = buckets.get(keyOf(...key));
+			owner.push(part);
+			planes.push(nx, ny, nz, d);
+			corners.push(...world);
+			keys.push(key);
+			if (bucket) bucket.push(id);
+			else buckets.set(keyOf(...key), [id]);
+		}
+	});
+	const margin = gap / 2;
+	const flat = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+	const frame = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+	const overlaps = (s, t) => {
+		const S = s * 9;
+		const T = t * 9;
+		let ux = corners[S + 3] - corners[S];
+		let uy = corners[S + 4] - corners[S + 1];
+		let uz = corners[S + 5] - corners[S + 2];
+		const length = Math.hypot(ux, uy, uz) || 1;
+		ux /= length;
+		uy /= length;
+		uz /= length;
+		const nx = planes[s * 4];
+		const ny = planes[s * 4 + 1];
+		const nz = planes[s * 4 + 2];
+		const vx = ny * uz - nz * uy;
+		const vy = nz * ux - nx * uz;
+		const vz = nx * uy - ny * ux;
+		frame[0] = ux;
+		frame[1] = uy;
+		frame[2] = uz;
+		frame[3] = vx;
+		frame[4] = vy;
+		frame[5] = vz;
+		for (let i = 0; i < 6; i += 1) {
+			const at = i < 3 ? S + i * 3 : T + (i - 3) * 3;
+			const px = corners[at];
+			const py = corners[at + 1];
+			const pz = corners[at + 2];
+			flat[i * 2] = px * ux + py * uy + pz * uz;
+			flat[i * 2 + 1] = px * vx + py * vy + pz * vz;
+		}
+		for (let edge = 0; edge < 6; edge += 1) {
+			const from = edge;
+			const to = edge < 3 ? (edge + 1) % 3 : 3 + (edge + 1) % 3;
+			const ex = flat[to * 2] - flat[from * 2];
+			const ey = flat[to * 2 + 1] - flat[from * 2 + 1];
+			const edgeLength = Math.hypot(ex, ey) || 1;
+			const axisX = -ey / edgeLength;
+			const axisY = ex / edgeLength;
+			let p0 = Infinity;
+			let p1 = -Infinity;
+			let q0 = Infinity;
+			let q1 = -Infinity;
+			for (let i = 0; i < 6; i += 1) {
+				const value = flat[i * 2] * axisX + flat[i * 2 + 1] * axisY;
+				if (i < 3) {
+					p0 = Math.min(p0, value);
+					p1 = Math.max(p1, value);
+				} else {
+					q0 = Math.min(q0, value);
+					q1 = Math.max(q1, value);
+				}
+			}
+			if (Math.min(p1, q1) - Math.max(p0, q0) < margin) return false;
+		}
+		return true;
+	};
+	/**
+	* The overlap `overlaps` just found, as area and centroid in s's plane: t's triangle clipped to
+	* s's (Sutherland–Hodgman), then the shoelace formula.
+	*/
+	const clipped = () => {
+		const order = (flat[2] - flat[0]) * (flat[5] - flat[1]) - (flat[4] - flat[0]) * (flat[3] - flat[1]) >= 0 ? [
+			0,
+			1,
+			2
+		] : [
+			0,
+			2,
+			1
+		];
+		let polygon = flat.slice(6, 12);
+		for (let edge = 0; edge < 3 && polygon.length >= 6; edge += 1) {
+			const ax = flat[order[edge] * 2];
+			const ay = flat[order[edge] * 2 + 1];
+			const ex = flat[order[(edge + 1) % 3] * 2] - ax;
+			const ey = flat[order[(edge + 1) % 3] * 2 + 1] - ay;
+			const next = [];
+			const n = polygon.length / 2;
+			for (let i = 0; i < n; i += 1) {
+				const px = polygon[i * 2];
+				const py = polygon[i * 2 + 1];
+				const qx = polygon[(i + 1) % n * 2];
+				const qy = polygon[(i + 1) % n * 2 + 1];
+				const dp = ex * (py - ay) - ey * (px - ax);
+				const dq = ex * (qy - ay) - ey * (qx - ax);
+				if (dp >= 0) next.push(px, py);
+				if (dp >= 0 !== dq >= 0) {
+					const k = dp / (dp - dq);
+					next.push(px + (qx - px) * k, py + (qy - py) * k);
+				}
+			}
+			polygon = next;
+		}
+		let twice = 0;
+		let cx = 0;
+		let cy = 0;
+		const n = polygon.length / 2;
+		for (let i = 0; i < n; i += 1) {
+			const x0 = polygon[i * 2];
+			const y0 = polygon[i * 2 + 1];
+			const x1 = polygon[(i + 1) % n * 2];
+			const y1 = polygon[(i + 1) % n * 2 + 1];
+			const cross = x0 * y1 - x1 * y0;
+			twice += cross;
+			cx += (x0 + x1) * cross;
+			cy += (y0 + y1) * cross;
+		}
+		return Math.abs(twice) < 1e-12 ? {
+			area: 0,
+			x: 0,
+			y: 0
+		} : {
+			area: Math.abs(twice) / 2,
+			x: cx / (3 * twice),
+			y: cy / (3 * twice)
+		};
+	};
+	const onPlane = (s, t) => {
+		const nx = planes[s * 4];
+		const ny = planes[s * 4 + 1];
+		const nz = planes[s * 4 + 2];
+		const d = planes[s * 4 + 3];
+		for (let c = 0; c < 3; c += 1) {
+			const at = t * 9 + c * 3;
+			if (Math.abs(nx * corners[at] + ny * corners[at + 1] + nz * corners[at + 2] - d) > gap) return false;
+		}
+		return true;
+	};
+	const pairs = /* @__PURE__ */ new Map();
+	for (let s = 0; s < owner.length; s += 1) {
+		const [kx, ky, kz, kd] = keys[s];
+		for (let i = -1; i <= 1; i += 1) for (let j = -1; j <= 1; j += 1) for (let k = -1; k <= 1; k += 1) for (let l = -1; l <= 1; l += 1) for (const t of buckets.get(keyOf(kx + i, ky + j, kz + k, kd + l)) ?? []) {
+			const a = owner[s];
+			const b = owner[t];
+			if (t <= s || a === b && !self || !canFight(parts[a], parts[b]) || planes[s * 4] * planes[t * 4] + planes[s * 4 + 1] * planes[t * 4 + 1] + planes[s * 4 + 2] * planes[t * 4 + 2] < PARALLEL || !onPlane(s, t) || !onPlane(t, s) || !overlaps(s, t)) continue;
+			const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+			const pair = pairs.get(key) ?? {
+				a: Math.min(a, b),
+				b: Math.max(a, b),
+				triangles: 0,
+				area: 0,
+				centre: [
+					0,
+					0,
+					0
+				],
+				planes: /* @__PURE__ */ new Map()
+			};
+			const nx = planes[s * 4];
+			const ny = planes[s * 4 + 1];
+			const nz = planes[s * 4 + 2];
+			const d = planes[s * 4 + 3];
+			const { area, x, y } = clipped();
+			const plane = planeLabel(nx, ny, nz, d);
+			pair.triangles += 1;
+			pair.area += area;
+			pair.centre[0] += area * (x * frame[0] + y * frame[3] + d * nx);
+			pair.centre[1] += area * (x * frame[1] + y * frame[4] + d * ny);
+			pair.centre[2] += area * (x * frame[2] + y * frame[5] + d * nz);
+			pair.planes.set(plane, (pair.planes.get(plane) ?? 0) + area);
+			pairs.set(key, pair);
+		}
+	}
+	const rows = /* @__PURE__ */ new Map();
+	for (const pair of [...pairs.values()].sort((x, y) => y.triangles - x.triangles)) {
+		const meshes = [parts[pair.a].mesh, parts[pair.b].mesh];
+		const a = labelOf(parts[pair.a]);
+		const b = labelOf(parts[pair.b]);
+		const planeLabels = [...pair.planes.entries()].sort((x, y) => y[1] - x[1]).map(([plane]) => plane);
+		const key = JSON.stringify([
+			a,
+			b,
+			pair.triangles,
+			planeLabels
+		]);
+		const folded = rows.get(key);
+		if (folded) {
+			folded.count += 1;
+			folded.pairs.push(meshes);
+			continue;
+		}
+		const weight = pair.area > 0 ? pair.area : 1;
+		const row = withHidden(withHidden({
+			a,
+			b,
+			triangles: pair.triangles,
+			planes: planeLabels,
+			overlap: {
+				area: round(pair.area, 4),
+				centre: pair.centre.map((sum) => round(sum / weight))
+			},
+			count: 1
+		}, "meshes", meshes), "pairs", [meshes]);
+		rows.set(key, row);
+	}
+	return [...rows.values()];
+};
+//#endregion
+//#region src/audit-scene.ts
+/** The skip every check runs with: the caller's, narrowed to `tag` when given. */
+const scopeOf = (root, options) => options.tag === void 0 ? options.skip : onlyTag(asObject3D(root), options.tag, options.tagKey ?? "studioObject", options.skip);
+/**
+* Every check at once, JSON-safe: what a test asserts on or a headless browser prints. A clean
+* scene has `zFighting`, `badGeometry` and `emptyMeshes` all `[]`.
+*/
+const auditScene = (root, options = {}) => {
+	const { tagKey } = options;
+	const skip = scopeOf(root, options);
+	const keyed = tagKey === void 0 ? { skip } : {
+		skip,
+		tagKey
+	};
+	return {
+		triangles: countTriangles(root, { skip }),
+		draws: countDraws(root, { skip }),
+		zFighting: findZFighting(root, {
+			...options,
+			skip,
+			...options.tag === void 0 ? {} : { tagged: true }
+		}),
+		badGeometry: findBadGeometry(root, keyed),
+		emptyMeshes: findEmptyMeshes(root, keyed),
+		meshes: listMeshes(root, { skip }).slice(0, options.top ?? 10)
+	};
+};
+/**
+* Every check as one count each: the single call to run after every edit. `0` everywhere (and
+* `triangles`, `draws` where you expect them) is a pass. Use `auditScene` to see what failed.
+*/
+const summarizeScene = (root, options = {}) => {
+	const { tagKey } = options;
+	const skip = scopeOf(root, options);
+	const keyed = tagKey === void 0 ? { skip } : {
+		skip,
+		tagKey
+	};
+	let zFighting = null;
+	let selfZFighting = null;
+	if (options.zFighting !== false) {
+		zFighting = 0;
+		selfZFighting = 0;
+		for (const row of findZFighting(root, {
+			...options.gap === void 0 ? {} : { gap: options.gap },
+			...tagKey === void 0 ? {} : { tagKey },
+			...options.tag === void 0 ? {} : { tagged: true },
+			skip,
+			self: true
+		})) if (row.meshes[0] === row.meshes[1]) selfZFighting += row.count;
+		else zFighting += row.count;
+	}
+	return {
+		triangles: countTriangles(root, { skip }),
+		draws: countDraws(root, { skip }),
+		meshes: listMeshes(root, { skip }).length,
+		zFighting,
+		selfZFighting,
+		badGeometry: findBadGeometry(root, keyed).length,
+		emptyMeshes: findEmptyMeshes(root, keyed).length
+	};
+};
+//#endregion
+export { triangleCount as _, countTriangles as a, findBadGeometry as c, batchedTriangles as d, isBatched as f, pathOf as g, meshLabel as h, countDraws as i, findEmptyMeshes as l, isMesh as m, summarizeScene as n, geometryCensus as o, isInstanced as p, findZFighting as r, listMeshes as s, auditScene as t, asObject3D as u, walk as v };
+
+//# sourceMappingURL=audit-scene-CJG1DgRF.js.map