@woosh/meep-engine 2.41.0 → 2.42.1

package/engine/graphics/geometry/MikkT/AvgTSpace.js

@@ -0,0 +1,38 @@
+import { vec3 } from "gl-matrix";
+import { NormalizeSafe } from "./NormalizeSafe.js";
+
+/**
+ *
+ * @param {STSpace} ts_res
+ * @param {STSpace} pTS0
+ * @param {STSpace} pTS1
+ * @returns {void}
+ */
+export function AvgTSpace(ts_res, pTS0, pTS1) {
+
+    // this if is important. Due to floating point precision
+    // averaging when ts0==ts1 will cause a slight difference
+    // which results in tangent space splits later on
+    if (
+        pTS0.fMagS === pTS1.fMagS && pTS0.fMagT === pTS1.fMagT &&
+        vec3.exactEquals(pTS0.vOs, pTS1.vOs) && vec3.exactEquals(pTS0.vOt, pTS1.vOt)
+    ) {
+
+        ts_res.fMagS = pTS0.fMagS;
+        ts_res.fMagT = pTS0.fMagT;
+
+        vec3.copy(ts_res.vOs, pTS0.vOs);
+        vec3.copy(ts_res.vOt, pTS0.vOt);
+
+    } else {
+        ts_res.fMagS = 0.5 * (pTS0.fMagS + pTS1.fMagS);
+        ts_res.fMagT = 0.5 * (pTS0.fMagT + pTS1.fMagT);
+
+        vec3.add(ts_res.vOs, pTS0.vOs, pTS1.vOs);
+        vec3.add(ts_res.vOt, pTS0.vOt, pTS1.vOt);
+
+        NormalizeSafe(ts_res.vOs, ts_res.vOs);
+        NormalizeSafe(ts_res.vOt, ts_res.vOt);
+    }
+
+}

package/engine/graphics/geometry/MikkT/Build4RuleGroups.js

@@ -0,0 +1,96 @@
+import { GROUP_WITH_ANY } from "./constants/GROUP_WITH_ANY.js";
+import { assert } from "../../../../core/assert.js";
+import { ORIENT_PRESERVING } from "./constants/ORIENT_PRESERVING.js";
+import { AddTriToGroup } from "./AddTriToGroup.js";
+import { AssignRecur } from "./AssignRecur.js";
+
+/**
+ *
+ * @param {STriInfo[]} pTriInfos
+ * @param {SGroup[]} pGroups
+ * @param {number[]|Int32Array} piGroupTrianglesBuffer
+ * @param {number[]|Int32Array} piTriListIn
+ * @param {number} iNrTrianglesIn
+ * @return {number}
+ */
+export function Build4RuleGroups(
+    pTriInfos,
+    pGroups,
+    piGroupTrianglesBuffer,
+    piTriListIn,
+    iNrTrianglesIn
+) {
+
+    const iNrMaxGroups = iNrTrianglesIn * 3;
+    let iNrActiveGroups = 0;
+    let iOffset = 0;
+
+    for (let f=0; f < iNrTrianglesIn; f++) {
+        const tri_info_f = pTriInfos[f];
+
+        for (let i = 0; i < 3; i++) {
+
+            // if not assigned to a group
+            if ((tri_info_f.iFlag & GROUP_WITH_ANY) === 0 && tri_info_f.AssignedGroup[i] === null) {
+
+                const vert_index = piTriListIn[f * 3 + i];
+
+                assert.lessThan(iNrActiveGroups, iNrMaxGroups);
+
+                const assigned_group = pGroups[iNrActiveGroups];
+                tri_info_f.AssignedGroup[i] = assigned_group;
+
+                assigned_group.iVertexRepresentitive = vert_index;
+
+                const bOrPre = (tri_info_f.iFlag & ORIENT_PRESERVING) !== 0;
+
+                assigned_group.bOrientPreservering = bOrPre;
+                assigned_group.iNrFaces = 0;
+                assigned_group.pFaceIndices = new Int32Array(piGroupTrianglesBuffer.buffer, iOffset * 4);
+                ++iNrActiveGroups;
+
+                AddTriToGroup(assigned_group, f);
+
+                const neigh_indexL = tri_info_f.FaceNeighbors[i];
+                const neigh_indexR = tri_info_f.FaceNeighbors[i > 0 ? (i - 1) : 2];
+
+                if (neigh_indexL >= 0) {
+
+                    // neighbor
+                    const bAnswer = AssignRecur(
+                        piTriListIn,
+                        pTriInfos,
+                        neigh_indexL,
+                        assigned_group
+                    );
+
+                    assert(bAnswer || (bOrPre !== ((pTriInfos[neigh_indexL].iFlag & ORIENT_PRESERVING) !== 0)) );
+
+                }
+                if (neigh_indexR >= 0) {
+
+                    // neighbor
+                    const bAnswer = AssignRecur(
+                        piTriListIn,
+                        pTriInfos,
+                        neigh_indexR,
+                        assigned_group
+                    );
+
+                    assert(bAnswer || bOrPre !== ((pTriInfos[neigh_indexR].iFlag & ORIENT_PRESERVING) !== 0));
+
+                }
+
+                // update offset
+                iOffset += assigned_group.iNrFaces;
+
+                // since the groups are disjoint a triangle can never
+                // belong to more than 3 groups. Subsequently, something
+                // is completely screwed if this assertion ever hits.
+                assert.lessThanOrEqual(iOffset, iNrMaxGroups);
+            }
+        }
+    }
+
+    return iNrActiveGroups;
+}

