@woosh/meep-engine 2.33.22 → 2.33.26

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

@@ -8,25 +8,21 @@ import { max2 } from "../../../../core/math/max2.js";
 import { System } from '../../../ecs/System.js';
 import { Transform } from '../../../ecs/transform/Transform.js';
 import Vector3 from '../../../../core/geom/Vector3.js';
-import { computeHashFloat, computeHashIntegerArray } from '../../../../core/math/MathUtils.js';
 
 import Trail2D, { Trail2DFlags } from './Trail2D.js';
-import { ClampToEdgeWrapping, DoubleSide, LinearFilter, TextureLoader } from 'three';
 
 import { LeafNode } from '../../../../core/bvh2/LeafNode.js';
 import ThreeFactory from '../../three/ThreeFactory.js';
 import { GraphicsEngine } from "../../GraphicsEngine.js";
-import { ReferenceManager } from "../../../reference/v1/ReferenceManager.js";
-import { AssetManager } from "../../../asset/AssetManager.js";
-import { Cache } from "../../../../core/cache/Cache.js";
 import { RibbonXFixedPhysicsSimulator } from "../../trail/x/simulator/RibbonXFixedPhysicsSimulator.js";
 import { RibbonX } from "../../trail/x/RibbonX.js";
 import {
     RIBBON_ATTRIBUTE_ADDRESS_AGE,
     RIBBON_ATTRIBUTE_ADDRESS_UV_OFFSET
 } from "../../trail/x/ribbon_attributes_spec.js";
-import { RibbonMaterialX } from "../../trail/x/RibbonMaterialX.js";
-import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { Reference } from "../../../reference/v2/Reference.js";
+import { RibbonXPlugin } from "../../trail/x/RibbonXPlugin.js";
+import { assert } from "../../../../core/assert.js";
 
 const v3Temp1 = new Vector3();
 
