@woosh/meep-engine 2.42.0 → 2.42.2

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

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

@@ -0,0 +1,180 @@
+import { GROUP_WITH_ANY } from "./constants/GROUP_WITH_ANY.js";
+import { vec3 } from "gl-matrix";
+import { GetPosition } from "./GetPosition.js";
+import { GetTexCoord } from "./GetTexCoord.js";
+import { ORIENT_PRESERVING } from "./constants/ORIENT_PRESERVING.js";
+import { NotZero } from "./NotZero.js";
+import { fabsf } from "../../../../core/math/fabsf.js";
+import { Length } from "./Length.js";
+import { MARK_DEGENERATE } from "./constants/MARK_DEGENERATE.js";
+import { CalcTexArea } from "./CalcTexArea.js";
+import { BuildNeighborsFast } from "./BuildNeighborsFast.js";
+
+const t1 = vec3.create();
+const t2 = vec3.create();
+const t3 = vec3.create();
+
+const d1 = vec3.create();
+const d2 = vec3.create();
+
+const vOs = vec3.create();
+const vOt = vec3.create();
+
+const v1 = vec3.create();
+const v2 = vec3.create();
+const v3 = vec3.create();
+
+const v_temp_0 = vec3.create();
+const v_temp_1 = vec3.create();
+
+/**
+ *
+ * @param {STriInfo[]} pTriInfos
+ * @param {number[]|Int32Array} piTriListIn
+ * @param {SMikkTSpaceContext} pContext
+ * @param {number} iNrTrianglesIn
+ * @returns {void}
+ */
+export function InitTriInfo(pTriInfos, piTriListIn, pContext, iNrTrianglesIn) {
+    let f = 0, i = 0, t = 0;
+    // pTriInfos[f].iFlag is cleared in GenerateInitialVerticesIndexList() which is called before this function.
+
+    // generate neighbor info list
+    for (f = 0; f < iNrTrianglesIn; f++) {
+        const tri = pTriInfos[f];
+
+        for (i = 0; i < 3; i++) {
+
+            tri.FaceNeighbors[i] = -1;
+            tri.AssignedGroup[i] = null;
+        }
+
+        tri.vOs[0] = 0.0;
+        tri.vOs[1] = 0.0;
+        tri.vOs[2] = 0.0;
+
+        tri.vOt[0] = 0.0;
+        tri.vOt[1] = 0.0;
+        tri.vOt[2] = 0.0;
+
+        tri.fMagS = 0;
+        tri.fMagT = 0;
+
+        // assumed bad
+        tri.iFlag |= GROUP_WITH_ANY;
+    }
+
+
+    // evaluate first order derivatives
+    for (f = 0; f < iNrTrianglesIn; f++) {
+        // initial values
+        const f3 = f * 3;
+
+        GetPosition(v1,0, pContext, piTriListIn[f3 + 0]);
+        GetPosition(v2,0, pContext, piTriListIn[f3 + 1]);
+        GetPosition(v3,0, pContext, piTriListIn[f3 + 2]);
+
+        GetTexCoord(t1, pContext, piTriListIn[f3 + 0]);
+        GetTexCoord(t2, pContext, piTriListIn[f3 + 1]);
+        GetTexCoord(t3, pContext, piTriListIn[f3 + 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];
+
+        vec3.sub(d1, v2, v1);
+        vec3.sub(d2, v3, v1);
+
+        const fSignedAreaSTx2 = t21x * t31y - t21y * t31x;
+        //assert(fSignedAreaSTx2!=0);
+
+        vec3.scale(v_temp_0, d1, t31y);
+        vec3.scale(v_temp_1, d2, t21y);
+        vec3.sub(vOs, v_temp_0, v_temp_1);	// eq 18
+
+
+        vec3.scale(v_temp_0, d1, -t31x);
+        vec3.scale(v_temp_1, d2, t21x);
+        vec3.add(vOt, v_temp_0, v_temp_1); // eq 19
+
+        const tri_info = pTriInfos[f];
+        tri_info.iFlag |= (fSignedAreaSTx2 > 0 ? ORIENT_PRESERVING : 0);
+
+        if (NotZero(fSignedAreaSTx2)) {
+            const fAbsArea = fabsf(fSignedAreaSTx2);
+
+            const fLenOs = Length(vOs);
+            const fLenOt = Length(vOt);
+
+            const fS = (tri_info.iFlag & ORIENT_PRESERVING) === 0 ? (-1.0) : 1.0;
+
+            if (NotZero(fLenOs)) {
+                vec3.scale(tri_info.vOs, vOs, fS / fLenOs);
+            }
+
+            if (NotZero(fLenOt)) {
+                vec3.scale(tri_info.vOt, vOt, fS / fLenOt);
+            }
+
+            // evaluate magnitudes prior to normalization of vOs and vOt
+            tri_info.fMagS = fLenOs / fAbsArea;
+            tri_info.fMagT = fLenOt / fAbsArea;
+
+            // if this is a good triangle
+            if (NotZero(tri_info.fMagS) && NotZero(tri_info.fMagT)) {
+                tri_info.iFlag &= (~GROUP_WITH_ANY);
+            }
+        }
+    }
+
+    // force otherwise healthy quads to a fixed orientation
+    while (t < (iNrTrianglesIn - 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;
+
+            // bad triangles should already have been removed by
+            // DegenPrologue(), but just in case check bIsDeg_a and bIsDeg_a are false
+            if ((bIsDeg_a || bIsDeg_b) === false) {
+                const bOrientA = (tri_0.iFlag & ORIENT_PRESERVING) !== 0;
+                const bOrientB = (tri_1.iFlag & ORIENT_PRESERVING) !== 0;
+
+                // if this happens the quad has extremely bad mapping!!
+                if (bOrientA !== bOrientB) {
+                    //printf("found quad with bad mapping\n");
+                    let bChooseOrientFirstTri = false;
+
+                    if ((tri_1.iFlag & GROUP_WITH_ANY) !== 0) {
+                        bChooseOrientFirstTri = true;
+                    } else if (CalcTexArea(pContext, piTriListIn, t * 3) >= CalcTexArea(pContext, piTriListIn, (t + 1) * 3 + 0)) {
+                        bChooseOrientFirstTri = true;
+                    }
+
+                    // force match
+                    const t0 = bChooseOrientFirstTri ? tri_0 : tri_1;
+                    const t1 = bChooseOrientFirstTri ? tri_1 : tri_0;
+                    t1.iFlag &= (~ORIENT_PRESERVING);	// clear first
+                    t1.iFlag |= (t0.iFlag & ORIENT_PRESERVING);	// copy bit
+                }
+            }
+            t += 2;
+        } else {
+            ++t;
+        }
+    }
+
+    // match up edge pairs
+
+    const pEdges = new Float32Array(iNrTrianglesIn * 3 * 3);
+    BuildNeighborsFast(pTriInfos, pEdges, piTriListIn, iNrTrianglesIn);
+
+}

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

@@ -0,0 +1,10 @@
+import { vec3 } from "gl-matrix";
+
+/**
+ *
+ * @param {vec3} v
+ * @returns {number}
+ */
+export function Length(v) {
+    return Math.sqrt(vec3.squaredLength(v));
+}

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

@@ -0,0 +1,18 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number} iFace
+ * @param {number} iVert
+ * @returns {number}
+ */
+export function MakeIndex(iFace, iVert) {
+    assert.greaterThanOrEqual(iVert, 0);
+    assert.lessThan(iVert, 4);
+    assert.greaterThanOrEqual(iFace, 0);
+
+    assert.isNonNegativeInteger(iFace,'iFace');
+    assert.isNonNegativeInteger(iVert,'iVert');
+
+    return (iFace << 2) | (iVert & 0x3);
+}