@woosh/meep-engine 2.34.44 → 2.34.45

package/core/geom/3d/topology/TopoMesh.js

@@ -31,14 +31,6 @@ export class TopoMesh {
         this.__faces = new Set();
     }
 
-    get edges() {
-        throw new Error('Deprecated accessor, use getEdges instead');
-    }
-
-    get faces() {
-        throw new Error('Deprecated accessor, use getEdges instead');
-    }
-
     /**
      *
      * @returns {Set<TopoEdge>}

package/core/geom/3d/topology/TopoVertex.js

@@ -241,24 +241,25 @@ export class TopoVertex {
         const faces = victim.faces;
         const face_count = faces.length;
 
-        for (let i = 0; i < face_count; i++) {
+        let i = 0;
+
+        for (; i < face_count; i++) {
             // take over the victim's faces
             const face = faces[i];
 
-            // DEBUG
-            face.computeNormal();
+
+            // face.computeNormal(); // DEBUG
             face.replaceVertex(victim, this);
 
             this.addUniqueFace(face);
 
-            // DEBUG
-            face.computeNormal();
+            // face.computeNormal(); // DEBUG
         }
 
         const edges = victim.edges;
         const edge_count = edges.length;
 
-        for (let i = 0; i < edge_count; i++) {
+        for (i = 0; i < edge_count; i++) {
             // take over the victim's edges
             const edge = edges[i];
 

package/core/geom/3d/topology/simplify/quadratic/Quadratic3.js

@@ -1,4 +1,7 @@
 import { v3_dot } from "../../../../v3_dot.js";
+import { fabsf } from "../../../../../math/fabsf.js";
+import { EPSILON } from "../../../../../math/MathUtils.js";
+import { vec3 } from "gl-matrix";
 
 export class Quadratic3 {
     constructor() {
@@ -21,6 +24,74 @@ export class Quadratic3 {
         this.d2 = 0;
     }
 
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} result
+     */
+    toVector3(result) {
+        result[0] = this.ad;
+        result[1] = this.bd;
+        result[2] = this.cd;
+    }
+
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} m3
+     */
+    toTensorM3(m3) {
+        m3[0] = this.a2;
+        m3[1] = this.ab;
+        m3[2] = this.ac;
+
+        m3[3] = this.ab;
+        m3[4] = this.b2;
+        m3[5] = this.bc;
+
+        m3[6] = this.ac;
+        m3[7] = this.bc;
+        m3[8] = this.c2;
+    }
+
+    /**
+     * Equivalent to taking a tensor followed by matrix inversion
+     * @param {ArrayLike<number>|number[]|Float32Array} m3
+     * @param {number} epsilon
+     * @returns {boolean} whether operation was successful or not
+     */
+    toTensorM3Inverse(m3, epsilon) {
+        const a2 = this.a2;
+        const b2 = this.b2;
+        const c2 = this.c2;
+        const bc = this.bc;
+        const ab = this.ab;
+        const ac = this.ac;
+
+        const det = a2 * (b2 * c2 - bc * bc) -
+            ab * (ab * c2 - ac * bc) +
+            ac * (ab * bc - ac * b2);
+
+        if (fabsf(det) > epsilon) {
+
+            const invdet = 1.0 / det;
+
+            m3[0] = (b2 * c2 - bc * bc) * invdet;
+            m3[3] = (bc * ac - ab * c2) * invdet;
+            m3[6] = (ab * bc - b2 * ac) * invdet;
+
+            m3[1] = (ac * bc - ab * c2) * invdet;
+            m3[4] = (a2 * c2 - ac * ac) * invdet;
+            m3[7] = (ab * ac - a2 * bc) * invdet;
+
+            m3[2] = (ab * bc - ac * b2) * invdet;
+            m3[5] = (ac * ab - a2 * bc) * invdet;
+            m3[8] = (a2 * b2 - ab * ab) * invdet;
+
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * Set from plane expressed as a 4 component vector
      * @param {number} x plane normal
@@ -78,18 +149,35 @@ export class Quadratic3 {
     evaluate(x, y, z) {
         // Evaluate vAv + 2bv + c
 
-        return x * x * this.a2 + 2 * x * y * this.ab + 2 * x * z * this.ac + 2 * x * this.ad
-            + y * y * this.b2 + 2 * y * z * this.bc + 2 * y * this.bd
-            + z * z * this.c2 + 2 * z * this.cd
-            + this.d2;
+        return (x * x * this.a2) + (2 * x * y * this.ab) + (2 * x * z * this.ac) + (2 * x * this.ad)    // A
+            + (y * y * this.b2) + (2 * y * z * this.bc) + (2 * y * this.bd)                             // B
+            + (z * z * this.c2) + (2 * z * this.cd)                                                     // C
+            + this.d2;                                                                                  // D
     }
 
     /**
+     * Find optimal vertex position based on the quadratic
+     *
+     * Based on Bleder's implementation: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/quadric.c
      *
      * @param {number[]} out
+     * @returns {boolean}
      */
     optimize(out) {
-        throw new Error('Not Implemented');
+        const m = new Float32Array(9);
+
+        if (this.toTensorM3Inverse(m, EPSILON)) {
+
+            this.toVector3(out);
+
+            vec3.transformMat3(out, out, m);
+            vec3.negate(out, out);
+
+            return true;
+        }
+
+        return false;
+
     }
 
     /**

package/core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js

@@ -31,7 +31,10 @@ export function build_vertex_quadratics(mesh, quadratics) {
     const mesh_vertices = mesh.vertices;
     const mesh_vertex_count = mesh_vertices.length;
 
-    for (let i = 0; i < mesh_vertex_count; i++) {
+
+    let i, face;
+
+    for (i = 0; i < mesh_vertex_count; i++) {
         const mesh_vertex = mesh_vertices[i];
 
         const vertex_quadratic = new Quadratic3();
@@ -44,15 +47,15 @@ export function build_vertex_quadratics(mesh, quadratics) {
 
     const faces = mesh.getFaces();
 
-    for (let face of faces) {
+    for (face of faces) {
 
         q.setFromFace(face);
 
         const face_vertices = face.vertices;
         const face_vertex_count = face_vertices.length;
 
-        for (let j = 0; j < face_vertex_count; j++) {
-            const face_vertex = face_vertices[j];
+        for (i = 0; i < face_vertex_count; i++) {
+            const face_vertex = face_vertices[i];
 
             // accumulate to adjacent vertex
             const face_vertex_quadratic = quadratics.get(face_vertex.index);

package/core/geom/3d/topology/simplify/quadratic/compute_edge_collapse_cost_quadratic.js

@@ -18,5 +18,11 @@ export function compute_edge_collapse_cost_quadratic(
     const q_v0 = q0.evaluate(target.x, target.y, target.z);
     const q_v1 = q1.evaluate(target.x, target.y, target.z);
 
-    return q_v0 + q_v1;
+    /**
+     * 'cost' shouldn't be negative but happens sometimes with small values.
+     * @type {number}
+     */
+    const cost = Math.abs(q_v0 + q_v1);
+
+    return cost;
 }

package/core/geom/3d/topology/simplify/simplifyTopoMesh.js

@@ -23,7 +23,6 @@ export function extract_edge_cost(edge) {
 /**
  * @param {number} number_faces_to_remove minimum number of faces to removed
  * @param {BinaryHeap<EdgeCollapseCandidate>} heap
- * @param {EdgeCollapseCandidate[]} removed_edges
  * @param {TopoMesh} mesh
  * @param {Map<TopoEdge, EdgeCollapseCandidate>} edge_to_collapse_map
  * @param {Map<number, Quadratic3>} vertex_quadratics
@@ -32,7 +31,6 @@ export function extract_edge_cost(edge) {
 export function collapse_edges(
     number_faces_to_remove,
     heap,
-    removed_edges,
     mesh,
     edge_to_collapse_map,
     vertex_quadratics,
@@ -64,8 +62,6 @@ export function collapse_edges(
         //     continue;
         // }
 
-        removed_edges.push(collapse_candidate);
-
         // find edges that need to be updated
         const victim_vertex = collapse_candidate.victim_vertex;
 
@@ -208,21 +204,15 @@ export function collapse_edges(
  * @param {TopoMesh} mesh
  * @param {number} num_faces_to_remove desired number of faces to remove
  * @param {Set<number>} [restricted_vertices] vertices that are not allowed to be removed
- * @returns {EdgeCollapseCandidate[]} collapsed edges
  */
 export function simplifyTopoMesh(mesh, num_faces_to_remove, restricted_vertices = new Set()) {
-    /**
-     *
-     * @type {EdgeCollapseCandidate[]}
-     */
-    const removed_edges = [];
 
     const faces = mesh.getFaces();
     const face_count = faces.size;
 
     if (num_faces_to_remove <= 0 || face_count <= 0) {
         // we're already at the target
-        return removed_edges;
+        return ;
     }
 
 
@@ -258,7 +248,6 @@ export function simplifyTopoMesh(mesh, num_faces_to_remove, restricted_vertices
     collapse_edges(
         num_faces_to_remove,
         open_set,
-        removed_edges,
         mesh,
         edge_to_collapse_map,
         vertex_quadratics,
@@ -270,6 +259,4 @@ export function simplifyTopoMesh(mesh, num_faces_to_remove, restricted_vertices
     collapse_all_degenerate_edges(mesh.getEdges(), mesh);
 
     // debugValidateMesh(mesh);
-
-    return removed_edges;
 }

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -15,6 +15,7 @@ import { compute_buffer_geometry_byte_size } from "../../geometry/buffered/compu
 import { deinterleaveBufferGeometry } from "../../geometry/buffered/deinterleaveBufferGeometry.js";
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import { aabb3_from_v3_array } from "../../../../core/bvh2/aabb3/aabb3_from_v3_array.js";
+import { update_topo_face_normals } from "../../../../core/geom/3d/topology/update_topo_face_normals.js";
 
 /**
  * Returns current time in milliseconds
@@ -142,6 +143,9 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
 
     expandConnectivityByLocality(topoMesh, geometry_aabb);
 
+    // ensure faces have normals for mesh simplification
+    update_topo_face_normals(Array.from(topoMesh.getFaces()), topoMesh.getFaces().size);
+
     /**
      * Used to generate neighbourhood assignment
      * @type {Map<number, PatchRepresentation>}

package/engine/graphics/micron/build/hierarchy/merge_patches.js

@@ -399,7 +399,6 @@ async function many_to_many_merge(
         collapse_edges(
             num_desired_faces_to_remove,
             open_set,
-            [],
             merged_mesh,
             edge_to_collapse_map,
             vertex_quadratics,
@@ -462,6 +461,7 @@ async function many_to_many_merge(
     // );
 
     const group_per_pixel_error = group_inverse_polycount;
+    // const group_per_pixel_error = Math.sqrt(largest_squared_error);
 
     // split topology into desired number of pieces
     const pieces = recursive_split_mesh_partition(merged_mesh, actual_up_count, MICRON_PATCH_SIZE_MAX);

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -76,6 +76,8 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
 
         await micron_cache.set(g, micron_geometry);
 
+        // console.log(micron_geometry);
+
         return micron_geometry;
     }
 

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -48,7 +48,6 @@ import { CanvasView } from "../../../view/elements/CanvasView.js";
 import { Sampler2D } from "../texture/sampler/Sampler2D.js";
 import { downsampleSampler2D } from "../texture/sampler/downsampleSampler2D.js";
 import { ShadowMapRenderer } from "../shadows/ShadowMapRenderer.js";
-import { MouseEvents } from "../../input/devices/events/MouseEvents.js";
 import { mat4 } from "gl-matrix";
 
 const background = new TextureLoader().load('data/textures/utility/checkers_white_grey_256x256.png');
@@ -461,13 +460,14 @@ function init() {
     // sample_gltf_sponza();
     // gltf_sample('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
     sample_lucy();
+    // sample_dragon();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
     // sample_gltf_broken_isiflow();
     // gltf_grid('data/models/moicon/Kople/EVCharger1.gltf');
     // gltf_grid('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
-    // gltf_sample('data/models/moicon/08-clickable-assets/model.gltf');
-    // gltf_sample('data/models/moicon/05-ground-floor/model.gltf');
+    // gltf_sample('moicon/08-clickable-assets/model.gltf');
+    // gltf_sample('moicon/05-ground-floor/model.gltf');
     // gltf_sample('data/models/moicon/isiflow_Oct_15_21/0/model.gltf');
     // gltf_sample('moicon/29_Dec_2021_Nammo/1/model.gltf');
     // gltf_sample('moicon/29_Dec_2021_Nammo/1-onematerial/model.gltf');
@@ -546,6 +546,7 @@ function onWindowResize() {
  * @param {number} scale
  */
 function createScene(geometry, m1, scale) {
+
     geometry.computeVertexNormals();
 
 
@@ -798,7 +799,7 @@ function render() {
     // console.log(`patches:${active_patches.length}, polycount:${polycount}`);
 }
 
-window.document.body.addEventListener(MouseEvents.Move, ({ clientX, clientY }) => {
+const raycast_handler = ({ clientX, clientY }) => {
     const direction = new Vector3();
 
     const viewport_size = new Vector2();
@@ -858,5 +859,7 @@ window.document.body.addEventListener(MouseEvents.Move, ({ clientX, clientY }) =
     if (hits.length > 0) {
         console.log(`HITS: ${hits.map(JSON.stringify).join(',')}`);
     }
-});
+};
+
+// window.document.body.addEventListener(MouseEvents.Move, raycast_handler);
 

package/engine/graphics/micron/render/VirtualGeometryBuilder.js

@@ -125,7 +125,6 @@ export class VirtualGeometryBuilder {
                 // get acl
                 const acl = this.__acl;
 
-                acl.initializeFromGeometry(micron_geometry);
 
                 this.buildForMesh(
                     object.instance_id,
@@ -159,6 +158,7 @@ export class VirtualGeometryBuilder {
         transform,
         apl
     ) {
+        apl.initializeFromGeometry(geometry);
 
         refinement_spec.build(transform, this.view_projection_matrix);
 
@@ -239,7 +239,6 @@ export class VirtualGeometryBuilder {
         // clear output
         this.output.clear();
 
-        this.__info_enforced_node_splits = 0;
 
         const n = this.input_scene_length;
         const input_objects = this.input_scene;

package/engine/graphics/micron/render/refinement/ActivePatchList.js

@@ -194,8 +194,6 @@ export class ActivePatchList {
 
             const node = record.patch;
 
-            // check if record needs to be split
-            const prev_is_visible = record.getFlag(ActivePatchFlags.Visible);
 
             /*
              check if node is in view frustum
@@ -205,16 +203,11 @@ export class ActivePatchList {
 
             if (!in_view_frustum) {
                 // outside of view frustum, cull
-                if (prev_is_visible) {
-                    record.clearFlag(ActivePatchFlags.Visible);
-                }
                 record = record.link_next;
                 continue;
             }
 
-            if (!prev_is_visible) {
-                record.setFlag(ActivePatchFlags.Visible);
-            }
+            record.setFlag(ActivePatchFlags.Visible);
 
             /*
              scale error to projection space:
@@ -224,6 +217,7 @@ export class ActivePatchList {
              */
 
 
+            // check if record needs to be split
             if (node.lod > 0) {
 
                 // not the lowest level of LOD, see if subdivision might be necessary

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -303,8 +303,8 @@ async function sample_scene_0(engine) {
     }
 
     // load_model('moicon/06_04_hapro/00-environment/model.gltf', -0.1);
-    load_model_s('moicon/06_04_hapro/05-ground-floor/model.gltf');
-    load_model_s('C:/git/moh/app/moicon/06_04_hapro/08-clickable-assets-new/model.gltf');
+    // load_model_s('moicon/06_04_hapro/05-ground-floor/model.gltf');
+    // load_model_s('C:/git/moh/app/moicon/06_04_hapro/08-clickable-assets-new/model.gltf');
     // load_model('moicon/06_04_hapro/02-bearers/model.gltf');
     // load_model('moicon/06_04_hapro/04-1st-floor/model.gltf');
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.34.44",
+  "version": "2.34.45",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",