@metamesh/modeling 0.0.0-bootstrap.0 → 0.6.0

package/dist/engine/profile-mesh.js

@@ -0,0 +1,279 @@
+import { GeometryError } from "../geometry/errors.js";
+import { loftFrame } from "../geometry/loft-options.js";
+import { assertMeshAllocationWithinLimits } from "../geometry/model-limits.js";
+import { writeMeshVertex } from "../geometry/numeric.js";
+import { normalizeRegion2, signedAreaLoop2 } from "../geometry/regions.js";
+import { assertSamplingCount } from "../geometry/sampling-limits.js";
+import { resolveSweepScales } from "../geometry/sweeps/options.js";
+import { computeSweepFrames, validateSweepOptions } from "../geometry/sweeps/orientation.js";
+import { planSweepStations, refineSweepStations } from "../geometry/sweeps/stations.js";
+import { normalizeSweepPath } from "../geometry/sweeps/validation.js";
+import { resolveGeometryTolerance } from "../geometry/tolerance.js";
+import { frameTransform3 } from "../geometry/transform3.js";
+const fail = (message) => {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "loft" });
+};
+const isArray = (value) => Array.isArray(value);
+const contourList = (profile) => profile.components.flatMap((component) => [component.outer, ...component.holes]);
+function profileMeshAllocation(first, stationCount, limits, closed) {
+    if (!isArray(first.components) || first.components.length === 0 || first.components.length > 1000)
+        fail("Matched profiles require one through 1000 identified components.");
+    const validIdentity = (id) => typeof id === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id) && id.length <= 64;
+    const componentIds = new Set();
+    for (const component of first.components) {
+        if (!validIdentity(component.id) || componentIds.has(component.id) || !isArray(component.holes))
+            fail("Matched component identities must be canonical and unique.");
+        componentIds.add(component.id);
+        const contourIds = new Set();
+        for (const contour of [component.outer, ...component.holes]) {
+            if (!validIdentity(contour.id) || contourIds.has(contour.id))
+                fail("Matched contour identities must be canonical and unique within a component.");
+            contourIds.add(contour.id);
+        }
+    }
+    const firstContours = contourList(first);
+    let logicalCount = 0;
+    for (const contour of firstContours) {
+        if (!isArray(contour.points) ||
+            !isArray(contour.spans) ||
+            contour.spans.some((span) => !validIdentity(span)) ||
+            contour.points.length !== contour.spans.length ||
+            contour.points.length < 3)
+            fail("Matched contours require at least three logical points and paired span identities.");
+        logicalCount += contour.points.length;
+    }
+    const maximumVertices = logicalCount * stationCount;
+    const capTriangles = 2 * (logicalCount + firstContours.length * 2);
+    const maximumTriangles = (closed ? stationCount : stationCount - 1) * logicalCount * 2 + (closed ? 0 : capTriangles);
+    assertSamplingCount(logicalCount, "loft", limits.maxProfilePoints);
+    assertMeshAllocationWithinLimits(maximumVertices, maximumTriangles, 12 * (maximumVertices + maximumTriangles), "loft", limits);
+    return { firstContours, maximumVertices, maximumTriangles };
+}
+/** Internal native hole-cap triangulation over copied, explicit matched logical slots. */
+export function buildProfileLoftMesh(module, stations, limits, closed = false, seamProfileOffset = 0, positionFor) {
+    if (!isArray(stations) || stations.length < (closed ? 3 : 2))
+        fail("Profile lofts require a bounded station array with two stations, or three for a closed path.");
+    assertSamplingCount(stations.length, "loft", limits.maxPathPoints);
+    const first = stations[0].profile;
+    const { firstContours, maximumVertices, maximumTriangles } = profileMeshAllocation(first, stations.length, limits, closed);
+    const positions = new Float32Array(maximumVertices * 3);
+    const indices = new Uint32Array(maximumTriangles * 3);
+    let vertexCount = 0, cursor = 0;
+    const physicalStations = stations.map((station, stationIndex) => {
+        const profile = station.profile;
+        if (!isArray(profile.components) || profile.components.length !== first.components.length)
+            fail("Matched component topology cannot change between stations.");
+        profile.components.forEach((component, index) => {
+            const expected = first.components[index];
+            if (component.id !== expected.id ||
+                !isArray(component.holes) ||
+                component.holes.length !== expected.holes.length)
+                fail("Matched component identities and hole counts must preserve their order.");
+        });
+        const transform = frameTransform3(loftFrame(station));
+        const physical = contourList(profile).map((contour, contourIndex) => {
+            const expected = firstContours[contourIndex];
+            if (contour.id !== expected.id ||
+                !isArray(contour.points) ||
+                !isArray(contour.spans) ||
+                contour.points.length !== expected.points.length ||
+                contour.spans.length !== expected.spans.length ||
+                contour.spans.some((span, index) => span !== expected.spans[index]))
+                fail("Matched contours must preserve identities, logical slots, and span order.");
+            const points = [], vertices = [], slots = [];
+            for (let slot = 0; slot < contour.points.length; slot++) {
+                const point = contour.points[slot];
+                if (!isArray(point) || point.length !== 2 || !point.every(Number.isFinite))
+                    fail("Matched profile points must be finite XY tuples.");
+                const [x, y] = point;
+                const placed = positionFor?.(stationIndex, contourIndex, slot);
+                const world = placed === undefined
+                    ? [
+                        Math.fround(transform[0] * x + transform[1] * y + transform[3]),
+                        Math.fround(transform[4] * x + transform[5] * y + transform[7]),
+                        Math.fround(transform[8] * x + transform[9] * y + transform[11]),
+                    ]
+                    : [Math.fround(placed[0]), Math.fround(placed[1]), Math.fround(placed[2])];
+                const previous = vertices.at(-1);
+                if (previous !== undefined &&
+                    world.every((value, axis) => value === positions[previous * 3 + axis])) {
+                    slots.push(previous);
+                }
+                else {
+                    writeMeshVertex(positions, vertexCount * 3, world, "loft");
+                    vertices.push(vertexCount);
+                    slots.push(vertexCount++);
+                    points.push([x, y]);
+                }
+            }
+            const start = vertices[0], end = vertices.at(-1);
+            if (start !== undefined &&
+                end !== undefined &&
+                start !== end &&
+                [0, 1, 2].every((axis) => positions[start * 3 + axis] === positions[end * 3 + axis])) {
+                slots.forEach((value, index) => {
+                    if (value === end)
+                        slots[index] = start;
+                });
+                vertices.pop();
+                points.pop();
+                vertexCount -= 1;
+            }
+            if (vertices.length < 3)
+                fail("Contours cannot collapse their filled topology at a station.");
+            return { points, vertices, slots };
+        });
+        const intermediateWorldGrid = positionFor !== undefined && stationIndex > 0 && stationIndex < stations.length - 1;
+        let contourIndex = 0;
+        const region = profile.components.map((component) => {
+            const outer = physical[contourIndex++];
+            if (!intermediateWorldGrid && !(signedAreaLoop2(outer.points) > 0))
+                fail("Matched outer contours must retain CCW winding.");
+            const holes = component.holes.map(() => {
+                const hole = physical[contourIndex++];
+                if (!intermediateWorldGrid && !(signedAreaLoop2(hole.points) < 0))
+                    fail("Matched hole contours must retain CW winding.");
+                return hole.points;
+            });
+            return { outer: outer.points, holes };
+        });
+        const normalized = intermediateWorldGrid ? [] : normalizeRegion2(region);
+        normalized.forEach((component, index) => {
+            if (component.outer.length !== region[index].outer.length ||
+                component.holes.some((hole, holeIndex) => hole.length !== region[index].holes[holeIndex].length))
+                fail("Profile features collapsed below the geometry tolerance; matching does not remove logical topology.");
+        });
+        return physical;
+    });
+    const triangle = (a, b, c) => {
+        if (a === b || b === c || c === a)
+            return;
+        const ax = positions[a * 3], ay = positions[a * 3 + 1], az = positions[a * 3 + 2];
+        const abx = positions[b * 3] - ax, aby = positions[b * 3 + 1] - ay, abz = positions[b * 3 + 2] - az;
+        const acx = positions[c * 3] - ax, acy = positions[c * 3 + 1] - ay, acz = positions[c * 3 + 2] - az;
+        if (aby * acz - abz * acy === 0 && abz * acx - abx * acz === 0 && abx * acy - aby * acx === 0)
+            return;
+        indices[cursor++] = a;
+        indices[cursor++] = b;
+        indices[cursor++] = c;
+    };
+    for (let station = 0; station < (closed ? stations.length : stations.length - 1); station += 1) {
+        const lower = physicalStations[station], upper = physicalStations[(station + 1) % stations.length];
+        lower.forEach((contour, contourIndex) => {
+            const paired = upper[contourIndex];
+            for (let index = 0; index < contour.slots.length; index += 1) {
+                const next = (index + 1) % contour.slots.length;
+                const advance = signedAreaLoop2(paired.points) < 0 ? -seamProfileOffset : seamProfileOffset;
+                const offset = closed && station === stations.length - 1
+                    ? ((advance % paired.slots.length) + paired.slots.length) % paired.slots.length
+                    : 0;
+                const pairedIndex = (index + offset) % paired.slots.length;
+                const pairedNext = (next + offset) % paired.slots.length;
+                triangle(contour.slots[index], contour.slots[next], paired.slots[pairedNext]);
+                triangle(contour.slots[index], paired.slots[pairedNext], paired.slots[pairedIndex]);
+            }
+        });
+    }
+    if (!closed) {
+        for (const [stationIndex, reverse] of [
+            [0, true],
+            [stations.length - 1, false],
+        ]) {
+            const physical = physicalStations[stationIndex];
+            let contourIndex = 0;
+            for (const component of first.components) {
+                const contours = physical.slice(contourIndex, contourIndex + component.holes.length + 1);
+                contourIndex += component.holes.length + 1;
+                const flat = contours.flatMap((contour) => contour.vertices);
+                const caps = module.triangulate(contours.map((contour) => contour.points.map(([x, y]) => [x, y])), 0, false);
+                for (const [a, b, c] of caps) {
+                    if (reverse)
+                        triangle(flat[a], flat[c], flat[b]);
+                    else
+                        triangle(flat[a], flat[b], flat[c]);
+                }
+            }
+        }
+    }
+    return { positions: positions.slice(0, vertexCount * 3), indices: indices.slice(0, cursor) };
+}
+/** Internal hollow sweep using explicit matched contours and transported right-handed frames. */
+export function buildProfileSweepMesh(module, profile, inputPath, options, limits) {
+    const closed = options.closed ?? false;
+    validateSweepOptions(options);
+    let path = normalizeSweepPath(inputPath, closed, "sweep", limits);
+    assertSamplingCount(contourList(profile).reduce((count, contour) => count + contour.points.length, 0), "sweep", limits.maxSweepProfilePoints);
+    profileMeshAllocation(profile, path.length, limits, closed);
+    let scales = resolveSweepScales(options.scale, path.length);
+    const twist = options.twistDegrees ?? 0;
+    if (!Number.isFinite(twist))
+        fail("Sweep twistDegrees must be finite.");
+    const seamProfileOffset = options.seamProfileOffset ?? 0;
+    if (!Number.isSafeInteger(seamProfileOffset) || (!closed && seamProfileOffset !== 0))
+        fail("A finite integer seamProfileOffset requires a closed path.");
+    if (closed) {
+        const [scaleX, scaleY] = scales[0];
+        const angle = (twist * Math.PI) / 180, cosine = Math.cos(angle), sine = Math.sin(angle);
+        for (const contour of contourList(profile)) {
+            const extent = contour.points.reduce((maximum, [x, y]) => Math.max(maximum, Math.abs(x * scaleX), Math.abs(y * scaleY)), 1);
+            const tolerance = resolveGeometryTolerance(extent).linear;
+            const advance = signedAreaLoop2(contour.points) < 0 ? -seamProfileOffset : seamProfileOffset;
+            const offset = ((advance % contour.points.length) + contour.points.length) % contour.points.length;
+            for (let index = 0; index < contour.points.length; index++) {
+                const [x, y] = contour.points[index], target = contour.points[(index + offset) % contour.points.length];
+                if (Math.hypot(x * scaleX * cosine - y * scaleY * sine - target[0] * scaleX, x * scaleX * sine + y * scaleY * cosine - target[1] * scaleY) > tolerance)
+                    fail("Sweep twist must match the explicit seam offset on every component and contour.");
+            }
+        }
+    }
+    if (twist !== 0) {
+        const plan = planSweepStations(contourList(profile).map((contour) => contour.points), path, scales, options);
+        profileMeshAllocation(profile, plan.stationCount, limits, closed);
+    }
+    let frames = computeSweepFrames(path, options);
+    let twists;
+    if (twist !== 0) {
+        const plan = planSweepStations(contourList(profile).map((contour) => contour.points), path, scales, options, frames);
+        profileMeshAllocation(profile, plan.stationCount, limits, closed);
+        const refined = refineSweepStations(path, scales, frames, options, plan);
+        path = refined.path;
+        scales = refined.scales;
+        frames = refined.frames;
+        twists = refined.twists;
+    }
+    const stations = path.map((origin, index) => {
+        const frame = frames[index];
+        const angle = twists?.[index] ??
+            (((twist * Math.PI) / 180) * index) / (closed ? path.length : path.length - 1), cosine = Math.cos(angle), sine = Math.sin(angle);
+        const combine = (a, b, ac, bc) => [
+            a[0] * ac + b[0] * bc,
+            a[1] * ac + b[1] * bc,
+            a[2] * ac + b[2] * bc,
+        ];
+        return {
+            profile: {
+                components: profile.components.map((component) => {
+                    const scaled = (contour) => ({
+                        ...contour,
+                        points: contour.points.map(([x, y]) => [
+                            x * scales[index][0],
+                            y * scales[index][1],
+                        ]),
+                    });
+                    return {
+                        ...component,
+                        outer: scaled(component.outer),
+                        holes: component.holes.map(scaled),
+                    };
+                }),
+            },
+            frame: {
+                origin,
+                xAxis: combine(frame.normal, frame.binormal, cosine, sine),
+                yAxis: combine(frame.normal, frame.binormal, -sine, cosine),
+                zAxis: frame.tangent,
+            },
+        };
+    });
+    return buildProfileLoftMesh(module, stations, limits, closed, seamProfileOffset);
+}

