@woosh/meep-engine 2.42.0 → 2.42.2

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);
+}

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

@@ -0,0 +1,128 @@
+import { STSpace } from "./STSpace.js";
+import { vec3 } from "gl-matrix";
+import { GROUP_WITH_ANY } from "./constants/GROUP_WITH_ANY.js";
+import { assert } from "../../../../core/assert.js";
+import { GetNormal } from "./GetNormal.js";
+import { NormalizeSafe } from "./NormalizeSafe.js";
+import { GetPosition } from "./GetPosition.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
+import { v3_scale_dot_sub_normalize } from "./v3_scale_dot_sub_normalize.js";
+
+
+let offset = 0;
+const _buffer = new ArrayBuffer(3 * 4 * 6);
+
+const vOs = new Float32Array(_buffer, offset, 3);
+offset += 12;
+const vOt = new Float32Array(_buffer, offset, 3);
+offset += 12;
+const n = new Float32Array(_buffer, offset, 3);
+offset += 12;
+
+const p0 = new Float32Array(_buffer, offset, 3);
+offset += 12;
+const p1 = new Float32Array(_buffer, offset, 3);
+offset += 12;
+const p2 = new Float32Array(_buffer, offset, 3);
+offset += 12;
+
+/**
+ *
+ * @param {STSpace} res
+ * @param {number[]|Uint32Array|Int32Array} face_indices
+ * @param {number} iFaces
+ * @param {number[]} piTriListIn
+ * @param {STriInfo[]} pTriInfos
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number} iVertexRepresentitive
+ */
+export function EvalTspace(res, face_indices, iFaces, piTriListIn, pTriInfos, pContext, iVertexRepresentitive) {
+
+    let fAngleSum = 0;
+
+    res.vOs[0] = 0.0;
+    res.vOs[1] = 0.0;
+    res.vOs[2] = 0.0;
+
+    res.vOt[0] = 0.0;
+    res.vOt[1] = 0.0;
+    res.vOt[2] = 0.0;
+
+    res.fMagS = 0;
+    res.fMagT = 0;
+
+
+    for (let face = 0; face < iFaces; face++) {
+        const f = face_indices[face];
+        const tri_info = pTriInfos[f];
+
+        // only valid triangles get to add their contribution
+        if ((tri_info.iFlag & GROUP_WITH_ANY) === 0) {
+            let i = -1;
+
+            const f3 = 3 * f;
+
+            if (piTriListIn[f3] === iVertexRepresentitive) {
+                i = 0;
+            } else if (piTriListIn[f3 + 1] === iVertexRepresentitive) {
+                i = 1;
+            } else if (piTriListIn[f3 + 2] === iVertexRepresentitive) {
+                i = 2;
+            }
+
+            assert(i >= 0 && i < 3);
+
+            // project
+            const index = piTriListIn[f3 + i];
+
+            GetNormal(n, pContext, index);
+
+            v3_scale_dot_sub_normalize(vOs, n, tri_info.vOs);
+            v3_scale_dot_sub_normalize(vOt, n, tri_info.vOt);
+
+            const i0 = piTriListIn[f3 + (i > 0 ? (i - 1) : 2)];
+            const i1 = piTriListIn[f3 + i];
+            const i2 = piTriListIn[f3 + (i < 2 ? (i + 1) : 0)];
+
+            GetPosition(p0, 0, pContext, i0);
+            GetPosition(p1, 0, pContext, i1);
+            GetPosition(p2, 0, pContext, i2);
+
+            vec3.sub(p0, p0, p1);
+            vec3.sub(p1, p2, p1);
+
+            // project
+            v3_scale_dot_sub_normalize(p0, n, p0);
+            v3_scale_dot_sub_normalize(p1, n, p1);
+
+            // weight contribution by the angle
+            // between the two edge vectors
+
+            const fCos = clamp01(vec3.dot(p0, p1));
+            const fAngle = Math.acos(fCos);
+            const fMagS = tri_info.fMagS;
+            const fMagT = tri_info.fMagT;
+
+            vec3.scale(p2, vOs, fAngle);
+            vec3.add(res.vOs, res.vOs, p2);
+
+            vec3.scale(p2, vOt, fAngle);
+            vec3.add(res.vOt, res.vOt, p2);
+
+            res.fMagS += (fAngle * fMagS);
+            res.fMagT += (fAngle * fMagT);
+
+            fAngleSum += fAngle;
+        }
+    }
+
+    // normalize
+    NormalizeSafe(res.vOs, res.vOs);
+    NormalizeSafe(res.vOt, res.vOt);
+
+    if (fAngleSum > 0) {
+        res.fMagS /= fAngleSum;
+        res.fMagT /= fAngleSum;
+    }
+
+}

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

