@woosh/meep-engine 2.33.58 → 2.33.62

package/engine/graphics/ecs/trail2d/Trail2D.js

@@ -6,6 +6,10 @@
 import Vector3 from "../../../../core/geom/Vector3.js";
 import Vector4 from "../../../../core/geom/Vector4.js";
 import { RibbonXMaterialSpec } from "../../trail/x/RibbonXMaterialSpec.js";
+import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
+import { makeGradientTrail } from "./makeGradientTrail.js";
+import { RibbonX } from "../../trail/x/RibbonX.js";
+import ThreeFactory from "../../three/ThreeFactory.js";
 
 /**
  * @readonly
@@ -14,6 +18,7 @@ import { RibbonXMaterialSpec } from "../../trail/x/RibbonXMaterialSpec.js";
 export const Trail2DFlags = {
     Spawning: 1,
     Aging: 2,
+    Built: 4,
 };
 
 class Trail2D {
@@ -37,6 +42,12 @@ class Trail2D {
          */
         this.time = 0;
 
+        /**
+         *
+         * @type {number}
+         */
+        this.trailingIndex = 0;
+
         /**
          * Time elapsed since last update
          * @type {number}
@@ -72,7 +83,11 @@ class Trail2D {
          * transient
          * @type {LeafNode|null}
          */
-        this.bvhLeaf = null;
+        this.bvhLeaf = new LeafNode(
+            this,
+            0, 0, 0,
+            0, 0, 0
+        );
 
         /**
          * @private
@@ -165,6 +180,21 @@ class Trail2D {
         }
     }
 
+    build(segment_count) {
+
+        const ribbon = new RibbonX();
+
+        ribbon.buildGeometry();
+        ribbon.setCount(segment_count);
+
+        const geometry = ribbon.getGeometry();
+
+        const mesh = ThreeFactory.createMesh(geometry, null);
+
+        this.ribbon = ribbon;
+        this.mesh = mesh;
+    }
+
     toJSON() {
         return {
             maxAge: this.maxAge,
@@ -187,10 +217,14 @@ class Trail2D {
             && this.offset.equals(other.offset)
             ;
     }
+
+
 }
 
 Trail2D.typeName = "Trail2D";
 
 Trail2D.serializable = false;
 
+Trail2D.makeGradientTrail = makeGradientTrail;
+
 export default Trail2D;

package/engine/graphics/ecs/trail2d/Trail2DSystem.js

@@ -10,9 +10,6 @@ import { Transform } from '../../../ecs/transform/Transform.js';
 import Vector3 from '../../../../core/geom/Vector3.js';
 
 import Trail2D, { Trail2DFlags } from './Trail2D.js';
-
-import { LeafNode } from '../../../../core/bvh2/LeafNode.js';
-import ThreeFactory from '../../three/ThreeFactory.js';
 import { GraphicsEngine } from "../../GraphicsEngine.js";
 import { RibbonXFixedPhysicsSimulator } from "../../trail/x/simulator/RibbonXFixedPhysicsSimulator.js";
 import { RibbonX } from "../../trail/x/RibbonX.js";
@@ -118,11 +115,11 @@ class Trail2DSystem extends System {
 
     /**
      *
-     * @param {Transform} transform
      * @param {Trail2D} trail
-     * @param {number} entityId
+     * @param {Transform} transform
+     * @private
      */
