@woosh/meep-engine 2.48.20 → 2.48.21

package/src/engine/graphics/micron/buildPatchwork.js

@@ -1,68 +0,0 @@
-import { FrontSide, Group, Mesh, MeshBasicMaterial, MeshStandardMaterial } from "three";
-import { patchToBufferGeometry } from "./util/patchToBufferGeometry.js";
-import { Color } from "../../../core/color/Color.js";
-import { seededRandom } from "../../../core/math/random/seededRandom.js";
-import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
-
-/**
- *
- * @param {MicronGeometryPatch[]} patches
- * @returns {THREE.Object3D}
- */
-function buildPatchMesh(patches) {
-    const group = new Group();
-
-
-    const n = patches.length;
-    for (let i = 0; i < n; i++) {
-        const patch = patches[i];
-
-        const geometry = patchToBufferGeometry(patch);
-
-        const color = new Color();
-
-        const random = seededRandom(patch.hash());
-
-        color.setHSV(random(), randomFloatBetween(random, 0.5, 0.9), randomFloatBetween(random, 0.7, 1));
-
-        // const material = new MeshBasicMaterial({ color: color.toUint(), wireframe: false, side: FrontSide });
-        const material = new MeshStandardMaterial({ color: 0xAAAAFF, wireframe: false, side: FrontSide });
-        // material.polygonOffset = true;
-        // material.polygonOffsetFactor = 1;
-        const mesh = new Mesh(geometry, material);
-
-        group.add(mesh);
-
-
-        const material_wireframe = new MeshBasicMaterial({
-            color: 0x000000,
-            wireframe: true,
-            side: FrontSide,
-            polygonOffset: true,
-            polygonOffsetFactor: -4,
-            polygonOffsetUnits: 0
-        });
-
-        // group.add(new Mesh(geometry, material_wireframe));
-    }
-
-    return group;
-}
-
-/**
- *
- * @param {MicronGeometry} micron
- * @returns {Object3D}
- */
-function buildPatchwork(micron) {
-    const patches = [];
-
-    micron.root.traverse(p => {
-        if (p.lod === 0) {
-            patches.push(p);
-        }
-    });
-
-
-    return buildPatchMesh(patches);
-}

package/src/engine/graphics/micron/convert_three_object_to_micron.js

