@woosh/meep-engine 2.35.15 → 2.36.0

package/engine/graphics/geometry/MikkT/MikkTSpace.spec.js

@@ -0,0 +1,22 @@
+import { genTangSpace, SMikkTSpaceContext } from "./MikkTSpace.js";
+
+test('empty geometry', () => {
+    const ctx = new SMikkTSpaceContext();
+
+    expect(() => {
+        genTangSpace(ctx);
+    }).not.toThrow();
+
+});
+
+test('single triangle', () => {
+    const ctx = new SMikkTSpaceContext();
+
+    ctx.geometry_buffer_index = [0, 1, 2];
+    ctx.geometry_buffer_vertex_position = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+    ctx.geometry_buffer_vertex_normal = [0, 1, 0, 0, 1, 0, 0, 1, 0];
+    ctx.geometry_buffer_vertex_uv = [0, 0, 0, 0, 0, 0];
+
+    genTangSpace(ctx);
+
+});

package/engine/graphics/geometry/MikkT/buffer_geometry_ensure_tangents.js

@@ -0,0 +1,34 @@
+import { buffer_geometry_generate_tangents } from "./buffer_geometry_generate_tangents.js";
+
+/**
+ *
+ * @param {THREE.BufferGeometry} geo
+ */
+export function buffer_geometry_ensure_tangents(geo) {
+    if (geo.getAttribute('tangent') !== undefined) {
+        // already got tangents
+        return;
+    }
+
+    if (geo.getIndex() === null) {
+        // non-indexed, unsupported
+        return;
+    }
+
+    if (geo.getAttribute('normal') === undefined) {
+        // no normals
+        return;
+    }
+
+    if (geo.getAttribute('uv') === undefined) {
+        // UVs are required by the algorithm
+        return;
+    }
+
+    if (geo.getAttribute('position') === undefined) {
+        // positions are required as well
+        return;
+    }
+
+    buffer_geometry_generate_tangents(geo);
+}

package/engine/graphics/geometry/MikkT/buffer_geometry_generate_tangents.js

@@ -0,0 +1,28 @@
+import { BufferAttribute } from "three";
+import { genTangSpace, SMikkTSpaceContext } from "./MikkTSpace.js";
+
+/**
+ * only works with indexed geometries
+ * @param {THREE.BufferGeometry} geo
+ */
+export function buffer_geometry_generate_tangents(geo) {
+
+    const attribute_position = geo.getAttribute('position');
+
+    if (geo.getAttribute('tangent') === undefined) {
+        geo.setAttribute('tangent', new BufferAttribute(new Float32Array(attribute_position.count * 4), 4, false));
+    }
+
+    const attribute_tangent = geo.getAttribute('tangent');
+
+
+    const ctx = new SMikkTSpaceContext();
+
+    ctx.geometry_buffer_index = geo.getIndex().array;
+    ctx.geometry_buffer_vertex_position = attribute_position.array;
+    ctx.geometry_buffer_vertex_normal = geo.getAttribute('normal').array;
+    ctx.geometry_buffer_vertex_uv = geo.getAttribute('uv').array;
+    ctx.geometry_buffer_vertex_tangent = attribute_tangent.array;
+
+    genTangSpace(ctx);
+}

package/engine/graphics/geometry/skining/computeSkinnedMeshBoundingVolumes.js

@@ -3,7 +3,7 @@ import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import Vector4 from "../../../../core/geom/Vector4.js";
 import { computeBoundingSphereFromVertexData } from "../computeBoundingSphereFromVertexData.js";
 import { Box3, Sphere as ThreeSphere, Vector3 as ThreeVector3 } from "three";
-import { computeBoundingBoxFromVertexData } from "../../util/computeBoundingBoxFromVertexData.js";
+import { computeBoundingBoxFromVertexData } from "../../../../core/geom/3d/aabb/computeBoundingBoxFromVertexData.js";
 
 /**
  *

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

@@ -1,10 +1,3 @@
-/**
- *
- * @param {number} count
- * @returns {Function}
- * @constructor
- */
-
 import { DataType } from "../../../../core/collection/table/DataType.js";
 import { passThrough } from "../../../../core/function/Functions.js";
 import { to_half_float_uint16 } from "../../../../core/binary/to_half_float_uint16.js";