package/engine/graphics/geometry/MikkT/BuildNeighborsFast.js

@@ -0,0 +1,137 @@
+import { INTERNAL_RND_SORT_SEED } from "./constants/INTERNAL_RND_SORT_SEED.js";
+import { QuickSortEdges } from "./QuickSortEdges.js";
+import { vec3 } from "gl-matrix";
+import { GetEdge } from "./GetEdge.js";
+
+/**
+ *
+ * @param {STriInfo[]} pTriInfos
+ * @param {number[]|Float32Array} pEdges
+ * @param {number[]} piTriListIn
+ * @param {number} iNrTrianglesIn
+ * @returns {void}
+ */
+export function BuildNeighborsFast(pTriInfos, pEdges, piTriListIn, iNrTrianglesIn) {
+    // build array of edges
+    const uSeed = INTERNAL_RND_SORT_SEED; // could replace with a random seed?
+
+    for (let f = 0; f < iNrTrianglesIn; f++) {
+        for (let i = 0; i < 3; i++) {
+
+            const edge_index = f * 3 + i;
+
+            const i0 = piTriListIn[edge_index];
+            const i1 = piTriListIn[f * 3 + (i < 2 ? (i + 1) : 0)];
+
+            pEdges[edge_index * 3] = i0 < i1 ? i0 : i1;			    // put minimum index in i0
+            pEdges[edge_index * 3 + 1] = !(i0 < i1) ? i0 : i1;		// put maximum index in i1
+            pEdges[edge_index * 3 + 2] = f;							// record face number
+        }
+    }
+
+    // sort over all edges by i0, this is a pricey one.
+    QuickSortEdges(pEdges, 0, iNrTrianglesIn * 3 - 1, 0, uSeed);	// sort channel 0 which is i0
+
+    // sub sort over i1, should be fast.
+    // could replace this with a 64 bit int sort over (i0,i1)
+    // with i0 as msb in the quicksort call above.
+    const iEntries = iNrTrianglesIn * 3;
+    let iCurStartIndex = 0;
+
+    for (let i = 1; i < iEntries; i++) {
+        if (pEdges[iCurStartIndex * 3] !== pEdges[i * 3]) {
+
+            const iL = iCurStartIndex;
+            const iR = i - 1;
+            //const int iElems = i-iL;
+            iCurStartIndex = i;
+
+            QuickSortEdges(pEdges, iL, iR, 1, uSeed); // sort channel 1 which is i1
+
+        }
+    }
+
+    // sub sort over f, which should be fast.
+    // this step is to remain compliant with BuildNeighborsSlow() when
+    // more than 2 triangles use the same edge (such as a butterfly topology).
+    iCurStartIndex = 0;
+
+    for (let i = 1; i < iEntries; i++) {
+
+        if (
+            pEdges[iCurStartIndex * 3] !== pEdges[i * 3]
+            || pEdges[iCurStartIndex * 3 + 1] !== pEdges[i * 3 + 1]
+        ) {
+            const iL = iCurStartIndex;
+            const iR = i - 1;
+            //const int iElems = i-iL;
+            iCurStartIndex = i;
+            QuickSortEdges(pEdges, iL, iR, 2, uSeed);	// sort channel 2 which is f
+        }
+
+    }
+
+    const temp_edge_A = vec3.create();
+    const temp_edge_B = vec3.create();
+
+    // pair up, adjacent triangles
+    for (let i = 0; i < iEntries; i++) {
+
+        const i0 = pEdges[i * 3];
+        const i1 = pEdges[i * 3 + 1];
+        const f = pEdges[i * 3 + 2];
+
+        GetEdge(temp_edge_A, 0, piTriListIn, f * 3, i0, i1);	// resolve index ordering and edge_num
+
+        const i0_A = temp_edge_A[0];
+        const i1_A = temp_edge_A[1];
+        const edgenum_A = temp_edge_A[2];
+
+        const bUnassigned_A = pTriInfos[f].FaceNeighbors[edgenum_A] === -1;
+
+        if (!bUnassigned_A) {
+            continue;
+        }
+
+        let j = i + 1;
+
+        while (
+            j < iEntries
+            && i0 === pEdges[j * 3]
+            && i1 === pEdges[j * 3 + 1]
+            ) {
+
+            const t = pEdges[j * 3 + 2];
+
+
+            GetEdge(
+                temp_edge_B,
+                0,
+                piTriListIn,
+                t * 3,
+                pEdges[j * 3],
+                pEdges[j * 3 + 1]
+            );	// resolve index ordering and edge_num
+
+            // flip i0_B and i1_B
+            const i0_B = temp_edge_B[1];
+            const i1_B = temp_edge_B[2];
+            const edgenum_B = temp_edge_B[2];
+
+            //assert(!(i0_A==i1_B && i1_A==i0_B));
+           const bUnassigned_B = pTriInfos[t].FaceNeighbors[edgenum_B] === -1;
+
+            if (i0_A === i0_B && i1_A === i1_B && bUnassigned_B) {
+
+                const t = pEdges[j * 3 + 2];
+                pTriInfos[f].FaceNeighbors[edgenum_A] = t;
+                //assert(pTriInfos[t].FaceNeighbors[edgenum_B]==-1);
+                pTriInfos[t].FaceNeighbors[edgenum_B] = f;
+                break;
+
+            } else {
+                ++j;
+            }
+        }
+    }
+}

