@woosh/meep-engine 2.34.42 → 2.34.46

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/core/graph/convertGraphToDotString.js

@@ -2,7 +2,7 @@ import LineBuilder from "../codegen/LineBuilder.js";
 import { EdgeDirectionType } from "./Edge.js";
 
 /**
- * Build a DOT representation of the graph
+ * Build a Graphviz DOT representation of the graph
  * @param {Graph} graph
  * @returns {string}
  */
@@ -13,7 +13,7 @@ export function convertGraphToDotString(graph) {
 
     lb.indent();
 
-    const nodes = graph.nodes;
+    const nodes = Array.from(graph.getNodes());
     const nodeCount = nodes.length;
 
     function nodeId(index) {
@@ -33,9 +33,9 @@ export function convertGraphToDotString(graph) {
 
         const node = nodes[i];
 
-        const attachedEdges = graph.getAttachedEdges(node);
+        const attachedEdges = [];
 
-        const nAttachedEdges = attachedEdges.length;
+        const nAttachedEdges = graph.getAttachedEdges(attachedEdges, node);
 
         for (let j = 0; j < nAttachedEdges; j++) {
             const edge = attachedEdges[j];

package/core/graph/v2/Graph.js

@@ -335,6 +335,10 @@ export class Graph {
      * @returns {number}
      */
     getAttachedEdges(result, node) {
+        assert.defined(result, 'result');
+        assert.isArray(result, 'result');
+        assert.defined(node, 'node');
+
         const context = this.__nodes.get(node);
 
         if (context === undefined) {

package/core/math/fabsf.js

@@ -0,0 +1,8 @@
+/**
+ * Float ABS, from standard C lib
+ * @param {Number} val
+ * @returns {number}
+ */
+export function fabsf(val) {
+    return val >= 0 ? val : -val;
+}

package/engine/development/performance/MetricCollection.js

@@ -10,6 +10,12 @@ export class MetricCollection {
         this.data = new Map();
     }
 
+    clear() {
+        this.data.forEach((value, key) => {
+            value.clear();
+        });
+    }
+
     /**
      *
      * @returns {string[]}

package/engine/ecs/foliage/ecs/Foliage2System.js

@@ -116,8 +116,9 @@ export class Foliage2System extends System {
         graphics.views.elements.on.added.add(this.__handle_view_added, this);
         graphics.views.elements.on.removed.add(this.__handle_view_removed, this);
 
-        this.renderLayer.buildVisibleSet = (view, visitObject, thisArg) => {
+        this.renderLayer.buildVisibleSet = (destination, destination_offset, view) => {
             const data = this.data;
+            let additions = 0;
 
             for (let entity in data) {
 
@@ -147,11 +148,14 @@ export class Foliage2System extends System {
                         }
 
                         const mesh = group.mesh;
-                        visitObject.call(thisArg, mesh);
+
+                        destination[additions + destination_offset] = mesh;
                     }
 
                 }
             }
+
+            return additions;
         };
 
         readyCallback();

package/engine/graphics/compute_geometry_polycount.js

@@ -0,0 +1,21 @@
+/**
+ *
+ * @param {THREE.BufferGeometry} geometry
+ * @returns {number}
+ */
+export function compute_geometry_polycount(geometry) {
+    const index = geometry.getIndex();
+
+    if (index !== null) {
+        return index.count / 3;
+    }
+
+    const position_attribute = geometry.getAttribute('position');
+
+    if (position_attribute !== undefined) {
+        return position_attribute.count / 3;
+    }
+
+    // no valid way to discern polycount, assume 0
+    return 0;
+}

package/engine/graphics/ecs/light/binding/three/ThreeLightBinding.js

@@ -58,7 +58,7 @@ function scene_object_filter(object3D) {
         /**
          * @type {THREE.Material|null|undefined}
          */
-        const material = (object3D.customDepthMaterial !== null ? object3D.customDepthMaterial : object3D.material);
+        const material = (object3D.customDepthMaterial ? object3D.customDepthMaterial : object3D.material);
 
         if (material && material.visible === false) {
             //material's main

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

@@ -1,12 +1,12 @@
 import { ShadedGeometry } from "./ShadedGeometry.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { System } from "../../../ecs/System.js";
-import { intersectRay } from "../../../../core/bvh2/aabb3/AABB3Math.js";
 import { GeometrySpatialQueryAccelerator } from "../../geometry/buffered/query/GeometrySpatialQueryAccelerator.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
 import { mat4 } from "gl-matrix";
 import { returnTrue } from "../../../../core/function/Functions.js";
+import { aabb3_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
 
 /**
  *
@@ -142,7 +142,7 @@ export class ShadedGeometrySystem extends System {
             const node = traversal_stack[traversal_cursor];
 
             // test node against the ray
-            const intersects = intersectRay(
+            const intersects = aabb3_intersects_ray(
                 node.x0, node.y0, node.z0,
                 node.x1, node.y1, node.z1,
                 origin_x, origin_y, origin_z,

package/engine/graphics/ecs/mesh-v2/sample/prototypeShadedGeometry.js

@@ -1,9 +1,18 @@
 import { EngineHarness } from "../../../../EngineHarness.js";
-import { ShadedGeometrySystem } from "../ShadedGeometrySystem.d.ts";
-import EntityBuilder from "../../../../ecs/EntityBuilder.d.ts";
-import { Transform } from "../../../../ecs/transform/Transform.d.ts";
-import { ShadedGeometry } from "../ShadedGeometry.d.ts";
+import { ShadedGeometrySystem } from "../ShadedGeometrySystem.js";
+import EntityBuilder from "../../../../ecs/EntityBuilder.js";
+import { Transform } from "../../../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "../ShadedGeometry.js";
 import { BoxBufferGeometry, MeshBasicMaterial } from "three";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
+import ViewportPosition from "../../../../ecs/gui/position/ViewportPosition.js";
+import GUIElement from "../../../../ecs/gui/GUIElement.js";
+import ButtonView from "../../../../../view/elements/button/ButtonView.js";
+import { downloadAsFile } from "../../../../../core/binary/ByteArrayTools.js";
+import { convert_bvh_to_dot_format_string } from "../../../../../core/bvh2/visual/convert_bvh_to_dot_format_string.js";
+import ViewportPositionSystem from "../../../../ecs/gui/position/ViewportPositionSystem.js";
+import GUIElementSystem from "../../../../ecs/gui/GUIElementSystem.js";
 
 const eh = new EngineHarness();
 
@@ -22,10 +31,71 @@ async function main(engine) {
 
     const ecd = em.dataset;
 
+    const material = new MeshBasicMaterial({
+        color: 0xFFFFFF
+    });
+
+    // material.visible = false;
+
+    window.material = material;
+
+    const geometry = new BoxBufferGeometry();
+
+    const random = seededRandom(0);
+
+    for (let i = 0; i < 100000; i++) {
+
+        new EntityBuilder()
+            .add(Transform.fromJSON({
+                position: {
+                    x: randomFloatBetween(random, -50, 50),
+                    y: randomFloatBetween(random, 0, 10),
+                    z: randomFloatBetween(random, -50, 50)
+                },
+                scale: 0.01
+            }))
+            .add(ShadedGeometry.from(geometry, material))
+            .build(ecd);
+    }
+
+    debug_button(engine, () => {
+        const dot = convert_bvh_to_dot_format_string(engine.graphics.layers.getLayerByName('shaded-geometry').bvh);
+        downloadAsFile(dot, 'bvh.dot', 'text');
+
+    }, 'save dot file');
+
+}
+
+
+const entityManager = engine.entityManager;
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {function} action
+ * @param {string} [name]
+ * @param {EntityComponentDataset} ecd
+ */
+function debug_button(engine, action, name = "Button", ecd = entityManager.dataset) {
+    if (entityManager.getSystem(ViewportPositionSystem) === null) {
+        entityManager.addSystem(new ViewportPositionSystem(engine.graphics.viewport.size));
+    }
+
+    if (entityManager.getSystem(GUIElementSystem) === null) {
+        entityManager.addSystem(new GUIElementSystem(engine.gui.view, engine));
+    }
+
     new EntityBuilder()
-        .add(new Transform())
-        .add(ShadedGeometry.from(new BoxBufferGeometry(), new MeshBasicMaterial({
-            color: 0xFFFFFF
+        .add(ViewportPosition.fromJSON({}))
+        .add(GUIElement.fromView(new ButtonView({
+            action,
+            name,
+            css: {
+                background: 'rgba(255,255,255,0.8)',
+                border: '1px solid black',
+                borderRadius: '4px',
+                padding: '2px',
+            }
         })))
         .build(ecd);
 }

package/engine/graphics/geometry/buffered/query/RaycastNearestHitComputingVisitor.js

@@ -1,9 +1,9 @@
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import { NodeType } from "../../../../../core/bvh2/binary/NodeType.js";
-import { intersectRay } from "../../../../../core/bvh2/aabb3/AABB3Math.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
 import { computeTriangleRayIntersection } from "../../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import { GeometrySpatialAcceleratorVisitor } from "./GeometryVisitor.js";
+import { aabb3_intersects_ray } from "../../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
 
 export class RaycastNearestHitComputingVisitor extends GeometrySpatialAcceleratorVisitor {
     constructor() {
@@ -158,7 +158,7 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
             const y1 = data[address + 4];
             const z1 = data[address + 5];
 
-            return intersectRay(
+            return aabb3_intersects_ray(
                 x0, y0, z0,
                 x1, y1, z1,
 

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/format/MicronGeometryPatchOccurance.js

@@ -1,4 +1,5 @@
 import { squirrel3 } from "../../../../core/math/hash/squirrel3.js";
+import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 
 export class MicronGeometryPatchOccurrence {
     constructor() {
@@ -21,7 +22,7 @@ export class MicronGeometryPatchOccurrence {
         this.patch = null;
         /**
          *
-         * @type {THREE.Matrix4|null}
+         * @type {number[]|Float32Array|null}
          */
         this.transform = null;
     }
@@ -41,7 +42,7 @@ export class MicronGeometryPatchOccurrence {
         return this.geometry_id === other.geometry_id
             && this.instance_id === other.instance_id
             && this.patch.id === other.patch.id
-            && this.transform.equals(other.transform)
+            && isArrayEqualStrict(this.transform, other.transform)
             ;
     }
 

package/engine/graphics/micron/plugin/GLTFAssetTransformer.js

@@ -0,0 +1,176 @@
+import { AssetTransformer } from "../../../asset/AssetTransformer.js";
+import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
+import { MICRON_URI_FIELD } from "../MICRON_URI_FIELD.js";
+import { computePathDirectory } from "../../../../core/FilePath.js";
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { MicronGeometry } from "../format/MicronGeometry.js";
+import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
+import { async_traverse_three_object } from "../../../asset/loaders/async_traverse_three_object.js";
+import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
+import { compute_geometry_polycount } from "../../compute_geometry_polycount.js";
+import { traverseThreeObject } from "../../ecs/highlight/renderer/traverseThreeObject.js";
+import { max2 } from "../../../../core/math/max2.js";
+
+export const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
+
+const DEFAULT_THRESHOLD_POLYCOUNT = 1024;
+
+/**
+ *
+ * @param {THREE.Object3D} object
+ * @return {number}
+ */
+function max_polycount(object) {
+    let r = 0;
+
+    traverseThreeObject(object, (m) => {
+        if (m.isMesh) {
+            const geo = m.geometry;
+            if (geo !== null) {
+                r = max2(r, compute_geometry_polycount(geo))
+            }
+        }
+    });
+
+    return r;
+}
+
+export class GLTFAssetTransformer extends AssetTransformer {
+    /**
+     *
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
+     */
+    constructor(cache) {
+        super();
+
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @private
+         */
+        this.__cache = cache;
+
+        /**
+         *
+         * @type {AssetManager|null}
+         * @private
+         */
+        this.__am = null;
+
+        /**
+         * Minimum number of polygons required for micron to be used
+         * @type {number}
+         * @private
+         */
+        this.__threshold_polycount = DEFAULT_THRESHOLD_POLYCOUNT;
+
+        /**
+         *
+         * @type {MicronGeometryBinarySerializationAdapter}
+         * @private
+         */
+        this.__serde = new MicronGeometryBinarySerializationAdapter();
+    }
+
+    /**
+     *
+     * @param {AssetManager|null} am
+     */
+    set assetManager(am) {
+        this.__am = am;
+    }
+
+
+    /**
+     * @param {THREE.Object3D} object
+     * @param {{asset:AssetDescription}} ctx
+     * @return {Promise<void>}
+     * @private
+     */
+    async __visitObjectToLoadMicron(object, ctx) {
+        if (!object.isMesh) {
+            return;
+        }
+
+        /**
+         * @type {THREE.BufferGeometry}
+         */
+        const geometry = object.geometry;
+
+        const micron_uri = geometry.userData[MICRON_URI_FIELD];
+
+        if (typeof micron_uri !== "string") {
+            return;
+        }
+
+
+        /**
+         * @type {AssetDescription}
+         */
+        const ad = ctx.asset;
+
+        const base = computePathDirectory(ad.path);
+
+        let micron_data;
+
+        const micron_path = `${base}/${micron_uri}`;
+
+        try {
+            micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER);
+        } catch (e) {
+            console.error(`Failed to load micron geometry '${micron_path}' referenced in GLTF (will skip): ${e}`);
+            return;
+        }
+
+        // deserialize micron data
+        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
+        const micron_geometry = new MicronGeometry();
+
+        this.__serde.deserialize(buffer, micron_geometry);
+
+        // set proxy for raycasting
+        micron_geometry.proxy = geometry;
+
+        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
+    }
+
+
+    /**
+     *
+     * @param {Asset} source
+     * @param {AssetDescription} asset_description
+     * @return {Promise<Asset>}
+     */
+    async transform(source, asset_description) {
+        const animationClips = source.animations;
+
+        if (animationClips !== undefined && animationClips.length > 0) {
+            // animations might cause trouble
+            console.warn(`model '${asset_description.path}' contains animations, these animations might not works as intended with micron.`);
+        }
+
+        /**
+         * @type {THREE.Object3D}
+         */
+        const root = source.create();
+
+        const gltf_max_polycount = max_polycount(root);
+
+        if (gltf_max_polycount < this.__threshold_polycount) {
+            // no change, geometries are too small
+            return source;
+        }
+
+        // attempt to load existing micron geometries
+        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
+            asset: asset_description
+        });
+
+        const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
+        micron_root.boundingSphere = root.boundingSphere;
+
+        source.override_mesh = micron_root;
+
+        return source;
+    }
+}