@woosh/meep-engine 2.41.0 → 2.42.1

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

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

@@ -0,0 +1,226 @@
+import { malloc } from "./malloc.js";
+import { STSpace } from "./STSpace.js";
+import { SSubGroup } from "./SSubGroup.js";
+import { vec3 } from "gl-matrix";
+import { assert } from "../../../../core/assert.js";
+import { GetNormal } from "./GetNormal.js";
+import { GROUP_WITH_ANY } from "./constants/GROUP_WITH_ANY.js";
+import { INTERNAL_RND_SORT_SEED } from "./constants/INTERNAL_RND_SORT_SEED.js";
+import { QuickSort } from "./QuickSort.js";
+import { CompareSubGroups } from "./CompareSubGroups.js";
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { EvalTspace } from "./EvalTspace.js";
+import { ORIENT_PRESERVING } from "./constants/ORIENT_PRESERVING.js";
+import { AvgTSpace } from "./AvgTSpace.js";
+import { v3_scale_dot_sub_normalize } from "./v3_scale_dot_sub_normalize.js";
+
+const vOs = vec3.create();
+const vOt = vec3.create();
+
+const vOs2 = vec3.create();
+const vOt2 = vec3.create();
+/**
+ * @type {vec3}
+ */
+const n = vec3.create();
+
+/**
+ * @type {SSubGroup}
+ */
+const tmp_group = new SSubGroup();
+
+/**
+ *
+ * @param {STSpace[]} psTspace
+ * @param {STriInfo[]} pTriInfos
+ * @param {SGroup[]} pGroups
+ * @param {number} iNrActiveGroups
+ * @param {number[]|Int32Array} piTriListIn
+ * @param {number} fThresCos
+ * @param {SMikkTSpaceContext} pContext
+ */
+export function GenerateTSpaces(psTspace, pTriInfos, pGroups, iNrActiveGroups, piTriListIn, fThresCos, pContext) {
+
+    let iMaxNrFaces = 0, iUniqueTspaces = 0;
+
+    for (let g = 0; g < iNrActiveGroups; g++) {
+        const sGroup = pGroups[g];
+
+        if (iMaxNrFaces < sGroup.iNrFaces) {
+            iMaxNrFaces = sGroup.iNrFaces;
+        }
+
+    }
+
+    if (iMaxNrFaces === 0) {
+        // no faces, nothing to do
+        return;
+    }
+
+
+    // make initial allocations
+    /**
+     * @type {STSpace[]}
+     */
+    const pSubGroupTspace = malloc(STSpace, iMaxNrFaces);
+
+    /**
+     *
+     * @type {SSubGroup[]}
+     */
+    const pUniSubGroups = malloc(SSubGroup, iMaxNrFaces);
+
+    /**
+     *
+     * @type {Int32Array|null}
+     */
+    const pTmpMembers = new Int32Array(iMaxNrFaces);
+
+    iUniqueTspaces = 0;
+
+
+    for (let g = 0; g < iNrActiveGroups; g++) {
+        const pGroup = pGroups[g];
+        let iUniqueSubGroups = 0;
+
+        for (let i = 0; i < pGroup.iNrFaces; i++) {
+            // triangles
+            const f = pGroup.pFaceIndices[i];	// triangle number
+
+            let bFound = false;
+
+            const tri_info = pTriInfos[f];
+
+            let index = -1;
+            if (tri_info.AssignedGroup[0] === pGroup) {
+                index = 0;
+            } else if (tri_info.AssignedGroup[1] === pGroup) {
+                index = 1;
+            } else if (tri_info.AssignedGroup[2] === pGroup) {
+                index = 2;
+            }
+
+            assert(index >= 0 && index < 3);
+
+            const iVertIndex = piTriListIn[f * 3 + index];
+            assert.equal(iVertIndex, pGroup.iVertexRepresentitive);
+
+            // is normalized already
+            GetNormal(n, pContext, iVertIndex);
+
+            // project
+            v3_scale_dot_sub_normalize(vOs, n, tri_info.vOs);
+            v3_scale_dot_sub_normalize(vOt, n, tri_info.vOt);
+
+            // original face number
+            const iOF_1 = tri_info.iOrgFaceNumber;
+
+            let iMembers = 0;
+            for (let j = 0; j < pGroup.iNrFaces; j++) {
+                const t = pGroup.pFaceIndices[j];	// triangle number
+                const iOF_2 = pTriInfos[t].iOrgFaceNumber;
+
+                // project
+                v3_scale_dot_sub_normalize(vOs2, n, pTriInfos[t].vOs);
+                v3_scale_dot_sub_normalize(vOt2, n, pTriInfos[t].vOt);
+
+                const bAny = ((tri_info.iFlag | pTriInfos[t].iFlag) & GROUP_WITH_ANY) !== 0;
+
+                // make sure triangles which belong to the same quad are joined.
+                const bSameOrgFace = iOF_1 === iOF_2;
+
+                const fCosS = vec3.dot(vOs, vOs2);
+                const fCosT = vec3.dot(vOt, vOt2);
+
+                assert(f !== t || bSameOrgFace);	// sanity check
+
+                if (bAny || bSameOrgFace || (fCosS > fThresCos && fCosT > fThresCos)) {
+                    pTmpMembers[iMembers++] = t;
+                }
+
+            }
+
+            // sort pTmpMembers
+            tmp_group.iNrFaces = iMembers;
+            tmp_group.pTriMembers = pTmpMembers;
+
+            if (iMembers > 1) {
+                // could replace with a random seed?
+                QuickSort(pTmpMembers, 0, iMembers - 1, INTERNAL_RND_SORT_SEED);
+            }
+
+            // look for an existing match
+            bFound = false;
+            let l = 0;
+            while (l < iUniqueSubGroups && !bFound) {
+
+                bFound = CompareSubGroups(tmp_group, pUniSubGroups[l]);
+
+                if (!bFound) {
+                    ++l;
+                }
+            }
+
+            // assign tangent space index
+            assert(bFound || l === iUniqueSubGroups);
+            //piTempTangIndices[f*3+index] = iUniqueTspaces+l;
+
+            // if no match was found we allocate a new subgroup
+            if (!bFound) {
+                // insert new subgroup
+                const pIndices = new Int32Array(iMembers);
+
+                pUniSubGroups[iUniqueSubGroups].iNrFaces = iMembers;
+                pUniSubGroups[iUniqueSubGroups].pTriMembers = pIndices;
+
+                array_copy(tmp_group.pTriMembers, 0, pIndices, 0, iMembers);
+
+                EvalTspace(
+                    pSubGroupTspace[iUniqueSubGroups],
+                    tmp_group.pTriMembers,
+                    iMembers,
+                    piTriListIn,
+                    pTriInfos,
+                    pContext,
+                    pGroup.iVertexRepresentitive
+                );
+
+                ++iUniqueSubGroups;
+            }
+
+            // output tspace
+
+            const iOffs = tri_info.iTSpacesOffs;
+            const iVert = tri_info.vert_num[index];
+
+            /**
+             * @type {STSpace}
+             */
+            const pTS_out = psTspace[iOffs + iVert];
+
+            assert.lessThan(pTS_out.iCounter, 2);
+            assert.equal(((tri_info.iFlag & ORIENT_PRESERVING) !== 0), pGroup.bOrientPreservering);
+
+            if (pTS_out.iCounter === 1) {
+
+                AvgTSpace(pTS_out, pTS_out, pSubGroupTspace[l]);
+                pTS_out.iCounter = 2;	// update counter
+                pTS_out.bOrient = pGroup.bOrientPreservering;
+
+            } else {
+
+                assert.equal(pTS_out.iCounter, 0);
+
+                pTS_out.copy(pSubGroupTspace[l]);
+                pTS_out.iCounter = 1;	// update counter
+                pTS_out.bOrient = pGroup.bOrientPreservering;
+
+            }
+
+        }
+
+        // clean up and offset iUniqueTspaces
+
+        iUniqueTspaces += iUniqueSubGroups;
+    }
+}

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

