@woosh/meep-engine 2.48.20 → 2.48.22

package/src/engine/graphics/micron/build/compute_vertex_remap_cost.js

@@ -1,29 +0,0 @@
-import {
-    compute_face_normal_change_dot_product
-} from "../../../../core/geom/3d/topology/simplify/compute_face_normal_change_dot_product.js";
-
-/**
- *
- * @param {TopoVertex} from
- * @param {TopoVertex} to
- *
- * @returns {number}
- */
-export function computeVertexRemapCost(from, to) {
-    let result = 0;
-
-    const faces = from.faces;
-    const face_count = faces.length;
-
-    for (let i = 0; i < face_count; i++) {
-        const face = faces[i];
-
-        const normal_dot = compute_face_normal_change_dot_product(face, from, to);
-
-        const normal_cost = 1 - normal_dot;
-
-        result += normal_cost;
-    }
-
-    return result;
-}

package/src/engine/graphics/micron/build/debug/build_clustering_info.js

@@ -1,58 +0,0 @@
-import { computeStatisticalMedian } from "../../../../../core/math/statistics/computeStatisticalMedian.js";
-import { max2 } from "../../../../../core/math/max2.js";
-import { MICRON_PATCH_SIZE_MAX } from "../MICRON_PATCH_SIZE_MAX.js";
-import { computeStatisticalMean } from "../../../../../core/math/statistics/computeStatisticalMean.js";
-import { formatNumberByThousands, prettyPrint } from "../../../../../core/NumberFormat.js";
-import { computeStatisticalPercentile } from "../../../../../core/math/statistics/computeStatisticalPercentile.js";
-
-/**
- *
- * @param {PatchRepresentation[]} patches
- */
-export function build_clustering_info(patches) {
-
-    const patch_count = patches.length;
-
-    const patch_face_counts = patches.map(p => p.topology_snapshot.getFaces().size);
-    const total_patch_faces = patch_face_counts.reduce((previousValue, x) => previousValue + x, 0);
-
-    const patch_size_median = computeStatisticalMedian(patch_face_counts);
-    const undeflow_face_count = patch_face_counts.reduce((acc, c) => {
-        const local_underflow = max2(0, MICRON_PATCH_SIZE_MAX - c);
-        return acc + local_underflow;
-    }, 0);
-    const overflow_face_count = patch_face_counts.reduce((acc, c) => {
-        const local_overflow = max2(0, c - MICRON_PATCH_SIZE_MAX);
-        return acc + local_overflow;
-    }, 0);
-
-    const patch_size_mean = computeStatisticalMean(patch_face_counts);
-
-    const connection_count = patches.reduce((acc, p) => acc + p.neighbours.length, 0);
-
-    // compute perimeter lengths
-    const total_perimeter = patches.reduce((acc, p) => acc + p.computePerimeterLength(), 0);
-
-    const underflow_patch_count = patch_face_counts.filter(p => p < MICRON_PATCH_SIZE_MAX).length;
-
-    return `Leaf Stats:
-    Total faces: ${formatNumberByThousands(total_patch_faces)}
-    Patch count: ${formatNumberByThousands(patch_count)}
-    
-    patch size(median): ${patch_size_median}
-    patch size(mean): ${patch_size_mean.toFixed(2)}
-    patch size(10th %): ${computeStatisticalPercentile(patch_face_counts, .1, 0.1)}
-    patch size(25th %): ${computeStatisticalPercentile(patch_face_counts, .25, 0.25)}
-    patch size(90th %) : ${computeStatisticalPercentile(patch_face_counts, .9, 0.9)}
-    
-    Total undeflow patches: ${formatNumberByThousands(underflow_patch_count)} (${(underflow_patch_count * 100 / patch_count).toPrecision(3)}%)
-    Total undeflow faces: ${formatNumberByThousands(undeflow_face_count)} (${(undeflow_face_count * 100 / total_patch_faces).toPrecision(3)}%)
-    Total overflow faces: ${formatNumberByThousands(overflow_face_count)}
-    
-    Total connections: ${formatNumberByThousands(connection_count)}
-    Average connectedness : ${(connection_count / patch_count).toPrecision(4)} neighbours/patch
-    
-    Total perimeter: ${prettyPrint(total_perimeter)}
-    Average patch perimeter: ${(total_perimeter / patch_count).toPrecision(4)}
-    `
-}

