@woosh/meep-engine 2.48.20 → 2.48.21

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

@@ -1,205 +0,0 @@
-import { ConicRay } from "../../../../core/geom/ConicRay.js";
-import { vec4 } from "gl-matrix";
-import { assert } from "../../../../core/assert.js";
-
-
-const EMPTY_ARRAY_UINT8 = new Uint8Array(0);
-
-/**
- * Patches are organized into a tree hierarchy
- */
-export class MicronGeometryPatch {
-    constructor() {
-        /**
-         * Unique identification number in the context of a single geometry
-         * @type {number}
-         */
-        this.id = 0;
-
-        /**
-         * Bounds are used to determine screen error and whether a patch should be subdivided or not for rendering
-         * @type {number[]}
-         */
-        this.bounding_box = null;
-
-        /**
-         *
-         * @type {vec4|number[]}
-         */
-        this.bounding_sphere = vec4.create();
-
-        /**
-         *
-         * @type {number[]|Float32Array}
-         */
-        this.group_bounding_box = null;
-
-        /**
-         * TODO get rid of this, use bounding box instead for smaller memory footprint
-         * @type {number[]|Float32Array}
-         */
-        this.group_bounding_box_corners = null;
-
-        /**
-         * 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(144);
-        this.allocate_metadata(array_buffer, 0);
-
-        /**
-         *
-         * @type {vec4|number[]}
-         */
-        this.group_bounding_sphere = vec4.create();
-
-        /**
-         *
-         * @type {number}
-         */
-        this.group_error = 0;
-
-        /**
-         *
-         * @type {MicronGeometryPatch[]}
-         */
-        this.parents = [];
-
-        /**
-         *
-         * @type {MicronGeometryPatch[]}
-         */
-        this.children = [];
-
-        /**
-         * Level of detail, lower number means more detailed
-         * @type {number}
-         */
-        this.lod = 0;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.polygon_count = 0;
-
-        /**
-         * Number of vertices in the patch
-         * @type {number}
-         */
-        this.vertex_count = 0;
-
-        /**
-         * Accessors to the buffer array of attribute data
-         * @type {Float32Array|Float64Array|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array[]}
-         */
-        this.vertex_attribute_arrays = [];
-
-        /**
-         *
-         * @type {Uint8Array|Uint16Array|null}
-         */
-        this.face_indices = EMPTY_ARRAY_UINT8;
-
-        /**
-         * Bounding cone of all of the face normals
-         * @type {ConicRay}
-         */
-        this.normal_cone = new ConicRay();
-
-        /*
-         TODO compute polygon side distribution, use a gaussian spherics or spherical harmonics representation
-         Having a distribution will allow us to better estimate smallest polygon area based on view angle
-         Better estimation of area => better error estimation => better image quality
-
-         IDEA 2) We can use spherics to approximate projected area of the patch within it's bounding_box
-         */
-    }
-
-    /**
-     *
-     * @param {ArrayBuffer} buffer
-     * @param {number} offset
-     * @returns {number}
-     */
-    allocate_metadata(buffer, offset) {
-        assert.isNonNegativeInteger(offset, 'offset');
-        assert.greaterThanOrEqual(buffer.byteLength, offset + 144, 'buffer underflow');
-
-        this.bounding_box = new Float32Array(buffer, offset, 6);
-
-        this.group_bounding_box = new Float32Array(buffer, offset + 24, 6);
-
-        this.group_bounding_box_corners = new Float32Array(buffer, offset + 48, 24);
-
-        return 144;
-    }
-
-    hash() {
-        return this.id;
-    }
-
-    computeByteSize() {
-        let result = 0;
-
-        result += this.face_indices.buffer.byteLength;
-
-        const attribute_arrays = this.vertex_attribute_arrays;
-        const attribute_count = attribute_arrays.length;
-
-        for (let i = 0; i < attribute_count; i++) {
-            const attribute_array = attribute_arrays[i];
-
-            result += attribute_array.buffer.byteLength;
-        }
-
-        return result;
-    }
-
-
-    /**
-     *
-     * @param {function(MicronGeometryPatch)} callback
-     * @param {*} [thisArg]
-     */
-    traverse(callback, thisArg) {
-        const stack = [this];
-        let stack_cursor = 1;
-        const seen_nodes = new Set();
-        seen_nodes.add(this);
-
-
-        while (stack_cursor > 0) {
-            stack_cursor--;
-
-            const patch = stack[stack_cursor];
-
-
-            callback.call(thisArg, patch);
-
-            const children = patch.children;
-            const child_count = children.length;
-
-            for (let i = 0; i < child_count; i++) {
-                const child = children[i];
-
-                if (seen_nodes.has(child)) {
-                    continue;
-                }
-
-                seen_nodes.add(child);
-
-                stack[stack_cursor++] = child;
-            }
-        }
-    }
-
-}
-
-
-/**
- * @readonly
- * @type {boolean}
- */
-MicronGeometryPatch.prototype.isMicronGeometryPatch = true;