package/engine/graphics/geometry/MikkT/CalcTexArea.js

@@ -0,0 +1,31 @@
+import { vec3 } from "gl-matrix";
+import { GetTexCoord } from "./GetTexCoord.js";
+import { fabsf } from "../../../../core/math/fabsf.js";
+
+const t1 = vec3.create();
+const t2 = vec3.create();
+const t3 = vec3.create();
+
+/**
+ * returns the texture area times 2
+ * @param {SMikkTSpaceContext } pContext
+ * @param {number[]} indices
+ * @param {number} indices_offset
+ * @returns {number}
+ */
+export function CalcTexArea(pContext, indices, indices_offset) {
+
+    GetTexCoord(t1, pContext, indices[indices_offset ]);
+    GetTexCoord(t2, pContext, indices[indices_offset + 1]);
+    GetTexCoord(t3, pContext, indices[indices_offset + 2]);
+
+    const t21x = t2[0] - t1[0];
+    const t21y = t2[1] - t1[1];
+
+    const t31x = t3[0] - t1[0];
+    const t31y = t3[1] - t1[1];
+
+    const fSignedAreaSTx2 = t21x * t31y - t21y * t31x;
+
+    return fabsf(fSignedAreaSTx2);
+}

package/engine/graphics/geometry/MikkT/CompareSubGroups.js

