@zkmake/three-audit 0.1.0 → 0.2.0

package/README.md

@@ -33,6 +33,48 @@ A failure lists each pair of meshes with faces in one plane, facing the same way
 [{ a: "windmill/plinth [stone] @ (0, 0.1, 0)", b: "windmill/wall [plaster] @ (0, 0.5, 0)", triangles: 4 }]
 ```
 
+## From the command line
+
+Check exported models without writing any code:
+
+```sh
+npx @zkmake/three-audit assets/*.glb   # or bunx
+```
+
+```
+windmill.glb  4,812 triangles
+  ✗ 1 z-fighting pair
+      windmill/plinth [stone] @ (0, 0.1, 0)
+    ↔ windmill/wall [plaster] @ (0, 0.5, 0)  (4 triangles)
+  ✓ no NaN geometry
+  most triangles:
+          1,920  sails
+            …
+```
+
+It exits 1 when any model fails a check (2 when one can't be read), so it can gate CI. Options:
+`--gap <m>`, `--self`, `--skip <regex>` (leave out objects by name, e.g. decals), `--top <n>`,
+`--json`, `--no-fail`.
+
+`.glb` and `.gltf` (buffers beside it) both load. Textures are stripped first: no check reads them.
+Draco models need `draco3dgltf` installed and Meshopt models `meshoptimizer`
+(`npx -p @zkmake/three-audit -p draco3dgltf three-audit model.glb`).
+
+In a test, load a model the same way:
+
+```ts
+import { findZFighting } from "@zkmake/three-audit";
+import { loadModel } from "@zkmake/three-audit/node";
+
+test("windmill.glb has no z-fighting", async () => {
+  expect(findZFighting(await loadModel("assets/windmill.glb"))).toEqual([]);
+});
+```
+
+glTF is in metres, which is what `--gap`'s default assumes. Instanced meshes
+(`EXT_mesh_gpu_instancing`) aren't checked for z-fighting; skinned and morphing meshes are
+checked in their rest pose.
+
 ## In the console
 
 ```ts

package/dist/audit-scene-Cz1FZxhd.js

@@ -0,0 +1,414 @@
+//#region src/scene.ts
+/** 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;
+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));
+};
+/** Triangles a batch draws across its visible instances, and how many instances that is. */
+const batchedTriangles = (batch) => {
+	let triangles = 0;
+	let instances = 0;
+	for (let id = 0; id < batch.maxInstanceCount; id += 1) {
+		let geometryId;
+		try {
+			if (!batch.getVisibleAt(id)) continue;
+			geometryId = batch.getGeometryIdAt(id);
+		} catch {
+			continue;
+		}
+		const range = batch.getGeometryRangeAt(geometryId);
+		const elements = range.count ?? (batch.geometry.index ? range.indexCount : range.vertexCount);
+		triangles += Math.floor(elements / 3);
+		instances += 1;
+	}
+	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;
+};
+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;
+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(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;
+};
+//#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(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 = (root, options = {}) => {
+	const rows = [];
+	walk(root, {
+		skip: options.skip,
+		visibleOnly: true
+	}, (object) => {
+		if (!isMesh(object)) return;
+		const { instances, triangles } = cost(object);
+		const row = {
+			name: meshName(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. Batches are left out: their shared buffer is not one
+* geometry; `listMeshes` counts them.
+*/
+const geometryCensus = (root, options = {}) => {
+	const rows = /* @__PURE__ */ new Map();
+	walk(root, { skip: options.skip }, (object) => {
+		if (!isMesh(object) || isBatched(object) || !object.geometry.attributes.position) return;
+		const geometry = object.geometry;
+		const key = geometry.name || `${geometry.type}:${geometry.uuid.slice(0, 6)}`;
+		const triangles = triangleCount(geometry);
+		const uses = isInstanced(object) ? object.count : 1;
+		const row = rows.get(key) ?? {
+			geometry: key,
+			uses: 0,
+			triangles,
+			total: 0
+		};
+		row.uses += uses;
+		row.total += triangles * uses;
+		rows.set(key, row);
+	});
+	return [...rows.values()].sort((a, b) => b.total - a.total);
+};
+//#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) => Math.round(value * 100) / 100;
+const labelOf = (part) => {
+	const centre = part.min.map((low, axis) => round((low + part.max[axis]) / 2));
+	return `${part.tag === null ? "" : `${part.tag}/`}${meshName(part.mesh)} [${materialName(part.mesh)}] @ (${centre.join(", ")})`;
+};
+/** Pairs of meshes that z-fight, most overlapping triangles first. `[]` is a pass. */
+const findZFighting = (root, options = {}) => {
+	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 }, (object) => {
+		if (!isMesh(object) || isInstanced(object) || isBatched(object) || !object.geometry.attributes.position) return;
+		const tag = tagOf(object, tagKey);
+		if (tagged && tag === null) 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,
+			tag,
+			min,
+			max
+		});
+		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 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;
+		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;
+	};
+	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 || planes[s * 4] * planes[t * 4] + planes[s * 4 + 1] * planes[t * 4 + 1] + planes[s * 4 + 2] * planes[t * 4 + 2] < PARALLEL || Math.abs(planes[s * 4 + 3] - planes[t * 4 + 3]) > gap || !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
+			};
+			pair.triangles += 1;
+			pairs.set(key, pair);
+		}
+	}
+	return [...pairs.values()].sort((x, y) => y.triangles - x.triangles).map(({ a, b, triangles }) => withHidden({
+		a: labelOf(parts[a]),
+		b: labelOf(parts[b]),
+		triangles
+	}, "meshes", [parts[a].mesh, parts[b].mesh]));
+};
+//#endregion
+//#region src/audit-scene.ts
+/**
+* Every check at once, JSON-safe: what a test asserts on or a headless browser prints. A clean
+* scene has `zFighting` and `badGeometry` both `[]`.
+*/
+const auditScene = (root, options = {}) => {
+	const { skip, tagKey } = options;
+	return {
+		triangles: countTriangles(root, { skip }),
+		zFighting: findZFighting(root, options),
+		badGeometry: findBadGeometry(root, tagKey === void 0 ? { skip } : {
+			skip,
+			tagKey
+		}),
+		meshes: listMeshes(root, { skip }).slice(0, options.top ?? 10)
+	};
+};
+//#endregion
+export { listMeshes as a, geometryCensus as i, findZFighting as n, findBadGeometry as o, countTriangles as r, triangleCount as s, auditScene as t };
+
+//# sourceMappingURL=audit-scene-Cz1FZxhd.js.map