package/dist/engine/section-operations.js

@@ -0,0 +1,93 @@
+import { assertSamplingCount } from "../geometry/sampling-limits.js";
+import { preflightSvgRegion } from "../geometry/svg-import.js";
+import { parseSvgPath } from "../geometry/svg/index.js";
+import { sampleTextContours } from "../geometry/text-contours.js";
+import * as kernel from "./native/index.js";
+/** Internal host-bound section operations. */
+export function createSectionOperations(environment, transforms) {
+    const { module, limits, scope, assertActive, throwGeometryError, nativeSolid, nativeSection, wrapSection, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, assertOperandCount, withResolutionDefaults, resolveCircularSegments, } = environment;
+    const { translate } = transforms.operations;
+    const fromContours = (contours, value = {}) => {
+        assertActive();
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            throwGeometryError("INVALID_ARGUMENT", "sectionFromContours", "Options must be an object.");
+        assertOperandCount(contours, "sectionFromContours", 0);
+        let count = 0;
+        const copied = Array.from(contours, (contour) => {
+            if (!Array.isArray(contour) || contour.length < 3)
+                throwGeometryError("INVALID_ARGUMENT", "sectionFromContours", "Each contour needs at least three points.");
+            count += contour.length;
+            assertSamplingCount(count, "sectionFromContours", limits.maxProfilePoints);
+            return Array.from(contour, (point) => {
+                validateCoordinates(point, 2, "sectionFromContours");
+                return [point[0], point[1]];
+            });
+        });
+        if (value.fillRule !== undefined &&
+            value.fillRule !== "nonzero" &&
+            value.fillRule !== "evenodd")
+            throwGeometryError("INVALID_ARGUMENT", "sectionFromContours", "Unsupported fill rule.");
+        if (copied.length === 0)
+            return ownSection(module.CrossSection.union([]));
+        return ownSection(new module.CrossSection(copied, value.fillRule === "evenodd" ? "EvenOdd" : "NonZero"));
+    };
+    const operations = {
+        sectionFromContours: fromContours,
+        fromRegion: (region) => {
+            assertActive();
+            return wrapSection(kernel.regionToCrossSection(scope, region, limits));
+        },
+        toRegion: (handle) => {
+            const profile = environment.sectionProfileFor(handle);
+            const copiedLoop = (points) => Object.freeze(points.map(([x, y]) => Object.freeze([x, y])));
+            return Object.freeze(profile.components.map((component) => Object.freeze({
+                outer: copiedLoop(component.outer.points),
+                holes: Object.freeze(component.holes.map((contour) => copiedLoop(contour.points))),
+            })));
+        },
+        offset: (handle, distance, value = {}) => {
+            const native = nativeSection(handle);
+            validateFiniteNumber(distance, "offset");
+            const join = value.join ?? "round";
+            if (!["round", "miter", "square"].includes(join))
+                throwGeometryError("INVALID_ARGUMENT", "offset", "Unsupported offset join.");
+            if (value.miterLimit !== undefined)
+                requirePositiveNumber(value.miterLimit, "offset");
+            return ownSection(native.offset(distance, join === "round" ? "Round" : join === "miter" ? "Miter" : "Square", value.miterLimit, resolveCircularSegments(Math.max(Math.abs(distance), 0.001), {
+                ...(value.circularSegments === undefined ? {} : { segments: value.circularSegments }),
+                ...(value.resolution === undefined ? {} : { resolution: value.resolution }),
+            })));
+        },
+        projectSection: (value) => ownSection(nativeSolid(value).project()),
+        sliceSection: (value, z) => ownSection(nativeSolid(value).slice(validateFiniteNumber(z, "sliceSection"))),
+        textSection: (layout, value = {}) => {
+            const selected = withResolutionDefaults(value);
+            return fromContours(sampleTextContours(layout, selected.resolution, selected.limits));
+        },
+        svgSection: (svg, value = {}) => {
+            let result = wrapSection(kernel.regionToCrossSection(scope, preflightSvgRegion(svg, { ...withResolutionDefaults(value), origin: "document" }).region, limits));
+            if ((value.origin ?? "center") === "center") {
+                const bounds = nativeSection(result).bounds();
+                result = translate(result, [
+                    -(bounds.min[0] + bounds.max[0]) / 2,
+                    -(bounds.min[1] + bounds.max[1]) / 2,
+                ]);
+            }
+            return result;
+        },
+        svgPathSection: (path, value = {}) => {
+            const parsed = parseSvgPath(path, withResolutionDefaults(value));
+            const filled = parsed.groups.map((group) => fromContours(group.contours, { fillRule: group.fillRule }));
+            let result = ownSection(module.CrossSection.union(filled.map(nativeSection)));
+            if ((value.origin ?? "center") === "center") {
+                const bounds = nativeSection(result).bounds();
+                result = translate(result, [
+                    -(bounds.min[0] + bounds.max[0]) / 2,
+                    -(bounds.min[1] + bounds.max[1]) / 2,
+                ]);
+            }
+            return result;
+        },
+    };
+    return operations;
+}