@@ -0,0 +1,48 @@
+import { m_getNumFaces } from "./m_getNumFaces.js";
+import { MakeIndex } from "./MakeIndex.js";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {STriInfo[]} pTriInfos
+ * @param {number[]|Int32Array} piTriList_out
+ * @param {SMikkTSpaceContext } pContext
+ * @param {number} iNrTrianglesIn
+ * @return {number}
+ */
+export function GenerateInitialVerticesIndexList(pTriInfos, piTriList_out, pContext, iNrTrianglesIn) {
+    let iTSpacesOffs = 0;
+    let iDstTriIndex = 0;
+
+    const face_count = m_getNumFaces(pContext);
+
+    for (let f = 0; f < face_count; f++) {
+
+        const tri_info = pTriInfos[iDstTriIndex];
+
+        tri_info.iOrgFaceNumber = f;
+        tri_info.iTSpacesOffs = iTSpacesOffs;
+
+        const pVerts = tri_info.vert_num;
+
+        pVerts[0] = 0;
+        pVerts[1] = 1;
+        pVerts[2] = 2;
+
+        piTriList_out[iDstTriIndex * 3 ] = MakeIndex(f, 0);
+        piTriList_out[iDstTriIndex * 3 + 1] = MakeIndex(f, 1);
+        piTriList_out[iDstTriIndex * 3 + 2] = MakeIndex(f, 2);
+
+        ++iDstTriIndex;	// next
+
+        iTSpacesOffs += 3;
+        assert.lessThanOrEqual(iDstTriIndex, iNrTrianglesIn);
+    }
+
+    for (let t = 0; t < iNrTrianglesIn; t++) {
+        pTriInfos[t].iFlag = 0;
+    }
+
+    // return total amount of tspaces
+    return iTSpacesOffs;
+}

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