@@ -1,179 +0,0 @@
-import { HashMap } from "../../../core/collection/HashMap.js";
-import { computeGeometryHash } from "../geometry/buffered/computeGeometryHash.js";
-import { computeGeometryEquality } from "../geometry/buffered/computeGeometryEquality.js";
-import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
-import { ThreeMicronMesh } from "./format/ThreeMicronMesh.js";
-import { AsyncMapWrapper } from "../../../core/collection/map/AsyncMapWrapper.js";
-import { MICRON_GEOMETRY_FIELD } from "./MICRON_GEOMETRY_FIELD.js";
-
-/**
- *
- * @type {HashMap<THREE.BufferGeometry, MicronGeometry>}
- */
-const default_micron_cache = new AsyncMapWrapper(new HashMap({
-    keyHashFunction: computeGeometryHash,
-    keyEqualityFunction: computeGeometryEquality
-}));
-
-const pending_cache = new HashMap({
-    keyHashFunction: computeGeometryHash,
-    keyEqualityFunction: computeGeometryEquality
-});
-
-/**
- *
- * @param {THREE.Object3D} object
- * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} micron_cache
- * @returns {THREE.Object3D}
- */
-export async function convert_three_object_to_micron(object, micron_cache = default_micron_cache) {
-
-    const promises = [];
-
-    /**
-     *
-     * @param {THREE.BufferGeometry} g
-     * @returns {MicronGeometry}
-     */
-    async function obtain_geometry(g) {
-        const attached_micron = g[MICRON_GEOMETRY_FIELD];
-
-        if (attached_micron !== undefined && attached_micron.isMicronGeometry) {
-            // micron geometry is already attached, use it
-            return attached_micron;
-        }
-
-        const cached_micron = await micron_cache.get(g);
-
-
-        if (cached_micron !== undefined && cached_micron !== null) {
-
-            // set proxy
-            cached_micron.proxy = g;
-
-            return cached_micron;
-        }
-
-        const pending = pending_cache.get(g);
-
-        if (pending !== undefined) {
-            return await pending;
-        }
-
-        const micron_geometry_promise = buildMicronGeometryFromBufferGeometry(g);
-
-        pending_cache.set(g, micron_geometry_promise);
-
-        promises.push(micron_geometry_promise);
-
-        /**
-         *
-         * @type {MicronGeometry}
-         */
-        const micron_geometry = await micron_geometry_promise;
-
-        micron_geometry.proxy = g;
-
-        await micron_cache.set(g, micron_geometry);
-
-        return micron_geometry;
-    }
-
-
-    /**
-     *
-     * @param {THREE.Mesh} mesh
-     */
-    function process_mesh(mesh) {
-        obtain_geometry(mesh.geometry);
-    }
-
-    object.traverse(o => {
-        if (o.isMesh) {
-            process_mesh(o);
-        }
-    });
-
-    await Promise.all(promises);
-
-    /**
-     *
-     * @param {THREE.Object3D|THREE.Mesh|THREE.SkinnedMesh} mesh
-     * @returns {ThreeMicronMesh|THREE.Object3D}
-     */
-    async function convert(mesh) {
-
-        if (
-            mesh.isMesh
-            && !mesh.isSkinnedMesh // skinned meshes not supported
-        ) {
-
-            let micronGeometry;
-            try {
-                micronGeometry = await obtain_geometry(mesh.geometry);
-            } catch (e) {
-                console.error(`Failed to convert geometry to micron, skipping : ${e}`);
-
-                // return original
-                return mesh;
-            }
-
-            const micron_mesh = new ThreeMicronMesh(micronGeometry, mesh.material);
-
-            micron_mesh.scale.copy(mesh.scale);
-            micron_mesh.rotation.copy(mesh.rotation);
-            micron_mesh.position.copy(mesh.position);
-
-
-            micron_mesh.castShadow = mesh.castShadow;
-            micron_mesh.receiveShadow = mesh.receiveShadow;
-
-            micron_mesh.children = mesh.children;
-            micron_mesh.matrixAutoUpdate = mesh.matrixAutoUpdate;
-
-            micron_mesh.matrix.copy(mesh.matrix);
-            micron_mesh.matrixWorld.copy(mesh.matrixWorld);
-
-            return micron_mesh;
-        } else {
-            return mesh;
-        }
-    }
-
-    /**
-     *
-     * @param {THREE.Object3D} x
-     */
-    async function convert_object(x) {
-        const children = x.children;
-
-        for (let i = 0; i < children.length; i++) {
-            const child = children[i];
-
-            const converted_child = await convert(child);
-            converted_child.parent = x;
-
-            children[i] = converted_child;
-
-            await convert_object(converted_child);
-        }
-
-        x.updateMatrix();
-    }
-
-    let result;
-
-    if (object.isMesh) {
-        result = await convert(object);
-    } else {
-        await convert_object(object);
-
-        result = object;
-    }
-
-    result.updateWorldMatrix(false, true);
-
-    // console.warn(`Processed geometries ${micron_cache.size}`);
-
-    return result;
-}

package/src/engine/graphics/micron/debug/VirtualGeometryStats.js

@@ -1,42 +0,0 @@
-import View from "../../../../view/View.js";
-import { FrameRunner } from "../../FrameRunner.js";
-import LabelView from "../../../../view/common/LabelView.js";
-import ObservedString from "../../../../core/model/ObservedString.js";
-import { formatNumberByThousands } from "../../../../core/NumberFormat.js";
-import LineBuilder from "../../../../core/codegen/LineBuilder.js";
-
-export class VirtualGeometryStats extends View {
-    /**
-     *
-     * @param {VirtualGeometry} vg
-     */
-    constructor(vg) {
-        super();
-
-        this.el = document.createElement('div');
-
-        const vText = new ObservedString("");
-
-        this.addChild(new LabelView(vText));
-
-        this.__updater = new FrameRunner(() => {
-            const lb = new LineBuilder();
-            lb
-                .add(`Source:`)
-                .add(`   Instances: ${formatNumberByThousands(vg.stats_instance_count)}`)
-                .add(`   Triangles: ${formatNumberByThousands(vg.stats_source_triangle_count)}`)
-                .add(`   Vertices: ${formatNumberByThousands(vg.stats_source_vertex_count)}`)
-                .add(`Virtual:`)
-                .add(`   Triangles: ${formatNumberByThousands(vg.computeFaceCount())}`)
-                .add(`   Vertices: ${formatNumberByThousands(vg.computeVertexCount())}`)
-                .add(`   Patches: ${formatNumberByThousands(vg.patch_count)}`)
-            ;
-
-            vText.set(lb.build());
-        });
-
-        this.on.linked.add(this.__updater.startup, this.__updater);
-        this.on.unlinked.add(this.__updater.shutdown, this.__updater);
-    }
-
-}

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

@@ -1 +0,0 @@
-export const MICRON_GEOMETRY_PROPERTY_NAME = "@micron-geometry";

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

