@woosh/meep-engine 2.42.0 → 2.42.2

package/engine/graphics/ecs/decal/v2/prototypeDecalSystem.js

@@ -1,15 +1,18 @@
 import { EngineHarness } from "../../../../EngineHarness.js";
 import { FPDecalSystem } from "./FPDecalSystem.js";
-import EntityBuilder from "../../../../ecs/EntityBuilder.js";
+import EntityBuilder, { EntityBuilderFlags } from "../../../../ecs/EntityBuilder.js";
 import { Decal } from "./Decal.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
-import Quaternion from "../../../../../core/geom/Quaternion.js";
 import { randomFromArray } from "../../../../../core/math/random/randomFromArray.js";
-import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
-import { RotationBehavior } from "../../../../../../model/game/util/behavior/RotationBehavior.js";
 import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { SGMeshSystem } from "../../mesh-v2/aggregate/SGMeshSystem.js";
+import { ShadedGeometrySystem } from "../../mesh-v2/ShadedGeometrySystem.js";
+import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
+import { SGMesh } from "../../mesh-v2/aggregate/SGMesh.js";
+import { GameAssetType } from "../../../../asset/GameAssetType.js";
+import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 
 const decal_urls = `data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/staff_13_t.png
 data/textures/icons/FantasyIconsMegaPack/MagicItems/MagicItems_png/transparent/x64/artifact_01_t.png
@@ -195,6 +198,12 @@ data/textures/utility/sampling-test.png`
     .split('\n')
     .map(a => a.trim());
 
+function promise_time_out(t) {
+    return new Promise(resolve => {
+        setTimeout(resolve, t);
+    });
+}
+
 /**
  *
  * @param {Engine} engine
@@ -202,36 +211,68 @@ data/textures/utility/sampling-test.png`
 async function main(engine) {
 
     await EngineHarness.buildBasics({
-        engine
+        engine,
+        enableWater: false,
+        cameraFarDistance: 300
     });
 
+    new EntityBuilder()
+        .add(SGMesh.fromURL("moicon/gnutti_not_optimized/model.gltf"))
+        .add(Transform.fromJSON({
+            position: { x: 10, y: 3, z: 10 },
+            scale: 1.5
+        }))
+    // .build(engine.entityManager.dataset);
+
+
     const random = seededRandom();
 
-    for (let i = 0; i < 100; i++) {
+    const ENTITY_COUNT = 10000;
+
+    for (let i = 0; i < ENTITY_COUNT; i++) {
         const decal = new Decal();
 
         decal.uri = randomFromArray(random, decal_urls);
 
-        new EntityBuilder()
-            .add(Transform.fromJSON({
-                position: { x: randomFloatBetween(random, 0, 10), y: 0, z: randomFloatBetween(random, 0, 10) },
-                rotation: Quaternion.random(random)
-            }))
+        const entity = new EntityBuilder();
+
+        entity.clearFlag(EntityBuilderFlags.WatchDestruction);
+
+        const transform = new Transform();
+        transform.position.set(
+            randomFloatBetween(random, -400, 400),
+            randomFloatBetween(random, 0, 0),
+            randomFloatBetween(random, -400, 400)
+        );
+        transform.rotation.random(random);
+        transform.scale.setScalar(0.5);
+
+        entity
+            .add(transform)
             .add(decal)
-            .add(BehaviorComponent.fromOne(RotationBehavior.fromJSON({
-                speed: 1
-            })))
-            .build(engine.entityManager.dataset);
+        // .add(BehaviorComponent.fromOne(RotationBehavior.fromJSON({ speed: 1 })))
+
+        entity.build(engine.entityManager.dataset);
+
     }
 
+    await promise_time_out(10);
+
+
 }
 
 new EngineHarness()
     .initialize({
         configuration(config, engine) {
+            const gltfAssetLoader = new GLTFAssetLoader();
+
+            config.addLoader(GameAssetType.ModelGLTF_JSON, gltfAssetLoader);
+            config.addLoader(GameAssetType.ModelGLTF, gltfAssetLoader);
 
             config.addSystem(new FPDecalSystem(engine));
             config.addSystem(new BehaviorSystem(engine))
-
+            config.addSystem(new SGMeshSystem(engine));
+            config.addSystem(new ShadedGeometrySystem(engine));
+            config.addSystem(new TransformAttachmentSystem(engine));
         }
     }).then(main);

package/engine/graphics/ecs/mesh-v2/allocate_v3.js

@@ -0,0 +1,37 @@
+/**
+ * Larger bucket sizes provide better cache locality
+ * Larger bucket sizes also cause more hanging GC references, as if one matrix element is still held - ENTIRE bucket is still referenced
+ * @type {number}
+ */
+const ALLOCATOR_BUCKET_CAPACITY = 42;
+
+/**
+ *
+ * @type {ArrayBuffer|null}
+ */
+let bucket = null;
+
+/**
+ *
+ * @type {number}
+ */
+let bucket_cursor = ALLOCATOR_BUCKET_CAPACITY;
+
+const ELEMENT_BYTE_SIZE = 4 * 3;
+
+/**
+ * custom Float32Array allocator, allocated memory in continuous chunks
+ * @returns {Float32Array}
+ */
+export function allocate_v3() {
+    if (bucket_cursor >= ALLOCATOR_BUCKET_CAPACITY) {
+        bucket = new ArrayBuffer(ALLOCATOR_BUCKET_CAPACITY * ELEMENT_BYTE_SIZE);
+        bucket_cursor = 0;
+    }
+
+    const result = new Float32Array(bucket, bucket_cursor * ELEMENT_BYTE_SIZE, 3);
+
+    bucket_cursor++;
+
+    return result;
+}

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

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {SGroup} pGroup
+ * @param {number} iTriIndex
+ * @returns {void}
+ */
+export function AddTriToGroup(pGroup, iTriIndex) {
+    pGroup.pFaceIndices[pGroup.iNrFaces] = iTriIndex;
+    pGroup.iNrFaces++;
+}

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