@@ -0,0 +1,184 @@
+import { vec3 } from "gl-matrix";
+import { GetPosition } from "./GetPosition.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { GetNormal } from "./GetNormal.js";
+import { GetTexCoord } from "./GetTexCoord.js";
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+function HASH(x, y, z) {
+    return ((x) * 73856093) ^ ((y) * 19349663) ^ ((z) * 83492791);
+}
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+function HASH_F(x, y, z) {
+    return (computeHashFloat(x) * 73856093) ^ (computeHashFloat(y) * 19349663) ^ (computeHashFloat(z) * 83492791);
+}
+
+/**
+ * Sort comp and data based on comp.
+ * comp2 and data2 are used as temporary storage.
+ *
+ * @param {Uint32Array} comp
+ * @param {Int32Array} data
+ * @param {Uint32Array} comp2
+ * @param {Int32Array} data2
+ * @param {number} n
+ */
+function radixsort_pair(comp, data, comp2, data2, n) {
+    let shift = 0;
+
+    let _data_0 = data;
+    let _data_1 = data2;
+
+    let _comp_0 = comp;
+    let _comp_1 = comp2;
+
+    for (let pass = 0; pass < 4; pass++, shift += 8) {
+        const bins = new Int32Array(257);
+        /* Count number of elements per bin. */
+        for (let i = 0; i < n; i++) {
+            bins[((_comp_0[i] >> shift) & 0xff) + 1]++;
+        }
+        /* Compute prefix sum to find position of each bin in the sorted array. */
+        for (let i = 2; i < 256; i++) {
+            bins[i] += bins[i - 1];
+        }
+        /* Insert the elements in their correct location based on their bin. */
+        for (let i = 0; i < n; i++) {
+            const pos = bins[(_comp_0[i] >> shift) & 0xff]++;
+            _comp_1[pos] = _comp_0[i];
+            _data_1[pos] = _data_0[i];
+        }
+
+        /* Swap arrays. */
+        let tmpdata = _data_0;
+        _data_0 = _data_1;
+        _data_1 = tmpdata;
+
+        let tmpcomp = _comp_0;
+        _comp_0 = _comp_1;
+        _comp_1 = tmpcomp;
+    }
+}
+
+/**
+ *
+ * @param {number[]|Int32Array} piTriList_in_and_out
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number} iNrTrianglesIn
+ * @returns {void}
+ */
+export function GenerateSharedVerticesIndexList(
+    piTriList_in_and_out,
+    pContext,
+    iNrTrianglesIn
+) {
+    const numVertices = iNrTrianglesIn * 3;
+
+    const _buffer = new ArrayBuffer(numVertices * 4 * 4);
+
+    const hashes = new Uint32Array(_buffer, 0, numVertices);
+    const indices = new Int32Array(_buffer, numVertices * 4, numVertices);
+    const temp_hashes = new Uint32Array(_buffer, numVertices * 2 * 4, numVertices);
+    const temp_indices = new Int32Array(_buffer, numVertices * 3 * 4, numVertices);
+
+    const v = vec3.create();
+
+    for (let i = 0; i < numVertices; i++) {
+        const index = piTriList_in_and_out[i];
+
+        GetPosition(v, 0, pContext, index);
+        const hashP = HASH_F(v[0], v[1], v[2]);
+
+        GetNormal(v, pContext, index);
+        const hashN = HASH_F(v[0], v[1], v[2]);
+
+        GetTexCoord(v, pContext, index);
+        const hashT = HASH_F(v[0], v[1], v[2]);
+
+        hashes[i] = HASH(hashP, hashN, hashT);
+        indices[i] = i;
+    }
+
+    radixsort_pair(hashes, indices, temp_hashes, temp_indices, numVertices);
+
+    // free(temp_hashes);
+    // free(temp_indices);
+
+
+    const vT = vec3.create();
+    const vP = vec3.create();
+
+    const vT2 = vec3.create();
+    const vP2 = vec3.create();
+
+    const vN = vec3.create();
+    const vN2 = vec3.create();
+
+    /*
+     * Process blocks of vertices with the same hash.
+     * Vertices in the block might still be separate, but we know for sure that
+     * vertices in different blocks will never be identical.
+     */
+    let blockstart = 0;
+    while (blockstart < numVertices) {
+        /* Find end of this block (exclusive). */
+        const hash = hashes[blockstart];
+        let blockend = blockstart + 1;
+        for (; blockend < numVertices; blockend++) {
+            if (hashes[blockend] !== hash)
+                break;
+        }
+
+        for (let i = blockstart; i < blockend; i++) {
+
+            const index1 = piTriList_in_and_out[indices[i]];
+
+            GetPosition(vP, 0, pContext, index1);
+            GetNormal(vN, pContext, index1);
+            GetTexCoord(vT, pContext, index1);
+
+            for (let i2 = i + 1; i2 < blockend; i2++) {
+                const index2 = piTriList_in_and_out[indices[i2]];
+
+                if (index1 === index2) {
+                    continue;
+                }
+
+                GetPosition(vP2, 0, pContext, index2);
+                GetNormal(vN2, pContext, index2);
+                GetTexCoord(vT2, pContext, index2);
+
+                if (
+                    vP[0] === vP2[0] && vP[1] === vP2[1] && vP[2] === vP2[2] &&
+                    vN[0] === vN2[0] && vN[1] === vN2[1] && vN[2] === vN2[2] &&
+                    vT[0] === vT2[0] && vT[1] === vT2[1] && vT[2] === vT2[2]
+                ) {
+                    piTriList_in_and_out[indices[i2]] = index1;
+                    /* Once i2>i has been identified as a duplicate, we can stop since any
+                     * i3>i2>i that is a duplicate of i (and therefore also i2) will also be
+                     * compared to i2 and therefore be identified there anyways. */
+                    break;
+                }
+            }
+        }
+
+        /* Advance to next block. */
+        blockstart = blockend;
+    }
+
+    // free(hashes);
+    // free(indices);
+}