@@ -0,0 +1,26 @@
+/**
+ *
+ * @param {SSubGroup} pg1
+ * @param {SSubGroup } pg2
+ * @returns {boolean}
+ */
+export function CompareSubGroups(pg1, pg2) {
+    const n = pg1.iNrFaces;
+
+    if (n !== pg2.iNrFaces) {
+        return false;
+    }
+
+    const tris_1 = pg1.pTriMembers;
+    const tris_2 = pg2.pTriMembers;
+
+    for (let i = 0; i < n; i++) {
+
+        if (tris_1[i] !== tris_2[i]) {
+            return false
+        }
+
+    }
+
+    return true;
+}

package/engine/graphics/geometry/MikkT/DegenEpilogue.js

@@ -0,0 +1,220 @@
+import { QUAD_ONE_DEGEN_TRI } from "./constants/QUAD_ONE_DEGEN_TRI.js";
+import { vec3 } from "gl-matrix";
+import { GetPosition } from "./GetPosition.js";
+import { MakeIndex } from "./MakeIndex.js";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * @type {vec3}
+ */
+const vDstP = vec3.create();
+const vSrcP = vec3.create();
+
+class VertReverseLookupContext {
+    /**
+     *
+     * @type {boolean}
+     */
+    bIsInitialized = false;
+    /**
+     * int*
+     * @type {Int32Array|null}
+     */
+    pLookup = null;
+    /**
+     * int
+     * @type {number}
+     */
+    iMaxVertIndex = 0;
+}
+
+/**
+ *
+ * @param {number[]} piTriListIn
+ * @param {number} iNrTrianglesIn
+ * @param {VertReverseLookupContext} pLookupCtx
+ */
+function GenerateReverseLookup(
+    piTriListIn,
+    iNrTrianglesIn,
+    pLookupCtx
+) {
+    let t;
+
+    // Figure out what size of lookup array we need.
+    pLookupCtx.iMaxVertIndex = -1;
+
+    for (t = 0; t < 3 * iNrTrianglesIn; t++) {
+        const iVertIndex = piTriListIn[t];
+
+        if (iVertIndex > pLookupCtx.iMaxVertIndex) {
+            pLookupCtx.iMaxVertIndex = iVertIndex;
+        }
+
+    }
+    // Allocate memory.
+    if (pLookupCtx.iMaxVertIndex < 1) {
+        // Nothing to allocate, all triangles are degenerate.
+        return;
+    }
+    pLookupCtx.pLookup = new Int32Array(pLookupCtx.iMaxVertIndex + 1);
+
+    // Fill in lookup.
+    for (t = 0; t <= pLookupCtx.iMaxVertIndex; t++) {
+        pLookupCtx.pLookup[t] = -1;
+    }
+
+    for (t = 0; t < 3 * iNrTrianglesIn; t++) {
+        const iVertIndex = piTriListIn[t];
+
+        if (pLookupCtx.pLookup[iVertIndex] !== -1) {
+            continue;
+        }
+
+        pLookupCtx.pLookup[iVertIndex] = t;
+    }
+}
+
+/**
+ *
+ * @param {VertReverseLookupContext} pLookupCtx
+ * @param {number[]} piTriListIn
+ * @param {number} iNrTrianglesIn
+ * @param {number} iVertexIndex
+ * @returns {number}
+ */
+function LookupVertexIndexFromGoodTriangle(
+    pLookupCtx,
+    piTriListIn,
+    iNrTrianglesIn,
+    iVertexIndex
+) {
+    // Allocate lookup on demand.
+    if (!pLookupCtx.bIsInitialized) {
+        GenerateReverseLookup(piTriListIn, iNrTrianglesIn, pLookupCtx);
+        pLookupCtx.bIsInitialized = true;
+    }
+    // Make sure vertex index is in the mapping.
+    if (iVertexIndex > pLookupCtx.iMaxVertIndex) {
+        return -1;
+    }
+    if (pLookupCtx.pLookup === null) {
+        return -1;
+    }
+
+    // Perform actual lookup.
+    return pLookupCtx.pLookup[iVertexIndex];
+}
+
+/**
+ *
+ * @param {STSpace[]} psTspace
+ * @param {STriInfo[]} pTriInfos
+ * @param {number[]|Int32Array} piTriListIn
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number} iNrTrianglesIn
+ * @param {number} iTotTris
+ * @returns {void}
+ */
+export function DegenEpilogue(psTspace, pTriInfos, piTriListIn, pContext, iNrTrianglesIn, iTotTris) {
+
+    // deal with degenerate triangles
+    // punishment for degenerate triangles is O(N^2)
+    const lookupCtx = new VertReverseLookupContext();
+
+    for (let t = iNrTrianglesIn; t < iTotTris; t++) {
+        const tri0 = pTriInfos[t];
+
+        // degenerate triangles on a quad with one good triangle are skipped
+        // here but processed in the next loop
+        const bSkip = (tri0.iFlag & QUAD_ONE_DEGEN_TRI) !== 0;
+
+        if (bSkip) {
+            continue;
+        }
+
+        for (let i = 0; i < 3; i++) {
+
+            const index1 = piTriListIn[t * 3 + i];
+            const j = LookupVertexIndexFromGoodTriangle(lookupCtx, piTriListIn, iNrTrianglesIn, index1);
+
+            if (j < 0) {
+                // Matching vertex from good triangle is not found.
+                continue;
+            }
+
+            const iTri = Math.floor(j / 3);
+            const iVert = j % 3;
+
+            const tri1 = pTriInfos[iTri];
+
+            const iSrcVert = tri1.vert_num[iVert];
+            const iSrcOffs = tri1.iTSpacesOffs;
+
+            const iDstVert = tri0.vert_num[i];
+            const iDstOffs = tri0.iTSpacesOffs;
+
+            // copy tspace
+            const dst_tspace = psTspace[iDstOffs + iDstVert];
+            const src_tspace = psTspace[iSrcOffs + iSrcVert];
+
+            dst_tspace.copy(src_tspace);
+        }
+    }
+
+
+    // deal with degenerate quads with one good triangle
+    for (let t = 0; t < iNrTrianglesIn; t++) {
+        // this triangle belongs to a quad where the
+        // other triangle is degenerate
+        const tri = pTriInfos[t];
+
+        if ((tri.iFlag & QUAD_ONE_DEGEN_TRI) === 0) {
+            continue;
+        }
+
+        const pV = tri.vert_num;
+
+        const iFlag = (1 << pV[0]) | (1 << pV[1]) | (1 << pV[2]);
+
+        let iMissingIndex = 0;
+
+        if ((iFlag & 2) === 0) {
+            iMissingIndex = 1;
+        } else if ((iFlag & 4) === 0) {
+            iMissingIndex = 2;
+        } else if ((iFlag & 8) === 0) {
+            iMissingIndex = 3;
+        }
+
+        const iOrgF = tri.iOrgFaceNumber;
+
+        GetPosition(vDstP, 0, pContext, MakeIndex(iOrgF, iMissingIndex));
+
+        let bNotFound = true;
+        let i = 0;
+
+        while (i < 3) {
+
+            const iVert = pV[i];
+            GetPosition(vSrcP, 0, pContext, MakeIndex(iOrgF, iVert));
+
+            if (vec3.exactEquals(vSrcP, vDstP)) {
+
+                const iOffs = tri.iTSpacesOffs;
+
+                psTspace[iOffs + iMissingIndex].copy(psTspace[iOffs + iVert]);
+
+                bNotFound = false;
+
+                break;
+
+            } else {
+                ++i;
+            }
+
+        }
+
+        assert(!bNotFound);
+    }
+}