package/src/engine/graphics/micron/build/debug/build_graph_info.js

@@ -1,59 +0,0 @@
-//
-
-import { prettyPrint } from "../../../../../core/NumberFormat.js";
-import { MICRON_PATCH_SIZE_MAX } from "../MICRON_PATCH_SIZE_MAX.js";
-import { max2 } from "../../../../../core/math/max2.js";
-
-/**
- *
- * @param {PatchRepresentation} root
- * @returns {string}
- */
-export function build_graph_info(root) {
-    // ingest all patches into a flat hierarchy
-    const all_nodes = [];
-    const leaf_nodes = [];
-    const intermediate_nodes = [];
-
-    root.traverse(n => {
-        all_nodes.push(n);
-
-        if (n.lod === 0) {
-            leaf_nodes.push(n);
-        } else {
-            intermediate_nodes.push(n);
-        }
-    });
-
-    const intermediate_face_count = intermediate_nodes.reduce((acc, p) => {
-        return acc + p.topology_snapshot.getFaces().size;
-    }, 0);
-
-    const leaf_face_count = leaf_nodes.reduce((acc, p) => {
-        return acc + p.topology_snapshot.getFaces().size;
-    }, 0);
-
-    const intermediate_node_count = all_nodes.length - leaf_nodes.length;
-    const balance_quality = (leaf_nodes.length - 1) / intermediate_node_count;
-
-    const intermediate_overflow_patch_count = intermediate_nodes.filter(p => p.topology_snapshot.getFaces().size > MICRON_PATCH_SIZE_MAX).length;
-
-    const intermediate_overflow_face_count = intermediate_nodes
-        .map(n => n.topology_snapshot.getFaces().size)
-        .reduce((acc, c) => {
-            const local_overflow = max2(0, c - MICRON_PATCH_SIZE_MAX);
-            return acc + local_overflow;
-        }, 0);
-
-    return `Graph Stats:
-    Total nodes: ${prettyPrint(all_nodes.length)}
-    Total intermediate nodes: ${prettyPrint(intermediate_node_count)}
-    Depth: ${prettyPrint(root.lod)}
-    Balance quality: ${(balance_quality * 100).toPrecision(3)}%
-    
-    Intermediate face count: ${prettyPrint(intermediate_face_count)} (${(intermediate_face_count * 100 / leaf_face_count).toPrecision(3)}% of original)
-    Intermediate overflow faces: ${prettyPrint(intermediate_overflow_face_count)} (${(intermediate_overflow_face_count * 100 / intermediate_face_count).toPrecision(3)}%)
-    
-    Intermediate overflow patches: ${prettyPrint(intermediate_overflow_patch_count)} (${(intermediate_overflow_patch_count * 100 / intermediate_node_count).toPrecision(3)}%) 
-    `;
-}

package/src/engine/graphics/micron/build/fill_patch_geometry_data.js

