@nodetool-ai/base-nodes 0.7.0-rc.23 → 0.8.2

package/dist/nodes/model3d/mesh-ops.js

@@ -1,775 +0,0 @@
-import { buildGlb, COMP_FLOAT, COMP_UNSIGNED_INT, glbGetIndexAccessor, glbGetVec3Accessor, glbReadIndices, glbReadVec3, glbUpdateMinMax, glbWriteIndices, glbWriteVec3, parseGlb } from "./glb.js";
-function buildSequentialIndices(vertexCount) {
-    const indices = new Uint32Array(vertexCount);
-    for (let i = 0; i < vertexCount; i++) {
-        indices[i] = i;
-    }
-    return indices;
-}
-function transformNormal(data, r00, r01, r02, r10, r11, r12, r20, r21, r22) {
-    for (let i = 0; i < data.length; i += 3) {
-        const x = data[i];
-        const y = data[i + 1];
-        const z = data[i + 2];
-        const nx = r00 * x + r01 * y + r02 * z;
-        const ny = r10 * x + r11 * y + r12 * z;
-        const nz = r20 * x + r21 * y + r22 * z;
-        const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
-        data[i] = nx / len;
-        data[i + 1] = ny / len;
-        data[i + 2] = nz / len;
-    }
-}
-function applyAxisPreset(data, axisPreset) {
-    if (axisPreset === "keep")
-        return;
-    for (let i = 0; i < data.length; i += 3) {
-        const x = data[i];
-        const y = data[i + 1];
-        const z = data[i + 2];
-        if (axisPreset === "z_to_y") {
-            data[i] = x;
-            data[i + 1] = z;
-            data[i + 2] = -y;
-        }
-        else {
-            data[i] = x;
-            data[i + 1] = -z;
-            data[i + 2] = y;
-        }
-    }
-}
-function computeBoundsAndCentroid(glb) {
-    let sumX = 0;
-    let sumY = 0;
-    let sumZ = 0;
-    let totalVerts = 0;
-    let minX = Infinity;
-    let minY = Infinity;
-    let minZ = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    let maxZ = -Infinity;
-    for (const mesh of glb.json.meshes ?? []) {
-        for (const primitive of mesh.primitives) {
-            const posIdx = primitive.attributes["POSITION"];
-            if (posIdx === undefined)
-                continue;
-            const position = glbGetVec3Accessor(glb.json, posIdx);
-            if (!position)
-                continue;
-            const data = glbReadVec3(glb.bin, position.acc, position.bv);
-            for (let i = 0; i < data.length; i += 3) {
-                sumX += data[i];
-                sumY += data[i + 1];
-                sumZ += data[i + 2];
-                minX = Math.min(minX, data[i]);
-                minY = Math.min(minY, data[i + 1]);
-                minZ = Math.min(minZ, data[i + 2]);
-                maxX = Math.max(maxX, data[i]);
-                maxY = Math.max(maxY, data[i + 1]);
-                maxZ = Math.max(maxZ, data[i + 2]);
-                totalVerts++;
-            }
-        }
-    }
-    return {
-        minX,
-        minY,
-        minZ,
-        maxX,
-        maxY,
-        maxZ,
-        centroidX: totalVerts > 0 ? sumX / totalVerts : 0,
-        centroidY: totalVerts > 0 ? sumY / totalVerts : 0,
-        centroidZ: totalVerts > 0 ? sumZ / totalVerts : 0,
-        totalVerts
-    };
-}
-function collectTriangleMeshData(glb) {
-    const positions = [];
-    const indices = [];
-    let vertexOffset = 0;
-    for (const mesh of glb.json.meshes ?? []) {
-        for (const primitive of mesh.primitives) {
-            const mode = primitive.mode ?? 4;
-            if (mode !== 4) {
-                continue;
-            }
-            const posIdx = primitive.attributes["POSITION"];
-            if (posIdx === undefined) {
-                continue;
-            }
-            const position = glbGetVec3Accessor(glb.json, posIdx);
-            if (!position) {
-                continue;
-            }
-            const primitivePositions = glbReadVec3(glb.bin, position.acc, position.bv);
-            positions.push(...primitivePositions);
-            let primitiveIndices;
-            if (primitive.indices !== undefined) {
-                const indexAccessor = glbGetIndexAccessor(glb.json, primitive.indices);
-                const read = indexAccessor &&
-                    glbReadIndices(glb.bin, indexAccessor.acc, indexAccessor.bv);
-                if (!read) {
-                    vertexOffset += position.acc.count;
-                    continue;
-                }
-                primitiveIndices = read;
-            }
-            else {
-                primitiveIndices = buildSequentialIndices(position.acc.count);
-            }
-            for (const index of primitiveIndices) {
-                indices.push(index + vertexOffset);
-            }
-            vertexOffset += position.acc.count;
-        }
-    }
-    return { positions, indices };
-}
-function buildTriangleOnlyGlb(positions, indices) {
-    const positionsArray = new Float32Array(positions);
-    const indicesArray = new Uint32Array(indices);
-    const positionBytes = new Uint8Array(positionsArray.buffer);
-    const indexBytes = new Uint8Array(indicesArray.buffer);
-    const min = [Infinity, Infinity, Infinity];
-    const max = [-Infinity, -Infinity, -Infinity];
-    for (let i = 0; i < positions.length; i += 3) {
-        for (let axis = 0; axis < 3; axis++) {
-            min[axis] = Math.min(min[axis], positions[i + axis]);
-            max[axis] = Math.max(max[axis], positions[i + axis]);
-        }
-    }
-    const json = {
-        asset: { version: "2.0" },
-        scenes: [{ nodes: [0] }],
-        scene: 0,
-        nodes: [{ mesh: 0 }],
-        meshes: [
-            {
-                primitives: [
-                    {
-                        attributes: { POSITION: 0 },
-                        indices: 1
-                    }
-                ]
-            }
-        ],
-        buffers: [{ byteLength: positionBytes.byteLength + indexBytes.byteLength }],
-        bufferViews: [
-            { buffer: 0, byteOffset: 0, byteLength: positionBytes.byteLength },
-            {
-                buffer: 0,
-                byteOffset: positionBytes.byteLength,
-                byteLength: indexBytes.byteLength
-            }
-        ],
-        accessors: [
-            {
-                bufferView: 0,
-                componentType: COMP_FLOAT,
-                count: positions.length / 3,
-                type: "VEC3",
-                min,
-                max
-            },
-            {
-                bufferView: 1,
-                componentType: COMP_UNSIGNED_INT,
-                count: indices.length,
-                type: "SCALAR"
-            }
-        ]
-    };
-    const bin = new Uint8Array(positionBytes.byteLength + indexBytes.byteLength);
-    bin.set(positionBytes, 0);
-    bin.set(indexBytes, positionBytes.byteLength);
-    return buildGlb(json, bin);
-}
-function compactTriangleMesh(mesh) {
-    const remap = new Map();
-    const positions = [];
-    const indices = [];
-    for (const sourceIndex of mesh.indices) {
-        if (!remap.has(sourceIndex)) {
-            const targetIndex = remap.size;
-            remap.set(sourceIndex, targetIndex);
-            positions.push(mesh.positions[sourceIndex * 3], mesh.positions[sourceIndex * 3 + 1], mesh.positions[sourceIndex * 3 + 2]);
-        }
-        indices.push(remap.get(sourceIndex));
-    }
-    return { positions, indices };
-}
-function quantizedKey(x, y, z, tolerance) {
-    if (tolerance <= 0) {
-        return `${x}:${y}:${z}`;
-    }
-    return [
-        Math.round(x / tolerance),
-        Math.round(y / tolerance),
-        Math.round(z / tolerance)
-    ].join(":");
-}
-function mergeDuplicateVertices(mesh, tolerance) {
-    const indexMap = new Map();
-    const remap = new Uint32Array(Math.floor(mesh.positions.length / 3));
-    const positions = [];
-    for (let i = 0; i < remap.length; i++) {
-        const x = mesh.positions[i * 3];
-        const y = mesh.positions[i * 3 + 1];
-        const z = mesh.positions[i * 3 + 2];
-        const key = quantizedKey(x, y, z, tolerance);
-        const existing = indexMap.get(key);
-        if (existing !== undefined) {
-            remap[i] = existing;
-            continue;
-        }
-        const next = Math.floor(positions.length / 3);
-        indexMap.set(key, next);
-        remap[i] = next;
-        positions.push(x, y, z);
-    }
-    const indices = mesh.indices.map((index) => remap[index]);
-    return compactTriangleMesh({ positions, indices });
-}
-function removeDegenerateFaces(mesh, tolerance) {
-    const keptIndices = [];
-    const areaThreshold = tolerance > 0 ? tolerance * tolerance : 0;
-    for (let i = 0; i < mesh.indices.length; i += 3) {
-        const a = mesh.indices[i];
-        const b = mesh.indices[i + 1];
-        const c = mesh.indices[i + 2];
-        if (a === b || b === c || a === c) {
-            continue;
-        }
-        const ax = mesh.positions[a * 3];
-        const ay = mesh.positions[a * 3 + 1];
-        const az = mesh.positions[a * 3 + 2];
-        const bx = mesh.positions[b * 3];
-        const by = mesh.positions[b * 3 + 1];
-        const bz = mesh.positions[b * 3 + 2];
-        const cx = mesh.positions[c * 3];
-        const cy = mesh.positions[c * 3 + 1];
-        const cz = mesh.positions[c * 3 + 2];
-        const abx = bx - ax;
-        const aby = by - ay;
-        const abz = bz - az;
-        const acx = cx - ax;
-        const acy = cy - ay;
-        const acz = cz - az;
-        const crossX = aby * acz - abz * acy;
-        const crossY = abz * acx - abx * acz;
-        const crossZ = abx * acy - aby * acx;
-        const areaSquared = crossX * crossX + crossY * crossY + crossZ * crossZ;
-        if (areaSquared <= areaThreshold) {
-            continue;
-        }
-        keptIndices.push(a, b, c);
-    }
-    return compactTriangleMesh({
-        positions: mesh.positions,
-        indices: keptIndices
-    });
-}
-export function transformGlb(bytes, options) {
-    const glb = parseGlb(bytes);
-    if (!glb)
-        return null;
-    const tx = options.translateX;
-    const ty = options.translateY;
-    const tz = options.translateZ;
-    const rx = (options.rotateXDeg * Math.PI) / 180;
-    const ry = (options.rotateYDeg * Math.PI) / 180;
-    const rz = (options.rotateZDeg * Math.PI) / 180;
-    const scX = options.scaleX * options.uniformScale;
-    const scY = options.scaleY * options.uniformScale;
-    const scZ = options.scaleZ * options.uniformScale;
-    const cx = Math.cos(rx);
-    const sx = Math.sin(rx);
-    const cy = Math.cos(ry);
-    const sy = Math.sin(ry);
-    const cz = Math.cos(rz);
-    const sz = Math.sin(rz);
-    const r00 = cy * cz;
-    const r01 = sx * sy * cz - cx * sz;
-    const r02 = cx * sy * cz + sx * sz;
-    const r10 = cy * sz;
-    const r11 = sx * sy * sz + cx * cz;
-    const r12 = cx * sy * sz - sx * cz;
-    const r20 = -sy;
-    const r21 = sx * cy;
-    const r22 = cx * cy;
-    for (const mesh of glb.json.meshes ?? []) {
-        for (const primitive of mesh.primitives) {
-            const posIdx = primitive.attributes["POSITION"];
-            if (posIdx !== undefined) {
-                const position = glbGetVec3Accessor(glb.json, posIdx);
-                if (position) {
-                    const data = glbReadVec3(glb.bin, position.acc, position.bv);
-                    for (let i = 0; i < data.length; i += 3) {
-                        const x = data[i] * scX;
-                        const y = data[i + 1] * scY;
-                        const z = data[i + 2] * scZ;
-                        data[i] = r00 * x + r01 * y + r02 * z + tx;
-                        data[i + 1] = r10 * x + r11 * y + r12 * z + ty;
-                        data[i + 2] = r20 * x + r21 * y + r22 * z + tz;
-                    }
-                    glbWriteVec3(glb.bin, position.acc, position.bv, data);
-                    glbUpdateMinMax(position.acc, data);
-                }
-            }
-            const normIdx = primitive.attributes["NORMAL"];
-            if (normIdx !== undefined) {
-                const normal = glbGetVec3Accessor(glb.json, normIdx);
-                if (normal) {
-                    const data = glbReadVec3(glb.bin, normal.acc, normal.bv);
-                    transformNormal(data, r00, r01, r02, r10, r11, r12, r20, r21, r22);
-                    glbWriteVec3(glb.bin, normal.acc, normal.bv, data);
-                }
-            }
-        }
-    }
-    return buildGlb(glb.json, glb.bin);
-}
-export function recalculateNormalsGlb(bytes, options) {
-    const glb = parseGlb(bytes);
-    if (!glb)
-        return null;
-    const mode = options.mode.toLowerCase();
-    for (const mesh of glb.json.meshes ?? []) {
-        for (const primitive of mesh.primitives) {
-            const posIdx = primitive.attributes["POSITION"];
-            const normIdx = primitive.attributes["NORMAL"];
-            if (posIdx === undefined || normIdx === undefined)
-                continue;
-            const position = glbGetVec3Accessor(glb.json, posIdx);
-            const normal = glbGetVec3Accessor(glb.json, normIdx);
-            if (!position || !normal || position.acc.count !== normal.acc.count) {
-                continue;
-            }
-            const pos = glbReadVec3(glb.bin, position.acc, position.bv);
-            const normals = new Float32Array(pos.length);
-            const vertexCount = position.acc.count;
-            let indices;
-            if (primitive.indices !== undefined) {
-                const indexAccessor = glbGetIndexAccessor(glb.json, primitive.indices);
-                if (indexAccessor) {
-                    indices =
-                        glbReadIndices(glb.bin, indexAccessor.acc, indexAccessor.bv) ??
-                            new Uint32Array(0);
-                }
-                else {
-                    indices = new Uint32Array(0);
-                }
-            }
-            else {
-                indices = buildSequentialIndices(vertexCount);
-            }
-            const triCount = Math.floor(indices.length / 3);
-            for (let t = 0; t < triCount; t++) {
-                const i0 = indices[t * 3];
-                const i1 = indices[t * 3 + 1];
-                const i2 = indices[t * 3 + 2];
-                const ax = pos[i1 * 3] - pos[i0 * 3];
-                const ay = pos[i1 * 3 + 1] - pos[i0 * 3 + 1];
-                const az = pos[i1 * 3 + 2] - pos[i0 * 3 + 2];
-                const bx = pos[i2 * 3] - pos[i0 * 3];
-                const by = pos[i2 * 3 + 1] - pos[i0 * 3 + 1];
-                const bz = pos[i2 * 3 + 2] - pos[i0 * 3 + 2];
-                const nx = ay * bz - az * by;
-                const ny = az * bx - ax * bz;
-                const nz = ax * by - ay * bx;
-                if (mode === "flat") {
-                    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
-                    for (const idx of [i0, i1, i2]) {
-                        normals[idx * 3] = nx / len;
-                        normals[idx * 3 + 1] = ny / len;
-                        normals[idx * 3 + 2] = nz / len;
-                    }
-                }
-                else {
-                    for (const idx of [i0, i1, i2]) {
-                        normals[idx * 3] += nx;
-                        normals[idx * 3 + 1] += ny;
-                        normals[idx * 3 + 2] += nz;
-                    }
-                }
-            }
-            if (mode !== "flat") {
-                for (let i = 0; i < normals.length; i += 3) {
-                    const len = Math.sqrt(normals[i] * normals[i] +
-                        normals[i + 1] * normals[i + 1] +
-                        normals[i + 2] * normals[i + 2]) || 1;
-                    normals[i] /= len;
-                    normals[i + 1] /= len;
-                    normals[i + 2] /= len;
-                }
-            }
-            glbWriteVec3(glb.bin, normal.acc, normal.bv, normals);
-            if (options.fixWinding && primitive.indices !== undefined) {
-                const indexAccessor = glbGetIndexAccessor(glb.json, primitive.indices);
-                if (indexAccessor) {
-                    const idx = glbReadIndices(glb.bin, indexAccessor.acc, indexAccessor.bv);
-                    if (idx) {
-                        let fixed = false;
-                        for (let t = 0; t < triCount; t++) {
-                            const i0 = idx[t * 3];
-                            const i1 = idx[t * 3 + 1];
-                            const i2 = idx[t * 3 + 2];
-                            const ax = pos[i1 * 3] - pos[i0 * 3];
-                            const ay = pos[i1 * 3 + 1] - pos[i0 * 3 + 1];
-                            const az = pos[i1 * 3 + 2] - pos[i0 * 3 + 2];
-                            const bx = pos[i2 * 3] - pos[i0 * 3];
-                            const by = pos[i2 * 3 + 1] - pos[i0 * 3 + 1];
-                            const bz = pos[i2 * 3 + 2] - pos[i0 * 3 + 2];
-                            const fnx = ay * bz - az * by;
-                            const fny = az * bx - ax * bz;
-                            const fnz = ax * by - ay * bx;
-                            const vn0 = normals[i0 * 3] * fnx +
-                                normals[i0 * 3 + 1] * fny +
-                                normals[i0 * 3 + 2] * fnz;
-                            if (vn0 < 0) {
-                                idx[t * 3 + 1] = i2;
-                                idx[t * 3 + 2] = i1;
-                                fixed = true;
-                            }
-                        }
-                        if (fixed) {
-                            glbWriteIndices(glb.bin, indexAccessor.acc, indexAccessor.bv, idx);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return buildGlb(glb.json, glb.bin);
-}
-export function centerGlb(bytes, options) {
-    const glb = parseGlb(bytes);
-    if (!glb)
-        return null;
-    let sumX = 0;
-    let sumY = 0;
-    let sumZ = 0;
-    let totalVerts = 0;
-    let minX = Infinity;
-    let minY = Infinity;
-    let minZ = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    let maxZ = -Infinity;
-    for (const mesh of glb.json.meshes ?? []) {
-        for (const primitive of mesh.primitives) {
-            const posIdx = primitive.attributes["POSITION"];
-            if (posIdx === undefined)
-                continue;
-            const position = glbGetVec3Accessor(glb.json, posIdx);
-            if (!position)
-                continue;
-            const data = glbReadVec3(glb.bin, position.acc, position.bv);
-            for (let i = 0; i < data.length; i += 3) {
-                sumX += data[i];
-                sumY += data[i + 1];
-                sumZ += data[i + 2];
-                minX = Math.min(minX, data[i]);
-                minY = Math.min(minY, data[i + 1]);
-                minZ = Math.min(minZ, data[i + 2]);
-                maxX = Math.max(maxX, data[i]);
-                maxY = Math.max(maxY, data[i + 1]);
-                maxZ = Math.max(maxZ, data[i + 2]);
-                totalVerts++;
-            }
-        }
-    }
-    if (totalVerts === 0) {
-        return buildGlb(glb.json, glb.bin);
-    }
-    let cx;
-    let cy;
-    let cz;
-    if (options.useCentroid) {
-        cx = sumX / totalVerts;
-        cy = sumY / totalVerts;
-        cz = sumZ / totalVerts;
-    }
-    else {
-        cx = (minX + maxX) / 2;
-        cy = (minY + maxY) / 2;
-        cz = (minZ + maxZ) / 2;
-    }
-    for (const mesh of glb.json.meshes ?? []) {
-        for (const primitive of mesh.primitives) {
-            const posIdx = primitive.attributes["POSITION"];
-            if (posIdx === undefined)
-                continue;
-            const position = glbGetVec3Accessor(glb.json, posIdx);
-            if (!position)
-                continue;
-            const data = glbReadVec3(glb.bin, position.acc, position.bv);
-            for (let i = 0; i < data.length; i += 3) {
-                data[i] -= cx;
-                data[i + 1] -= cy;
-                data[i + 2] -= cz;
-            }
-            glbWriteVec3(glb.bin, position.acc, position.bv, data);
-            glbUpdateMinMax(position.acc, data);
-        }
-    }
-    return buildGlb(glb.json, glb.bin);
-}
-export function flipNormalsGlb(bytes) {
-    const glb = parseGlb(bytes);
-    if (!glb)
-        return null;
-    for (const mesh of glb.json.meshes ?? []) {
-        for (const primitive of mesh.primitives) {
-            const normIdx = primitive.attributes["NORMAL"];
-            if (normIdx !== undefined) {
-                const normal = glbGetVec3Accessor(glb.json, normIdx);
-                if (normal) {
-                    const data = glbReadVec3(glb.bin, normal.acc, normal.bv);
-                    for (let i = 0; i < data.length; i++) {
-                        data[i] = -data[i];
-                    }
-                    glbWriteVec3(glb.bin, normal.acc, normal.bv, data);
-                }
-            }
-            if (primitive.indices !== undefined) {
-                const indexAccessor = glbGetIndexAccessor(glb.json, primitive.indices);
-                if (indexAccessor) {
-                    const idx = glbReadIndices(glb.bin, indexAccessor.acc, indexAccessor.bv);
-                    if (idx) {
-                        const triCount = Math.floor(idx.length / 3);
-                        for (let t = 0; t < triCount; t++) {
-                            const tmp = idx[t * 3 + 1];
-                            idx[t * 3 + 1] = idx[t * 3 + 2];
-                            idx[t * 3 + 2] = tmp;
-                        }
-                        glbWriteIndices(glb.bin, indexAccessor.acc, indexAccessor.bv, idx);
-                    }
-                }
-            }
-        }
-    }
-    return buildGlb(glb.json, glb.bin);
-}
-export function normalizeGlb(bytes, options) {
-    const glb = parseGlb(bytes);
-    if (!glb)
-        return null;
-    for (const mesh of glb.json.meshes ?? []) {
-        for (const primitive of mesh.primitives) {
-            const posIdx = primitive.attributes["POSITION"];
-            if (posIdx !== undefined) {
-                const position = glbGetVec3Accessor(glb.json, posIdx);
-                if (position) {
-                    const data = glbReadVec3(glb.bin, position.acc, position.bv);
-                    applyAxisPreset(data, options.axisPreset);
-                    glbWriteVec3(glb.bin, position.acc, position.bv, data);
-                    glbUpdateMinMax(position.acc, data);
-                }
-            }
-            const normIdx = primitive.attributes["NORMAL"];
-            if (normIdx !== undefined) {
-                const normal = glbGetVec3Accessor(glb.json, normIdx);
-                if (normal) {
-                    const data = glbReadVec3(glb.bin, normal.acc, normal.bv);
-                    applyAxisPreset(data, options.axisPreset);
-                    glbWriteVec3(glb.bin, normal.acc, normal.bv, data);
-                }
-            }
-        }
-    }
-    let summary = computeBoundsAndCentroid(glb);
-    if (summary.totalVerts === 0) {
-        return buildGlb(glb.json, glb.bin);
-    }
-    let translateX = 0;
-    let translateY = 0;
-    let translateZ = 0;
-    if (options.centerMode === "bounds") {
-        translateX = -((summary.minX + summary.maxX) / 2);
-        translateY = -((summary.minY + summary.maxY) / 2);
-        translateZ = -((summary.minZ + summary.maxZ) / 2);
-    }
-    else if (options.centerMode === "centroid") {
-        translateX = -summary.centroidX;
-        translateY = -summary.centroidY;
-        translateZ = -summary.centroidZ;
-    }
-    for (const mesh of glb.json.meshes ?? []) {
-        for (const primitive of mesh.primitives) {
-            const posIdx = primitive.attributes["POSITION"];
-            if (posIdx === undefined)
-                continue;
-            const position = glbGetVec3Accessor(glb.json, posIdx);
-            if (!position)
-                continue;
-            const data = glbReadVec3(glb.bin, position.acc, position.bv);
-            for (let i = 0; i < data.length; i += 3) {
-                data[i] += translateX;
-                data[i + 1] += translateY;
-                data[i + 2] += translateZ;
-            }
-            glbWriteVec3(glb.bin, position.acc, position.bv, data);
-            glbUpdateMinMax(position.acc, data);
-        }
-    }
-    summary = computeBoundsAndCentroid(glb);
-    const sizeX = summary.maxX - summary.minX;
-    const sizeY = summary.maxY - summary.minY;
-    const sizeZ = summary.maxZ - summary.minZ;
-    const longest = Math.max(sizeX, sizeY, sizeZ);
-    if (options.scaleToSize && options.targetSize > 0 && longest > 0) {
-        const scale = options.targetSize / longest;
-        for (const mesh of glb.json.meshes ?? []) {
-            for (const primitive of mesh.primitives) {
-                const posIdx = primitive.attributes["POSITION"];
-                if (posIdx !== undefined) {
-                    const position = glbGetVec3Accessor(glb.json, posIdx);
-                    if (position) {
-                        const data = glbReadVec3(glb.bin, position.acc, position.bv);
-                        for (let i = 0; i < data.length; i++) {
-                            data[i] *= scale;
-                        }
-                        glbWriteVec3(glb.bin, position.acc, position.bv, data);
-                        glbUpdateMinMax(position.acc, data);
-                    }
-                }
-            }
-        }
-    }
-    summary = computeBoundsAndCentroid(glb);
-    if (options.placeOnGround) {
-        const groundOffset = options.groundAxis === "y" ? -summary.minY : -summary.minZ;
-        for (const mesh of glb.json.meshes ?? []) {
-            for (const primitive of mesh.primitives) {
-                const posIdx = primitive.attributes["POSITION"];
-                if (posIdx === undefined)
-                    continue;
-                const position = glbGetVec3Accessor(glb.json, posIdx);
-                if (!position)
-                    continue;
-                const data = glbReadVec3(glb.bin, position.acc, position.bv);
-                for (let i = 0; i < data.length; i += 3) {
-                    if (options.groundAxis === "y") {
-                        data[i + 1] += groundOffset;
-                    }
-                    else {
-                        data[i + 2] += groundOffset;
-                    }
-                }
-                glbWriteVec3(glb.bin, position.acc, position.bv, data);
-                glbUpdateMinMax(position.acc, data);
-            }
-        }
-    }
-    return buildGlb(glb.json, glb.bin);
-}
-export function extractLargestComponentGlb(bytes) {
-    const glb = parseGlb(bytes);
-    if (!glb)
-        return null;
-    const mesh = collectTriangleMeshData(glb);
-    if (mesh.positions.length === 0 || mesh.indices.length === 0) {
-        return buildGlb(glb.json, glb.bin);
-    }
-    const vertexCount = Math.floor(mesh.positions.length / 3);
-    const parent = new Uint32Array(vertexCount);
-    const rank = new Uint8Array(vertexCount);
-    for (let i = 0; i < vertexCount; i++) {
-        parent[i] = i;
-    }
-    const find = (value) => {
-        let current = value;
-        while (parent[current] !== current) {
-            parent[current] = parent[parent[current]];
-            current = parent[current];
-        }
-        return current;
-    };
-    const union = (a, b) => {
-        const rootA = find(a);
-        const rootB = find(b);
-        if (rootA === rootB)
-            return;
-        if (rank[rootA] < rank[rootB]) {
-            parent[rootA] = rootB;
-        }
-        else if (rank[rootA] > rank[rootB]) {
-            parent[rootB] = rootA;
-        }
-        else {
-            parent[rootB] = rootA;
-            rank[rootA] += 1;
-        }
-    };
-    for (let i = 0; i < mesh.indices.length; i += 3) {
-        const a = mesh.indices[i];
-        const b = mesh.indices[i + 1];
-        const c = mesh.indices[i + 2];
-        union(a, b);
-        union(b, c);
-        union(a, c);
-    }
-    const faceCounts = new Map();
-    for (let i = 0; i < mesh.indices.length; i += 3) {
-        const root = find(mesh.indices[i]);
-        faceCounts.set(root, (faceCounts.get(root) ?? 0) + 1);
-    }
-    let largestRoot = -1;
-    let largestFaceCount = -1;
-    for (const [root, faceCount] of faceCounts.entries()) {
-        if (faceCount > largestFaceCount) {
-            largestRoot = root;
-            largestFaceCount = faceCount;
-        }
-    }
-    if (largestRoot < 0) {
-        return buildGlb(glb.json, glb.bin);
-    }
-    const remap = new Map();
-    const positions = [];
-    const indices = [];
-    for (let i = 0; i < mesh.indices.length; i += 3) {
-        const a = mesh.indices[i];
-        const b = mesh.indices[i + 1];
-        const c = mesh.indices[i + 2];
-        if (find(a) !== largestRoot)
-            continue;
-        for (const sourceIndex of [a, b, c]) {
-            if (!remap.has(sourceIndex)) {
-                const targetIndex = remap.size;
-                remap.set(sourceIndex, targetIndex);
-                positions.push(mesh.positions[sourceIndex * 3], mesh.positions[sourceIndex * 3 + 1], mesh.positions[sourceIndex * 3 + 2]);
-            }
-            indices.push(remap.get(sourceIndex));
-        }
-    }
-    if (positions.length === 0 || indices.length === 0) {
-        return buildGlb(glb.json, glb.bin);
-    }
-    return buildTriangleOnlyGlb(positions, indices);
-}
-export function repairGlb(bytes, options) {
-    const glb = parseGlb(bytes);
-    if (!glb)
-        return null;
-    const collected = collectTriangleMeshData(glb);
-    if (collected.positions.length === 0 || collected.indices.length === 0) {
-        return buildGlb(glb.json, glb.bin);
-    }
-    let repaired = collected;
-    if (options.mergeDuplicateVertices) {
-        repaired = mergeDuplicateVertices(repaired, Math.max(0, Number(options.positionTolerance) || 0));
-    }
-    if (options.removeDegenerateFaces) {
-        repaired = removeDegenerateFaces(repaired, Math.max(0, Number(options.positionTolerance) || 0));
-    }
-    if (repaired.positions.length === 0 || repaired.indices.length === 0) {
-        return buildGlb(glb.json, glb.bin);
-    }
-    return buildTriangleOnlyGlb(repaired.positions, repaired.indices);
-}
-//# sourceMappingURL=mesh-ops.js.map