@flighthq/mesh 0.3.0 → 0.3.1-next.1041.35b950c

package/dist/meshGeometryCompute.js

@@ -1,11 +1,12 @@
 import { createAabb } from '@flighthq/geometry/contract';
 import { EntityRuntimeKey } from '@flighthq/types/contract';
+import { getMeshGeometryTriangleCount, getMeshGeometryTriangleVertexIndices } from './meshGeometryOperations';
 // Per-vertex compute over the canonical interleaved PBR record: position(3) + normal(3) +
 // tangent(4) + uv0(2) = 12 floats / 48 bytes, stride read from geometry.layout. These functions
 // derive normals, tangents, and the local-space AABB from `geometry.vertices` (+ `geometry.indices`)
 // and write into `out`. They read every input field they need into locals before writing, so each
 // is safe when `out` aliases `geometry`. Normals write back in place; tangents do too unless an
-// indexed UV-frame seam requires complete interleaved vertex records to be duplicated first.
+// indexed mirrored-UV seam requires complete interleaved vertex records to be duplicated first.
 // Writes the bounding sphere of all vertex positions into `out`. Uses the AABB midpoint as the
 // center (fast, not minimal) and max-distance from that center as the radius. An empty vertex
 // stream yields center = (0,0,0) and a negative radius (empty convention). The radius is always