@@ -1,21 +0,0 @@
-import {BufferGeometry} from "three";
-import {VertexDataSpec} from "../../geometry/VertexDataSpec";
-import {SurfacePoint3} from "../../../../core/geom/3d/SurfacePoint3";
-import {MicronGeometryPatch} from "./MicronGeometryPatch";
-
-export class MicronGeometry {
-    vertex_spec: VertexDataSpec
-    public proxy: BufferGeometry
-
-    initialize(): void
-
-    raycast(
-        destination: SurfacePoint3[], destination_offset: number,
-        origin_x: number, origin_y: number, origin_z: number,
-        direction_x: number, direction_y: number, direction_z: number
-    ): number
-
-    readonly isMicronGeometry: boolean
-
-    readonly patches: MicronGeometryPatch[]
-}

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

@@ -1,334 +0,0 @@
-import { VertexDataSpec } from "../../geometry/VertexDataSpec.js";
-import { assert } from "../../../../core/assert.js";
-import { computeTriangleRayIntersection } from "../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
-import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
-import { aabb3_array_intersects_ray } from "../../../../core/geom/3d/aabb/aabb3_array_intersects_ray.js";
-import { sphere_array_intersects_ray } from "../../../../core/geom/3d/sphere/sphere_array_intersects_ray.js";
-import { BitSet } from "../../../../core/binary/BitSet.js";
-import { micron_build_proxy_geometry } from "./micron_build_proxy_geometry.js";
-
-let id_counter = 0;
-
-/**
- * @readonly
- * @type {MicronGeometryPatch[]}
- */
-const scratch_traversal_stack = [];
-
-/**
- *
- * @type {BitSet}
- */
-const scratch_traversal_bitset = new BitSet();
-scratch_traversal_bitset.preventShrink();
-
-export class MicronGeometry {
-    constructor() {
-        /**
-         * How many vertices original mesh contains
-         * @type {number}
-         */
-        this.source_vertex_count = 0;
-        /**
-         * How many triangles original mesh contains
-         * @type {number}
-         */
-        this.source_triangle_count = 0;
-
-        /**
-         * How much memory is needed to store the original
-         * @type {number}
-         */
-        this.source_byte_size = 0;
-
-        /**
-         *
-         * @type {MicronGeometryPatch|null}
-         */
-        this.root = null;
-
-        /**
-         *
-         * @type {VertexDataSpec|null}
-         */
-        this.vertex_spec = new VertexDataSpec();
-
-        /**
-         *
-         * @type {number}
-         */
-        this.id = id_counter++;
-
-        /**
-         *
-         * @type {MicronGeometryPatch[]}
-         * @private
-         */
-        this.__patches = [];
-
-        /**
-         * Physical proxy geometry, useful for raycasting and other spatial queries
-         * @type {THREE.BufferGeometry|null}
-         * @private
-         */
-        this.__proxy = null;
-    }
-
-    /**
-     *
-     * @param {SurfacePoint3[]} destination
-     * @param {number} destination_offset
-     * @param {number} origin_x
-     * @param {number} origin_y
-     * @param {number} origin_z
-     * @param {number} direction_x
-     * @param {number} direction_y
-     * @param {number} direction_z
-     * @returns {number}
-     */
-    raycast(
-        destination,
-        destination_offset,
-        origin_x, origin_y, origin_z,
-        direction_x, direction_y, direction_z
-    ) {
-        let destination_address = destination_offset;
-        let i;
-        let stack_cursor = 1;
-
-        // initialize stack
-        const stack = scratch_traversal_stack;
-        stack[0] = this.root;
-
-        const spec = this.vertex_spec;
-
-        const position_attribute_index = spec.getAttributeIndexByName('position');
-
-        // check that position attribute actually exists
-        assert.isNonNegativeInteger(position_attribute_index, 'position_attribute_index');
-
-        const included_set = scratch_traversal_bitset;
-        included_set.reset();
-
-        included_set.set(this.root.id, true);
-
-        const temp_hit = new SurfacePoint3();
-
-        while (stack_cursor > 0) {
-            stack_cursor--;
-
-            const patch = stack[stack_cursor];
-
-
-            if (patch.lod === 0) {
-                // LOD 0 - source geometry
-
-                // cast against bounds
-
-                // sphere test
-                if (!sphere_array_intersects_ray(patch.bounding_sphere,
-                    origin_x, origin_y, origin_z,
-                    direction_x, direction_y, direction_z
-                )) {
-                    continue;
-                }
-
-                // box test
-                if (!aabb3_array_intersects_ray(
-                    patch.bounding_box,
-                    origin_x, origin_y, origin_z,
-                    direction_x, direction_y, direction_z
-                )) {
-                    continue;
-                }
-
-                // raycast against geometry
-                const indices = patch.face_indices;
-                const index_count = indices.length;
-
-                const vertices = patch.vertex_attribute_arrays[position_attribute_index];
-
-                for (i = 0; i < index_count;) {
-                    const a = indices[i++];
-                    const b = indices[i++];
-                    const c = indices[i++];
-
-
-                    const a_address = a * 3;
-                    const b_address = b * 3;
-                    const c_address = c * 3;
-
-
-                    const ax = vertices[a_address];
-                    const ay = vertices[a_address + 1];
-                    const az = vertices[a_address + 2];
-
-                    const bx = vertices[b_address];
-                    const by = vertices[b_address + 1];
-                    const bz = vertices[b_address + 2];
-
-                    const cx = vertices[c_address];
-                    const cy = vertices[c_address + 1];
-                    const cz = vertices[c_address + 2];
-
-                    if (computeTriangleRayIntersection(
-                        temp_hit,
-                        origin_x, origin_y, origin_z,
-                        direction_x, direction_y, direction_z,
-                        ax, ay, az,
-                        bx, by, bz,
-                        cx, cy, cz
-                    )) {
-
-                        const contact = new SurfacePoint3();
-
-                        contact.copy(temp_hit);
-
-                        destination[destination_address++] = contact;
-
-                    }
-                }
-
-            } else {
-
-                // using group bounds because it's conservative, as we want to be able to hit LOD_0
-
-                // sphere test
-                if (!sphere_array_intersects_ray(patch.group_bounding_sphere,
-                    origin_x, origin_y, origin_z,
-                    direction_x, direction_y, direction_z
-                )) {
-                    continue;
-                }
-
-
-                // box test (more expensive, different volume)
-                if (!aabb3_array_intersects_ray(
-                    patch.group_bounding_box,
-                    origin_x, origin_y, origin_z,
-                    direction_x, direction_y, direction_z
-                )) {
-                    // no intersection
-                    continue;
-                }
-
-                // refine more
-                const children = patch.children;
-
-                const child_count = children.length;
-
-                for (i = 0; i < child_count; i++) {
-                    const child = children[i];
-
-                    if (included_set.get(child.id)) {
-                        continue;
-                    }
-
-                    // push to stack
-                    stack[stack_cursor++] = child;
-
-                    included_set.set(child.id, true);
-                }
-            }
-        }
-
-        return destination_address - destination_offset;
-    }
-
-    /**
-     *
-     * @param {number} lod
-     * @returns {number}
-     */
-    computeLodFaceCount(lod) {
-        let r = 0;
-
-        const patches = this.patches;
-        const patch_count = patches.length;
-        for (let i = 0; i < patch_count; i++) {
-            const patch = patches[i];
-
-            if (patch.lod !== lod) {
-                continue;
-            }
-
-            r += patch.polygon_count;
-        }
-
-        return r;
-    }
-
-    get patches() {
-        return this.__patches;
-    }
-
-    /**
-     *
-     * @param {MicronGeometryPatch[]} v
-     */
-    set patches(v) {
-        this.__patches = v;
-    }
-
-    /**
-     * @param {THREE.BufferGeometry} geometry
-     */
-    set proxy(geometry) {
-        this.__proxy = geometry;
-    }
-
-    /**
-     *
-     * @return {THREE.BufferGeometry|null}
-     */
-    get proxy() {
-        return this.__proxy;
-    }
-
-    /**
-     * Build geometry proxy from the patches
-     * @param {number} [fraction] percentage of the original geometry to keep
-     * @param {number} [min] minimum number of triangles to keep, this will be respected first before percentage value
-     */
-    buildProxy(fraction = 0.05, min = 2048) {
-        const bufferGeometry = micron_build_proxy_geometry(this, fraction, min);
-
-        this.__proxy = bufferGeometry;
-    }
-
-    computeByteSize() {
-        let result = 0;
-
-        const patches = this.__patches;
-        const patch_count = patches.length;
-
-        for (let i = 0; i < patch_count; i++) {
-            result += patches[i].computeByteSize();
-        }
-
-        return result;
-    }
-
-    initialize() {
-        this.root.traverse(p => {
-            this.__patches[p.id] = p;
-        });
-    }
-
-    /**
-     *
-     * @param {number} id
-     * @returns {MicronGeometryPatch|undefined}
-     */
-    getPatchById(id) {
-        assert.isNonNegativeInteger(id, 'id');
-
-        return this.__patches[id];
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-MicronGeometry.prototype.isMicronGeometry = true;

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

@@ -1,3 +0,0 @@
-export class MicronGeometryPatch {
-    allocate_metadata(buffer: ArrayBuffer, offset: number): number
-}