@@ -12,17 +5,7 @@ import { compute_micron_buffer_array_constructor } from "./compute_micron_buffer
 import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
 import { dataTypeByteSize } from "../../../../core/collection/table/DataTypeByteSizes.js";
 import { clamp } from "../../../../core/math/clamp.js";
-
-function UintArrayForCount(count) {
-
-    if (count <= 256) {
-        return Uint8Array;
-    } else if (count <= 65536) {
-        return Uint16Array;
-    } else {
-        throw new Error(`Unsupported size ${count}`)
-    }
-}
+import { UintArrayForCount } from "../../../../core/collection/array/typed/uint_array_for_count.js";
 
 /**
  * @param {number} vertex_count

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

@@ -5,6 +5,7 @@ import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { aabb3_array_intersects_ray } from "../../../../core/bvh2/aabb3/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;
 
@@ -286,11 +287,13 @@ export class MicronGeometry {
 
     /**
      * 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
+     * @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, min) {
-        throw new Error('Not Implemented');
+    buildProxy(fraction = 0.05, min = 2048) {
+        const bufferGeometry = micron_build_proxy_geometry(this, fraction, min);
+
+        this.__proxy = bufferGeometry;
     }
 
     computeByteSize() {

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

@@ -0,0 +1,203 @@
+//
+
+import BinaryHeap from "../../../navigation/grid/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/collection/table/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);
+}

package/engine/graphics/micron/format/serialization/collection/geometry_collection_serialization.js

@@ -0,0 +1,83 @@
+import { MicronGeometryBinarySerializationAdapter } from "../MicronGeometryBinarySerializationAdapter.js";
+import { MicronGeometry } from "../../MicronGeometry.js";
+
+const SUPPORTED_ADAPTER_VERSION = 0;
+const HEADER_MAGIC_TEXT = 'MICRON#001';
+
+function obtain_micron_adapter() {
+
+    const ga = new MicronGeometryBinarySerializationAdapter();
+
+    if (ga.version !== SUPPORTED_ADAPTER_VERSION) {
+        throw new Error(`Incorrect version of serialization adapter, expected ${SUPPORTED_ADAPTER_VERSION}, instead got ${ga.version}`);
+    }
+
+    return ga;
+}
+
+/**
+ *
+ * @param {MicronGeometry[]} destination
+ * @param {BinaryBuffer} buffer
+ * @returns {number} how many geometries were read
+ */
+export function deserialize_geometry_collection(destination, buffer) {
+    // read header
+    const header_text = buffer.readASCIICharacters(HEADER_MAGIC_TEXT.length);
+
+    if (header_text !== HEADER_MAGIC_TEXT) {
+        throw new Error(`Wrong header magic, expected '${HEADER_MAGIC_TEXT}', instead got '${header_text}'`);
+    }
+
+    // read how many geometries we're expecting
+    const geometry_occupies_count = buffer.readUint32();
+
+    const ga = obtain_micron_adapter();
+
+    for (let i = 0; i < geometry_occupies_count; i++) {
+        // read key
+        const key = buffer.readUint32();
+
+        const geometry = new MicronGeometry();
+
+        ga.deserialize(buffer, geometry);
+
+        destination[key] = geometry;
+    }
+
+    return geometry_occupies_count;
+}
+
+/**
+ *
+ * @param {MicronGeometry[]} geometries
+ * @param {BinaryBuffer} buffer
+ */
+export function serialize_geometry_collection(geometries, buffer) {
+    // write header
+    buffer.writeASCIIString(HEADER_MAGIC_TEXT); // magic bytes
+
+    // count geometries
+    let geometry_occupied_count = 0;
+    const geometry_count = geometries.length;
+    for (let i = 0; i < geometry_count; i++) {
+        if (geometries[i] === undefined) {
+            geometry_occupied_count++;
+        }
+    }
+
+    buffer.writeUint32(geometry_occupied_count); // how many geometries to expect
+
+    const ga = obtain_micron_adapter();
+
+    for (let i = 0; i < geometry_count; i++) {
+        const geometry = geometries[i];
+        if (geometry === undefined) {
+            continue;
+        }
+
+        buffer.writeUint32(i); // key
+
+        ga.serialize(buffer, geometry);
+    }
+}

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