@@ -0,0 +1,84 @@
+import { assert } from "../../../../core/assert.js";
+import { GROUP_WITH_ANY } from "./constants/GROUP_WITH_ANY.js";
+import { ORIENT_PRESERVING } from "./constants/ORIENT_PRESERVING.js";
+import { AddTriToGroup } from "./AddTriToGroup.js";
+
+/**
+ *
+ * @param {number[]} piTriListIn
+ * @param {STriInfo[]} psTriInfos
+ * @param {number} iMyTriIndex
+ * @param {SGroup} pGroup
+ * @return {boolean}
+ */
+export function AssignRecur(
+    piTriListIn,
+    psTriInfos,
+    iMyTriIndex,
+    pGroup
+) {
+
+    // track down vertex
+    const iVertRep = pGroup.iVertexRepresentitive;
+    const triangle_address = iMyTriIndex * 3;
+
+    let i = -1;
+
+    if (piTriListIn[triangle_address] === iVertRep) {
+        i = 0;
+    } else if (piTriListIn[triangle_address + 1] === iVertRep) {
+        i = 1;
+    } else if (piTriListIn[triangle_address + 2] === iVertRep) {
+        i = 2;
+    }
+
+    assert.greaterThanOrEqual(i, 0);
+    assert.lessThan(i, 3);
+
+    const pMyTriInfo = psTriInfos[iMyTriIndex];
+
+    // early out
+    const sGroups = pMyTriInfo.AssignedGroup;
+
+    if (sGroups[i] === pGroup) {
+        return true;
+    } else if (sGroups[i] !== null) {
+        return false;
+    }
+
+    if ((pMyTriInfo.iFlag & GROUP_WITH_ANY) !== 0) {
+        // first to group with a group-with-anything triangle
+        // determines its orientation.
+        // This is the only existing order dependency in the code!!
+        if (
+            sGroups[0] === null &&
+            sGroups[1] === null &&
+            sGroups[2] === null
+        ) {
+            pMyTriInfo.iFlag &= (~ORIENT_PRESERVING);
+            pMyTriInfo.iFlag |= (pGroup.bOrientPreservering ? ORIENT_PRESERVING : 0);
+        }
+    }
+
+    const bOrient = (pMyTriInfo.iFlag & ORIENT_PRESERVING) !== 0;
+
+    if (bOrient !== pGroup.bOrientPreservering) {
+        return false;
+    }
+
+    AddTriToGroup(pGroup, iMyTriIndex);
+    sGroups[i] = pGroup;
+
+    const neigh_indexL = pMyTriInfo.FaceNeighbors[i];
+    const neigh_indexR = pMyTriInfo.FaceNeighbors[i > 0 ? (i - 1) : 2];
+
+    if (neigh_indexL >= 0) {
+        AssignRecur(piTriListIn, psTriInfos, neigh_indexL, pGroup);
+    }
+    if (neigh_indexR >= 0) {
+        AssignRecur(piTriListIn, psTriInfos, neigh_indexR, pGroup);
+    }
+
+
+    return true;
+}

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