@@ -0,0 +1,45 @@
+/**
+ * resolve ordering and edge number
+ * @param {number[]} out
+ * @param {number} out_offset
+ * @param {number[]} indices
+ * @param {number} indices_offset
+ * @param {number} i0_in
+ * @param {number} i1_in
+ * @returns {void}
+ */
+export function GetEdge(out, out_offset, indices, indices_offset, i0_in, i1_in) {
+
+    // test if first index is on the edge
+    const index_0 = indices[indices_offset];
+    const index_1 = indices[indices_offset + 1];
+
+    if (index_0 === i0_in || index_0 === i1_in) {
+
+        // test if second index is on the edge
+        if (index_1 === i0_in || index_1 === i1_in) {
+
+            out[out_offset + 2] = 0; // first edge
+
+            out[out_offset] = index_0; //i0
+            out[out_offset + 1] = index_1; //i1
+
+        } else {
+
+            out[out_offset + 2] = 2; // third edge
+
+            out[out_offset] = indices[indices_offset + 2]; //i0
+            out[out_offset + 1] = index_0; //i1
+
+        }
+
+    } else {
+
+        // only second and third index is on the edge
+        out[out_offset + 2] = 1; // second edge
+
+        out[out_offset] = index_1; //i0
+        out[out_offset + 1] = indices[indices_offset + 2]; //i1
+
+    }
+}

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

@@ -0,0 +1,16 @@
+import { m_getNormal } from "./m_getNormal.js";
+
+/**
+ *
+ * @param {vec3|number[]|Float32Array} res
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number} index
+ */
+export function GetNormal(res, pContext, index) {
+
+    // inlined : IndexToData(&iF, &iI, index);
+    const iI = index & 0x3;
+    const iF = index >> 2;
+
+    m_getNormal(pContext, res, iF, iI);
+}

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

@@ -0,0 +1,25 @@
+/**
+ *
+ * @param {vec3|Float32Array|number[]} out
+ * @param {number} out_offset
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number} index
+ */
+export function GetPosition(out, out_offset, pContext, index) {
+
+    // inlined : IndexToData(&iF, &iI, index);
+    const iI = index & 0x3;
+    const iF = index >> 2;
+
+    // figure out which vertex it is
+    const vertex_index = pContext.geometry_buffer_index[iF * 3 + iI];
+
+    const position = pContext.geometry_buffer_vertex_position;
+
+    const position_offset = vertex_index * 3;
+
+    out[out_offset] = position[position_offset];
+    out[out_offset + 1] = position[position_offset + 1];
+    out[out_offset + 2] = position[position_offset + 2];
+
+}

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

@@ -0,0 +1,18 @@
+import { m_getTexCoord } from "./m_getTexCoord.js";
+
+/**
+ * TODO doesn't need to be V3, can save memory
+ * @param {vec3} res
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number} index
+ */
+export function GetTexCoord(res, pContext, index) {
+
+    // inlined : IndexToData(&iF, &iI, index);
+    const iI = index & 0x3;
+    const iF = index >> 2;
+
+    m_getTexCoord(pContext, res, iF, iI);
+
+    res[2] = 1;
+}