@@ -1,270 +0,0 @@
-import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
-import { passThrough } from "../../../../core/function/Functions.js";
-import { to_half_float_uint16 } from "../../../../core/binary/to_half_float_uint16.js";
-import { compute_micron_buffer_array_constructor } from "./compute_micron_buffer_array_constructor.js";
-import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
-import { dataTypeByteSize } from "../../../../core/binary/type/DataTypeByteSizes.js";
-import { UintArrayForCount } from "../../../../core/collection/array/typed/uint_array_for_count.js";
-import { clamp01 } from "../../../../core/math/clamp01.js";
-
-/**
- * @param {number} vertex_count
- * @param {Map<number, number>} index_map_backward
- * @param {number} itemSize
- * @param {ArrayLike<number>} attribute_array
- * @param {number[]} vertex_data_buffer_accessor
- * @param {function} transformer_method
- * @param {*} [transformer_context]
- */
-function transform_attribute_data(
-    vertex_count,
-    index_map_backward,
-    itemSize,
-    attribute_array,
-    vertex_data_buffer_accessor,
-    transformer_method,
-    transformer_context
-) {
-    let j, k;
-
-    for (j = 0; j < vertex_count; j++) {
-        // map patch vertex index to original geometry's vertex index
-        const source_vertex_index = index_map_backward.get(j);
-
-        const source_vertex_offset = source_vertex_index * itemSize;
-        const target_vertex_offset = j * itemSize;
-
-        for (k = 0; k < itemSize; k++) {
-
-            // get item value
-            const value = attribute_array[source_vertex_offset + k];
-
-            // transform
-            const transformed_value = transformer_method.call(transformer_context, value);
-
-            // write into buffer
-            vertex_data_buffer_accessor[target_vertex_offset + k] = transformed_value;
-        }
-    }
-}
-
-/**
- * @param {number} vertex_count
- * @param {Map<number, number>} index_map_backward
- * @param {number} itemSize
- * @param {ArrayLike<number>} attribute_array
- * @param {number[]} vertex_data_buffer_accessor
- */
-function copy_attribute_data(vertex_count, index_map_backward, itemSize, attribute_array, vertex_data_buffer_accessor) {
-    let j, k;
-
-    for (j = 0; j < vertex_count; j++) {
-        // map patch vertex index to original geometry's vertex index
-        const source_vertex_index = index_map_backward.get(j);
-
-        const source_vertex_offset = source_vertex_index * itemSize;
-        const target_vertex_offset = j * itemSize;
-
-        for (k = 0; k < itemSize; k++) {
-
-            // get item value
-            const value = attribute_array[source_vertex_offset + k];
-
-            // write into buffer
-            vertex_data_buffer_accessor[target_vertex_offset + k] = value;
-        }
-    }
-}
-
-/**
- *
- * @param {number} value
- * @returns {number}
- */
-function resample_normalized_uint16_to_uint8(value) {
-    const normalized = clamp01(value / 65535);
-
-    return Math.round(normalized * 255);
-}
-
-/**
- *
- * @param {number} value
- * @return {number}
- */
-function normalize_to_int8(value) {
-    return Math.round(value * 127);
-}
-
-/**
- *
- * @param {number} value
- * @return {number}
- */
-function normalize_to_uint8(value) {
-    return Math.round(value * 255);
-}
-
-/**
- * @enum {function(number):number}
- */
-const DataConverterType = {
-    None: passThrough,
-    Number2HalfFloat: to_half_float_uint16,
-    Normalize2Int8: normalize_to_int8,
-    Normalize2Uint8: normalize_to_uint8,
-    ResampleNormalized_Uint16_to_Uint8: resample_normalized_uint16_to_uint8
-};
-
-/**
- * How to convert data from source three.js buffer attribute to what we store in the patch description based on the supplied micron spec
- * @param {AttributeSpec} spec
- * @param {THREE.BufferAttribute} source
- * @returns {DataConverterType}
- */
-function compute_attribute_data_converter(source, spec) {
-    const target_type = spec.type;
-    if (target_type === BinaryDataType.Float16) {
-        return DataConverterType.Number2HalfFloat;
-    } else if (spec.normalized && !source.normalized) {
-        // source data can be normalized but isn't
-        if (target_type === BinaryDataType.Int8) {
-            return DataConverterType.Normalize2Int8;
-        } else if (target_type === BinaryDataType.Uint8) {
-            return DataConverterType.Normalize2Uint8;
-        } else {
-            throw new Error(`Unsupported normalized type '${target_type}'`);
-        }
-    } else {
-        const source_array = source.array;
-
-        const source_type = typedArrayToDataType(source_array);
-
-        const target_byte_size = dataTypeByteSize(target_type);
-        const source_byte_size = dataTypeByteSize(source_type)
-
-        if (target_byte_size !== source_byte_size) {
-            // wrong data size
-
-            if (target_type === BinaryDataType.Uint8 && source_type === BinaryDataType.Uint16) {
-                return DataConverterType.ResampleNormalized_Uint16_to_Uint8;
-            } else {
-                throw new Error(`Unsupported conversion ${source_type} -> ${target_type}`);
-            }
-
-        } else {
-            return DataConverterType.None;
-        }
-    }
-}
-
-/**
- *
- * @param {MicronGeometryPatch} result
- * @param {THREE.BufferGeometry} buffer_geometry
- * @param {TopoMesh} topo
- * @param {VertexDataSpec} vertex_data_spec
- */
-export function fill_patch_geometry_data(result, buffer_geometry, topo, vertex_data_spec) {
-    /**
-     *
-     * @type {Map<number, number>}
-     */
-    const index_map_forward = new Map();
-    /**
-     *
-     * @type {Map<number, number>}
-     */
-    const index_map_backward = new Map();
-
-    let vertex_count = 0;
-
-    // remap vertices
-    const faces = topo.getFaces();
-    const face_count = faces.size;
-    const polygon_buffer_size = face_count * 3;
-
-    // pick container just large enough to point to all vertices
-    const FaceArrayConstructor = UintArrayForCount(topo.vertices.length);
-
-    result.face_indices = new FaceArrayConstructor(polygon_buffer_size);
-    result.polygon_count = face_count;
-
-    let i3 = 0;
-    for (const topo_face of faces) {
-
-        for (let j = 0; j < 3; j++) {
-            // get vertices
-            const topo_vertex = topo_face.vertices[j];
-
-            const index = topo_vertex.index;
-
-            if (!index_map_forward.has(index)) {
-                index_map_forward.set(index, vertex_count);
-                index_map_backward.set(vertex_count, index);
-
-                vertex_count++;
-            }
-
-            // write index into patch
-            result.face_indices[i3 + j] = index_map_forward.get(index);
-        }
-
-        i3 += 3;
-    }
-
-    // write vertices
-    result.vertex_count = vertex_count;
-
-    // collect metadata about vertices
-
-
-    // compute byte size of each vertex
-    const source_attributes = buffer_geometry.attributes;
-
-    let vertex_buffer_attribute_address = 0;
-
-    const micron_attributes = vertex_data_spec.attributes;
-    const attribute_count = micron_attributes.length;
-
-    //TODO create a single ArrayBuffer for all attributes to get better cache coherence for rendering
-
-    for (let i = 0; i < attribute_count; i++) {
-        const attribute_spec = micron_attributes[i];
-
-        /**
-         *
-         * @type {THREE.BufferAttribute | THREE.InterleavedBufferAttribute}
-         */
-        const attribute = source_attributes[attribute_spec.name];
-
-
-        if (attribute.isInterleavedBufferAttribute) {
-            throw new Error('Interleaved buffers are not supported');
-        }
-
-        const attribute_array = attribute.array;
-
-        const itemSize = attribute.itemSize;
-
-        const TypedArrayConstructor = compute_micron_buffer_array_constructor(attribute_spec.type);
-
-        const vertex_data_buffer_accessor = new TypedArrayConstructor(
-            vertex_count * itemSize
-        );
-
-        const converter = compute_attribute_data_converter(attribute, attribute_spec);
-
-        if (converter === DataConverterType.None) {
-            copy_attribute_data(vertex_count, index_map_backward, itemSize, attribute_array, vertex_data_buffer_accessor);
-
-        } else {
-            transform_attribute_data(vertex_count, index_map_backward, itemSize, attribute_array, vertex_data_buffer_accessor, converter);
-        }
-
-        vertex_buffer_attribute_address += attribute_spec.getByteSize() * vertex_count;
-
-        result.vertex_attribute_arrays[i] = vertex_data_buffer_accessor;
-    }
-
-}