package/dist/audit-scene-Cz1FZxhd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-scene-Cz1FZxhd.js","names":[],"sources":["../src/scene.ts","../src/bad-geometry.ts","../src/triangles.ts","../src/z-fighting.ts","../src/audit-scene.ts"],"sourcesContent":["/**\n * Scene-graph plumbing every check shares: the walk, mesh kinds, triangle counts, tags and names.\n *\n * Nothing here imports three at runtime; objects are recognised by three's own `is*` flags, so the\n * checks work on whatever copy of three the app bundles.\n */\nimport type { BatchedMesh, BufferGeometry, InstancedMesh, Material, Mesh, Object3D } from \"three\";\n\n/** Leave an object and everything under it out of a check. */\nexport type Skip = (object: Object3D) => boolean;\n\nexport type WalkOptions = {\n  skip?: Skip | undefined;\n  /** Prune hidden objects and their subtrees, as the renderer does. */\n  visibleOnly?: boolean;\n};\n\n/** Depth-first, in child order. A skipped (or, with `visibleOnly`, hidden) object prunes its subtree. */\nexport const walk = (root: Object3D, options: WalkOptions, visit: (object: Object3D) => void) => {\n  const stack = [root];\n\n  while (stack.length > 0) {\n    const object = stack.pop()!;\n\n    if ((options.visibleOnly === true && !object.visible) || options.skip?.(object) === true) {\n      continue;\n    }\n\n    visit(object);\n\n    for (let i = object.children.length - 1; i >= 0; i -= 1) {\n      stack.push(object.children[i]!);\n    }\n  }\n};\n\nexport const isMesh = (object: Object3D): object is Mesh => (object as Mesh).isMesh === true;\n\nexport const isInstanced = (mesh: Mesh): mesh is InstancedMesh =>\n  (mesh as InstancedMesh).isInstancedMesh === true;\n\nexport const isBatched = (mesh: Mesh): mesh is BatchedMesh =>\n  (mesh as unknown as BatchedMesh).isBatchedMesh === true;\n\n/** Triangles one draw of this geometry makes: indexed or not, within its draw range. */\nexport const triangleCount = (geometry: BufferGeometry) => {\n  const elements = geometry.index?.count ?? geometry.attributes.position?.count ?? 0;\n  const { start, count } = geometry.drawRange;\n  const drawn = Math.min(elements, start + count) - start;\n\n  return Math.max(0, Math.floor(drawn / 3));\n};\n\n/** Triangles a batch draws across its visible instances, and how many instances that is. */\nexport const batchedTriangles = (batch: BatchedMesh) => {\n  let triangles = 0;\n  let instances = 0;\n\n  for (let id = 0; id < batch.maxInstanceCount; id += 1) {\n    let geometryId: number;\n\n    // Deleted and never-used ids throw.\n    try {\n      if (!batch.getVisibleAt(id)) {\n        continue;\n      }\n\n      geometryId = batch.getGeometryIdAt(id);\n    } catch {\n      continue;\n    }\n\n    const range = batch.getGeometryRangeAt(geometryId) as {\n      count?: number;\n      indexCount: number;\n      vertexCount: number;\n    };\n    const elements = range.count ?? (batch.geometry.index ? range.indexCount : range.vertexCount);\n\n    triangles += Math.floor(elements / 3);\n    instances += 1;\n  }\n\n  return { instances, triangles };\n};\n\n/** The tag of the nearest tagged ancestor (the object itself included), or `null`. */\nexport const tagOf = (object: Object3D, tagKey: string) => {\n  for (let at: Object3D | null = object; at; at = at.parent) {\n    const tag: unknown = at.userData[tagKey];\n\n    if (tag !== undefined && tag !== null) {\n      return String(tag);\n    }\n  }\n\n  return null;\n};\n\nexport const hasTag = (root: Object3D, tagKey: string, skip?: Skip) => {\n  let found = false;\n\n  walk(root, { skip }, (object) => {\n    found ||= object.userData[tagKey] !== undefined && object.userData[tagKey] !== null;\n  });\n\n  return found;\n};\n\nexport const meshName = (mesh: Mesh) => mesh.name || mesh.geometry.name || mesh.geometry.type;\n\nexport const materialName = (mesh: Mesh) => {\n  const material = (Array.isArray(mesh.material) ? mesh.material[0] : mesh.material) as\n    | Material\n    | undefined;\n\n  return material ? material.name || material.type : \"none\";\n};\n\n/** Adds a property JSON and `console.table` leave out: a live object that would serialise the scene. */\nexport const withHidden = <Row extends object, Key extends string, Value>(\n  row: Row,\n  key: Key,\n  value: Value,\n) => Object.defineProperty(row, key, { value, enumerable: false }) as Row & Record<Key, Value>;\n","/**\n * Geometry that lights a pixel NaN: a non-finite position or normal, or a zero-length normal on a\n * triangle with area. Bloom and other blurs spread one NaN pixel into a black block.\n */\nimport type { BufferGeometry, Mesh, Object3D } from \"three\";\n\nimport { isMesh, meshName, type Skip, tagOf, walk, withHidden } from \"./scene.ts\";\n\nexport type BadGeometryOptions = {\n  skip?: Skip | undefined;\n  /** `userData` key naming the part a mesh belongs to, for the `under` column. */\n  tagKey?: string;\n};\n\nexport type BadGeometryRow = {\n  mesh: string;\n  /** The tagged part it sits in, or its parent's name. */\n  under: string;\n  /** Vertices with a NaN or infinite position or normal component. */\n  nonFinite: number;\n  /** Vertices of triangles with area whose normal has no length. */\n  zeroNormals: number;\n  /** Not enumerable: kept out of JSON and `console.table`. */\n  readonly object: Mesh;\n};\n\nconst corner = (geometry: BufferGeometry, k: number) => geometry.index?.getX(k) ?? k;\n\nconst check = (geometry: BufferGeometry) => {\n  const position = geometry.attributes.position!;\n  const normal = geometry.attributes.normal;\n  const flagged = new Uint8Array(position.count);\n  let nonFinite = 0;\n  let zeroNormals = 0;\n\n  for (let v = 0; v < position.count; v += 1) {\n    const finite =\n      Number.isFinite(position.getX(v)) &&\n      Number.isFinite(position.getY(v)) &&\n      Number.isFinite(position.getZ(v)) &&\n      (!normal ||\n        (Number.isFinite(normal.getX(v)) &&\n          Number.isFinite(normal.getY(v)) &&\n          Number.isFinite(normal.getZ(v))));\n\n    if (!finite) {\n      flagged[v] = 1;\n      nonFinite += 1;\n    }\n  }\n\n  if (!normal) {\n    return { nonFinite, zeroNormals };\n  }\n\n  const corners = geometry.index?.count ?? position.count;\n\n  for (let k = 0; k + 2 < corners; k += 3) {\n    const a = corner(geometry, k);\n    const b = corner(geometry, k + 1);\n    const c = corner(geometry, k + 2);\n    const ux = position.getX(b) - position.getX(a);\n    const uy = position.getY(b) - position.getY(a);\n    const uz = position.getZ(b) - position.getZ(a);\n    const vx = position.getX(c) - position.getX(a);\n    const vy = position.getY(c) - position.getY(a);\n    const vz = position.getZ(c) - position.getZ(a);\n    const area = Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx);\n\n    if (!(area > 1e-8)) {\n      continue;\n    }\n\n    for (const v of [a, b, c]) {\n      if (flagged[v] === 0 && Math.hypot(normal.getX(v), normal.getY(v), normal.getZ(v)) < 1e-4) {\n        flagged[v] = 1;\n        zeroNormals += 1;\n      }\n    }\n  }\n\n  return { nonFinite, zeroNormals };\n};\n\n/** Meshes with geometry that renders NaN, hidden ones included. `[]` is a pass. */\nexport const findBadGeometry = (\n  root: Object3D,\n  options: BadGeometryOptions = {},\n): BadGeometryRow[] => {\n  const tagKey = options.tagKey ?? \"studioObject\";\n  const rows: BadGeometryRow[] = [];\n\n  walk(root, { skip: options.skip }, (object) => {\n    if (!isMesh(object) || !object.geometry.attributes.position) {\n      return;\n    }\n\n    const { nonFinite, zeroNormals } = check(object.geometry);\n\n    if (nonFinite > 0 || zeroNormals > 0) {\n      const under = tagOf(object, tagKey) ?? object.parent?.name ?? \"\";\n\n      rows.push(\n        withHidden({ mesh: meshName(object), under, nonFinite, zeroNormals }, \"object\", object),\n      );\n    }\n  });\n\n  return rows;\n};\n","/**\n * Where a triangle budget goes: the total one pass draws, the meshes drawing it, and the\n * geometries behind them.\n */\nimport type { Mesh, Object3D } from \"three\";\n\nimport {\n  batchedTriangles,\n  isBatched,\n  isInstanced,\n  isMesh,\n  meshName,\n  type Skip,\n  triangleCount,\n  walk,\n  withHidden,\n} from \"./scene.ts\";\n\nexport type TriangleOptions = { skip?: Skip | undefined };\n\nexport type MeshRow = {\n  name: string;\n  /** Triangles in one copy (a batch's average). */\n  triangles: number;\n  instances: number;\n  total: number;\n  /** Not enumerable: kept out of JSON and `console.table`. */\n  readonly mesh: Mesh;\n};\n\nexport type GeometryRow = {\n  /** `geometry.name`, or its type and the start of its uuid. */\n  geometry: string;\n  /** Copies drawn: every mesh using it, instances counted. */\n  uses: number;\n  triangles: number;\n  total: number;\n};\n\nconst cost = (mesh: Mesh) => {\n  if (isBatched(mesh)) {\n    return batchedTriangles(mesh);\n  }\n\n  const instances = isInstanced(mesh) ? mesh.count : 1;\n\n  return { instances, triangles: triangleCount(mesh.geometry) * instances };\n};\n\n/**\n * Triangles one pass draws: visible meshes, instances counted, no frustum culling. A shadow pass\n * adds roughly as much again for each shadow-casting light.\n */\nexport const countTriangles = (root: Object3D, options: TriangleOptions = {}) => {\n  let total = 0;\n\n  walk(root, { skip: options.skip, visibleOnly: true }, (object) => {\n    if (isMesh(object)) {\n      total += cost(object).triangles;\n    }\n  });\n\n  return total;\n};\n\n/** Every visible mesh, most triangles drawn first. */\nexport const listMeshes = (root: Object3D, options: TriangleOptions = {}): MeshRow[] => {\n  const rows: MeshRow[] = [];\n\n  walk(root, { skip: options.skip, visibleOnly: true }, (object) => {\n    if (!isMesh(object)) {\n      return;\n    }\n\n    const { instances, triangles } = cost(object);\n    const row = {\n      name: meshName(object),\n      triangles: instances > 0 ? Math.round(triangles / instances) : 0,\n      instances,\n      total: triangles,\n    };\n\n    rows.push(withHidden(row, \"mesh\", object));\n  });\n\n  return rows.sort((a, b) => b.total - a.total);\n};\n\n/**\n * Geometries by triangles drawn, hidden meshes included, most first. Name geometries\n * (`geometry.name`) to make this readable. Batches are left out: their shared buffer is not one\n * geometry; `listMeshes` counts them.\n */\nexport const geometryCensus = (root: Object3D, options: TriangleOptions = {}): GeometryRow[] => {\n  const rows = new Map<string, GeometryRow>();\n\n  walk(root, { skip: options.skip }, (object) => {\n    if (!isMesh(object) || isBatched(object) || !object.geometry.attributes.position) {\n      return;\n    }\n\n    const geometry = object.geometry;\n    const key = geometry.name || `${geometry.type}:${geometry.uuid.slice(0, 6)}`;\n    const triangles = triangleCount(geometry);\n    const uses = isInstanced(object) ? object.count : 1;\n    const row = rows.get(key) ?? { geometry: key, uses: 0, triangles, total: 0 };\n\n    row.uses += uses;\n    row.total += triangles * uses;\n    rows.set(key, row);\n  });\n\n  return [...rows.values()].sort((a, b) => b.total - a.total);\n};\n","/**\n * Z-fighting found by geometry instead of by eye: pairs of meshes with triangles in (nearly) one\n * plane, facing the same way, overlapping. Those flicker wherever depth precision runs out.\n *\n * Triangles are bucketed by their quantised plane (normal and offset), so only triangles in\n * neighbouring buckets are compared; overlap in the shared plane is a separating-axis test.\n */\nimport type { Mesh, Object3D } from \"three\";\n\nimport {\n  hasTag,\n  isBatched,\n  isInstanced,\n  isMesh,\n  materialName,\n  meshName,\n  type Skip,\n  tagOf,\n  walk,\n  withHidden,\n} from \"./scene.ts\";\n\nexport type ZFightingOptions = {\n  /**\n   * How close two planes count as one, in world units. 0.004 (4 mm at 1 unit = 1 m) is about what\n   * depth precision loses with a camera ~50 m out. Scale it with your units.\n   */\n  gap?: number;\n  /** Also compare triangles within one mesh: for merged geometry whose parts share a buffer. */\n  self?: boolean;\n  /**\n   * Only meshes inside a tagged object (`userData[tagKey]`), so a studio's ground and props stay\n   * out. Defaults to true when anything under the root is tagged, false otherwise.\n   */\n  tagged?: boolean;\n  tagKey?: string;\n  skip?: Skip | undefined;\n};\n\nexport type ZFightingRow = {\n  /** `tag/mesh [material] @ (x, y, z)`, the centre in world space. */\n  a: string;\n  b: string;\n  /** Overlapping triangle pairs between the two. */\n  triangles: number;\n  /** Not enumerable: kept out of JSON and `console.table`. */\n  readonly meshes: readonly [Mesh, Mesh];\n};\n\n/** Normals quantised to 1/40: neighbouring buckets are searched, so this only sets bucket size. */\nconst QUANT = 40;\n/** Normals this aligned count as parallel (about 2.6°). */\nconst PARALLEL = 0.999;\n\ntype Part = { mesh: Mesh; tag: string | null; min: number[]; max: number[] };\n\nconst round = (value: number) => Math.round(value * 100) / 100;\n\nconst labelOf = (part: Part) => {\n  const centre = part.min.map((low, axis) => round((low + part.max[axis]!) / 2));\n  const tag = part.tag === null ? \"\" : `${part.tag}/`;\n\n  return `${tag}${meshName(part.mesh)} [${materialName(part.mesh)}] @ (${centre.join(\", \")})`;\n};\n\n/** Pairs of meshes that z-fight, most overlapping triangles first. `[]` is a pass. */\nexport const findZFighting = (root: Object3D, options: ZFightingOptions = {}): ZFightingRow[] => {\n  const gap = options.gap ?? 0.004;\n  const self = options.self ?? false;\n  const tagKey = options.tagKey ?? \"studioObject\";\n  const tagged = options.tagged ?? hasTag(root, tagKey, options.skip);\n\n  root.updateWorldMatrix(true, true);\n\n  const parts: Part[] = [];\n  // Per triangle: its part, plane (nx, ny, nz, d) and world corners (9 numbers).\n  const owner: number[] = [];\n  const planes: number[] = [];\n  const corners: number[] = [];\n  const keys: [number, number, number, number][] = [];\n  const buckets = new Map<string, number[]>();\n  const keyOf = (x: number, y: number, z: number, d: number) => `${x},${y},${z},${d}`;\n\n  walk(root, { skip: options.skip }, (object) => {\n    if (\n      !isMesh(object) ||\n      isInstanced(object) ||\n      isBatched(object) ||\n      !object.geometry.attributes.position\n    ) {\n      return;\n    }\n\n    const tag = tagOf(object, tagKey);\n\n    if (tagged && tag === null) {\n      return;\n    }\n\n    const part = parts.length;\n    const { index, attributes } = object.geometry;\n    const position = attributes.position!;\n    const e = object.matrixWorld.elements;\n    const min = [Infinity, Infinity, Infinity];\n    const max = [-Infinity, -Infinity, -Infinity];\n    const count = index?.count ?? position.count;\n    const world = [0, 0, 0, 0, 0, 0, 0, 0, 0];\n\n    parts.push({ mesh: object, tag, min, max });\n\n    for (let k = 0; k + 2 < count; k += 3) {\n      for (let c = 0; c < 3; c += 1) {\n        const v = index?.getX(k + c) ?? k + c;\n        const x = position.getX(v);\n        const y = position.getY(v);\n        const z = position.getZ(v);\n\n        for (let axis = 0; axis < 3; axis += 1) {\n          const value = e[axis]! * x + e[axis + 4]! * y + e[axis + 8]! * z + e[axis + 12]!;\n\n          world[c * 3 + axis] = value;\n          min[axis] = Math.min(min[axis]!, value);\n          max[axis] = Math.max(max[axis]!, value);\n        }\n      }\n\n      const [ax, ay, az, bx, by, bz, cx, cy, cz] = world as [\n        number,\n        number,\n        number,\n        number,\n        number,\n        number,\n        number,\n        number,\n        number,\n      ];\n      const ux = bx - ax;\n      const uy = by - ay;\n      const uz = bz - az;\n      const vx = cx - ax;\n      const vy = cy - ay;\n      const vz = cz - az;\n      let nx = uy * vz - uz * vy;\n      let ny = uz * vx - ux * vz;\n      let nz = ux * vy - uy * vx;\n      const length = Math.hypot(nx, ny, nz);\n\n      // Slivers under ~1e-5 m² show nothing.\n      if (!(length / 2 >= 1e-5)) {\n        continue;\n      }\n\n      nx /= length;\n      ny /= length;\n      nz /= length;\n\n      const d = nx * ax + ny * ay + nz * az;\n      const id = owner.length;\n      const key: [number, number, number, number] = [\n        Math.round(nx * QUANT),\n        Math.round(ny * QUANT),\n        Math.round(nz * QUANT),\n        Math.round(d / gap),\n      ];\n      const bucket = buckets.get(keyOf(...key));\n\n      owner.push(part);\n      planes.push(nx, ny, nz, d);\n      corners.push(...world);\n      keys.push(key);\n\n      if (bucket) {\n        bucket.push(id);\n      } else {\n        buckets.set(keyOf(...key), [id]);\n      }\n    }\n  });\n\n  // Overlap in s's plane, with a margin so triangles merely sharing an edge don't count.\n  const margin = gap / 2;\n  const flat = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n\n  const overlaps = (s: number, t: number) => {\n    const S = s * 9;\n    const T = t * 9;\n    let ux = corners[S + 3]! - corners[S]!;\n    let uy = corners[S + 4]! - corners[S + 1]!;\n    let uz = corners[S + 5]! - corners[S + 2]!;\n    const length = Math.hypot(ux, uy, uz) || 1;\n\n    ux /= length;\n    uy /= length;\n    uz /= length;\n\n    const nx = planes[s * 4]!;\n    const ny = planes[s * 4 + 1]!;\n    const nz = planes[s * 4 + 2]!;\n    const vx = ny * uz - nz * uy;\n    const vy = nz * ux - nx * uz;\n    const vz = nx * uy - ny * ux;\n\n    // Corners 0–2 are s, 3–5 are t, as (x, y) in the plane.\n    for (let i = 0; i < 6; i += 1) {\n      const at = i < 3 ? S + i * 3 : T + (i - 3) * 3;\n      const px = corners[at]!;\n      const py = corners[at + 1]!;\n      const pz = corners[at + 2]!;\n\n      flat[i * 2] = px * ux + py * uy + pz * uz;\n      flat[i * 2 + 1] = px * vx + py * vy + pz * vz;\n    }\n\n    for (let edge = 0; edge < 6; edge += 1) {\n      const from = edge;\n      const to = edge < 3 ? (edge + 1) % 3 : 3 + ((edge + 1) % 3);\n      const ex = flat[to * 2]! - flat[from * 2]!;\n      const ey = flat[to * 2 + 1]! - flat[from * 2 + 1]!;\n      const edgeLength = Math.hypot(ex, ey) || 1;\n      const axisX = -ey / edgeLength;\n      const axisY = ex / edgeLength;\n      let p0 = Infinity;\n      let p1 = -Infinity;\n      let q0 = Infinity;\n      let q1 = -Infinity;\n\n      for (let i = 0; i < 6; i += 1) {\n        const value = flat[i * 2]! * axisX + flat[i * 2 + 1]! * axisY;\n\n        if (i < 3) {\n          p0 = Math.min(p0, value);\n          p1 = Math.max(p1, value);\n        } else {\n          q0 = Math.min(q0, value);\n          q1 = Math.max(q1, value);\n        }\n      }\n\n      if (Math.min(p1, q1) - Math.max(p0, q0) < margin) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  const pairs = new Map<string, { a: number; b: number; triangles: number }>();\n\n  // Every neighbouring bucket, so near-equal planes that round apart still meet.\n  for (let s = 0; s < owner.length; s += 1) {\n    const [kx, ky, kz, kd] = keys[s]!;\n\n    for (let i = -1; i <= 1; i += 1) {\n      for (let j = -1; j <= 1; j += 1) {\n        for (let k = -1; k <= 1; k += 1) {\n          for (let l = -1; l <= 1; l += 1) {\n            for (const t of buckets.get(keyOf(kx + i, ky + j, kz + k, kd + l)) ?? []) {\n              const a = owner[s]!;\n              const b = owner[t]!;\n\n              if (\n                t <= s ||\n                (a === b && !self) ||\n                planes[s * 4]! * planes[t * 4]! +\n                  planes[s * 4 + 1]! * planes[t * 4 + 1]! +\n                  planes[s * 4 + 2]! * planes[t * 4 + 2]! <\n                  PARALLEL ||\n                Math.abs(planes[s * 4 + 3]! - planes[t * 4 + 3]!) > gap ||\n                !overlaps(s, t)\n              ) {\n                continue;\n              }\n\n              const key = a < b ? `${a}:${b}` : `${b}:${a}`;\n              const pair = pairs.get(key) ?? { a: Math.min(a, b), b: Math.max(a, b), triangles: 0 };\n\n              pair.triangles += 1;\n              pairs.set(key, pair);\n            }\n          }\n        }\n      }\n    }\n  }\n\n  return [...pairs.values()]\n    .sort((x, y) => y.triangles - x.triangles)\n    .map(({ a, b, triangles }) =>\n      withHidden({ a: labelOf(parts[a]!), b: labelOf(parts[b]!), triangles }, \"meshes\", [\n        parts[a]!.mesh,\n        parts[b]!.mesh,\n      ] as const),\n    );\n};\n","import type { Object3D } from \"three\";\n\nimport { type BadGeometryRow, findBadGeometry } from \"./bad-geometry.ts\";\nimport type { Skip } from \"./scene.ts\";\nimport { countTriangles, listMeshes, type MeshRow } from \"./triangles.ts\";\nimport { findZFighting, type ZFightingOptions, type ZFightingRow } from \"./z-fighting.ts\";\n\nexport type AuditSceneOptions = Pick<ZFightingOptions, \"gap\" | \"self\" | \"tagged\"> & {\n  skip?: Skip | undefined;\n  tagKey?: string;\n  /** How many of the costliest meshes to list. */\n  top?: number;\n};\n\nexport type AuditReport = {\n  triangles: number;\n  zFighting: ZFightingRow[];\n  badGeometry: BadGeometryRow[];\n  /** The costliest meshes, most triangles first. */\n  meshes: MeshRow[];\n};\n\n/**\n * Every check at once, JSON-safe: what a test asserts on or a headless browser prints. A clean\n * scene has `zFighting` and `badGeometry` both `[]`.\n */\nexport const auditScene = (root: Object3D, options: AuditSceneOptions = {}): AuditReport => {\n  const { skip, tagKey } = options;\n\n  return {\n    triangles: countTriangles(root, { skip }),\n    zFighting: findZFighting(root, options),\n    badGeometry: findBadGeometry(root, tagKey === undefined ? { skip } : { skip, tagKey }),\n    meshes: listMeshes(root, { skip }).slice(0, options.top ?? 10),\n  };\n};\n"],"mappings":"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"}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cli.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import { t as auditScene } from "./audit-scene-Cz1FZxhd.js";
+import { t as loadModel } from "./load-nqfCU3-k.js";
+import { basename } from "node:path";
+import { readFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+//#region src/cli/main.ts
+/**
+* `three-audit model.glb [more.gltf …]`: load each model in Node and check it for z-fighting and
+* NaN geometry. Exits 1 when a check fails, so it can gate CI; `--json` for machines.
+*/
+const HELP = `Usage: three-audit <model.glb|model.gltf>… [options]
+
+Checks glTF models for z-fighting (faces in one plane, facing the same way, overlapping) and
+geometry that renders NaN (non-finite positions or normals, zero-length normals). Exits 1 when
+any model fails a check, 2 when a model can't be read.
+
+Options:
+  --gap <m>       How close two planes count as one, in metres (default 0.004)
+  --self          Also check for z-fighting within each mesh (merged geometry)
+  --skip <regex>  Leave out objects whose name matches, and everything under them (decals)
+  --top <n>       List the n costliest meshes (default 5, 0 for none)
+  --json          Print the reports as JSON
+  --no-fail       Exit 0 even when a check fails
+  -h, --help      Show this help
+  -v, --version   Show the version
+
+Draco and Meshopt models need draco3dgltf / meshoptimizer installed alongside.`;
+/** This package's version: its package.json is the nearest one up from here (`src/cli` or `dist`). */
+const version = () => {
+	for (let up = "../"; up.length <= 12; up += "../") try {
+		const pkg = JSON.parse(readFileSync(new URL(`${up}package.json`, import.meta.url), "utf8"));
+		if (pkg.name === "@zkmake/three-audit") return pkg.version;
+	} catch {}
+	return "unknown";
+};
+const count = (value) => value.toLocaleString("en-US");
+const printReport = (file, report, top) => {
+	const lines = [`${basename(file)}  ${count(report.triangles)} triangles`];
+	if (report.zFighting.length === 0) lines.push("  ✓ no z-fighting");
+	else {
+		lines.push(`  ✗ ${report.zFighting.length} z-fighting pair${report.zFighting.length === 1 ? "" : "s"}`);
+		for (const row of report.zFighting) lines.push(`      ${row.a}`, `    ↔ ${row.b}  (${row.triangles} triangles)`);
+	}
+	if (report.badGeometry.length === 0) lines.push("  ✓ no NaN geometry");
+	else {
+		lines.push(`  ✗ ${report.badGeometry.length} mesh${report.badGeometry.length === 1 ? "" : "es"} with NaN geometry`);
+		for (const row of report.badGeometry) lines.push(`      ${row.mesh}${row.under ? ` (${row.under})` : ""}: ${row.nonFinite} non-finite, ${row.zeroNormals} zero normals`);
+	}
+	if (top > 0 && report.meshes.length > 0) {
+		lines.push("  most triangles:");
+		for (const row of report.meshes) lines.push(`      ${count(row.total).padStart(9)}  ${row.name}${row.instances > 1 ? ` ×${row.instances}` : ""}`);
+	}
+	return lines.join("\n");
+};
+const main = async (argv) => {
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args: argv,
+			allowPositionals: true,
+			options: {
+				gap: { type: "string" },
+				self: {
+					type: "boolean",
+					default: false
+				},
+				skip: { type: "string" },
+				top: { type: "string" },
+				json: {
+					type: "boolean",
+					default: false
+				},
+				"no-fail": {
+					type: "boolean",
+					default: false
+				},
+				help: {
+					type: "boolean",
+					short: "h",
+					default: false
+				},
+				version: {
+					type: "boolean",
+					short: "v",
+					default: false
+				}
+			}
+		});
+	} catch (error) {
+		console.error(`three-audit: ${error.message}\n\n${HELP}`);
+		return 2;
+	}
+	const { values, positionals } = parsed;
+	if (values.help) {
+		console.log(HELP);
+		return 0;
+	}
+	if (values.version) {
+		console.log(version());
+		return 0;
+	}
+	if (positionals.length === 0) {
+		console.error(HELP);
+		return 2;
+	}
+	const gap = values.gap === void 0 ? void 0 : Number(values.gap);
+	const top = values.top === void 0 ? 5 : Number(values.top);
+	if (gap !== void 0 && !(gap > 0) || !(top >= 0)) {
+		console.error("three-audit: --gap must be a positive number and --top zero or more");
+		return 2;
+	}
+	const skipPattern = values.skip === void 0 ? void 0 : new RegExp(values.skip);
+	const results = [];
+	for (const file of positionals) try {
+		const scene = await loadModel(file);
+		const report = auditScene(scene, {
+			top,
+			...gap === void 0 ? {} : { gap },
+			...values.self ? { self: true } : {},
+			...skipPattern ? { skip: (object) => skipPattern.test(object.name) } : {}
+		});
+		results.push({
+			file,
+			report
+		});
+	} catch (error) {
+		results.push({
+			file,
+			error: error.message
+		});
+	}
+	if (values.json) console.log(JSON.stringify(results, null, 2));
+	else console.log(results.map(({ file, report, error }) => report ? printReport(file, report, top) : `${basename(file)}\n  ✗ couldn't read: ${error}`).join("\n\n"));
+	if (results.some((result) => result.error !== void 0)) return 2;
+	return results.some(({ report }) => report.zFighting.length > 0 || report.badGeometry.length > 0) && !values["no-fail"] ? 1 : 0;
+};
+//#endregion
+//#region src/cli.ts
+/** The `three-audit` bin. The work is in `cli/main.ts`, which the tests import. */
+process.exitCode = await main(process.argv.slice(2));
+//#endregion
+
+//# sourceMappingURL=cli.js.map