package/dist/engine/shape-anchors.js

@@ -0,0 +1,88 @@
+import { createAnchor3 } from "../geometry/anchors.js";
+import { GeometryError } from "../geometry/errors.js";
+import { applyTransformDirection3, applyTransformPoint3, inverseTransform3, } from "../geometry/transform3.js";
+const maximumAnchors = 128;
+function fail(operation, message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation });
+}
+function anchorName(name, operation) {
+    if (typeof name !== "string" || name.length > 64 || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name))
+        fail(operation, "Anchor names must use lowercase kebab-case and at most 64 characters.");
+}
+function copyAnchor(anchor, operation) {
+    if (typeof anchor !== "object" || anchor === null)
+        fail(operation, "Anchor definitions require position, direction and up vectors.");
+    for (const vector of [anchor.position, anchor.direction, anchor.up])
+        if (!Array.isArray(vector) || vector.length !== 3 || !vector.every(Number.isFinite))
+            fail(operation, "Anchor vectors must contain exactly three finite coordinates.");
+    return createAnchor3(anchor.position, anchor.direction, anchor.up);
+}
+function unit(vector) {
+    const maximum = Math.max(...vector.map(Math.abs));
+    if (!Number.isFinite(maximum) || maximum === 0)
+        fail("transform", "Transformed anchor directions must remain finite and nonzero.");
+    const scaled = [vector[0] / maximum, vector[1] / maximum, vector[2] / maximum];
+    const length = Math.hypot(...scaled);
+    return [scaled[0] / length, scaled[1] / length, scaled[2] / length];
+}
+/** Maps positions affinely, outward normals by inverse transpose, and roll tangents linearly. */
+function transformedAnchor(anchor, matrix, inverse) {
+    const normal = anchor.direction;
+    const direction = [
+        inverse[0] * normal[0] + inverse[4] * normal[1] + inverse[8] * normal[2],
+        inverse[1] * normal[0] + inverse[5] * normal[1] + inverse[9] * normal[2],
+        inverse[2] * normal[0] + inverse[6] * normal[1] + inverse[10] * normal[2],
+    ];
+    return createAnchor3(applyTransformPoint3(matrix, anchor.position), unit(direction), unit(applyTransformDirection3(matrix, anchor.up)));
+}
+/** Run-owned immutable anchor metadata. Geometry operations acquire metadata only deliberately. */
+export function createShapeAnchorOwner(assertShape, aliasShape) {
+    const anchors = new Map();
+    const remember = (shape, definitions) => {
+        assertShape(shape);
+        if (typeof definitions !== "object" || definitions === null || Array.isArray(definitions))
+            fail("withAnchors", "Named anchors require an object of anchor definitions.");
+        const entries = Object.entries(definitions);
+        if (entries.length > maximumAnchors)
+            fail("withAnchors", `A shape may define at most ${maximumAnchors} anchors.`);
+        const copied = entries.map(([name, value]) => {
+            anchorName(name, "withAnchors");
+            return [name, copyAnchor(value, "withAnchors")];
+        });
+        anchors.set(shape, Object.freeze(Object.fromEntries(copied)));
+        return shape;
+    };
+    return {
+        remember,
+        anchor(shape, name) {
+            assertShape(shape);
+            anchorName(name, "anchor");
+            const definitions = anchors.get(shape);
+            if (definitions !== undefined && Object.hasOwn(definitions, name))
+                return definitions[name];
+            const available = Object.keys(definitions ?? {});
+            return fail("anchor", `Shape has no anchor "${name}".${available.length === 0 ? " Define named anchors explicitly for constructed or Boolean geometry." : ` Available anchors: ${available.join(", ")}.`}`);
+        },
+        withAnchors(shape, definitions) {
+            assertShape(shape);
+            if (typeof definitions !== "object" || definitions === null || Array.isArray(definitions))
+                fail("withAnchors", "Named anchors require an object of anchor definitions.");
+            return remember(aliasShape(shape), { ...anchors.get(shape), ...definitions });
+        },
+        preserve(source, result, matrix) {
+            assertShape(source);
+            assertShape(result);
+            const definitions = anchors.get(source);
+            if (definitions === undefined)
+                return result;
+            const inverse = inverseTransform3(matrix);
+            return remember(result, Object.fromEntries(Object.entries(definitions).map(([name, value]) => [
+                name,
+                transformedAnchor(value, matrix, inverse),
+            ])));
+        },
+        dispose() {
+            anchors.clear();
+        },
+    };
+}