@woosh/meep-engine 2.33.64 → 2.33.65

package/core/FilePath.js

@@ -1,3 +1,5 @@
+const PATH_SEPARATOR = '/';
+
 /**
  * Strips all directories from the path.
  * @example 'a/b/c' -> 'c'
@@ -9,7 +11,7 @@ function computePathBase(path) {
         throw new Error('path is not a string');
     }
 
-    const lastSlashIndex = path.lastIndexOf('/');
+    const lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
 
     if (lastSlashIndex !== -1) {
         return path.substring(lastSlashIndex + 1);
@@ -18,6 +20,30 @@ function computePathBase(path) {
     }
 }
 
+/**
+ * Returns the directory name of a path, similar to the Unix dirname command.
+ * @param {string} path
+ * @return {string}
+ */
+export function computePathDirectory(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    let lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
+
+    //rewind in case of trailing slashes
+    while (lastSlashIndex > 0 && path.charAt(lastSlashIndex - 1) === PATH_SEPARATOR) {
+        lastSlashIndex--;
+    }
+
+    if (lastSlashIndex !== -1) {
+        return path.substring(0, lastSlashIndex);
+    } else {
+        return path;
+    }
+}
+
 /**
  *
  * @param {string} path
@@ -44,4 +70,4 @@ function computeFileExtension(path) {
 export {
     computePathBase,
     computeFileExtension
-};
+};

package/core/binary/BinaryBuffer.js

@@ -57,6 +57,19 @@ BinaryBuffer.prototype.fromArrayBuffer = function (arrayBuffer) {
     this.position = 0;
 };
 
+/**
+ *
+ * @param {ArrayBuffer} v
+ * @return {BinaryBuffer}
+ */
+BinaryBuffer.fromArrayBuffer = function (v) {
+    const r = new BinaryBuffer();
+
+    r.fromArrayBuffer(v);
+
+    return r;
+};
+
 /**
  *
  * @returns {BinaryBuffer}

package/engine/asset/AssetManager.js

@@ -231,7 +231,7 @@ AssetManager.prototype.submitRequest = function (path, type, request) {
             for (let i = 0; i < transformer_count; i++) {
                 const transformer = transformers[i];
 
-                const transformed_asset = await transformer.transform(asset);
+                const transformed_asset = await transformer.transform(asset, assetDescription);
 
                 if (typeof transformed_asset !== "object") {
                     console.error('Transformer produced invalid result. Ignoring result.', transformer, assetDescription);

package/engine/asset/AssetTransformer.js

@@ -7,9 +7,10 @@
 export class AssetTransformer {
     /**
      * @param {A} source
+     * @param {AssetDescription} asset_description
      * @returns {A}
      */
-    async transform(source) {
+    async transform(source, asset_description) {
         throw new Error('Not Implemented');
     }
 }

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -25,6 +25,8 @@ import { computeGeometryEquality } from "./geometry/geometry/computeGeometryEqua
 import { traverseThreeObject } from "../../graphics/ecs/highlight/renderer/traverseThreeObject.js";
 import { computeTextureHash } from "./material/computeTextureHash.js";
 import { computeTextureEquality } from "./material/computeTextureEquality.js";
+import { async_traverse_three_object } from "./async_traverse_three_object.js";
+import { deinterleaveBufferGeometry } from "../../graphics/geometry/buffered/deinterleaveBufferGeometry.js";
 
 const animationOptimizer = new AnimationOptimizer();
 const materialCache = StaticMaterialCache.Global;
@@ -130,26 +132,6 @@ function buildDracoDecoderPath() {
     return `${pathname}/libs/draco/`;
 }
 