package/src/engine/graphics/micron/format/MicronGeometryPatchOccurance.js

@@ -1,50 +0,0 @@
-import { squirrel3 } from "../../../../core/math/hash/squirrel3.js";
-import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
-
-export class MicronGeometryPatchOccurrence {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         */
-        this.geometry_id = -1;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.instance_id = -1;
-
-        /**
-         *
-         * @type {MicronGeometryPatch|null}
-         */
-        this.patch = null;
-        /**
-         *
-         * @type {number[]|Float32Array|null}
-         */
-        this.transform = null;
-    }
-
-    hash() {
-        return squirrel3(this.patch.id)
-            ^ squirrel3(this.geometry_id)
-            ^ this.instance_id;
-    }
-
-    /**
-     *
-     * @param {MicronGeometryPatchOccurrence} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.geometry_id === other.geometry_id
-            && this.instance_id === other.instance_id
-            && this.patch.id === other.patch.id
-            && isArrayEqualStrict(this.transform, other.transform)
-            ;
-    }
-
-
-}

package/src/engine/graphics/micron/format/ThreeMicronMesh.d.ts

@@ -1,10 +0,0 @@
-import {Material, Object3D} from "three";
-import {MicronGeometry} from "./MicronGeometry";
-
-export class ThreeMicronMesh extends Object3D {
-    readonly instance_id: number
-    material: Material
-    geometry: MicronGeometry
-
-    readonly isMicronMesh: boolean
-}

package/src/engine/graphics/micron/format/ThreeMicronMesh.js

@@ -1,45 +0,0 @@
-import { Object3D } from "three";
-
-let instance_id = 0;
-
-export class ThreeMicronMesh extends Object3D {
-    /**
-     *
-     * @param {MicronGeometry} geometry
-     * @param {THREE.Material} material
-     */
-    constructor(geometry, material) {
-        super();
-
-        /**
-         *
-         * @type {number}
-         */
-        this.instance_id = instance_id++;
-
-        /**
-         *
-         * @type {Material}
-         */
-        this.material = material;
-
-        /**
-         *
-         * @type {MicronGeometry}
-         */
-        this.geometry = geometry;
-    }
-
-    copy(other,r) {
-        this.material = other.material;
-        this.geometry = other.geometry;
-
-        return super.copy(other,r);
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-ThreeMicronMesh.prototype.isMicronMesh = true;

package/src/engine/graphics/micron/format/VirtualGeometry.js

@@ -1,158 +0,0 @@
-import { MicronGeometryPatchOccurrence } from "./MicronGeometryPatchOccurance.js";
-import { max3 } from "../../../../core/math/max3.js";
-
-const DEFAULT_CAPACITY = 10000;
-/**
- *
- * @type {number}
- */
-const CAPACITY_GROW_FACTOR = 1.2;
-/**
- *
- * @type {number}
- */
-const CAPACITY_GROW_MIN_STEP = 64;
-
-/**
- * Number of words making up a single patch element
- * @type {number}
- */
-const PATCH_WORD_COUNT = 3;
-
-export class VirtualGeometry {
-    constructor() {
-        this.__capacity = DEFAULT_CAPACITY;
-        /**
-         * pack patch instance as [INSTANCE_ID, GEOMETRY_ID, PATCH_ID]
-         * @type {number[]}
-         */
-        this.patches = new Uint32Array(this.__capacity * PATCH_WORD_COUNT);
-
-
-        /**
-         *
-         * @type {number}
-         */
-        this.patch_count = 0;
-
-        /**
-         * Lookup table of matrix transforms
-         * @type {number[][]}
-         */
-        this.lookup_instance_transforms = [];
-
-        /**
-         * Lookup table of geometries
-         * @type {MicronGeometry[]}
-         */
-        this.loolup_geometries = [];
-
-        /**
-         *
-         * @type {number}
-         */
-        this.stats_instance_count = 0;
-        this.stats_source_triangle_count = 0;
-        this.stats_source_vertex_count = 0;
-        this.stats_source_byte_size = 0;
-    }
-
-    /**
-     *
-     * @param {number} patch_count how much must be supported
-     * @return {boolean} true if capacity was sufficient, false if had to be resized
-     */
-    ensureCapacity(patch_count) {
-        if (this.__capacity < patch_count) {
-            // grow capacity
-
-            const new_capacity = Math.ceil(max3(
-                patch_count,
-                patch_count * CAPACITY_GROW_FACTOR,
-                patch_count + CAPACITY_GROW_MIN_STEP
-            ));
-
-            const new_array = new Uint32Array(new_capacity * PATCH_WORD_COUNT);
-
-            new_array.set(this.patches);
-
-            this.patches = new_array;
-
-            this.__capacity = new_capacity;
-
-            return false;
-        }
-
-        return true;
-    }
-
-    resetStats() {
-        this.stats_instance_count = 0;
-        this.stats_source_triangle_count = 0;
-        this.stats_source_vertex_count = 0;
-        this.stats_source_byte_size = 0;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    computeFaceCount() {
-        let r = 0;
-        const patch_count = this.patch_count;
-        const patches = this.patches;
-
-        for (let i = 0; i < patch_count; i++) {
-            const i3 = i * PATCH_WORD_COUNT;
-
-            const geometry_id = patches[i3 + 1];
-            const patch_id = patches[i3 + 2];
-
-            const geometry = this.loolup_geometries[geometry_id];
-
-            const patch = geometry.patches[patch_id];
-
-            r += patch.polygon_count;
-        }
-
-        return r;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    computeVertexCount() {
-        let r = 0;
-        const patch_count = this.patch_count;
-        const patches = this.patches;
-        for (let i = 0; i < patch_count; i++) {
-            const i3 = i * PATCH_WORD_COUNT;
-
-            const geometry_id = patches[i3 + 1];
-            const patch_id = patches[i3 + 2];
-
-            const geometry = this.loolup_geometries[geometry_id];
-
-            const patch = geometry.patches[patch_id];
-
-            r += patch.vertex_count;
-        }
-
-        return r;
-    }
-
-    /**
-     *
-     * @param {MicronGeometryPatchOccurrence} patch
-     */
-    add(patch) {
-        throw new Error('Deprecated');
-    }
-
-    clear() {
-        this.patch_count = 0;
-
-        this.resetStats();
-    }
-}

package/src/engine/graphics/micron/format/micron_build_proxy_geometry.js

@@ -1,205 +0,0 @@
-//
-
-import BinaryHeap from "../../../../core/collection/heap/FastBinaryHeap.js";
-import { BufferAttribute, BufferGeometry } from "three";
-import { UintArrayForCount } from "../../../../core/collection/array/typed/uint_array_for_count.js";
-import {
-    compute_typed_array_constructor_from_data_type
-} from "../../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
-import { BitSet } from "../../../../core/binary/BitSet.js";
-import { min2 } from "../../../../core/math/min2.js";
-import { max2 } from "../../../../core/math/max2.js";
-
-/**
- *
- * @param {MicronGeometry} micron_geometry
- * @param {number} fraction
- * @param {number} min_face_count
- * @returns {MicronGeometryPatch[]}
- */
-function collect_patches(micron_geometry, fraction, min_face_count) {
-    /**
-     *
-     * @type {BinaryHeap<MicronGeometryPatch>}
-     */
-    const heap = new BinaryHeap(patch => {
-        // LOD is a good proxy for how much detail there is in a patch
-        return -patch.lod;
-    });
-
-    let closed_set = new BitSet();
-
-    let current_polycount = 0;
-
-    /**
-     *
-     * @param {MicronGeometryPatch} patch
-     */
-    function add(patch) {
-
-        closed_set.set(patch.id, true);
-
-        heap.push(patch);
-
-        current_polycount += patch.polygon_count;
-    }
-
-    /**
-     *
-     * @param {MicronGeometryPatch} patch
-     */
-    function refine(patch) {
-        const children = patch.children;
-        const child_count = children.length;
-
-
-        for (let i = 0; i < child_count; i++) {
-            const child = children[i];
-
-            if (closed_set.get(child.id)) {
-                // already refined
-                continue;
-            }
-
-            add(child);
-
-            const parents = child.parents;
-
-            const parent_count = parents.length;
-            for (let j = 0; j < parent_count; j++) {
-                const parent = parents[j];
-
-                if (parent === parent) {
-                    continue;
-                }
-
-                // remove and refine other patches in the same group
-                if (heap.delete(parent)) {
-                    refine(parent);
-                }
-            }
-        }
-    }
-
-    add(micron_geometry.root);
-
-    const target_polycount_threshold = max2(
-        micron_geometry.source_triangle_count * fraction,
-        min2(
-            min_face_count,
-            micron_geometry.source_triangle_count
-        )
-    );
-
-    while (current_polycount < target_polycount_threshold) {
-        const p = heap.peek();
-
-        if (p === undefined || p.lod === 0) {
-            // no refinement possible
-            break;
-        }
-
-        heap.pop();
-
-        current_polycount -= p.polygon_count;
-
-        refine(p);
-    }
-
-    const result = [];
-
-    // collect
-    while (!heap.isEmpty()) {
-        result.push(heap.pop());
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {MicronGeometryPatch[]} patches
- * @param {VertexDataSpec} vertex_spec
- * @returns {THREE.BufferGeometry}
- */
-function assemble_patches_to_geometry(patches, vertex_spec) {
-    const geo = new BufferGeometry();
-
-    //compute total number of vertices and faces
-    let total_faces = 0;
-    let total_vertices = 0;
-
-    for (let i = 0; i < patches.length; i++) {
-        const patch = patches[i];
-
-        total_faces += patch.polygon_count;
-        total_vertices += patch.vertex_count;
-    }
-
-    const index_data = new (UintArrayForCount(total_vertices))(total_faces * 3);
-
-    geo.setIndex(new BufferAttribute(index_data, 1, false));
-
-    const attribute_arrays = [];
-
-    const attribute_specs = vertex_spec.attributes;
-    const attribute_count = attribute_specs.length;
-    for (let i = 0; i < attribute_count; i++) {
-        const attribute = attribute_specs[i];
-
-        const TA = compute_typed_array_constructor_from_data_type(attribute.type);
-
-        const attribute_data = new TA(total_vertices * 3);
-
-        attribute_arrays[i] = attribute_data;
-
-        geo.setAttribute(attribute.name, new BufferAttribute(attribute_data, attribute.itemSize, attribute.normalized));
-    }
-
-    let index_cursor = 0;
-    let vertex_cursor = 0;
-
-    // add patches to resulting geometry
-    for (let i = 0; i < patches.length; i++) {
-        const patch = patches[i];
-
-        const local_index_size = patch.polygon_count * 3;
-
-        // copy transformed indices
-        for (let j = 0; j < local_index_size; j++) {
-            const local_index = patch.face_indices[j];
-
-            index_data[index_cursor + j] = local_index + vertex_cursor;
-        }
-
-        // copy vertex data
-
-        for (let j = 0; j < attribute_count; j++) {
-            const attribute_destination = attribute_arrays[j];
-
-            const attribute_source = patch.vertex_attribute_arrays[j];
-            const destination_offset = vertex_cursor * attribute_specs[j].itemSize;
-
-            attribute_destination.set(attribute_source, destination_offset);
-        }
-
-        vertex_cursor += patch.vertex_count;
-        index_cursor += local_index_size;
-    }
-
-    return geo;
-}
-
-
-/**
- *
- * @param {MicronGeometry} micron_geometry
- * @param {number} fraction
- * @param {number} [min_face_count]
- * @returns {THREE.BufferGeometry}
- */
-export function micron_build_proxy_geometry(micron_geometry, fraction, min_face_count = 128) {
-    const patches = collect_patches(micron_geometry, fraction, min_face_count);
-
-    return assemble_patches_to_geometry(patches, micron_geometry.vertex_spec);
-}