brepjs 18.119.2 → 18.119.4

package/dist/originTrackingFns-fpEgTIwV.cjs

@@ -0,0 +1,226 @@
+const require_shapeTypes = require("./shapeTypes-CkcIL7zv.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-Bia7o8l_.cjs");
+const require_constants = require("./constants-BOVyEYGH.cjs");
+//#region src/topology/metadata/originTrackingFns.ts
+/**
+* Face origin tracking — tag faces with integer origins and propagate
+* them through kernel operations via ShapeEvolution records.
+*/
+/**
+* Tag all faces of a shape with an opaque integer origin.
+* Consumers assign meaning (e.g., source line number).
+*/
+function setShapeOrigin(shape, origin) {
+	const cache = require_topologyQueryFns.getOrCreateCache(shape);
+	const map = /* @__PURE__ */ new Map();
+	for (const hash of require_topologyQueryFns.subShapeHashes(shape, "face")) map.set(hash, origin);
+	cache.faceOrigins = map;
+}
+/**
+* Get the face origin map for a shape (faceHash → originTag).
+* Returns undefined if no origins have been set or propagated.
+*/
+function getFaceOrigins(shape) {
+	return require_topologyQueryFns.getCacheEntry(shape)?.faceOrigins;
+}
+/**
+* Propagate face origins using a kernel-provided ShapeEvolution record.
+*/
+function propagateOriginsFromEvolution(evolution, inputs, result) {
+	const inputOrigins = /* @__PURE__ */ new Map();
+	for (const input of inputs) {
+		const origins = getFaceOrigins(input);
+		if (!origins) continue;
+		for (const [hash, origin] of origins) inputOrigins.set(hash, origin);
+	}
+	if (inputOrigins.size === 0) return;
+	const resultMap = /* @__PURE__ */ new Map();
+	for (const [hash, origin] of inputOrigins) {
+		if (evolution.deleted.has(hash)) continue;
+		const modifiedHashes = evolution.modified.get(hash);
+		if (modifiedHashes && modifiedHashes.length > 0) for (const modHash of modifiedHashes) resultMap.set(modHash, origin);
+		else resultMap.set(hash, origin);
+		const generatedHashes = evolution.generated.get(hash);
+		if (generatedHashes) {
+			for (const genHash of generatedHashes) if (!resultMap.has(genHash)) resultMap.set(genHash, origin);
+		}
+	}
+	if (resultMap.size > 0) {
+		const cache = require_topologyQueryFns.getOrCreateCache(result);
+		cache.faceOrigins = resultMap;
+	}
+}
+/** Max 3D centroid separation (mm²) for a "near" match — the general case. */
+var MAX_MATCH_DIST_SQ = 100;
+/** Min |outNormal·inNormal| for two faces to count as sharing a plane's orientation. */
+var COPLANAR_NORMAL_MIN = .985;
+/**
+* Max squared perpendicular offset (mm²) from an input face's plane for the
+* output face to count as *coplanar* with it — i.e. a piece the boolean sliced
+* off that same planar surface. 0.1mm² tolerates kernel/mesh float noise while
+* still separating floors that sit even a fraction of a mm apart in depth.
+*/
+var COPLANAR_OFFSET_SQ = .1;
+/**
+* Find the best origin match for a result face by comparing normals and centroids
+* against input face signatures. Returns `undefined` if no good match exists.
+*
+* Two passes, near strictly preferred:
+*  1. Near match — same-facing normal (signed dot ≥ 0.707) and centroids within
+*     {@link MAX_MATCH_DIST_SQ}. The general case for regenerated seam faces
+*     (feature tops, flush walls). Unchanged legacy behavior. If any near match
+*     exists it wins outright — the coplanar pass never runs — so a distant
+*     coplanar candidate can't outscore a valid near one.
+*  2. Coplanar match (only when no near match, and only between PLANAR faces) —
+*     the output face lies on an input face's plane (parallel *or* antiparallel
+*     normal, tiny perpendicular offset) regardless of how far its centroid
+*     drifted in-plane. Two cases pass 1 misses:
+*       • A boolean that splits a large planar face — a wide cutout floor sliced
+*         by an overlapping deeper cutout — leaves pieces >10mm from the parent
+*         centroid (past pass 1's cutoff).
+*       • A cut flips the cavity face's normal versus the tool face it came from,
+*         so the floor is antiparallel to its origin's input face.
+*     Both left the surface tagless → body color in multi-color consumers
+*     (gridfinity GH #2443). The planar gate keeps a curved output face from
+*     inheriting an origin off an unrelated face that merely shares a sampled
+*     tangent plane; among coplanar candidates the nearest in-plane wins.
+*/
+function findBestOriginMatch(outNormal, outCentroid, outPlanar, inputSigs) {
+	let bestNearScore = -Infinity;
+	let bestNear;
+	for (const inp of inputSigs) {
+		const dot = outNormal[0] * inp.normal[0] + outNormal[1] * inp.normal[1] + outNormal[2] * inp.normal[2];
+		if (dot < .707) continue;
+		const dx = outCentroid[0] - inp.centroid[0];
+		const dy = outCentroid[1] - inp.centroid[1];
+		const dz = outCentroid[2] - inp.centroid[2];
+		const distSq = dx * dx + dy * dy + dz * dz;
+		if (distSq > MAX_MATCH_DIST_SQ) continue;
+		const score = dot - distSq / MAX_MATCH_DIST_SQ;
+		if (score > bestNearScore) {
+			bestNearScore = score;
+			bestNear = inp.origin;
+		}
+	}
+	if (bestNear !== void 0) return bestNear;
+	if (!outPlanar) return void 0;
+	let bestInPlaneSq = Infinity;
+	let bestCoplanar;
+	for (const inp of inputSigs) {
+		if (!inp.planar) continue;
+		const dot = outNormal[0] * inp.normal[0] + outNormal[1] * inp.normal[1] + outNormal[2] * inp.normal[2];
+		if (Math.abs(dot) < COPLANAR_NORMAL_MIN) continue;
+		const dx = outCentroid[0] - inp.centroid[0];
+		const dy = outCentroid[1] - inp.centroid[1];
+		const dz = outCentroid[2] - inp.centroid[2];
+		const perp = dx * inp.normal[0] + dy * inp.normal[1] + dz * inp.normal[2];
+		if (perp * perp > COPLANAR_OFFSET_SQ) continue;
+		const inPlaneSq = Math.max(0, dx * dx + dy * dy + dz * dz - perp * perp);
+		if (inPlaneSq < bestInPlaneSq) {
+			bestInPlaneSq = inPlaneSq;
+			bestCoplanar = inp.origin;
+		}
+	}
+	return bestCoplanar;
+}
+/**
+* Fallback origin propagation when no kernel op object is available
+* (native `fuseAll` / `cutAll`, which expose no ShapeEvolution record).
+*
+* Matches result faces to input faces by hash code first. Faces that pass
+* through the boolean unchanged keep their hash and recover their origin
+* directly. Faces the boolean *regenerates* (split, merged, or re-created at
+* the intersection) get a fresh hash that matches no input — these fall back
+* to geometric matching (normal + centroid) against the input face
+* signatures.
+*
+* The geometric pass runs for every unmatched face, not only when the hash
+* pass found nothing. A partial hash match is the common case for additive
+* features (pass-through side walls match by hash; the surfaces where the
+* tool meets the body — feature tops, flush walls — are regenerated and need
+* the geometric pass). Gating the fallback on "zero hash matches" left those
+* regenerated faces with no origin, so they fell back to 0 (body) at mesh
+* time — the multi-color export bug where a scoop/label/lip top printed in
+* the body color. Matching against the full signature set (body origin 0
+* included) keeps body faces body and feature faces feature.
+*/
+function propagateOriginsByHash(inputs, result) {
+	const lookup = /* @__PURE__ */ new Map();
+	for (const input of inputs) {
+		const origins = getFaceOrigins(input);
+		if (!origins) continue;
+		for (const [hash, origin] of origins) lookup.set(hash, origin);
+	}
+	if (lookup.size === 0) return;
+	const kernel = require_shapeTypes.getKernel();
+	const resultMap = /* @__PURE__ */ new Map();
+	const resultFaces = require_topologyQueryFns.getFaces(result);
+	const unmatched = [];
+	for (const f of resultFaces) {
+		const hash = kernel.hashCode(f.wrapped, require_constants.HASH_CODE_MAX);
+		const origin = lookup.get(hash);
+		if (origin !== void 0) resultMap.set(hash, origin);
+		else unmatched.push(f);
+	}
+	if (unmatched.length > 0) {
+		const inputSigs = [];
+		for (const input of inputs) {
+			const origins = getFaceOrigins(input);
+			if (!origins) continue;
+			for (const f of require_topologyQueryFns.getFaces(input)) {
+				const hash = kernel.hashCode(f.wrapped, require_constants.HASH_CODE_MAX);
+				const origin = origins.get(hash);
+				if (origin === void 0) continue;
+				try {
+					const bounds = kernel.uvBounds(f.wrapped);
+					const normal = kernel.surfaceNormal(f.wrapped, .5 * (bounds.uMin + bounds.uMax), .5 * (bounds.vMin + bounds.vMax));
+					const centroid = kernel.surfaceCenterOfMass(f.wrapped);
+					const planar = kernel.surfaceType(f.wrapped) === "plane";
+					inputSigs.push({
+						origin,
+						normal,
+						centroid,
+						planar
+					});
+				} catch {}
+			}
+		}
+		if (inputSigs.length > 0) for (const f of unmatched) {
+			const hash = kernel.hashCode(f.wrapped, require_constants.HASH_CODE_MAX);
+			try {
+				const outBounds = kernel.uvBounds(f.wrapped);
+				const bestOrigin = findBestOriginMatch(kernel.surfaceNormal(f.wrapped, .5 * (outBounds.uMin + outBounds.uMax), .5 * (outBounds.vMin + outBounds.vMax)), kernel.surfaceCenterOfMass(f.wrapped), kernel.surfaceType(f.wrapped) === "plane", inputSigs);
+				if (bestOrigin !== void 0) resultMap.set(hash, bestOrigin);
+			} catch {}
+		}
+	}
+	if (resultMap.size > 0) {
+		const cache = require_topologyQueryFns.getOrCreateCache(result);
+		cache.faceOrigins = resultMap;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "getFaceOrigins", {
+	enumerable: true,
+	get: function() {
+		return getFaceOrigins;
+	}
+});
+Object.defineProperty(exports, "propagateOriginsByHash", {
+	enumerable: true,
+	get: function() {
+		return propagateOriginsByHash;
+	}
+});
+Object.defineProperty(exports, "propagateOriginsFromEvolution", {
+	enumerable: true,
+	get: function() {
+		return propagateOriginsFromEvolution;
+	}
+});
+Object.defineProperty(exports, "setShapeOrigin", {
+	enumerable: true,
+	get: function() {
+		return setShapeOrigin;
+	}
+});

package/dist/{planeOps-Cp6GQ23-.js → planeOps-CQahLrCx.js}

@@ -1,4 +1,4 @@
-import { I as unwrap, O as ok, d as validationError, v as err } from "./errors-B3CDG537.js";
+import { E as ok, P as unwrap, d as validationError, g as err } from "./errors-MHLiNE-C.js";
 import { t as DEG2RAD } from "./constants-ITRzCnCp.js";
 import { r as toVec3 } from "./types-D24Y27N0.js";
 import { d as vecNormalize, h as vecScale, m as vecRotate, r as vecCross, s as vecIsZero, t as vecAdd } from "./vecOps-SKPRvPH-.js";

package/dist/{planeOps-Cr25KWWA.cjs → planeOps-VlFxtvzY.cjs}

@@ -1,4 +1,4 @@
-const require_errors = require("./errors-CJU8CHng.cjs");
+const require_errors = require("./errors-RHkKO5bZ.cjs");
 const require_constants = require("./constants-BOVyEYGH.cjs");
 const require_types = require("./types-KjA8tY4Y.cjs");
 const require_vecOps = require("./vecOps-CCnJt-yH.cjs");