-/**
- *
- * @param {THREE.Object3D} object
- * @param {function} callback
- * @param {*} [thisArg]
- */
-async function async_traverse(object, callback, thisArg) {
-    await callback.call(thisArg, object);
-
-    const children = object.children;
-    const n = children.length;
-
-    for (let i = 0; i < n; i++) {
-        const child = children[i];
-
-        // TODO we can parallelize this if necessary
-        await async_traverse(child, callback, thisArg);
-    }
-}
-
 export class GLTFAssetLoader extends AssetLoader {
 
     constructor() {
@@ -312,6 +294,8 @@ export class GLTFAssetLoader extends AssetLoader {
                 mesh.geometry = geometry;
             }
 
+            mesh.geometry = deinterleaveBufferGeometry(geometry);
+
 
             if (this.__enable_texture_cache) {
                 // replace textures from cache
@@ -387,7 +371,7 @@ export class GLTFAssetLoader extends AssetLoader {
             }
 
 
-            await async_traverse(root, process_object);
+            await async_traverse_three_object(root, process_object);
 
 
             // compute object bounding sphere

package/engine/asset/loaders/async_traverse_three_object.js

@@ -0,0 +1,24 @@
+/**
+ *
+ * @param {THREE.Object3D} object
+ * @param {function} callback
+ * @param {*} [thisArg]
+ * @param {*} [ctx]
+ */
+export async function async_traverse_three_object(object, callback, thisArg, ctx) {
+    await callback.call(thisArg, object, ctx);
+
+    const children = object.children;
+    const n = children.length;
+
+    const child_promises = [];
+
+    for (let i = 0; i < n; i++) {
+        const child = children[i];
+
+        child_promises.push(async_traverse_three_object(child, callback, thisArg, ctx));
+    }
+
+    // wait for all children at the same time
+    await Promise.all(child_promises);
+}

package/engine/graphics/micron/MICRON_GEOMETRY_FIELD.js

@@ -0,0 +1 @@
+export const MICRON_GEOMETRY_FIELD = '@micron_geometry';

package/engine/graphics/micron/MICRON_URI_FIELD.js

@@ -0,0 +1 @@
+export const MICRON_URI_FIELD = '@micron_path';

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -4,6 +4,7 @@ import { computeGeometryEquality } from "../../asset/loaders/geometry/geometry/c
 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";
 
 /**
  *
@@ -19,7 +20,6 @@ const pending_cache = new HashMap({
     keyEqualityFunction: computeGeometryEquality
 });
 
-
 /**
  *
  * @param {THREE.Object3D} object
@@ -36,6 +36,13 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
      * @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 existing = await micron_cache.get(g);
 
         if (existing !== undefined && existing !== null) {
@@ -90,7 +97,15 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
             && !mesh.isSkinnedMesh // skinned meshes not supported
         ) {
 
-            const micronGeometry = await obtain_geometry(mesh.geometry);
+            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);
 

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

@@ -117,3 +117,9 @@ export class MicronGeometry {
         return this.__patches[id];
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+MicronGeometry.prototype.isMicronGeometry = true;

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

@@ -13,6 +13,13 @@ import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteH
 import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";
 import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
 import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper.js";
+import { async_traverse_three_object } from "../../../asset/loaders/async_traverse_three_object.js";
+import { computePathDirectory } from "../../../../core/FilePath.js";
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { MicronGeometry } from "../format/MicronGeometry.js";
+import { ArrayBufferLoader } from "../../../asset/loaders/ArrayBufferLoader.js";
+import { MICRON_URI_FIELD } from "../MICRON_URI_FIELD.js";
+import { MICRON_GEOMETRY_FIELD } from "../MICRON_GEOMETRY_FIELD.js";
 
 /**
  *
@@ -20,6 +27,7 @@ import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper
  */
 const STORAGE_KEY = '@plugin/virtual-geometry-micron/geometry-cache';
 
+const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 
 class GLTFAssetTransformer extends AssetTransformer {
     /**
@@ -35,17 +43,97 @@ class GLTFAssetTransformer extends AssetTransformer {
          * @private
          */
         this.__cache = cache;
+
+        /**
+         *
+         * @type {AssetManager|null}
+         * @private
+         */
+        this.__am = null;
+
+        /**
+         *
+         * @type {MicronGeometryBinarySerializationAdapter}
+         * @private
+         */
+        this.__serde = new MicronGeometryBinarySerializationAdapter();
+    }
+
+    /**
+     *
+     * @param {AssetManager|null} am
+     */
+    set assetManager(am) {
+        this.__am = am;
+    }
+
+
+    /**
+     * @param {THREE.Object3D} object
+     * @param {{asset:AssetDescription}} ctx
+     * @return {Promise<void>}
+     * @private
+     */
+    async __visitObjectToLoadMicron(object, ctx) {
+        if (!object.isMesh) {
+            return;
+        }
+
+        /**
+         * @type {THREE.BufferGeometry}
+         */
+        const geometry = object.geometry;
+
+        const micron_uri = geometry.userData[MICRON_URI_FIELD];
+
+        if (typeof micron_uri !== "string") {
+            return;
+        }
+
+
+        /**
+         * @type {AssetDescription}
+         */
+        const ad = ctx.asset;
+
+        const base = computePathDirectory(ad.path);
+
+        const micron_data = await this.__am.promise(`${base}/${micron_uri}`, ASSET_TYPE_ARRAY_BUFFER);
+
+        // deserialize micron data
+        const buffer = BinaryBuffer.fromArrayBuffer(micron_data.create());
+        const micron_geometry = new MicronGeometry();
+
+        this.__serde.deserialize(buffer, micron_geometry);
+
+        geometry[MICRON_GEOMETRY_FIELD] = micron_geometry;
     }
 
-    async transform(source) {
+
+    /**
+     *
+     * @param {Asset} source
+     * @param asset_description
+     * @return {Promise<Asset>}
+     */
+    async transform(source, asset_description) {
         const animationClips = source.animations;
+
         if (animationClips !== undefined && animationClips.length > 0) {
             // not suitable
             return source;
         }
 
+        /**
+         * @type {THREE.Object3D}
+         */
         const root = source.create();
 
+        // attempt to load existing micron geometries
+        await async_traverse_three_object(root, this.__visitObjectToLoadMicron, this, {
+            asset: asset_description
+        });
+
         const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
         micron_root.boundingSphere = root.boundingSphere;
 
@@ -117,7 +205,7 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         /**
          *
-         * @type {AssetTransformer}
+         * @type {GLTFAssetTransformer}
          * @private
          */
         this.__asset_transformer = new GLTFAssetTransformer(this.__cache);
@@ -180,8 +268,17 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         const engine = this.engine;
 
-        engine.assetManager.registerTransformer("model/gltf", this.__asset_transformer);
-        engine.assetManager.registerTransformer("model/gltf+json", this.__asset_transformer);
+        const am = engine.assetManager;
+
+        // ensure that "arraybuffer" asset loader is present
+        if (am.getLoaderByType(ASSET_TYPE_ARRAY_BUFFER) === undefined) {
+            am.registerLoader(ASSET_TYPE_ARRAY_BUFFER, new ArrayBufferLoader());
+        }
+
+        this.__asset_transformer.assetManager = am;
+
+        am.registerTransformer("model/gltf", this.__asset_transformer);
+        am.registerTransformer("model/gltf+json", this.__asset_transformer);
 
         /**
          *
@@ -207,8 +304,12 @@ export class MicronRenderPlugin extends EnginePlugin {
 
         this.__persisted_geometry.detach_storage();
 
-        engine.assetManager.unregisterTransformer("model/gltf", this.__asset_transformer);
-        engine.assetManager.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+        const am = engine.assetManager;
+
+        am.unregisterTransformer("model/gltf", this.__asset_transformer);
+        am.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+
+        this.__asset_transformer.assetManager = null;
 
         const ge = engine.graphics;
 

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -433,7 +433,9 @@ async function sample_scene_nam(engine) {
         "distanceMax": 1000
     });
 
-    load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
+    // load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
+    load_model('moicon/20_Dec_2021_Nammo/with_assets_micron_conveted/model.gltf', ecd)
+    // load_model('moicon/micron_container/model.gltf', ecd)
 
     const P_SIZE_SMALL = 0.15;
     const P_SIZE_MEDIUM = 0.6;

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.64",
+  "version": "2.33.65",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",