package/src/engine/graphics/micron/build/hierarchy/buildAbstractPatchHierarchy.js

@@ -1,196 +0,0 @@
-import { merge_patches } from "./merge_patches.js";
-import { coarsen_graph } from "../../../../../core/graph/coarsen_graph.js";
-import { build_merge_graph } from "./build_merge_graph.js";
-import { assign_patch_neighbours_from_topology } from "../clustering/assign_patch_neighbours_from_topology.js";
-import { assert } from "../../../../../core/assert.js";
-import { graph_create_off_mesh_links } from "../../../../../core/graph/build_face_graph_from_mesh.js";
-import {
-    build_vertex_quadratics
-} from "../../../../../core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js";
-
-/**
- *
- * @param {Graph<MultiNode<PatchRepresentation>>} graph
- * @param {number} n
- */
-function merge_graph_level(graph, n) {
-    assert.isFiniteNumber(n, 'n');
-    assert.isNonNegativeInteger(n, 'n');
-
-    for (let i = 2; i <= n; i *= 2) {
-
-        if (graph.getNodeCount() <= 1) {
-            // fully merged, no further merge possible
-            break;
-        }
-
-        coarsen_graph(graph, i);
-    }
-
-}
-
-/**
- *
- * @type {number}
- */
-const DEFAULT_MERGE_COUNT = 4;
-/**
- * Maximum number of patches that can be merged together
- * @type {number}
- */
-const LIMIT_MERGE_COUNT = 64;
-
-/**
- *
- * @param {PatchRepresentation[]} nodes
- * @returns {PatchRepresentation}
- */
-async function assemble_graph(nodes) {
-    /**
-     *
-     * @type {PatchRepresentation[]}
-     * @private
-     */
-    let __nodes = nodes.slice();
-
-    const initial_node_count = __nodes.length;
-
-    /**
-     *
-     * @type {{value: number}}
-     * @private
-     */
-    const __node_count = {
-        value: initial_node_count
-    };
-
-    let level = 0;
-    let merge_count = DEFAULT_MERGE_COUNT;
-
-
-    /**
-     *
-     * @type {Map<number, Quadratic3>}
-     */
-    const vertex_quadratics = new Map();
-
-    /*
-     build initial quadratic errors for each vertex
-     To keep track of error throughout simplification levels
-     */
-    for (let i = 0; i < __node_count.value; i++) {
-        const patch = __nodes[i];
-
-        build_vertex_quadratics({ mesh: patch.topology_snapshot, quadratics: vertex_quadratics });
-    }
-
-    while (__node_count.value > 1) {
-
-        // assemble nodes into a graph
-        const leaf_cluster_weight_graph = build_merge_graph(__nodes);
-
-        if (__node_count.value <= 4 || merge_count >= 16) {
-            // graph is quite small now, it's possible that some patches are disconnected, force connections to allow for collapse
-            graph_create_off_mesh_links(leaf_cluster_weight_graph);
-        }
-
-        // merge graph nodes up to X nodes per cluster
-        merge_graph_level(leaf_cluster_weight_graph, merge_count);
-
-        // assemble multi-nodes
-        const graph_nodes = leaf_cluster_weight_graph.getNodes();
-
-        const old_node_count = __node_count.value;
-
-        __nodes = [];
-        __node_count.value = 0;
-
-        const __promises = [];
-
-        for (const multi_node of graph_nodes) {
-            const patches_to_merge = multi_node.source_nodes;
-
-            const promise = merge_patches(__nodes, __node_count, patches_to_merge, vertex_quadratics);
-            __promises.push(promise);
-
-        }
-
-        await Promise.all(__promises);
-
-        if (__node_count.value >= old_node_count) {
-            // new graph has the same number of nodes as the old one
-
-            if (leaf_cluster_weight_graph.getNodeCount() <= 1) {
-                // graph is already merged to the maximum level
-                throw new Error(`Simplification failed, graph already at maximum coarseness`);
-            }
-
-            if (merge_count >= LIMIT_MERGE_COUNT) {
-                throw new Error(`Exceeded merge limit(=${LIMIT_MERGE_COUNT}), attempting to merge too many patches together`);
-            }
-
-            if (old_node_count <= merge_count) {
-                throw new Error(`Already allowing to merge all of the nodes, yet merge still fails. Allowed patch count = ${merge_count}, Actual patches = ${old_node_count})`);
-            }
-
-            // failed to do any merging, increase merge scope
-            merge_count *= 2;
-
-            continue;
-        }
-
-        // clear existing neighbours for this level
-        for (let i = 0; i < __node_count.value; i++) {
-            const node = __nodes[i];
-
-            const neighbours = node.neighbours;
-            neighbours.splice(0, neighbours.length);
-        }
-
-        // write neighbours
-        assign_patch_neighbours_from_topology(__nodes);
-
-        level++;
-
-        merge_count = DEFAULT_MERGE_COUNT;
-    }
-
-    // return root
-    const root = __nodes[0];
-
-    if (initial_node_count === 1) {
-        // there are no children, whole hierarchy is just one node, set group bounds to equal node bounds
-        root.group_bounding_sphere.set(root.bounding_sphere);
-        root.group_aabb.copy(root.bounding_box);
-    }
-
-
-    return root;
-}
-
-
-/**
- * @param {TopoMesh} t
- */
-function cleanup_disconnected_edges(t) {
-
-    const edges = t.getEdges();
-
-    for (let edge of edges) {
-
-        if (edge.faces.length === 0) {
-            // cut
-            edges.delete(edge);
-        }
-    }
-}
-
-/**
- * @param {PatchRepresentation[]} leaves
- * @returns {PatchRepresentation} new root
- */
-export async function buildAbstractPatchHierarchy(leaves) {
-    const root = await assemble_graph(leaves);
-
-    return root;
-}