@@ -1,15 +1,15 @@
 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 { compute_geometry_polycount } from "../../geometry/compute_geometry_polycount.js";
 import { traverseThreeObject } from "../../ecs/highlight/renderer/traverseThreeObject.js";
 import { max2 } from "../../../../core/math/max2.js";
+import { deserialize_geometry_collection } from "../format/serialization/collection/geometry_collection_serialization.js";
+import { GLTF_MICRON_ID_FIELD } from "./GLTF_MICRON_ID_FIELD.js";
 
 export const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 
@@ -35,6 +35,25 @@ function max_polycount(object) {
     return r;
 }
 
+/**
+ *
+ * @param {THREE.Object3D} object
+ */
+function ensureProxy(object) {
+    if (object.isMicronMesh) {
+
+        /**
+         * @type {MicronGeometry}
+         */
+        const micron_geo = object.geometry;
+
+        if (micron_geo.proxy === null) {
+            // proxy geometry doesn't exist, build one
+            micron_geo.buildProxy();
+        }
+    }
+}
+
 export class GLTFAssetTransformer extends AssetTransformer {
     /**
      *
@@ -66,10 +85,10 @@ export class GLTFAssetTransformer extends AssetTransformer {
 
         /**
          *
-         * @type {MicronGeometryBinarySerializationAdapter}
+         * @type {MicronGeometry[]}
          * @private
          */
-        this.__serde = new MicronGeometryBinarySerializationAdapter();
+        this.__active_mesh_micron_cache = [];
     }
 
     /**
@@ -97,23 +116,52 @@ export class GLTFAssetTransformer extends AssetTransformer {
          */
         const geometry = object.geometry;
 
-        const micron_uri = geometry.userData[MICRON_URI_FIELD];
+        const micron_geometry_index = geometry.userData[GLTF_MICRON_ID_FIELD];
 
-        if (typeof micron_uri !== "string") {
+        if (typeof micron_geometry_index !== "number") {
             return;
         }
 
+        const micron_geometry = this.__active_mesh_micron_cache[micron_geometry_index];
 
-        /**
-         * @type {AssetDescription}
-         */
-        const ad = ctx.asset;
+        if (micron_geometry === undefined) {
+            console.error(`Micron geometry '${micron_geometry_index}' not found`);
+            return;
+        }
+
+        // set proxy for raycasting
+        micron_geometry.proxy = geometry;
+
+        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
+    }
+
+
+    /**
+     *
+     * @param {{userData:{}}} gltf
+     * @param {AssetDescription} ad
+     * @private
+     */
+    async __load_mesh_micron_data(gltf, ad) {
+        // clear active cache
+        this.__active_mesh_micron_cache = [];
+
+        const micron_metadata = gltf.userData.micron;
+
+        if (micron_metadata === undefined) {
+            return;
+        }
+
+        const uri = micron_metadata.geometry_data_uri;
+        if (uri === undefined) {
+            return;
+        }
 
         const base = computePathDirectory(ad.path);
 
         let micron_data;
 
-        const micron_path = `${base}/${micron_uri}`;
+        const micron_path = `${base}/${uri}`;
 
         try {
             micron_data = await this.__am.promise(micron_path, ASSET_TYPE_ARRAY_BUFFER);
@@ -124,14 +172,8 @@ export class GLTFAssetTransformer extends AssetTransformer {
 
         // 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;
+        deserialize_geometry_collection(this.__active_mesh_micron_cache, buffer);
     }
 
 
@@ -171,6 +213,8 @@ export class GLTFAssetTransformer extends AssetTransformer {
 
         source.override_mesh = micron_root;
 
+        traverseThreeObject(micron_root, ensureProxy);
+
         return source;
     }
 }

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

@@ -0,0 +1,5 @@
+/**
+ *
+ * @type {string}
+ */
+export const GLTF_MICRON_ID_FIELD = '@micron_geometry_index';

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

@@ -135,10 +135,6 @@ export class MicronRenderPlugin extends EnginePlugin {
         view.on.preRender.remove(observer);
     }
 
-    __ingest_cache() {
-        this.engine.storage.lo
-    }
-
     async startup() {
 
         const engine = this.engine;