@woosh/meep-engine 2.35.17 → 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/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";
 
@@ -85,10 +85,10 @@ export class GLTFAssetTransformer extends AssetTransformer {
 
         /**
          *
-         * @type {MicronGeometryBinarySerializationAdapter}
+         * @type {MicronGeometry[]}
          * @private
          */
-        this.__serde = new MicronGeometryBinarySerializationAdapter();
+        this.__active_mesh_micron_cache = [];
     }
 
     /**
@@ -116,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);
@@ -143,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);
     }
 
 

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;

package/engine/graphics/micron/render/refinement/ActivePatchList.js

@@ -2,7 +2,7 @@ import { ActivePatchRecord } from "./ActivePatchRecord.js";
 import { ActivePatchFlags } from "./ActivePatchFlags.js";
 import { aabb3_project_to_2d } from "../../../../../core/geom/3d/aabb/aabb3_compute_projected_area.js";
 import { BitSet } from "../../../../../core/binary/BitSet.js";
-import { aabb3_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum_array.js";
+import { aabb3_array_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_array_intersects_frustum_array.js";
 
 export class ActivePatchList {
     constructor() {
@@ -199,7 +199,7 @@ export class ActivePatchList {
              check if node is in view frustum
              NOTE: following suggestion in "FastMesh: Efficient View-dependent Meshing" by Renato Pajarola et al, we can do a more coarse frustum test approximating frustum as a cone initially
              */