-    link(trail, transform, entityId) {
+    __build_trail(trail, transform) {
         const segmentsPerSecond = 60;
         const maxSegments = 1000;
         //instantiation
@@ -130,24 +127,19 @@ class Trail2DSystem extends System {
         //make a mesh
         const segment_count = Math.ceil(clamp(trail.maxAge * segmentsPerSecond, 2, maxSegments));
 
-        const ribbon = new RibbonX();
-
-        ribbon.buildGeometry();
-        ribbon.setCount(segment_count);
+        trail.build(segment_count);
 
-
-        const geometry = ribbon.getGeometry();
+        const ribbon = trail.ribbon;
 
         const ribbons = this.__ribbon_plugin.getValue();
 
         const material = ribbons.obtain_material_x(trail.material);
 
-        const mesh = ThreeFactory.createMesh(geometry, material);
+        trail.mesh.material = material;
 
         trail.time = 0;
         trail.trailingIndex = 0;
         trail.ribbon = ribbon;
-        trail.mesh = mesh;
         trail.timeSinceLastUpdate = 0;
 
 
@@ -173,16 +165,31 @@ class Trail2DSystem extends System {
 
         }
 
-        const leafNode = new LeafNode(
-            trail,
-
+        trail.bvhLeaf.resize(
             position_x, position_y, position_z,
             position_x, position_y, position_z
         );
 
-        trail.bvhLeaf = leafNode;
+        trail.setFlag(Trail2DFlags.Built);
+    }
+
+    /**
+     *
+     * @param {Transform} transform
+     * @param {Trail2D} trail
+     * @param {number} entityId
+     */
+    link(trail, transform, entityId) {
+        if (!trail.getFlag(Trail2DFlags.Built)) {
+            this.__build_trail(trail, transform);
+        } else {
+
+            const material = this.__ribbon_plugin.getValue().obtain_material_x(trail.material);
+            trail.mesh.material = material;
+        }
+
 
-        this.bvh.insertNode(leafNode);
+        this.bvh.insertNode(trail.bvhLeaf);
     }
 
     /**

package/engine/graphics/ecs/trail2d/makeGradientTrail.js

@@ -0,0 +1,68 @@
+import Trail2D, { Trail2DFlags } from "./Trail2D.js";
+import {
+    RIBBON_ATTRIBUTE_ADDRESS_AGE,
+    RIBBON_ATTRIBUTE_ADDRESS_COLOR,
+    RIBBON_ATTRIBUTE_ADDRESS_THICKNESS,
+    RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET
+} from "../../trail/x/ribbon_attributes_spec.js";
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number[]} color
+ * @param {number[]} thickness
+ * @param {number} [duration]
+ * @param {number} [scale]
+ * @param {number[]} position
+ * @param {number[]} ages
+ * @param {string} texture
+ * @returns {Trail2D}
+ */
+export function makeGradientTrail({
+                                      color,
+                                      thickness,
+                                      position,
+                                      duration = 1,
+                                      scale = 1,
+                                      ages,
+                                      texture
+                                  }) {
+
+    const trail2D = new Trail2D();
+    trail2D.maxAge = duration;
+    trail2D.width = 1;
+    trail2D.textureURL = texture;
+
+    const point_count = thickness.length;
+
+    trail2D.build(point_count);
+
+    const ribbon = trail2D.ribbon;
+
+    for (let i = 0; i < point_count; i++) {
+
+        const f = i / (point_count - 1);
+        const i3 = i * 3;
+
+        ribbon.setPointAlpha(i, 0);
+        ribbon.setPointPosition(i, position[i3], position[i3 + 1], position[i3 + 2]);
+
+        ribbon.setPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_AGE, ages[i] * duration);
+        ribbon.setPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET, f);
+        ribbon.setPointAttribute_Scalar(i, RIBBON_ATTRIBUTE_ADDRESS_THICKNESS, thickness[i]);
+
+        const c_0 = color[i];
+
+        assert.isNumber(c_0, `color[i]`);
+
+        ribbon.setPointAttribute_Vector3(i, RIBBON_ATTRIBUTE_ADDRESS_COLOR, c_0 >> 16, c_0 >> 8, c_0);
+    }
+
+    // don't spawn more trail segments
+    trail2D.clearFlag(Trail2DFlags.Spawning);
+    trail2D.setFlag(Trail2DFlags.Built);
+
+    ribbon.computeBoundingBox(trail2D.bvhLeaf);
+
+    return trail2D;
+}

package/engine/graphics/ecs/water/WaterSystem.js

@@ -8,10 +8,10 @@ import { LeafNode } from '../../../../core/bvh2/LeafNode.js';
 import { buildPlanarRenderLayerClipPlaneComputationMethod } from "../../render/layers/RenderLayerUtils.js";
 import ThreeFactory from "../../three/ThreeFactory.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
-import { obtainTerrain } from "../../../../../model/game/scenes/SceneUtils.js";
 import { makeAlexWaterMaterial } from "../water2/shader/AlexWaterShader.js";
 import { threeUpdateTransform } from "../../util/threeUpdateTransform.js";
 import { StandardFrameBuffers } from "../../StandardFrameBuffers.js";
+import { obtainTerrain } from "../../../ecs/terrain/util/obtainTerrain.js";
 
 const WATER_SIZE = 800;
 

package/engine/graphics/ecs/water2/shader/testWaterShader.js

@@ -1,4 +1,3 @@
-import { obtainTerrain } from "../../../../../../model/game/scenes/SceneUtils.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { EngineConfiguration } from "../../../../EngineConfiguration.js";
 import ScriptSystem from "../../../../ecs/systems/ScriptSystem.js";
@@ -28,6 +27,7 @@ import { EngineHarness } from "../../../../EngineHarness.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
 import SimplexNoise from 'simplex-noise';
+import { obtainTerrain } from "../../../../ecs/terrain/util/obtainTerrain.js";
 
 const engineHarness = new EngineHarness();
 

package/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -2,6 +2,7 @@ import { Cache } from "../../../../../core/cache/Cache.js";
 import { buildUnsorted } from "../../bvh/buffered/BinaryBVHFromBufferGeometry.js";
 import { ClippingPlaneContainmentComputingVisitor } from "./ClippingPlaneContainmentComputingVisitor.js";
 import { RaycastNearestHitComputingVisitor } from "./RaycastNearestHitComputingVisitor.js";
+import { assert } from "../../../../../core/assert.js";
 
 export class GeometrySpatialQueryAccelerator {
     constructor(cache_size = 100 * 1024 * 1024) {
@@ -38,6 +39,8 @@ export class GeometrySpatialQueryAccelerator {
      * @returns {number} -1,0,1. -1 means fully outside, 0 means partially inside, 1 means fully inside
      */
     queryContainmentViaClippingPlanes(geometry, planes) {
+        assert.notNull(geometry, 'geometry');
+        assert.defined(geometry, 'geometry');
 
         const bvh = this.__acquireBVH(geometry);
 
@@ -53,14 +56,25 @@ export class GeometrySpatialQueryAccelerator {
     }
 
     /**
-     * Get the nearest ray intersection
+     *
      * @param {SurfacePoint3} destination
      * @param {THREE.BufferGeometry} geometry
-     * @param {Vector3} ray_origin
-     * @param {Vector3} ray_direction
-     * @returns {boolean} true if hit detected, false otherwise
+     * @param {number} ray_origin_x
+     * @param {number} ray_origin_y
+     * @param {number} ray_origin_z
+     * @param {number} ray_direction_x
+     * @param {number} ray_direction_y
+     * @param {number} ray_direction_z
+     * @return {boolean}
      */
-    queryRaycastNearest(destination, geometry, ray_origin, ray_direction) {
+    queryRaycastNearest_primitive(
+        destination,
+        geometry,
+        ray_origin_x, ray_origin_y, ray_origin_z,
+        ray_direction_x, ray_direction_y, ray_direction_z
+    ) {
+        assert.notNull(geometry, 'geometry');
+        assert.defined(geometry, 'geometry');
 
         const bvh = this.__acquireBVH(geometry);
 
@@ -69,12 +83,12 @@ export class GeometrySpatialQueryAccelerator {
         this.__visitor_raycast.setGeometry(geometry);
         this.__visitor_raycast.setRoot(bvh);
         this.__visitor_raycast.setRay(
-            ray_origin.x,
-            ray_origin.y,
-            ray_origin.z,
-            ray_direction.x,
-            ray_direction.y,
-            ray_direction.z
+            ray_origin_x,
+            ray_origin_y,
+            ray_origin_z,
+            ray_direction_x,
+            ray_direction_y,
+            ray_direction_z
         );
 
         bvh.traversePreOrderStack(this.__visitor_raycast, 0);
@@ -87,6 +101,27 @@ export class GeometrySpatialQueryAccelerator {
         } else {
             return false;
         }
+    }
+
+    /**
+     * Get the nearest ray intersection
+     * @param {SurfacePoint3} destination
+     * @param {THREE.BufferGeometry} geometry
+     * @param {Vector3} ray_origin
+     * @param {Vector3} ray_direction
+     * @returns {boolean} true if hit detected, false otherwise
+     */
+    queryRaycastNearest(destination, geometry, ray_origin, ray_direction) {
+
+        return this.queryRaycastNearest_primitive(
+            destination, geometry,
+            ray_origin.x,
+            ray_origin.y,
+            ray_origin.z,
+            ray_direction.x,
+            ray_direction.y,
+            ray_direction.z
+        );
 
     }
 
@@ -96,6 +131,9 @@ export class GeometrySpatialQueryAccelerator {
      * @returns {IndexedBinaryBVH}
      */
     __acquireBVH(geometry) {
+        assert.notNull(geometry, 'geometry');
+        assert.defined(geometry, 'geometry');
+
         const existing = this.cache.get(geometry);
 
         if (existing !== null) {
@@ -122,3 +160,9 @@ export class GeometrySpatialQueryAccelerator {
     }
 
 }
+
+/**
+ * @readonly
+ * @type {GeometrySpatialQueryAccelerator}
+ */
+GeometrySpatialQueryAccelerator.INSTANCE = new GeometrySpatialQueryAccelerator();

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -3,12 +3,18 @@ import { computeGeometryHash } from "../../asset/loaders/geometry/geometry/compu
 import { computeGeometryEquality } from "../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
 import { buildMicronGeometryFromBufferGeometry } from "./build/buildMicronGeometryFromBufferGeometry.js";
 import { ThreeMicronMesh } from "./format/ThreeMicronMesh.js";
+import { AsyncMapWrapper } from "../../../core/collection/map/AsyncMapWrapper.js";
 
 /**
  *
  * @type {HashMap<THREE.BufferGeometry, MicronGeometry>}
  */
-const micron_cache = new HashMap({
+const default_micron_cache = new AsyncMapWrapper(new HashMap({
+    keyHashFunction: computeGeometryHash,
+    keyEqualityFunction: computeGeometryEquality
+}));
+
+const pending_cache = new HashMap({
     keyHashFunction: computeGeometryHash,
     keyEqualityFunction: computeGeometryEquality
 });
@@ -17,9 +23,10 @@ const micron_cache = new HashMap({
 /**
  *
  * @param {THREE.Object3D} object
+ * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} micron_cache
  * @returns {THREE.Object3D}
  */
-export async function convert_three_object_to_micron(object) {
+export async function convert_three_object_to_micron(object, micron_cache = default_micron_cache) {
 
     const promises = [];
 
@@ -29,19 +36,29 @@ export async function convert_three_object_to_micron(object) {
      * @returns {MicronGeometry}
      */
     async function obtain_geometry(g) {
-        const existing = micron_cache.get(g);
+        const existing = await micron_cache.get(g);
+
+        if (existing !== undefined && existing !== null) {
+            return existing;
+        }
+
+        const pending = pending_cache.get(g);
 
-        if (existing !== undefined) {
-            return await existing;
+        if (pending !== undefined) {
+            return await pending;
         }
 
         const micron_geometry_promise = buildMicronGeometryFromBufferGeometry(g);
 
-        micron_cache.set(g, micron_geometry_promise);
+        pending_cache.set(g, micron_geometry_promise);
 
         promises.push(micron_geometry_promise);
 
-        return await micron_geometry_promise;
+        const micron_geometry = await micron_geometry_promise;
+
+        await micron_cache.set(g, micron_geometry);
+
+        return micron_geometry;
     }
 
 

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

@@ -3,6 +3,57 @@ import { VGThreeRenderer } from "../render/v1/VGThreeRenderer.js";
 import { RenderLayer } from "../../render/layers/RenderLayer.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
 import { SOURCE_RENDER_LAYER_PROPERTY } from "../../render/visibility/VisibilityComputer.js";
+import { AssetTransformer } from "../../../asset/AssetTransformer.js";
+import { convert_three_object_to_micron } from "../convert_three_object_to_micron.js";
+import { Cache } from "../../../../core/cache/Cache.js";
+import { computeGeometryHash } from "../../../asset/loaders/geometry/geometry/computeGeometryHash.js";
+import { computeGeometryEquality } from "../../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
+import { CachedAsyncMap } from "../../../../core/collection/map/CachedAsyncMap.js";
+import { AsyncRemoteHashMap } from "../../../../core/collection/map/AsyncRemoteHashMap.js";
+import { BufferGeometrySerializationAdapter } from "./serialization/BufferGeometrySerializationAdapter.js";
+import { MicronGeometryBinarySerializationAdapter } from "../format/serialization/MicronGeometryBinarySerializationAdapter.js";
+import { AsyncMapWrapper } from "../../../../core/collection/map/AsyncMapWrapper.js";
+
+/**
+ *
+ * @type {string}
+ */
+const STORAGE_KEY = '@plugin/virtual-geometry-micron/geometry-cache';
+
+
+class GLTFAssetTransformer extends AssetTransformer {
+    /**
+     *
+     * @param {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>} cache
+     */
+    constructor(cache) {
+        super();
+
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @private
+         */
+        this.__cache = cache;
+    }
+
+    async transform(source) {
+        const animationClips = source.animations;
+        if (animationClips !== undefined && animationClips.length > 0) {
+            // not suitable
+            return source;
+        }
+
+        const root = source.create();
+
+        const micron_root = await convert_three_object_to_micron(root.clone(), this.__cache);
+        micron_root.boundingSphere = root.boundingSphere;
+
+        source.override_mesh = micron_root;
+
+        return source;
+    }
+}
 
 export class MicronRenderPlugin extends EnginePlugin {
     constructor() {
@@ -37,6 +88,40 @@ export class MicronRenderPlugin extends EnginePlugin {
         });
 
         this.__view_observers = new Map();
+
+        /**
+         *
+         * @type {AsyncRemoteHashMap}
+         * @private
+         */
+        this.__persisted_geometry = new AsyncRemoteHashMap({
+            keyHashFunction: computeGeometryHash,
+            keyEqualityFunction: computeGeometryEquality,
+            keySerializationAdapter: new BufferGeometrySerializationAdapter(),
+            valueSerializationAdapter: new MicronGeometryBinarySerializationAdapter(),
+            storageKeyPrefix: STORAGE_KEY,
+
+        });
+        /**
+         *
+         * @type {AbstractAsyncMap<THREE.BufferGeometry, MicronGeometry>}
+         * @private
+         */
+        this.__cache = new CachedAsyncMap(
+            new AsyncMapWrapper(new Cache({
+                keyHashFunction: computeGeometryHash,
+                keyEqualityFunction: computeGeometryEquality
+            })),
+            this.__persisted_geometry
+        );
+
+        /**
+         *
+         * @type {AssetTransformer}
+         * @private
+         */
+        this.__asset_transformer = new GLTFAssetTransformer(this.__cache);
+
     }
 
     /**
@@ -87,13 +172,22 @@ export class MicronRenderPlugin extends EnginePlugin {
         view.on.preRender.remove(observer);
     }
 
+    __ingest_cache() {
+        this.engine.storage.lo
+    }
+
     async startup() {
 
+        const engine = this.engine;
+
+        engine.assetManager.registerTransformer("model/gltf", this.__asset_transformer);
+        engine.assetManager.registerTransformer("model/gltf+json", this.__asset_transformer);
+
         /**
          *
          * @type {GraphicsEngine}
          */
-        const ge = this.engine.graphics;
+        const ge = engine.graphics;
 
         ge.layers.add(this.__micron_render_layer);
 
@@ -101,13 +195,22 @@ export class MicronRenderPlugin extends EnginePlugin {
         ge.views.elements.on.removed.add(this.__handle_view_removed, this);
 
         // link all views
-        ge.views.elements.forEach(this.__handle_view_added,this);
+        ge.views.elements.forEach(this.__handle_view_added, this);
+
+        this.__persisted_geometry.attach_storage(engine.storage);
 
         await super.startup();
     }
 
     async shutdown() {
-        const ge = this.engine.graphics;
+        const engine = this.engine;
+
+        this.__persisted_geometry.detach_storage();
+
+        engine.assetManager.unregisterTransformer("model/gltf", this.__asset_transformer);
+        engine.assetManager.unregisterTransformer("model/gltf+json", this.__asset_transformer);
+
+        const ge = engine.graphics;
 
         ge.layers.remove(this.__micron_render_layer);
 
@@ -115,7 +218,7 @@ export class MicronRenderPlugin extends EnginePlugin {
         ge.views.elements.on.removed.remove(this.__handle_view_removed, this);
 
         // clear all observer
-        ge.views.elements.forEach(this.__handle_view_removed,this);
+        ge.views.elements.forEach(this.__handle_view_removed, this);
 
         await super.shutdown();
     }