@@ -34,69 +30,32 @@ const v3_array = [];
 
 class Trail2DSystem extends System {
     /**
-     *
-     * @param {GraphicsEngine} graphics
-     * @param {AssetManager} assetManager
+     * @param {Engine} engine
      * @constructor
      */
-    constructor(graphics, assetManager) {
+    constructor(engine) {
         super();
 
-        this.dependencies = [Trail2D, Transform];
-
-        if (!(graphics instanceof GraphicsEngine)) {
-            throw new Error("'renderer' must be of type GraphicsEngine");
-        }
-
-        if (!(assetManager instanceof AssetManager)) {
-            throw new Error("'assetManager' must be of type AssetManager");
-        }
+        assert.defined(engine, 'engine');
+        assert.notNull(engine, 'engine');
+        assert.equal(engine.isEngine, true, 'engine.isEngine !== true');
 
-        /**
-         *
-         * @type {GraphicsEngine}
-         */
-        this.graphics = graphics;
+        this.dependencies = [Trail2D, Transform];
 
         /**
          *
-         * @type {AssetManager}
+         * @type {Engine}
+         * @private
          */
-        this.assetManager = assetManager;
-
-        function constructTexture(url) {
-            const assetPromise = assetManager.promise(url, "texture");
-
-            const texturePromise = assetPromise
-                .then(function (asset) {
-
-                    const texture = asset.create();
-
-                    texture.wrapS = ClampToEdgeWrapping;
-                    texture.wrapT = ClampToEdgeWrapping;
-
-                    texture.magFilter = LinearFilter;
-                    texture.minFilter = LinearFilter;
+        this.__engine = engine;
 
-                    return texture;
-                });
-
-            return texturePromise;
-        }
-
-        function destructTexture(url, texturePromise) {
-            texturePromise.then(function (t) {
-                //release used resourced
-                t.dispose();
-            });
-        }
+        const graphics = engine.graphics;
 
         /**
          *
-         * @type {ReferenceManager<string,Promise.<THREE.Texture>>}
+         * @type {GraphicsEngine}
          */
-        this.textures = new ReferenceManager(constructTexture, destructTexture);
-
+        this.graphics = graphics;
 
         /**
          *
@@ -117,28 +76,11 @@ class Trail2DSystem extends System {
         this.simulator = new RibbonXFixedPhysicsSimulator();
 
         /**
+         *
+         * @type {Reference<RibbonXPlugin>}
          * @private
-         * @readonly
-         * @type {Cache<Trail2D, Material>}
          */
-        this.materialCache = new Cache({
-            maxWeight: 100,
-            keyHashFunction(trail) {
-                return computeHashIntegerArray(
-                    computeStringHash(trail.textureURL),
-                    computeHashFloat(trail.width),
-                    computeHashFloat(trail.maxAge),
-                    trail.color.hash()
-                );
-            },
-            keyEqualityFunction(a, b) {
-                return a.textureURL === b.textureURL
-                    && a.width === b.width
-                    && a.maxAge === b.maxAge
-                    && a.color.equals(b.color)
-                    ;
-            }
-        });
+        this.__ribbon_plugin = Reference.NULL;
 
 
         /**
@@ -149,7 +91,7 @@ class Trail2DSystem extends System {
         this.__timeDelta = 0;
     }
 
-    startup(entityManager, readyCallback, errorCallback) {
+    async startup(entityManager, readyCallback, errorCallback) {
         this.entityManager = entityManager;
 
         this.renderLayer = this.graphics.layers.create('trail-2d-system');
@@ -161,19 +103,7 @@ class Trail2DSystem extends System {
 
         this.bvh = this.renderLayer.bvh;
 
-
-        this.graphics.viewport.size.onChanged.add((x, y) => {
-            const ecd = this.entityManager.dataset;
-
-            if (ecd === null) {
-                // no dataset attached
-                return;
-            }
-
-            ecd.traverseComponents(Trail2D, trail => {
-                trail.material.uniforms.resolution.value.set(x, y);
-            });
-        });
+        this.__ribbon_plugin = await this.__engine.plugins.acquire(RibbonXPlugin);
 
         readyCallback();
     }
@@ -181,32 +111,9 @@ class Trail2DSystem extends System {
     shutdown(entityManager, readyCallback, errorCallback) {
         this.graphics.layers.remove(this.renderLayer);
 
-        readyCallback();
-    }
-
-    /**
-     *
-     * @param {Trail2D} trail
-     * @returns {Material}
-     */
-    obtainMaterial(trail) {
-
-        const material = new RibbonMaterialX({
-            transparent: true,
-            depthWrite: false,
-            wireframe: false,
-            side: DoubleSide,
-            defines: {
-                USE_TEXTURE: false
-            }
-        });
-
-        if (trail.textureURL !== null) {
-            material.uniforms.uDiffuse.value = new TextureLoader().load(trail.textureURL);
-            material.defines.USE_TEXTURE = true;
-        }
+        this.__ribbon_plugin.release();
 
-        return material;
+        readyCallback();
     }
 
     /**
@@ -231,9 +138,9 @@ class Trail2DSystem extends System {
 
         const geometry = ribbon.getGeometry();
 
-        const material = this.obtainMaterial(trail);
+        const ribbons = this.__ribbon_plugin.getValue();
 
-        material.uniforms.resolution.value.copy(this.graphics.viewport.size);
+        const material = ribbons.obtain_material_x(trail.material);
 
         const mesh = ThreeFactory.createMesh(geometry, material);
 
@@ -274,12 +181,21 @@ class Trail2DSystem extends System {
         );
 
         trail.bvhLeaf = leafNode;
-        trail.material = material;
 
         this.bvh.insertNode(leafNode);
     }
 
+    /**
+     *
+     * @param {Trail2D} component
+     * @param {Transform} transform
+     * @param {number} entity
+     */
     unlink(component, transform, entity) {
+
+        // release resources
+        component.dispose();
+
         component.bvhLeaf.disconnect();
     }
 

package/engine/graphics/geometry/AttributeSpec.js

@@ -0,0 +1,105 @@
+import { DataType } from "../../../core/collection/table/DataType.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import { DataTypeByteSizes } from "../../../core/collection/table/DataTypeByteSizes.js";
+import { assert } from "../../../core/assert.js";
+
+export class AttributeSpec {
+    constructor() {
+        /**
+         *
+         * @type {string}
+         */
+        this.name = "";
+
+        /**
+         *
+         * @type {DataType}
+         */
+        this.type = DataType.Float32;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.itemSize = 1;
+
+        /**
+         * Normalized values will be automatically converted to float32 in the shader
+         * This gives good optimization opportunities for things like normal vectors
+         * Applies to integer types only
+         * @type {boolean}
+         */
+        this.normalized = false;
+    }
+
+    static fromJSON(j) {
+        const r = new AttributeSpec();
+
+        r.fromJSON(j);
+
+        return r;
+    }
+
+    fromJSON({
+                 name,
+                 type,
+                 itemSize,
+                 normalized = false
+             }) {
+
+        assert.isString(name, 'name');
+        assert.enum(type, DataType, 'type');
+
+        assert.isNumber(itemSize, 'itemSize');
+        assert.isNonNegativeInteger(itemSize, 'itemSize');
+        assert.greaterThanOrEqual(itemSize, 1, 'itemSize must be >= 1');
+
+        assert.isBoolean(normalized, 'normalized');
+
+        this.name = name;
+        this.type = type;
+        this.itemSize = itemSize;
+        this.normalized = normalized;
+    }
+
+    hash() {
+        return computeStringHash(this.name);
+    }
+
+    /**
+     *
+     * @param {AttributeSpec} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.type === other.type
+            && this.itemSize === other.itemSize
+            && this.normalized === other.normalized
+            && this.name === other.name
+            ;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    getByteSize() {
+        return this.itemSize * DataTypeByteSizes[this.type];
+    }
+
+    /**
+     *
+     * @param {AttributeSpec} a
+     * @param {AttributeSpec} b
+     * @return {number}
+     */
+    static byName(a, b) {
+        return a.name.localeCompare(b.name);
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+AttributeSpec.prototype.isAttributeSpec = true;

package/engine/graphics/{micron/format/MicronVertexDataSpec.js → geometry/VertexDataSpec.js}

@@ -1,14 +1,14 @@
-import { isArrayEqual } from "../../../../core/collection/ArrayUtils.js";
-import { computeHashArray } from "../../../../core/math/MathUtils.js";
-import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
+import { isArrayEqual } from "../../../core/collection/ArrayUtils.js";
+import { invokeObjectHash } from "../../../core/model/object/invokeObjectHash.js";
+import { computeHashArray } from "../../../core/collection/array/computeHashArray.js";
 
 const DEFAULT_HASH = 123456;
 
-export class MicronVertexDataSpec {
+export class VertexDataSpec {
     constructor() {
         /**
          *
-         * @type {MicronGeometryBufferAttributeSpec[]}
+         * @type {AttributeSpec[]}
          */
         this.attributes = [];
 
@@ -22,7 +22,49 @@ export class MicronVertexDataSpec {
 
     /**
      *
-     * @param {MicronGeometryBufferAttributeSpec[]} attributes
+     * @param {string} name
+     * @return {AttributeSpec|undefined}
+     */
+    getAttributeByName(name) {
+
+        const attributes = this.attributes;
+        const n = attributes.length;
+
+        for (let i = 0; i < n; i++) {
+            const attribute = attributes[i];
+
+            if (attribute.name === name) {
+                return attribute;
+            }
+        }
+
+        return undefined;
+    }
+
+    /**
+     *
+     * @param {AttributeSpec} attribute
+     * @return {VertexDataSpec}
+     */
+    add(attribute) {
+
+        //check uniqueness of name
+        if (this.getAttributeByName(attribute.name) !== undefined) {
+            throw new Error(`Attribute named '${attribute.name}' already exists`);
+        }
+
+        this.attributes.push(attribute);
+
+        // reset hash
+        this.__hash = DEFAULT_HASH;
+
+        //for chaining, return self
+        return this;
+    }
+
+    /**
+     *
+     * @param {AttributeSpec[]} attributes
      */
     setAttributes(attributes) {
         this.attributes = attributes;
@@ -33,7 +75,7 @@ export class MicronVertexDataSpec {
 
     /**
      *
-     * @param {MicronVertexDataSpec} other
+     * @param {VertexDataSpec} other
      * @returns {boolean}
      */
     equals(other) {
@@ -56,24 +98,6 @@ export class MicronVertexDataSpec {
         return this.__hash;
     }
 
-    /**
-     *
-     * @param {string} name
-     * @return {MicronGeometryBufferAttributeSpec|undefined}
-     */
-    getAttributeByName(name) {
-        const attributes = this.attributes;
-        const n = attributes.length;
-        for (let i = 0; i < n; i++) {
-            const spec = attributes[i];
-
-            if (spec.name === name) {
-                return spec;
-            }
-        }
-
-    }
-
     /**
      *
      * @returns {number}
@@ -93,3 +117,10 @@ export class MicronVertexDataSpec {
         return result;
     }
 }
+
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+VertexDataSpec.prototype.isVertexDataSpec = true;

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

@@ -2,7 +2,7 @@ import { TopoMesh } from "../../../../core/geom/3d/topology/TopoMesh.js";
 import { PatchRepresentation } from "./PatchRepresentation.js";
 import { MicronGeometry } from "../format/MicronGeometry.js";
 import { buildAbstractPatchHierarchy } from "./hierarchy/buildAbstractPatchHierarchy.js";
-import { MicronGeometryBufferAttributeSpec } from "../format/MicronGeometryBufferAttributeSpec.js";
+import { AttributeSpec } from "../../geometry/AttributeSpec.js";
 import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
 import { DataType } from "../../../../core/collection/table/DataType.js";
 import { MicronGeometryPatch } from "../format/MicronGeometryPatch.js";
@@ -28,7 +28,7 @@ function current_time_millis() {
 
 /**
  *
- * @param {MicronGeometryBufferAttributeSpec} spec
+ * @param {AttributeSpec} spec
  * @param {THREE.BufferAttribute} source
  */
 function custom_attribute_format_normal(spec, source) {
@@ -39,7 +39,7 @@ function custom_attribute_format_normal(spec, source) {
 
 /**
  *
- * @param {MicronGeometryBufferAttributeSpec} spec
+ * @param {AttributeSpec} spec
  * @param {THREE.BufferAttribute} source
  */
 function custom_attribute_format_uv(spec, source) {
@@ -49,7 +49,7 @@ function custom_attribute_format_uv(spec, source) {
 
 /**
  *
- * @param {MicronGeometryBufferAttributeSpec} spec
+ * @param {AttributeSpec} spec
  * @param {THREE.BufferAttribute} source
  * @param {string} name
  */
@@ -76,7 +76,7 @@ function format_attribute(spec, source, name) {
 /**
  *
  * @param {THREE.BufferGeometry} buffer_geometry
- * @returns {MicronGeometryBufferAttributeSpec[]}
+ * @returns {AttributeSpec[]}
  */
 function attributes_from_buffer_geometry(buffer_geometry) {
     const result = [];
@@ -84,7 +84,7 @@ function attributes_from_buffer_geometry(buffer_geometry) {
     const source_attributes = buffer_geometry.attributes;
     for (const attributesKey in source_attributes) {
         const source_attribute = source_attributes[attributesKey];
-        const spec = new MicronGeometryBufferAttributeSpec();
+        const spec = new AttributeSpec();
 
         format_attribute(spec, source_attribute, attributesKey);
 
@@ -92,7 +92,7 @@ function attributes_from_buffer_geometry(buffer_geometry) {
     }
 
     // to ensure that input order of attributes does not matter, we sort the attributes by name
-    result.sort(MicronGeometryBufferAttributeSpec.byName);
+    result.sort(AttributeSpec.byName);
 
     return result;
 }

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

@@ -110,7 +110,7 @@ const DataConverterType = {
 
 /**
  * How to convert data from source three.js buffer attribute to what we store in the patch description based on the supplied micron spec
- * @param {MicronGeometryBufferAttributeSpec} spec
+ * @param {AttributeSpec} spec
  * @param {THREE.BufferAttribute} source
  * @returns {DataConverterType}
  */

package/engine/graphics/micron/buildPatchwork.js

@@ -2,7 +2,7 @@ import { FrontSide, Group, Mesh, MeshBasicMaterial, MeshStandardMaterial } from
 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/MathUtils.js";
+import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
 
 /**
  *

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

@@ -1,4 +1,4 @@
-import { MicronVertexDataSpec } from "./MicronVertexDataSpec.js";
+import { VertexDataSpec } from "../../geometry/VertexDataSpec.js";
 import { assert } from "../../../../core/assert.js";
 
 let id_counter = 0;
@@ -30,9 +30,9 @@ export class MicronGeometry {
 
         /**
          *
-         * @type {MicronVertexDataSpec|null}
+         * @type {VertexDataSpec|null}
          */
-        this.vertex_spec = new MicronVertexDataSpec();
+        this.vertex_spec = new VertexDataSpec();
 
         /**
          *

package/engine/graphics/micron/format/serialization/MicronGeometryBinarySerializationAdapter.js

@@ -1,6 +1,6 @@
 import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { MicronGeometry } from "../MicronGeometry.js";
-import { MicronGeometryBufferAttributeSpec } from "../MicronGeometryBufferAttributeSpec.js";
+import { AttributeSpec } from "../../../geometry/AttributeSpec.js";
 import { MicronGeometryPatch } from "../MicronGeometryPatch.js";
 import { serialize_patch } from "./serialize_patch.js";
 import { deserialize_patch } from "./deserialize_patch.js";
@@ -63,7 +63,7 @@ export class MicronGeometryBinarySerializationAdapter extends BinaryClassSeriali
         const attribute_count = buffer.readUintVar();
         const attributes = [];
         for (let i = 0; i < attribute_count; i++) {
-            const spec = new MicronGeometryBufferAttributeSpec();
+            const spec = new AttributeSpec();
 
             deserialize_attribute_spec(buffer, spec);
             attributes[i] = spec;

package/engine/graphics/micron/format/serialization/deserialize_attribute_spec.js

@@ -3,7 +3,7 @@ import { computeDataTypeByIndex } from "../../../../../core/collection/table/com
 /**
  *
  * @param {BinaryBuffer} buffer
- * @param {MicronGeometryBufferAttributeSpec} spec
+ * @param {AttributeSpec} spec
  */
 export function deserialize_attribute_spec(buffer, spec) {
 

package/engine/graphics/micron/format/serialization/serialize_attribute_spec.js

@@ -3,7 +3,7 @@ import { DataTypeIndices } from "../../../../../core/collection/table/DataTypeIn
 /**
  *
  * @param {BinaryBuffer} buffer
- * @param {MicronGeometryBufferAttributeSpec} spec
+ * @param {AttributeSpec} spec
  */
 export function serialize_attribute_spec(buffer, spec) {
     buffer.writeUTF8String(spec.name);

package/engine/graphics/micron/render/PatchCacheKey.js

@@ -1,7 +1,7 @@
 import { mortonEncode_magicbits } from "../../../../core/geom/3d/morton/mortonEncode_magicbits.js";
-import { computeHashFloat } from "../../../../core/math/MathUtils.js";
 import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 import { SimpleObjectPoolFactory } from "../../../../core/model/object/SimpleObjectPoolFactory.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 export class PatchCacheKey {
     constructor() {

package/engine/graphics/micron/render/instanced/AttributeDataTexture.js

@@ -53,18 +53,18 @@ function normalized_internal_format(dt, channel_count) {
 export class AttributeDataTexture {
     /**
      *
-     * @param {MicronGeometryBufferAttributeSpec} spec
+     * @param {AttributeSpec} spec
      * @param {number} column_count
      */
     constructor(spec, column_count) {
         assert.defined(spec, 'spec');
-        assert.equal(spec.isMicronGeometryBufferAttributeSpec, true, 'spec.isMicronGeometryBufferAttributeSpec !== true');
+        assert.equal(spec.isAttributeSpec, true, 'spec.isAttributeSpec !== true');
 
         assert.isNonNegativeInteger(column_count, 'column_count');
 
         /**
          *
-         * @type {MicronGeometryBufferAttributeSpec}
+         * @type {AttributeSpec}
          * @private
          */
         this.__spec = spec;
@@ -90,7 +90,7 @@ export class AttributeDataTexture {
 
     /**
      *
-     * @return {MicronGeometryBufferAttributeSpec}
+     * @return {AttributeSpec}
      */
     get spec() {
         return this.__spec;
@@ -320,7 +320,7 @@ export class AttributeDataTexture {
     /**
      *
      * @return {AttributeDataTexture}
-     * @param {MicronGeometryBufferAttributeSpec} spec
+     * @param {AttributeSpec} spec
      * @param {number} column_count
      */
     static from(spec, column_count) {

package/engine/graphics/micron/render/v1/ThreeVirtualGeometryAdapter.js

@@ -4,7 +4,7 @@ import { DataType2TypedArrayConstructorMapping } from "../../../../../core/colle
 import { getTransformedPositionsCached } from "./getTransformedPositionsCached.js";
 import { Color } from "../../../../../core/color/Color.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
-import { randomFloatBetween } from "../../../../../core/math/MathUtils.js";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
 
 
 const scratch_random = seededRandom(0);

package/engine/graphics/particles/ParticleEmitterLibrary.js

@@ -2,6 +2,9 @@ import { ParticleEmitter } from "./particular/engine/emitter/ParticleEmitter.js"
 import { GameAssetType } from "../../asset/GameAssetType.js";
 import { assert } from "../../../core/assert.js";
 
+/**
+ * @deprecated Use "Effect" API to achieve the same results
+ */
 export class ParticleEmitterLibrary {
     /**
      *