@woosh/meep-engine 2.33.5 → 2.33.10

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

@@ -2,78 +2,6 @@ import { simplifyTopoMesh } from "../../../../../core/geom/3d/topology/simplify/
 import { MICRON_PATCH_SIZE_MAX } from "../MICRON_PATCH_SIZE_MAX.js";
 
 
-/**
- * @template T
- * @returns Set<T>
- * @param {Set<T>} a
- * @param {Set<T>} b
- */
-export function compute_set_intersection(a, b) {
-    const result = new Set();
-
-    const a_array = Array.from(a);
-
-    const n = a_array.length;
-    for (let i = 0; i < n; i++) {
-        const t = a_array[i];
-
-        if (b.has(t)) {
-            result.add(t);
-        }
-    }
-
-    return result;
-}
-
-/**
- * @template T
- * @returns Set<T>
- * @param {Set<T>} a
- * @param {Set<T>} b
- */
-export function compute_set_difference(a, b) {
-    const result = new Set();
-
-    const a_array = Array.from(a);
-    const a_count = a_array.length;
-    for (let i = 0; i < a_count; i++) {
-        const t = a_array[i];
-
-        if (!b.has(t)) {
-            result.add(t);
-        }
-    }
-
-    const b_array = Array.from(b);
-    const b_count = b_array.length;
-    for (let i = 0; i < b_count; i++) {
-        const t = b_array[i];
-
-        if (!a.has(t)) {
-            result.add(t);
-        }
-    }
-
-
-    return result;
-}
-
-/**
- * @template T
- * @param {Set<T>} a
- * @param {Set<T>} b
- */
-export function set_remove(a, b) {
-    const bs = Array.from(b);
-
-    const n = bs.length;
-    for (let i = 0; i < n; i++) {
-        const t = bs[i];
-
-        a.delete(t);
-    }
-}
-
 /**
  *
  * @param {Set<number>} result

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

@@ -1,7 +1,7 @@
 import { Graph } from "../../../../../core/graph/v2/Graph.js";
-import { MultiNode } from "../graph/MultiNode.js";
+import { MultiNode } from "../../../../../core/graph/MultiNode.js";
 import { computePatchMergeScore } from "./computePatchMergeScore.js";
-import { WeightedEdge } from "../graph/WeightedEdge.js";
+import { WeightedEdge } from "../../../../../core/graph/WeightedEdge.js";
 import { assert } from "../../../../../core/assert.js";
 
 /**

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

@@ -1,7 +1,7 @@
 import { ConicRay } from "../../../../../core/geom/ConicRay.js";
-import { compute_bounding_cone_of_2_cones } from "../bounds/compute_bounding_cone_of_2_cones.js";
+import { compute_bounding_cone_of_2_cones } from "../../../../../core/geom/3d/compute_bounding_cone_of_2_cones.js";
 import { compute_patches_shared_vertex_count } from "./compute_patches_shared_vertex_count.js";
-import { compute_bounding_sphere_of_2_spheres } from "../bounds/compute_bounding_sphere_of_2_spheres.js";
+import { compute_bounding_sphere_of_2_spheres } from "../../../../../core/geom/3d/compute_bounding_sphere_of_2_spheres.js";
 import { max2 } from "../../../../../core/math/max2.js";
 import { min2 } from "../../../../../core/math/min2.js";
 
@@ -58,7 +58,7 @@ const pi_sqr = 9.86960440109;
 
 /**
  *
- * @param {number} r
+ * @param {number} r radius
  * @return {number}
  */
 function compute_sphere_volume(r) {

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

@@ -9,12 +9,15 @@ import { collapse_edges, extract_edge_cost } from "../../../../../core/geom/3d/t
 import { build_edge_collapse_candidates } from "../../../../../core/geom/3d/topology/simplify/build_edge_collapse_candidates.js";
 import { collapse_all_degenerate_edges } from "../../../../../core/geom/3d/topology/simplify/collapse_all_degenerate_edges.js";
 import { deep_copy_vertex_quadratics } from "../../../../../core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js";
-import { SquareMatrix } from "../graph/SquareMatrix.js";
+import { SquareMatrix } from "../../../../../core/graph/SquareMatrix.js";
 import { DataType } from "../../../../../core/collection/table/DataType.js";
-import { matrix_eigenvalues_in_place } from "../graph/eigen/eigen.js";
+import { matrix_eigenvalues_in_place } from "../../../../../core/graph/eigen/eigen.js";
 import { min2 } from "../../../../../core/math/min2.js";
 import { PatchRepresentation } from "../PatchRepresentation.js";
-import { build_face_graph_from_mesh, graph_create_off_mesh_links } from "../graph/build_face_graph_from_mesh.js";
+import {
+    build_face_graph_from_mesh,
+    graph_create_off_mesh_links
+} from "../../../../../core/graph/build_face_graph_from_mesh.js";
 import { optimize_graph_partitioning_balance_detailed } from "./optimize_graph_partitioning_balance.js";
 import { patch_build_parent } from "./patch_combine.js";
 import { array_copy } from "../../../../../core/collection/array/copyArray.js";

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

@@ -1,6 +1,6 @@
 //
 
-import { metis_cluster_bs } from "../clustering/cluster_mesh_metis.js";
+import { metis_cluster_bs } from "../../../../../core/graph/cluster_mesh_metis.js";
 
 /**
  *

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

@@ -1,4 +1,4 @@
-import { graph_k_means_cluster_detailed } from "../graph/graph_k_means_cluster.js";
+import { graph_k_means_cluster_detailed } from "../../../../../core/graph/graph_k_means_cluster.js";
 import { array_remove_first } from "../../../../../core/collection/array/array_remove_first.js";
 
 /**

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

@@ -4,8 +4,8 @@ import { array_copy_unique } from "../../../../../core/collection/array/array_co
 import { array_remove_first } from "../../../../../core/collection/array/array_remove_first.js";
 import { max2 } from "../../../../../core/math/max2.js";
 import { array_push_if_unique } from "../../../../../core/collection/array/array_push_if_unique.js";
-import { compute_bounding_sphere_of_2_spheres } from "../bounds/compute_bounding_sphere_of_2_spheres.js";
-import { compute_bounding_cone_of_2_cones } from "../bounds/compute_bounding_cone_of_2_cones.js";
+import { compute_bounding_sphere_of_2_spheres } from "../../../../../core/geom/3d/compute_bounding_sphere_of_2_spheres.js";
+import { compute_bounding_cone_of_2_cones } from "../../../../../core/geom/3d/compute_bounding_cone_of_2_cones.js";
 import { ConicRay } from "../../../../../core/geom/ConicRay.js";
 import { passThrough } from "../../../../../core/function/Functions.js";
 

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

@@ -1,13 +1,14 @@
 import { array_push_if_unique } from "../../../../../core/collection/array/array_push_if_unique.js";
 import FastBinaryHeap from "../../../../navigation/grid/FastBinaryHeap.js";
 import { build_vertex_quadratics } from "../../../../../core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js";
-import { compute_set_intersection, compute_set_of_border_vertex_indices } from "./build_intermediate_patch_topology.js";
+import { compute_set_of_border_vertex_indices } from "./build_intermediate_patch_topology.js";
 import { compute_patches_shared_vertices } from "./compute_patches_shared_vertices.js";
 import { max2 } from "../../../../../core/math/max2.js";
 import { MICRON_PATCH_SIZE_MAX } from "../MICRON_PATCH_SIZE_MAX.js";
 import { collapse_edges, extract_edge_cost } from "../../../../../core/geom/3d/topology/simplify/simplifyTopoMesh.js";
 import { build_edge_collapse_candidates } from "../../../../../core/geom/3d/topology/simplify/build_edge_collapse_candidates.js";
 import { collapse_all_degenerate_edges } from "../../../../../core/geom/3d/topology/simplify/collapse_all_degenerate_edges.js";
+import { compute_set_intersection } from "../../../../../core/collection/set/compute_set_intersection.js";
 
 /**
  * Cluster must share at least this many vertices for the vertex boundary constraint to be relaxed and allow them to be made dependent on each other

package/engine/graphics/micron/format/MicronGeometry.js

@@ -55,6 +55,18 @@ export class MicronGeometry {
         this.__proxy = null;
     }
 
+    get patches() {
+        return this.__patches;
+    }
+
+    /**
+     *
+     * @param {MicronGeometryPatch[]} v
+     */
+    set patches(v) {
+        this.__patches = v;
+    }
+
     /**
      * @param {THREE.BufferGeometry} geometry
      */

package/engine/graphics/micron/format/MicronGeometryBufferAttributeSpec.js

@@ -1,6 +1,6 @@
 import { DataType } from "../../../../core/collection/table/DataType.js";
-import { DataTypeByteSizes } from "../../../../core/collection/table/RowFirstTableSpec.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { DataTypeByteSizes } from "../../../../core/collection/table/DataTypeByteSizes.js";
 
 export class MicronGeometryBufferAttributeSpec {
     constructor() {

package/engine/graphics/micron/format/MicronGeometryPatch.js

@@ -13,22 +13,36 @@ export class MicronGeometryPatch {
          */
         this.id = 0;
 
+        /**
+         * Continuous memory region for various pieces of data to get better memory access patterns
+         * All pieces of data end up in a continuous piece of memory, resulting in better cache coherence
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer((6 + 6 + 24) * 4);
+
         /**
          * Bounds are used to determine screen error and whether a patch should be subdivided or not for rendering
          * @type {number[]}
          */
-        this.bounding_box = new Float32Array(6);
+        this.bounding_box = new Float32Array(array_buffer, 0, 6);
+
+        /**
+         *
+         * @type {vec4|number[]}
+         */
+        this.bounding_sphere = vec4.create()
 
         /**
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box = new Float32Array(6);
+        this.group_bounding_box = new Float32Array(array_buffer, 6 * 4, 6);
+
         /**
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box_corners = new Float32Array(24);
+        this.group_bounding_box_corners = new Float32Array(array_buffer, 12 * 4, 24);
 
         /**
          *
@@ -42,12 +56,6 @@ export class MicronGeometryPatch {
          */
         this.group_error = 0;
 
-        /**
-         *
-         * @type {vec4}
-         */
-        this.bounding_sphere = vec4.create()
-
         /**
          *
          * @type {MicronGeometryPatch[]}

package/engine/graphics/micron/format/MicronVertexDataSpec.js

@@ -2,6 +2,8 @@ import { isArrayEqual } from "../../../../core/collection/ArrayUtils.js";
 import { computeHashArray } from "../../../../core/math/MathUtils.js";
 import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
 
+const DEFAULT_HASH = 123456;
+
 export class MicronVertexDataSpec {
     constructor() {
         /**
@@ -12,9 +14,21 @@ export class MicronVertexDataSpec {
 
         /**
          *
-         * @type {RowFirstTableSpec|null}
+         * @type {number}
+         * @private
          */
-        this.data = null;
+        this.__hash = DEFAULT_HASH;
+    }
+
+    /**
+     *
+     * @param {MicronGeometryBufferAttributeSpec[]} attributes
+     */
+    setAttributes(attributes) {
+        this.attributes = attributes;
+
+        // reset hash to trigger hash update
+        this.__hash = DEFAULT_HASH;
     }
 
     /**
@@ -30,10 +44,18 @@ export class MicronVertexDataSpec {
         return isArrayEqual(this.attributes, other.attributes);
     }
 
-    hash() {
+    computeHash() {
         return computeHashArray(this.attributes, invokeObjectHash);
     }
 
+    hash() {
+        if (this.__hash === DEFAULT_HASH) {
+            this.__hash = this.computeHash();
+        }
+
+        return this.__hash;
+    }
+
     /**
      *
      * @param {string} name

package/engine/graphics/micron/format/serialization/MicronGeometryBinarySerializationAdapter.js

@@ -0,0 +1,101 @@
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { MicronGeometry } from "../MicronGeometry.js";
+import { MicronGeometryBufferAttributeSpec } from "../MicronGeometryBufferAttributeSpec.js";
+import { MicronGeometryPatch } from "../MicronGeometryPatch.js";
+import { serialize_patch } from "./serialize_patch.js";
+import { deserialize_patch } from "./deserialize_patch.js";
+import { serialize_attribute_spec } from "./serialize_attribute_spec.js";
+import { deserialize_attribute_spec } from "./deserialize_attribute_spec.js";
+
+export class MicronGeometryBinarySerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = MicronGeometry;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {MicronGeometry} value
+     */
+    serialize(buffer, value) {
+        const spec = value.vertex_spec;
+
+        // serialize vertex spec
+        const attributes = spec.attributes;
+        const attribute_count = attributes.length;
+        buffer.writeUintVar(attribute_count);
+        for (let i = 0; i < attribute_count; i++) {
+            const attribute = attributes[i];
+
+            serialize_attribute_spec(buffer, attribute);
+        }
+
+        // serialize patches
+
+        /**
+         *
+         * @type {MicronGeometryPatch[]}
+         */
+        const patches = value.patches;
+        const patch_count = patches.length;
+
+        const root_patch_index = patches.indexOf(value.root);
+
+        buffer.writeUintVar(root_patch_index);
+
+        buffer.writeUintVar(patch_count);
+
+        for (let i = 0; i < patch_count; i++) {
+            serialize_patch(buffer, patches[i], spec, patches);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {MicronGeometry} value
+     */
+    deserialize(buffer, value) {
+        // read spec
+        const attribute_count = buffer.readUintVar();
+        const attributes = [];
+        for (let i = 0; i < attribute_count; i++) {
+            const spec = new MicronGeometryBufferAttributeSpec();
+
+            deserialize_attribute_spec(buffer, spec);
+            attributes[i] = spec;
+        }
+
+        const vertex_spec = value.vertex_spec;
+        vertex_spec.setAttributes(attributes);
+
+        // read patches
+        const root_patch_index = buffer.readUintVar();
+
+        const patch_count = buffer.readUintVar();
+
+        const patches = [];
+
+        // build initial patches
+        for (let i = 0; i < patch_count; i++) {
+            const patch = new MicronGeometryPatch();
+
+            patch.id = i;
+
+            patches[i] = patch;
+        }
+
+        //read patches
+        for (let i = 0; i < patch_count; i++) {
+            const patch = patches[i];
+
+            deserialize_patch(buffer, patch, vertex_spec, patches);
+        }
+
+        value.patches = patches;
+        value.root = patches[root_patch_index];
+    }
+}

package/engine/graphics/micron/format/serialization/deserialize_attribute_spec.js

@@ -0,0 +1,25 @@
+import { computeDataTypeByIndex } from "../../../../../core/collection/table/computeDataTypeByIndex.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {MicronGeometryBufferAttributeSpec} spec
+ */
+export function deserialize_attribute_spec(buffer, spec) {
+
+    spec.name = buffer.readUTF8String();
+    spec.itemSize = buffer.readUintVar();
+
+    const type_index = buffer.readUint8();
+    const type = computeDataTypeByIndex(type_index);
+
+    if (type === undefined) {
+        throw new Error(`Unknown data type marker '${type_index}'`);
+    }
+
+    spec.type = type;
+
+    const flags = buffer.readUint8();
+
+    spec.normalized = (flags & 0x1) !== 0;
+}

package/engine/graphics/micron/format/serialization/deserialize_patch.js

@@ -0,0 +1,104 @@
+import { aabb3_build_corners } from "../../../../../core/geom/3d/aabb/aabb3_build_corners.js";
+import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
+import { DataType2TypedArrayConstructorMapping } from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {MicronGeometryPatch} patch
+ * @param {MicronVertexDataSpec} vertex_spec
+ * @param {MicronGeometryPatch[]} patch_array
+ */
+export function deserialize_patch(buffer, patch, vertex_spec, patch_array) {
+    // METADATA
+    buffer.readFloat32Array(patch.bounding_box, 0, 6);
+    buffer.readFloat32Array(patch.bounding_sphere, 0, 4);
+
+    const gbb = patch.group_bounding_box;
+    buffer.readFloat32Array(gbb, 0, 6);
+    buffer.readFloat32Array(patch.group_bounding_sphere, 0, 4);
+
+    // reconstruct corners
+    aabb3_build_corners(
+        patch.group_bounding_box_corners,
+        0,
+        gbb[0],
+        gbb[1],
+        gbb[2],
+        gbb[3],
+        gbb[4],
+        gbb[5]
+    );
+
+    patch.group_error = buffer.readFloat32();
+    patch.lod = buffer.readUintVar();
+    patch.polygon_count = buffer.readUintVar();
+    patch.vertex_count = buffer.readUintVar();
+
+    // parents
+    const parents = [];
+    const parent_count = buffer.readUintVar();
+
+    for (let i = 0; i < parent_count; i++) {
+        const parent_index = buffer.readUintVar();
+
+        if (patch_array.length <= parent_index || parent_index < 0) {
+            throw new Error(`out of bounds parent index '${parent_index}'`);
+        }
+
+        parents[i] = patch_array[parent_index];
+    }
+
+    patch.parents = parents;
+
+    // children
+    const children = [];
+    const child_count = buffer.readUintVar();
+
+    for (let i = 0; i < child_count; i++) {
+        const child_index = buffer.readUintVar();
+
+        if (patch_array.length <= child_index || child_index < 0) {
+            throw new Error(`out of bounds child index '${child_index}'`);
+        }
+
+        children[i] = patch_array[child_index];
+    }
+
+    patch.children = children;
+
+    // INDICES
+    const index_count = patch.polygon_count * 3;
+
+    if (patch.vertex_count <= 256) {
+        patch.face_indices = new Uint8Array(index_count);
+        buffer.readUint8Array(patch.face_indices, 0, index_count);
+    } else if (patch.vertex_count <= 65536) {
+        patch.face_indices = new Uint16Array(index_count);
+        buffer.readUint16Array(patch.face_indices, 0, index_count);
+    } else {
+        throw new Error(`Unsupported vertex count '${patch.vertex_count}'`);
+    }
+
+    // VERTICES
+    const attributes = vertex_spec.attributes;
+    const attribute_count = attributes.length;
+
+    for (let i = 0; i < attribute_count; i++) {
+        const spec = attributes[i];
+
+        const data_type = spec.type;
+        const item_size = spec.itemSize;
+
+        const byte_size = DataTypeByteSizes[data_type];
+
+        const ArrayConstructor = DataType2TypedArrayConstructorMapping[data_type];
+
+        const elment_count = item_size * patch.vertex_count;
+        const array = new ArrayConstructor(elment_count);
+
+        buffer.readUint8Array(new Uint8Array(array.buffer), 0, byte_size * elment_count);
+
+        patch.vertex_attribute_arrays[i] = array;
+    }
+}

package/engine/graphics/micron/format/serialization/serialize_attribute_spec.js

@@ -0,0 +1,18 @@
+import { DataTypeIndices } from "../../../../../core/collection/table/DataTypeIndices.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {MicronGeometryBufferAttributeSpec} spec
+ */
+export function serialize_attribute_spec(buffer, spec) {
+    buffer.writeUTF8String(spec.name);
+    buffer.writeUintVar(spec.itemSize);
+
+    const dataTypeIndex = DataTypeIndices[spec.type];
+    buffer.writeUint8(dataTypeIndex);
+
+    const flags = spec.normalized ? 1 : 0;
+
+    buffer.writeUint8(flags);// flags
+}

package/engine/graphics/micron/format/serialization/serialize_patch.js

@@ -0,0 +1,84 @@
+import { DataTypeByteSizes } from "../../../../../core/collection/table/DataTypeByteSizes.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {MicronGeometryPatch} patch
+ * @param {MicronVertexDataSpec} vertex_spec
+ * @param {MicronGeometryPatch[]} patch_array
+ */
+export function serialize_patch(buffer, patch, vertex_spec, patch_array) {
+    // METADATA
+    buffer.writeFloat32Array(patch.bounding_box, 0, 6);
+    buffer.writeFloat32Array(patch.bounding_sphere, 0, 4);
+
+    buffer.writeFloat32Array(patch.group_bounding_box, 0, 6);
+    buffer.writeFloat32Array(patch.group_bounding_sphere, 0, 4);
+
+    buffer.writeFloat32(patch.group_error);
+    buffer.writeUintVar(patch.lod);
+    buffer.writeUintVar(patch.polygon_count);
+    buffer.writeUintVar(patch.vertex_count);
+
+    // write parents
+    const parents = patch.parents;
+    const parent_count = parents.length;
+
+    buffer.writeUintVar(parent_count);
+
+    for (let i = 0; i < parent_count; i++) {
+        const parent = parents[i];
+
+        const parent_index = patch_array.indexOf(parent);
+
+        if (parent_index === -1) {
+            throw new Error(`Patch '${parent.id}' not found in the lookup table`);
+        }
+
+        buffer.writeUintVar(parent_index);
+    }
+
+    // write children
+    const children = patch.children;
+    const child_count = children.length;
+
+    buffer.writeUintVar(child_count);
+
+    for (let i = 0; i < child_count; i++) {
+        const child = children[i];
+
+        const child_index = patch_array.indexOf(child);
+
+        if (child_index === -1) {
+            throw new Error(`Patch '${child.id}' not found in the lookup table`);
+        }
+
+        buffer.writeUintVar(child_index);
+    }
+
+    // INDICES
+    if (patch.vertex_count <= 256) {
+        buffer.writeUint8Array(patch.face_indices, 0, patch.polygon_count * 3);
+    } else if (patch.vertex_count <= 65536) {
+        buffer.writeUint16Array(patch.face_indices, 0, patch.polygon_count * 3);
+    } else {
+        throw new Error(`Unsupported vertex count '${patch.vertex_count}'`);
+    }
+
+    // VERTICES
+    const attributes = vertex_spec.attributes;
+    const attribute_count = attributes.length;
+
+    for (let i = 0; i < attribute_count; i++) {
+        const spec = attributes[i];
+
+        const data_type = spec.type;
+        const item_size = spec.itemSize;
+
+        const byte_size = DataTypeByteSizes[data_type];
+
+        const attribute_values = patch.vertex_attribute_arrays[i];
+
+        buffer.writeUint8Array(new Uint8Array(attribute_values.buffer), 0, item_size * byte_size * patch.vertex_count);
+    }
+}