package/engine/graphics/geometry/MikkT/DegenPrologue.js

@@ -0,0 +1,115 @@
+import { MARK_DEGENERATE } from "./constants/MARK_DEGENERATE.js";
+import { QUAD_ONE_DEGEN_TRI } from "./constants/QUAD_ONE_DEGEN_TRI.js";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {STriInfo[]} pTriInfos
+ * @param {number[]|Int32Array} piTriList_out
+ * @param {number} iNrTrianglesIn
+ * @param {number} iTotTris
+ * @returns {void}
+ */
+export function DegenPrologue(
+    pTriInfos,
+    piTriList_out,
+    iNrTrianglesIn,
+    iTotTris
+) {
+    // locate quads with only one good triangle
+    let t = 0;
+
+    while (t < (iTotTris - 1)) {
+
+        const tri_0 = pTriInfos[t];
+        const tri_1 = pTriInfos[t + 1];
+
+        const iFO_a = tri_0.iOrgFaceNumber;
+        const iFO_b = tri_1.iOrgFaceNumber;
+
+        if (iFO_a === iFO_b) {
+
+            // this is a quad
+            const bIsDeg_a = (tri_0.iFlag & MARK_DEGENERATE) !== 0;
+            const bIsDeg_b = (tri_1.iFlag & MARK_DEGENERATE) !== 0;
+
+            if (bIsDeg_a !== bIsDeg_b) {
+                tri_0.iFlag |= QUAD_ONE_DEGEN_TRI;
+                tri_1.iFlag |= QUAD_ONE_DEGEN_TRI;
+            }
+
+            t += 2;
+
+        } else {
+            ++t;
+        }
+    }
+
+    // reorder list so all degen triangles are moved to the back
+    // without reordering the good triangles
+    let iNextGoodTriangleSearchIndex = 1;
+    let bStillFindingGoodOnes = true;
+
+    t = 0;
+
+    while (t < iNrTrianglesIn && bStillFindingGoodOnes) {
+
+        const bIsGood = (pTriInfos[t].iFlag & MARK_DEGENERATE) === 0;
+
+        if (bIsGood) {
+            if (iNextGoodTriangleSearchIndex < (t + 2)) {
+                iNextGoodTriangleSearchIndex = t + 2;
+            }
+        } else {
+            // search for the first good triangle.
+            let bJustADegenerate = true;
+
+            while (bJustADegenerate && iNextGoodTriangleSearchIndex < iTotTris) {
+
+                const bIsGood = (pTriInfos[iNextGoodTriangleSearchIndex].iFlag & MARK_DEGENERATE) === 0;
+
+                if (bIsGood) {
+                    bJustADegenerate = false;
+                } else {
+                    ++iNextGoodTriangleSearchIndex;
+                }
+
+            }
+
+            const t0 = t;
+            const t1 = iNextGoodTriangleSearchIndex;
+
+            ++iNextGoodTriangleSearchIndex;
+            assert.greaterThan(iNextGoodTriangleSearchIndex, (t + 1));
+
+            // swap triangle t0 and t1
+            if (!bJustADegenerate) {
+
+                for (let i = 0; i < 3; i++) {
+                    const i0 = t0 * 3 + i;
+                    const i1 = t1 * 3 + i;
+
+                    const index = piTriList_out[i0];
+
+                    piTriList_out[i0] = piTriList_out[i1];
+                    piTriList_out[i1] = index;
+                }
+
+                const tri_info = pTriInfos[t0];
+                pTriInfos[t0] = pTriInfos[t1];
+                pTriInfos[t1] = tri_info;
+
+            } else {
+                // this is not supposed to happen
+                bStillFindingGoodOnes = false;
+            }
+        }
+
+        if (bStillFindingGoodOnes) {
+            ++t;
+        }
+    }
+
+    assert(bStillFindingGoodOnes);	// code will still work.
+    assert.equal(iNrTrianglesIn, t);
+}