-            const in_view_frustum = aabb3_intersects_frustum_array(node.bounding_box, frustum_planes);
+            const in_view_frustum = aabb3_array_intersects_frustum_array(node.bounding_box, frustum_planes);
 
             if (!in_view_frustum) {
                 // outside of view frustum, cull

package/engine/graphics/micron/render/refinement/get_geometry_patch_cut.js

@@ -1,5 +1,5 @@
 import { BitSet } from "../../../../../core/binary/BitSet.js";
-import { aabb3_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum_array.js";
+import { aabb3_array_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_array_intersects_frustum_array.js";
 import { aabb3_estimate_projected_area2 } from "../../../../../core/geom/3d/aabb/aabb3_estimate_projected_area2.js";
 
 
@@ -67,7 +67,7 @@ export function get_geometry_patch_cut(
          check if node is in view frustum
          NOTE: following suggestion in "FastMesh: Efficient View-dependent Meshing" by Renato Pajarola et al, we can do a more coarse frustum test approximating frustum as a cone initially
          */
-        const in_view_frustum = aabb3_intersects_frustum_array(patch.bounding_box, frustum_planes);
+        const in_view_frustum = aabb3_array_intersects_frustum_array(patch.bounding_box, frustum_planes);
 
         if (!in_view_frustum) {
             continue;

package/engine/graphics/render/forward_plus/LightManager.js

@@ -9,7 +9,7 @@ import {
     LinearMipMapLinearFilter,
     NearestFilter,
     RGBAFormat,
-    RGBIntegerFormat,
+    RGBAIntegerFormat,
     UnsignedByteType,
     UnsignedShortType
 } from "three";
@@ -158,8 +158,8 @@ export class LightManager {
         this.__cluster_texture.minFilter = NearestFilter;
 
         this.__cluster_texture.type = UnsignedShortType;
-        this.__cluster_texture.format = RGBIntegerFormat;
-        this.__cluster_texture.internalFormat = "RGB16UI";
+        this.__cluster_texture.format = RGBAIntegerFormat;
+        this.__cluster_texture.internalFormat = "RGBA16UI";
 
         /**
          *
@@ -347,7 +347,7 @@ export class LightManager {
 
         const texture = this.__cluster_texture;
 
-        const channelCount = 3;
+        const channelCount = 4;
 
         texture.dispose();
 
@@ -826,7 +826,7 @@ export class LightManager {
 
                     const tile_index = slice_offset + (i_y_0 * tr_x) + i_x_0;
 
-                    const tile_address = tile_index * 3;
+                    const tile_address = tile_index * 4;
 
 
                     // construct tile data

package/engine/graphics/render/forward_plus/data/channelCountToThreIntegerTextureType.js

@@ -1,4 +1,4 @@
-import { RedIntegerFormat, RGBAIntegerFormat, RGBIntegerFormat, RGIntegerFormat } from "three";
+import { RedIntegerFormat, RGBAIntegerFormat, RGIntegerFormat } from "three";
 
 export function channelCountToThreIntegerTextureType(channel_count) {
     switch (channel_count) {
@@ -6,10 +6,10 @@ export function channelCountToThreIntegerTextureType(channel_count) {
             return RedIntegerFormat;
         case 2:
             return RGIntegerFormat;
-        case 3:
-            return RGBIntegerFormat;
         case 4:
             return RGBAIntegerFormat;
+        case 3:
+        // see https://github.com/mrdoob/three.js/pull/23228
         default:
             throw new Error(`Unsupported channel count '${channel_count}'`);
     }

package/engine/graphics/texture/channelCountToThreeTextureFormat.js

@@ -1,4 +1,4 @@
-import { RedFormat, RGBAFormat, RGBFormat, RGFormat } from "three";
+import { RedFormat, RGBAFormat, RGFormat } from "three";
 
 /**
  *
@@ -12,7 +12,7 @@ export function channelCountToThreeTextureFormat(count) {
         case 2:
             return RGFormat;
         case 3:
-            return RGBFormat;
+        // see https://github.com/mrdoob/three.js/pull/23228
         case 4:
             return RGBAFormat;
         default:

package/engine/graphics/util/composeMatrix4.js

@@ -1,56 +1,4 @@
-/**
- *
- * @param {number[]|Float32Array|mat4} result
- * @param {Vector3} position
- * @param {Quaternion} rotation
- * @param {Vector3} scale
- */
-export function compose_matrix4_array(result, position, rotation, scale) {
-    const x = rotation.x;
-    const y = rotation.y;
-    const z = rotation.z;
-    const w = rotation.w;
-
-    const x2 = x + x;
-    const y2 = y + y;
-    const z2 = z + z;
-
-    const xx = x * x2;
-    const xy = x * y2;
-    const xz = x * z2;
-
-    const yy = y * y2;
-    const yz = y * z2;
-    const zz = z * z2;
-
-    const wx = w * x2;
-    const wy = w * y2;
-    const wz = w * z2;
-
-    const sx = scale.x;
-    const sy = scale.y;
-    const sz = scale.z;
-
-    result[0] = (1 - (yy + zz)) * sx;
-    result[1] = (xy + wz) * sx;
-    result[2] = (xz - wy) * sx;
-    result[3] = 0;
-
-    result[4] = (xy - wz) * sy;
-    result[5] = (1 - (xx + zz)) * sy;
-    result[6] = (yz + wx) * sy;
-    result[7] = 0;
-
-    result[8] = (xz + wy) * sz;
-    result[9] = (yz - wx) * sz;
-    result[10] = (1 - (xx + yy)) * sz;
-    result[11] = 0;
-
-    result[12] = position.x;
-    result[13] = position.y;
-    result[14] = position.z;
-    result[15] = 1;
-}
+import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
 
 /**
  *

package/engine/graphics/util/composeMatrix4RotationScale.js

@@ -1,5 +1,5 @@
-import { compose_matrix4_array } from "./composeMatrix4.js";
 import Vector3 from "../../../core/geom/Vector3.js";
+import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
 
 /**
  *

package/engine/intelligence/blackboard/AbstractBlackboard.js

@@ -48,6 +48,15 @@ export class AbstractBlackboard {
         return this.acquire(name, DataType.Number, initialValue);
     }
 
+    /**
+     *
+     * @param {string} name
+     * @returns {void}
+     */
+    incrementNumber(name) {
+        this.acquireNumber(name).increment();
+    }
+
     /**
      *
      * @param {string} name

package/engine/notify/Notification.js

@@ -16,7 +16,7 @@ export class Notification {
      * @constructor
      */
     constructor({ title = "", description = "", image = "", classList = [] }) {
-        assert.ok(Array.isArray(classList), 'classList must be an array, was something else instead');
+        assert.isArray(classList, 'classList');
 
         this.title = title;
 

package/engine/ui/notification/ViewEmitter.js

@@ -1,7 +1,9 @@
 import Vector2 from "../../../core/geom/Vector2.js";
 import { AnimatedObjectEmitter } from "./AnimatedObjectEmitter.js";
 
-
+/**
+ * @template T
+ */
 class ViewEmitter {
     /**
      *
@@ -24,6 +26,10 @@ class ViewEmitter {
             return view;
         };
 
+        /**
+         *
+         * @type {(T)=>View}
+         */
         this.viewFactory = null;
 
         /**

package/engine/ui/notification/notificationGenerator.js

@@ -41,7 +41,7 @@ function notificationGenerator(callback, timeout = 5) {
  *
  * @param {NotificationManager} notifications
  */
-function testNotifications(notifications) {
+export function testNotifications(notifications) {
     notificationGenerator(n => {
         notifications.addNotification(n, NotificationAreaKind.Primary);
     }, 1.3);