@@ -102,13 +103,17 @@ export function computeMeshGeometryBounds(out, geometry) {
 export function computeMeshGeometryFlatNormals(out, geometry) {
     const srcVerts = geometry.vertices;
     const floatsPerVertex = geometry.layout.stride / 4;
-    const indices = geometry.indices;
-    const indexCount = indices ? indices.length : floatsPerVertex > 0 ? Math.floor(srcVerts.length / floatsPerVertex) : 0;
     const dstVerts = out.vertices;
-    for (let t = 0; t + 2 < indexCount; t += 3) {
-        const i0 = indices ? indices[t] : t;
-        const i1 = indices ? indices[t + 1] : t + 1;
-        const i2 = indices ? indices[t + 2] : t + 2;
+    // Decode through the shared triangle walker so triangle-strip topology is honoured; hand-decoding
+    // index triples silently drops every strip triangle after the first.
+    const triangleCount = getMeshGeometryTriangleCount(geometry);
+    const corner = { i0: 0, i1: 0, i2: 0 };
+    for (let triangle = 0; triangle < triangleCount; triangle++) {
+        if (!getMeshGeometryTriangleVertexIndices(corner, geometry, triangle))
+            continue;
+        const i0 = corner.i0;
+        const i1 = corner.i1;
+        const i2 = corner.i2;
         const p0 = i0 * floatsPerVertex + POSITION_OFFSET;
         const p1 = i1 * floatsPerVertex + POSITION_OFFSET;
         const p2 = i2 * floatsPerVertex + POSITION_OFFSET;
@@ -146,26 +151,25 @@ export function computeMeshGeometryFlatNormals(out, geometry) {
 // Recomputes per-vertex smooth normals by area-weighted accumulation of triangle face normals
 // (right-handed, CCW front-face), normalizes them, and writes them into the normal slot of
 // `out.vertices`. Operates on indexed triangle-list geometry; non-indexed streams are treated as
-// sequential triangles. `out` is normally `geometry` itself (in-place), which is safe: positions
-// are only read and normals are accumulated in a scratch buffer before any write-back.
-export function computeMeshGeometryNormals(out, geometry) {
+// sequential triangles. When `positionGroups` is present, it must contain one canonical vertex
+// index per vertex; face normals accumulate into those groups before normalization and every member
+// reads back from its group. The opt-in map avoids smoothing unrelated surfaces that merely happen
+// to meet at the same position. `out` is normally `geometry` itself (in-place), which is safe:
+// positions are only read and normals are accumulated in a scratch buffer before any write-back.
+export function computeMeshGeometryNormals(out, geometry, positionGroups = null) {
     const vertices = geometry.vertices;
     const floatsPerVertex = geometry.layout.stride / 4;
     const vertexCount = floatsPerVertex > 0 ? Math.floor(vertices.length / floatsPerVertex) : 0;
-    const indices = geometry.indices;
-    const indexCount = indices ? indices.length : vertexCount;
-    const runtime = geometry[EntityRuntimeKey];
-    const recordedSmoothingSources = runtime?.tangentSmoothingSources;
-    const smoothingSources = recordedSmoothingSources !== null &&
-        recordedSmoothingSources !== undefined &&
-        recordedSmoothingSources.length === vertexCount
-        ? recordedSmoothingSources
-        : null;
     const accum = new Float64Array(vertexCount * 3);
-    for (let t = 0; t + 2 < indexCount; t += 3) {
-        const i0 = indices ? indices[t] : t;
-        const i1 = indices ? indices[t + 1] : t + 1;
-        const i2 = indices ? indices[t + 2] : t + 2;
+    // Same shared walker as the flat pass, for the same reason.
+    const triangleCount = getMeshGeometryTriangleCount(geometry);
+    const corner = { i0: 0, i1: 0, i2: 0 };
+    for (let triangle = 0; triangle < triangleCount; triangle++) {
+        if (!getMeshGeometryTriangleVertexIndices(corner, geometry, triangle))
+            continue;
+        const i0 = corner.i0;
+        const i1 = corner.i1;
+        const i2 = corner.i2;
         const b0 = i0 * floatsPerVertex + POSITION_OFFSET;
         const b1 = i1 * floatsPerVertex + POSITION_OFFSET;
         const b2 = i2 * floatsPerVertex + POSITION_OFFSET;
@@ -179,14 +183,14 @@ export function computeMeshGeometryNormals(out, geometry) {
         const nx = e1y * e2z - e1z * e2y;
         const ny = e1z * e2x - e1x * e2z;
         const nz = e1x * e2y - e1y * e2x;
-        accumulateNormal(accum, smoothingSources ? smoothingSources[i0] : i0, nx, ny, nz);
-        accumulateNormal(accum, smoothingSources ? smoothingSources[i1] : i1, nx, ny, nz);
-        accumulateNormal(accum, smoothingSources ? smoothingSources[i2] : i2, nx, ny, nz);
+        accumulateNormal(accum, positionGroups === null ? i0 : positionGroups[i0], nx, ny, nz);
+        accumulateNormal(accum, positionGroups === null ? i1 : positionGroups[i1], nx, ny, nz);
+        accumulateNormal(accum, positionGroups === null ? i2 : positionGroups[i2], nx, ny, nz);
     }
     const target = out.vertices;
     for (let i = 0; i < vertexCount; i++) {
-        const source = smoothingSources ? smoothingSources[i] : i;
-        let nx = accum[source * 3], ny = accum[source * 3 + 1], nz = accum[source * 3 + 2];
+        const accumulated = (positionGroups === null ? i : positionGroups[i]) * 3;
+        let nx = accum[accumulated], ny = accum[accumulated + 1], nz = accum[accumulated + 2];
         const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
         if (len > 0) {
             nx /= len;
@@ -198,212 +202,196 @@ export function computeMeshGeometryNormals(out, geometry) {
         target[base + 1] = ny;
         target[base + 2] = nz;
     }
+    out.version++;
+}
+// Returns one canonical representative index per vertex, grouping only vertices whose three stored
+// Float32 position components are bit-identical. Other attributes do not participate, and no
+// tolerance is applied. The first vertex encountered at a position is its canonical representative.
+export function computeMeshGeometryPositionGroups(geometry) {
+    const vertices = geometry.vertices;
+    const floatsPerVertex = geometry.layout.stride / 4;
+    const vertexCount = floatsPerVertex > 0 ? Math.floor(vertices.length / floatsPerVertex) : 0;
+    const groups = new Uint32Array(vertexCount);
+    const bits = new Uint32Array(vertices.buffer, vertices.byteOffset, vertices.length);
+    const buckets = new Map();
+    for (let vertex = 0; vertex < vertexCount; vertex++) {
+        const position = vertex * floatsPerVertex + POSITION_OFFSET;
+        const hash = hashMeshGeometryPosition(bits[position], bits[position + 1], bits[position + 2]);
+        let bucket = buckets.get(hash);
+        let representative = vertex;
+        if (bucket === undefined) {
+            bucket = [];
+            buckets.set(hash, bucket);
+        }
+        else {
+            for (const candidate of bucket) {
+                const candidatePosition = candidate * floatsPerVertex + POSITION_OFFSET;
+                if (bits[position] === bits[candidatePosition] &&
+                    bits[position + 1] === bits[candidatePosition + 1] &&
+                    bits[position + 2] === bits[candidatePosition + 2]) {
+                    representative = candidate;
+                    break;
+                }
+            }
+        }
+        groups[vertex] = representative;
+        if (representative === vertex)
+            bucket.push(vertex);
+    }
+    return groups;
 }
-function accumulateNormal(accumulator, vertex, nx, ny, nz) {
+function accumulateNormal(accum, vertex, nx, ny, nz) {
     const base = vertex * 3;
-    accumulator[base] += nx;
-    accumulator[base + 1] += ny;
-    accumulator[base + 2] += nz;
+    accum[base] += nx;
+    accum[base + 1] += ny;
+    accum[base + 2] += nz;
+}
+function hashMeshGeometryPosition(x, y, z) {
+    let hash = 0x811c9dc5;
+    hash = Math.imul(hash ^ x, 0x01000193);
+    hash = Math.imul(hash ^ y, 0x01000193);
+    hash = Math.imul(hash ^ z, 0x01000193);
+    return hash >>> 0;
 }
-// Recomputes a tangent basis from positions, normals, and uv0 with Flight-owned, dependency-free
-// vector math. Each corner contributes a normalized tangent weighted by its geometric corner angle,
-// preventing a tiny or UV-stretched triangle from dominating its neighbours. Indexed corners are
-// clustered by handedness and direction: a corner more than 60 degrees from a cluster's running frame
-// starts another record, so the complete interleaved vertex is duplicated and the corner is remapped. This preserves
-// joints0/weights0, colors, and secondary UVs while repairing both mirrored and folded UV seams.
+// Recomputes tangents from positions, normals, and uv0 using the Lengyel method, then
+// Gram-Schmidt-orthogonalizes each tangent against its normal and stores it with the glTF handedness
+// sign (`bitangent = cross(normal, tangent.xyz) * tangent.w`). A single indexed vertex cannot carry
+// both handednesses at a mirrored-UV boundary, so the indexed path duplicates the complete vertex
+// record and remaps the opposite-handed triangle corners before accumulating. Copying the complete
+// record is load-bearing for extended layouts: joints0/weights0, colors, and secondary UVs survive a
+// split unchanged. Non-indexed streams already have one vertex per corner and need no topology edit.
+// When `positionGroups` is present, mirrored contributions share a canonical frame at each exact
+// position: negative-orientation tangents are negated while bitangents are accumulated unchanged,
+// then each source/split output reads the frame with its own orientation. As with grouped normals,
+// this is opt-in so unrelated surfaces that merely coincide are not smoothed together.
 //
-// The runtime records which generated vertices came from the same authored vertex. A later normal
-// recomputation therefore keeps those tangent-only seams geometrically smooth. Non-indexed streams
-// already have one vertex per corner and require no topology edit. This is still an authoring operation:
-// call it before morph targets or skin bind poses are captured.
-export function computeMeshGeometryTangents(out, geometry) {
+// This is an authoring operation: call it before capturing morph/skin bind-pose runtime data. Safe
+// in-place (out === geometry): all source attributes and corner contributions are read into scratch
+// storage before tangent write-back or replacement of the output arrays.
+export function computeMeshGeometryTangents(out, geometry, positionGroups = null) {
     const sourceVertices = geometry.vertices;
-    const sourceStride = geometry.layout.stride / 4;
-    const sourceVertexCount = sourceStride > 0 ? Math.floor(sourceVertices.length / sourceStride) : 0;
+    const sourceFloatsPerVertex = geometry.layout.stride / 4;
+    const sourceVertexCount = sourceFloatsPerVertex > 0 ? Math.floor(sourceVertices.length / sourceFloatsPerVertex) : 0;
     const sourceIndices = geometry.indices;
-    const targetStride = out.layout.stride / 4;
-    if (sourceIndices === null) {
-        computeNonIndexedTangents(out.vertices, targetStride, sourceVertices, sourceStride, sourceVertexCount);
-        copyTangentSmoothingSources(out, geometry, sourceVertexCount);
-        out.version++;
-        return;
+    const elementCount = sourceIndices ? sourceIndices.length : sourceVertexCount;
+    // Indexed geometry needs an orientation census before accumulation. Grouped non-indexed geometry
+    // also needs the signs so each already-distinct corner can read the canonical group frame in its
+    // own orientation. Store one byte per triangle and one per source vertex, not per corner. A state's
+    // sign records the first orientation and magnitude 2 records that both occurred.
+    // Walk logical triangles through the shared decoder so triangle-strip topology is honoured, and
+    // resolve every corner UP FRONT: the mirrored-UV split below replaces `out.indices`, and with
+    // `out === geometry` that would change what the decoder reads part way through the pass.
+    const triangleCount = getMeshGeometryTriangleCount(geometry);
+    const cornerIndices = new Uint32Array(triangleCount * 3);
+    {
+        const corner = { i0: 0, i1: 0, i2: 0 };
+        for (let triangle = 0; triangle < triangleCount; triangle++) {
+            if (!getMeshGeometryTriangleVertexIndices(corner, geometry, triangle))
+                continue;
+            cornerIndices[triangle * 3] = corner.i0;
+            cornerIndices[triangle * 3 + 1] = corner.i1;
+            cornerIndices[triangle * 3 + 2] = corner.i2;
+        }
     }
-    const elementCount = sourceIndices.length;
-    const triangleElementCount = elementCount - (elementCount % 3);
-    const primaryClusters = new Int32Array(sourceVertexCount);
-    primaryClusters.fill(-1);
-    const clusterHeads = new Int32Array(sourceVertexCount);
-    clusterHeads.fill(-1);
-    const clusterNext = new Int32Array(triangleElementCount);
-    clusterNext.fill(-1);
-    const clusterSources = new Uint32Array(triangleElementCount);
-    const clusterSigns = new Int8Array(triangleElementCount);
-    const clusterTangents = new Float64Array(triangleElementCount * 3);
-    const elementClusters = new Uint32Array(triangleElementCount);
-    let clusterCount = 0;
+    let triangleSigns = null;
+    let orientationStates = null;
     let splitCount = 0;
-    for (let triangle = 0; triangle < triangleElementCount; triangle += 3) {
-        const i0 = sourceIndices[triangle];
-        const i1 = sourceIndices[triangle + 1];
-        const i2 = sourceIndices[triangle + 2];
-        const p0 = i0 * sourceStride + POSITION_OFFSET;
-        const p1 = i1 * sourceStride + POSITION_OFFSET;
-        const p2 = i2 * sourceStride + POSITION_OFFSET;
-        const e1x = sourceVertices[p1] - sourceVertices[p0];
-        const e1y = sourceVertices[p1 + 1] - sourceVertices[p0 + 1];
-        const e1z = sourceVertices[p1 + 2] - sourceVertices[p0 + 2];
-        const e2x = sourceVertices[p2] - sourceVertices[p0];
-        const e2y = sourceVertices[p2 + 1] - sourceVertices[p0 + 1];
-        const e2z = sourceVertices[p2 + 2] - sourceVertices[p0 + 2];
-        const u0 = i0 * sourceStride + UV0_OFFSET;
-        const u1 = i1 * sourceStride + UV0_OFFSET;
-        const u2 = i2 * sourceStride + UV0_OFFSET;
-        const du1 = sourceVertices[u1] - sourceVertices[u0];
-        const dv1 = sourceVertices[u1 + 1] - sourceVertices[u0 + 1];
-        const du2 = sourceVertices[u2] - sourceVertices[u0];
-        const dv2 = sourceVertices[u2 + 1] - sourceVertices[u0 + 1];
-        const determinant = du1 * dv2 - du2 * dv1;
-        const reciprocal = determinant !== 0 ? 1 / determinant : 0;
-        const faceTx = (dv2 * e1x - dv1 * e2x) * reciprocal;
-        const faceTy = (dv2 * e1y - dv1 * e2y) * reciprocal;
-        const faceTz = (dv2 * e1z - dv1 * e2z) * reciprocal;
-        const faceBx = (du1 * e2x - du2 * e1x) * reciprocal;
-        const faceBy = (du1 * e2y - du2 * e1y) * reciprocal;
-        const faceBz = (du1 * e2z - du2 * e1z) * reciprocal;
-        for (let corner = 0; corner < 3; corner++) {
-            const element = triangle + corner;
-            const vertex = sourceIndices[element];
-            const normal = vertex * sourceStride + NORMAL_OFFSET;
-            const nx = sourceVertices[normal];
-            const ny = sourceVertices[normal + 1];
-            const nz = sourceVertices[normal + 2];
-            const normalDot = nx * faceTx + ny * faceTy + nz * faceTz;
-            let tx = faceTx - nx * normalDot;
-            let ty = faceTy - ny * normalDot;
-            let tz = faceTz - nz * normalDot;
-            const tangentLength = Math.sqrt(tx * tx + ty * ty + tz * tz);
-            let sign = 0;
-            if (tangentLength > 0) {
-                tx /= tangentLength;
-                ty /= tangentLength;
-                tz /= tangentLength;
-                const cx = ny * tz - nz * ty;
-                const cy = nz * tx - nx * tz;
-                const cz = nx * ty - ny * tx;
-                sign = cx * faceBx + cy * faceBy + cz * faceBz < 0 ? -1 : 1;
+    if (sourceIndices !== null || positionGroups !== null) {
+        triangleSigns = new Int8Array(triangleCount);
+        orientationStates = new Int8Array(sourceVertexCount);
+        for (let triangle = 0; triangle < triangleCount; triangle++) {
+            const i0 = cornerIndices[triangle * 3];
+            const i1 = cornerIndices[triangle * 3 + 1];
+            const i2 = cornerIndices[triangle * 3 + 2];
+            const u0 = i0 * sourceFloatsPerVertex + UV0_OFFSET;
+            const u1 = i1 * sourceFloatsPerVertex + UV0_OFFSET;
+            const u2 = i2 * sourceFloatsPerVertex + UV0_OFFSET;
+            const du1 = sourceVertices[u1] - sourceVertices[u0];
+            const dv1 = sourceVertices[u1 + 1] - sourceVertices[u0 + 1];
+            const du2 = sourceVertices[u2] - sourceVertices[u0];
+            const dv2 = sourceVertices[u2 + 1] - sourceVertices[u0 + 1];
+            const determinant = du1 * dv2 - du2 * dv1;
+            const sign = determinant < 0 ? -1 : determinant > 0 ? 1 : 0;
+            triangleSigns[triangle] = sign;
+            if (sign !== 0) {
+                markTangentOrientation(orientationStates, i0, sign);
+                markTangentOrientation(orientationStates, i1, sign);
+                markTangentOrientation(orientationStates, i2, sign);
             }
-            let cluster = clusterHeads[vertex];
-            let compatibleCluster = -1;
-            while (cluster !== -1) {
-                const clusterSign = clusterSigns[cluster];
-                const tangent = cluster * 3;
-                const clusterLength = Math.sqrt(clusterTangents[tangent] * clusterTangents[tangent] +
-                    clusterTangents[tangent + 1] * clusterTangents[tangent + 1] +
-                    clusterTangents[tangent + 2] * clusterTangents[tangent + 2]);
-                if (tangentLength === 0 ||
-                    clusterLength === 0 ||
-                    (clusterSign === sign &&
-                        (tx * clusterTangents[tangent] + ty * clusterTangents[tangent + 1] + tz * clusterTangents[tangent + 2]) /
-                            clusterLength >=
-                            MIN_TANGENT_CLUSTER_DOT)) {
-                    compatibleCluster = cluster;
-                    break;
-                }
-                cluster = clusterNext[cluster];
-            }
-            if (compatibleCluster === -1) {
-                compatibleCluster = clusterCount++;
-                clusterSources[compatibleCluster] = vertex;
-                clusterSigns[compatibleCluster] = sign;
-                clusterNext[compatibleCluster] = clusterHeads[vertex];
-                clusterHeads[vertex] = compatibleCluster;
-                if (primaryClusters[vertex] === -1)
-                    primaryClusters[vertex] = compatibleCluster;
-                else
+        }
+        if (sourceIndices !== null) {
+            for (let vertex = 0; vertex < sourceVertexCount; vertex++) {
+                if (Math.abs(orientationStates[vertex]) === BOTH_TANGENT_ORIENTATIONS)
                     splitCount++;
             }
-            else if (clusterSigns[compatibleCluster] === 0 && sign !== 0) {
-                clusterSigns[compatibleCluster] = sign;
-            }
-            elementClusters[element] = compatibleCluster;
-            if (tangentLength > 0) {
-                const other1 = sourceIndices[triangle + ((corner + 1) % 3)];
-                const other2 = sourceIndices[triangle + ((corner + 2) % 3)];
-                const weight = getMeshCornerAngle(sourceVertices, sourceStride, vertex, other1, other2);
-                const tangent = compatibleCluster * 3;
-                clusterTangents[tangent] += tx * weight;
-                clusterTangents[tangent + 1] += ty * weight;
-                clusterTangents[tangent + 2] += tz * weight;
-            }
         }
     }
-    const outputVertexCount = sourceVertexCount + splitCount;
-    const clusterOutputs = new Uint32Array(clusterCount);
+    const targetFloatsPerVertex = out.layout.stride / 4;
     let targetVertices = out.vertices;
-    if (splitCount > 0) {
-        const expanded = new Float32Array(outputVertexCount * targetStride);
-        expanded.set(targetVertices.subarray(0, sourceVertexCount * targetStride));
+    let remappedIndices = null;
+    const outputVertexCount = sourceVertexCount + splitCount;
+    // The mirrored-UV split remaps INDEX ELEMENTS, which is only well defined for a triangle list,
+    // where each element belongs to exactly one triangle. A strip element is shared by up to three
+    // triangles that may not agree on orientation, so there is no single vertex to remap it to;
+    // splitting a strip would mean converting it to a list, which would change the output topology.
+    const canSplitMirroredUVs = geometry.topology === 'triangle-list';
+    if (canSplitMirroredUVs &&
+        splitCount > 0 &&
+        sourceIndices !== null &&
+        triangleSigns !== null &&
+        orientationStates !== null) {
+        const splitVertices = new Uint32Array(sourceVertexCount);
+        splitVertices.fill(UINT32_UNMAPPED);
+        const expanded = new Float32Array(outputVertexCount * targetFloatsPerVertex);
+        expanded.set(targetVertices.subarray(0, sourceVertexCount * targetFloatsPerVertex));
         let nextVertex = sourceVertexCount;
-        for (let cluster = 0; cluster < clusterCount; cluster++) {
-            const source = clusterSources[cluster];
-            if (primaryClusters[source] === cluster) {
-                clusterOutputs[cluster] = source;
-            }
-            else {
-                const output = nextVertex++;
-                clusterOutputs[cluster] = output;
-                const sourceOffset = source * targetStride;
-                expanded.set(targetVertices.subarray(sourceOffset, sourceOffset + targetStride), output * targetStride);
-            }
+        for (let vertex = 0; vertex < sourceVertexCount; vertex++) {
+            if (Math.abs(orientationStates[vertex]) !== BOTH_TANGENT_ORIENTATIONS)
+                continue;
+            splitVertices[vertex] = nextVertex;
+            const source = vertex * targetFloatsPerVertex;
+            expanded.set(targetVertices.subarray(source, source + targetFloatsPerVertex), nextVertex * targetFloatsPerVertex);
+            nextVertex++;
         }
         targetVertices = expanded;
         out.vertices = expanded;
         const needsUint32 = sourceIndices instanceof Uint32Array || out.indices instanceof Uint32Array || outputVertexCount > UINT16_MAX;
-        const remappedIndices = needsUint32
-            ? new Uint32Array(elementCount)
-            : new Uint16Array(elementCount);
-        for (let element = 0; element < triangleElementCount; element++) {
-            remappedIndices[element] = clusterOutputs[elementClusters[element]];
-        }
-        for (let element = triangleElementCount; element < elementCount; element++) {
-            remappedIndices[element] = sourceIndices[element];
+        remappedIndices = needsUint32 ? new Uint32Array(elementCount) : new Uint16Array(elementCount);
+        for (let element = 0; element < elementCount; element++) {
+            const sourceVertex = sourceIndices[element];
+            const sign = triangleSigns[Math.floor(element / 3)];
+            const primarySign = orientationStates[sourceVertex] < 0 ? -1 : 1;
+            remappedIndices[element] = sign !== 0 && sign !== primarySign ? splitVertices[sourceVertex] : sourceVertex;
         }
         out.indices = remappedIndices;
-        recordTangentSmoothingSources(out, geometry, clusterSources, clusterOutputs, clusterCount, sourceVertexCount, outputVertexCount);
-    }
-    else {
-        for (let cluster = 0; cluster < clusterCount; cluster++)
-            clusterOutputs[cluster] = clusterSources[cluster];
-        copyTangentSmoothingSources(out, geometry, sourceVertexCount);
     }
-    for (let cluster = 0; cluster < clusterCount; cluster++) {
-        const tangent = cluster * 3;
-        writeMeshTangent(targetVertices, targetStride, clusterOutputs[cluster], clusterTangents[tangent], clusterTangents[tangent + 1], clusterTangents[tangent + 2], clusterSigns[cluster] < 0 ? -1 : 1);
-    }
-    for (let vertex = 0; vertex < sourceVertexCount; vertex++) {
-        if (primaryClusters[vertex] === -1)
-            writeMeshTangent(targetVertices, targetStride, vertex, 0, 0, 0, 1);
-    }
-    out.version++;
-}
-function computeNonIndexedTangents(target, targetStride, source, sourceStride, vertexCount) {
-    for (let triangle = 0; triangle + 2 < vertexCount; triangle += 3) {
-        const p0 = triangle * sourceStride + POSITION_OFFSET;
-        const p1 = (triangle + 1) * sourceStride + POSITION_OFFSET;
-        const p2 = (triangle + 2) * sourceStride + POSITION_OFFSET;
-        const e1x = source[p1] - source[p0];
-        const e1y = source[p1 + 1] - source[p0 + 1];
-        const e1z = source[p1 + 2] - source[p0 + 2];
-        const e2x = source[p2] - source[p0];
-        const e2y = source[p2 + 1] - source[p0 + 1];
-        const e2z = source[p2 + 2] - source[p0 + 2];
-        const u0 = triangle * sourceStride + UV0_OFFSET;
-        const u1 = (triangle + 1) * sourceStride + UV0_OFFSET;
-        const u2 = (triangle + 2) * sourceStride + UV0_OFFSET;
-        const du1 = source[u1] - source[u0];
-        const dv1 = source[u1 + 1] - source[u0 + 1];
-        const du2 = source[u2] - source[u0];
-        const dv2 = source[u2 + 1] - source[u0 + 1];
+    const tan = new Float64Array(outputVertexCount * 3);
+    const bitan = new Float64Array(outputVertexCount * 3);
+    for (let triangle = 0; triangle < triangleCount; triangle++) {
+        const i0 = cornerIndices[triangle * 3];
+        const i1 = cornerIndices[triangle * 3 + 1];
+        const i2 = cornerIndices[triangle * 3 + 2];
+        // `remappedIndices` is only built for a triangle list, where element == triangle * 3 + corner.
+        const element = triangle * 3;
+        const o0 = remappedIndices ? remappedIndices[element] : i0;
+        const o1 = remappedIndices ? remappedIndices[element + 1] : i1;
+        const o2 = remappedIndices ? remappedIndices[element + 2] : i2;
+        const p0 = i0 * sourceFloatsPerVertex + POSITION_OFFSET;
+        const p1 = i1 * sourceFloatsPerVertex + POSITION_OFFSET;
+        const p2 = i2 * sourceFloatsPerVertex + POSITION_OFFSET;
+        const e1x = sourceVertices[p1] - sourceVertices[p0];
+        const e1y = sourceVertices[p1 + 1] - sourceVertices[p0 + 1];
+        const e1z = sourceVertices[p1 + 2] - sourceVertices[p0 + 2];
+        const e2x = sourceVertices[p2] - sourceVertices[p0];
+        const e2y = sourceVertices[p2 + 1] - sourceVertices[p0 + 1];
+        const e2z = sourceVertices[p2 + 2] - sourceVertices[p0 + 2];
+        const u0 = i0 * sourceFloatsPerVertex + UV0_OFFSET;
+        const u1 = i1 * sourceFloatsPerVertex + UV0_OFFSET;
+        const u2 = i2 * sourceFloatsPerVertex + UV0_OFFSET;
+        const du1 = sourceVertices[u1] - sourceVertices[u0];
+        const dv1 = sourceVertices[u1 + 1] - sourceVertices[u0 + 1];
+        const du2 = sourceVertices[u2] - sourceVertices[u0];
+        const dv2 = sourceVertices[u2 + 1] - sourceVertices[u0 + 1];
         const determinant = du1 * dv2 - du2 * dv1;
         const reciprocal = determinant !== 0 ? 1 / determinant : 0;
         const tx = (dv2 * e1x - dv1 * e2x) * reciprocal;
@@ -412,54 +400,54 @@ function computeNonIndexedTangents(target, targetStride, source, sourceStride, v
         const bx = (du1 * e2x - du2 * e1x) * reciprocal;
         const by = (du1 * e2y - du2 * e1y) * reciprocal;
         const bz = (du1 * e2z - du2 * e1z) * reciprocal;
-        for (let corner = 0; corner < 3; corner++) {
-            const vertex = triangle + corner;
-            const normal = vertex * sourceStride + NORMAL_OFFSET;
-            const nx = source[normal];
-            const ny = source[normal + 1];
-            const nz = source[normal + 2];
-            const normalDot = nx * tx + ny * ty + nz * tz;
-            const tangentX = tx - nx * normalDot;
-            const tangentY = ty - ny * normalDot;
-            const tangentZ = tz - nz * normalDot;
-            const cx = ny * tangentZ - nz * tangentY;
-            const cy = nz * tangentX - nx * tangentZ;
-            const cz = nx * tangentY - ny * tangentX;
-            const sign = cx * bx + cy * by + cz * bz < 0 ? -1 : 1;
-            writeMeshTangent(target, targetStride, vertex, tangentX, tangentY, tangentZ, sign);
+        const tangentSign = positionGroups !== null && determinant < 0 ? -1 : 1;
+        accumulateTangent(tan, bitan, positionGroups === null ? o0 : positionGroups[i0], tx * tangentSign, ty * tangentSign, tz * tangentSign, bx, by, bz);
+        accumulateTangent(tan, bitan, positionGroups === null ? o1 : positionGroups[i1], tx * tangentSign, ty * tangentSign, tz * tangentSign, bx, by, bz);
+        accumulateTangent(tan, bitan, positionGroups === null ? o2 : positionGroups[i2], tx * tangentSign, ty * tangentSign, tz * tangentSign, bx, by, bz);
+    }
+    if (positionGroups === null) {
+        for (let output = 0; output < outputVertexCount; output++) {
+            writeAccumulatedTangent(targetVertices, targetFloatsPerVertex, output, tan, bitan, output, 1);
         }
     }
-    for (let vertex = vertexCount - (vertexCount % 3); vertex < vertexCount; vertex++) {
-        writeMeshTangent(target, targetStride, vertex, 0, 0, 0, 1);
+    else {
+        // Source outputs can read their groups directly. A split output has no positionGroups entry;
+        // write it from the source corner that produced it, keeping the source/output index spaces apart.
+        for (let source = 0; source < sourceVertexCount; source++) {
+            const sign = orientationStates !== null && orientationStates[source] < 0 ? -1 : 1;
+            writeAccumulatedTangent(targetVertices, targetFloatsPerVertex, source, tan, bitan, positionGroups[source], sign);
+        }
+        if (remappedIndices !== null && sourceIndices !== null && triangleSigns !== null) {
+            for (let element = 0; element < elementCount; element++) {
+                const output = remappedIndices[element];
+                if (output < sourceVertexCount)
+                    continue;
+                const source = sourceIndices[element];
+                const sign = triangleSigns[Math.floor(element / 3)] < 0 ? -1 : 1;
+                writeAccumulatedTangent(targetVertices, targetFloatsPerVertex, output, tan, bitan, positionGroups[source], sign);
+            }
+        }
     }
+    out.version++;
 }
-function getMeshCornerAngle(vertices, stride, center, other1, other2) {
-    const centerOffset = center * stride + POSITION_OFFSET;
-    const other1Offset = other1 * stride + POSITION_OFFSET;
-    const other2Offset = other2 * stride + POSITION_OFFSET;
-    const ax = vertices[other1Offset] - vertices[centerOffset];
-    const ay = vertices[other1Offset + 1] - vertices[centerOffset + 1];
-    const az = vertices[other1Offset + 2] - vertices[centerOffset + 2];
-    const bx = vertices[other2Offset] - vertices[centerOffset];
-    const by = vertices[other2Offset + 1] - vertices[centerOffset + 1];
-    const bz = vertices[other2Offset + 2] - vertices[centerOffset + 2];
-    const denominator = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz));
-    if (denominator === 0)
-        return 1;
-    const cosine = (ax * bx + ay * by + az * bz) / denominator;
-    return Math.acos(Math.max(-1, Math.min(1, cosine)));
-}
-function writeMeshTangent(vertices, stride, vertex, sourceX, sourceY, sourceZ, sign) {
-    const normal = vertex * stride + NORMAL_OFFSET;
-    const nx = vertices[normal];
-    const ny = vertices[normal + 1];
-    const nz = vertices[normal + 2];
-    const normalDot = nx * sourceX + ny * sourceY + nz * sourceZ;
-    let tx = sourceX - nx * normalDot;
-    let ty = sourceY - ny * normalDot;
-    let tz = sourceZ - nz * normalDot;
-    let length = Math.sqrt(tx * tx + ty * ty + tz * tz);
-    if (length === 0) {
+function writeAccumulatedTangent(targetVertices, targetFloatsPerVertex, outputVertex, tangents, bitangents, accumulatedVertex, tangentSign) {
+    const nBase = outputVertex * targetFloatsPerVertex + NORMAL_OFFSET;
+    const nx = targetVertices[nBase], ny = targetVertices[nBase + 1], nz = targetVertices[nBase + 2];
+    let tx = tangents[accumulatedVertex * 3] * tangentSign, ty = tangents[accumulatedVertex * 3 + 1] * tangentSign, tz = tangents[accumulatedVertex * 3 + 2] * tangentSign;
+    // Gram-Schmidt: t = normalize(t - n * dot(n, t)).
+    const ndt = nx * tx + ny * ty + nz * tz;
+    tx -= nx * ndt;
+    ty -= ny * ndt;
+    tz -= nz * ndt;
+    const len = Math.sqrt(tx * tx + ty * ty + tz * tz);
+    if (len > 0) {
+        tx /= len;
+        ty /= len;
+        tz /= len;
+    }
+    else {
+        // Degenerate UVs: choose the coordinate axis least parallel to the normal, then cross it with
+        // the normal. Unlike the old fixed +X fallback this stays perpendicular even for an X normal.
         if (Math.abs(nx) <= Math.abs(ny) && Math.abs(nx) <= Math.abs(nz)) {
             tx = 0;
             ty = nz;
@@ -475,51 +463,51 @@ function writeMeshTangent(vertices, stride, vertex, sourceX, sourceY, sourceZ, s
             ty = -nx;
             tz = 0;
         }
-        length = Math.sqrt(tx * tx + ty * ty + tz * tz);
-        if (length === 0) {
+        const fallbackLength = Math.sqrt(tx * tx + ty * ty + tz * tz);
+        if (fallbackLength > 0) {
+            tx /= fallbackLength;
+            ty /= fallbackLength;
+            tz /= fallbackLength;
+        }
+        else {
             tx = 1;
             ty = 0;
             tz = 0;
-            length = 1;
         }
     }
-    const tangent = vertex * stride + TANGENT_OFFSET;
-    vertices[tangent] = tx / length;
-    vertices[tangent + 1] = ty / length;
-    vertices[tangent + 2] = tz / length;
-    vertices[tangent + 3] = sign;
+    // Handedness: w = sign(dot(cross(n, t), accumulated bitangent)).
+    const cx = ny * tz - nz * ty;
+    const cy = nz * tx - nx * tz;
+    const cz = nx * ty - ny * tx;
+    const w = cx * bitangents[accumulatedVertex * 3] +
+        cy * bitangents[accumulatedVertex * 3 + 1] +
+        cz * bitangents[accumulatedVertex * 3 + 2] <
+        0
+        ? -1
+        : 1;
+    const base = outputVertex * targetFloatsPerVertex + TANGENT_OFFSET;
+    targetVertices[base] = tx;
+    targetVertices[base + 1] = ty;
+    targetVertices[base + 2] = tz;
+    targetVertices[base + 3] = w;
 }
-function copyTangentSmoothingSources(out, geometry, vertexCount) {
-    if (out === geometry)
-        return;
-    const sourceRuntime = geometry[EntityRuntimeKey];
-    const targetRuntime = out[EntityRuntimeKey];
-    const sources = sourceRuntime?.tangentSmoothingSources;
-    if (targetRuntime !== undefined) {
-        targetRuntime.tangentSmoothingSources =
-            sources !== null && sources !== undefined && sources.length === vertexCount ? sources.slice() : null;
+function markTangentOrientation(orientationStates, vertex, sign) {
+    const state = orientationStates[vertex];
+    if (state === 0) {
+        orientationStates[vertex] = sign;
     }
-}
-function recordTangentSmoothingSources(out, geometry, clusterSources, clusterOutputs, clusterCount, sourceVertexCount, outputVertexCount) {
-    const sourceRuntime = geometry[EntityRuntimeKey];
-    const targetRuntime = out[EntityRuntimeKey];
-    if (targetRuntime === undefined)
-        return;
-    const previous = sourceRuntime?.tangentSmoothingSources;
-    const sources = new Uint32Array(outputVertexCount);
-    for (let vertex = 0; vertex < sourceVertexCount; vertex++) {
-        sources[vertex] =
-            previous !== null && previous !== undefined && previous.length === sourceVertexCount ? previous[vertex] : vertex;
-    }
-    for (let cluster = 0; cluster < clusterCount; cluster++) {
-        const output = clusterOutputs[cluster];
-        if (output >= sourceVertexCount)
-            sources[output] = sources[clusterSources[cluster]];
+    else if ((state < 0 ? -1 : 1) !== sign) {
+        orientationStates[vertex] = state < 0 ? -BOTH_TANGENT_ORIENTATIONS : BOTH_TANGENT_ORIENTATIONS;
     }
-    targetRuntime.tangentSmoothingSources = sources;
-    targetRuntime.skinBindPose = null;
-    targetRuntime.morphBindPose = null;
-    targetRuntime.morphBlendedWeights = null;
+}
+function accumulateTangent(tangents, bitangents, vertex, tx, ty, tz, bx, by, bz) {
+    const base = vertex * 3;
+    tangents[base] += tx;
+    tangents[base + 1] += ty;
+    tangents[base + 2] += tz;
+    bitangents[base] += bx;
+    bitangents[base + 1] += by;
+    bitangents[base + 2] += bz;
 }
 // Returns the geometry's cached local bounds, recomputing them first if a vertex edit has invalidated
 // them. THIS IS THE ONLY CORRECT WAY TO READ BOUNDS: `geometry.bounds` is a dirty-gated cache, so a
@@ -564,6 +552,7 @@ const NORMAL_OFFSET = 3;
 const POSITION_OFFSET = 0;
 const TANGENT_OFFSET = 6;
 const UV0_OFFSET = 10;
-const MIN_TANGENT_CLUSTER_DOT = 0.5;
+const BOTH_TANGENT_ORIENTATIONS = 2;
 const UINT16_MAX = 65_535;
+const UINT32_UNMAPPED = 0xffffffff;
 //# sourceMappingURL=meshGeometryCompute.js.map