@woosh/meep-engine 2.33.51 → 2.33.55

package/core/geom/3d/shape/AbstractShape3D.js

@@ -62,4 +62,21 @@ export class AbstractShape3D {
     get surface_area() {
         throw new Error('Not Implemented');
     }
+
+    /**
+     * @template {AbstractShape3D} T
+     * @param {T} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.constructor === other.constructor;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    hash() {
+        return 0;
+    }
 }

package/core/geom/3d/shape/TransformedShape3D.d.ts

@@ -0,0 +1,10 @@
+import {AbstractShape3D} from "./AbstractShape3D";
+
+export class TransformedShape3D extends AbstractShape3D {
+
+    static from_m4(subject: AbstractShape3D, matrix: ArrayLike<number>): TransformedShape3D
+
+    static from_translation_scale(subject: AbstractShape3D, translation: ArrayLike<number>, scale: ArrayLike<number>): TransformedShape3D
+
+    static from_scale(subject: AbstractShape3D, scale: ArrayLike<number>): TransformedShape3D
+}

package/core/geom/3d/shape/TransformedShape3D.js

@@ -1,6 +1,8 @@
 import { mat4, vec3 } from "gl-matrix";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { sign } from "../../../math/sign.js";
+import { isArrayEqualStrict } from "../../../collection/array/isArrayEqualStrict.js";
+import { computeHashFloatArray } from "../../../math/hash/computeHashFloatArray.js";
 
 /**
  *
@@ -140,9 +142,9 @@ export class TransformedShape3D extends AbstractShape3D {
         // normalize gradient
         const gd = distance / Math.hypot(scratch_v3_0[0], scratch_v3_0[1], scratch_v3_0[2]);
 
-        const scaled_dx = scaled_gx * gd ;
-        const scaled_dy = scaled_gy * gd ;
-        const scaled_dz = scaled_gz * gd ;
+        const scaled_dx = scaled_gx * gd;
+        const scaled_dy = scaled_gy * gd;
+        const scaled_dz = scaled_gz * gd;
 
         // determine sign
         const result_sign = sign(distance);
@@ -178,4 +180,27 @@ export class TransformedShape3D extends AbstractShape3D {
         result[1] = scratch_v3_0[1];
         result[2] = scratch_v3_0[2];
     }
+
+    /**
+     *
+     * @param {TransformedShape3D} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return super.equals(other)
+            && this.__subject.equals(other.subject)
+            && isArrayEqualStrict(this.__matrix, other.__matrix)
+            ;
+    }
+
+    hash() {
+        // to avoid recursion, only use matrix for hash
+        return computeHashFloatArray(this.__matrix);
+    }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+TransformedShape3D.isTransformedShape3D = true;

package/core/geom/3d/shape/TransformedShape3D.spec.js

@@ -1,5 +1,6 @@
 import { UnitCubeShape3D } from "./UnitCubeShape3D.js";
 import { TransformedShape3D } from "./TransformedShape3D.js";
+import { UnitSphereShape3D } from "./UnitSphereShape3D.js";
 
 test('signed distance identity transform', () => {
 
@@ -31,3 +32,24 @@ test('signed distance scale', () => {
 
     expect(s.signed_distance_at_point([2, 0, 0])).toBeCloseTo(1);
 });
+
+test('equals', () => {
+
+    const a = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [2, 2, 2]);
+    const b = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [2, 2, 2]);
+
+    expect(a.equals(b)).toBe(true);
+
+    const c = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 1, 0], [2, 2, 2]);
+
+    expect(a.equals(c)).toBe(false);
+
+    const d = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [2, 1, 2]);
+
+    expect(a.equals(d)).toBe(false);
+
+    const e = TransformedShape3D.from_translation_scale(new UnitSphereShape3D(), [0, 0, 0], [2, 2, 2]);
+
+    expect(a.equals(e)).toBe(false);
+
+});

package/core/geom/3d/shape/UnionShape3D.d.ts

@@ -0,0 +1,5 @@
+import {AbstractShape3D} from "./AbstractShape3D";
+
+export class UnionShape3D extends AbstractShape3D {
+    static from(children: AbstractShape3D[]): UnionShape3D
+}

package/core/geom/3d/shape/UnionShape3D.js

@@ -4,6 +4,7 @@ import { binarySearchHighIndex } from "../../../collection/array/binarySearchHig
 import { compareNumbers } from "../../../primitives/numbers/compareNumbers.js";
 import { min2 } from "../../../math/min2.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
+import { isArrayEqual } from "../../../collection/ArrayUtils.js";
 
 /**
  * To avoid severe performance overhead, we limit number of possible rejections
@@ -119,6 +120,11 @@ export class UnionShape3D extends AbstractShape3D {
         this.__volume_overlap_fraction = tap_overlaps / (VOLUME_OVERLAP_ESTIMATION_TAPS);
     }
 
+    /**
+     *
+     * @param {AbstractShape3D[]} children
+     * @returns {UnionShape3D}
+     */
     static from(children) {
         const r = new UnionShape3D();
 
@@ -252,4 +258,27 @@ export class UnionShape3D extends AbstractShape3D {
             break;
         }
     }
+
+    /**
+     *
+     * @param {UnionShape3D} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return super.equals(other)
+            && isArrayEqual(this.children, other.children);
+    }
+
+    hash() {
+        const children = this.children;
+        const child_count = children.length;
+
+        let hash = child_count;
+
+        if (child_count > 0) {
+            hash ^= children[0].hash();
+        }
+
+        return hash;
+    }
 }

package/core/geom/3d/shape/UnitCubeShape3D.d.ts

@@ -0,0 +1,5 @@
+import {AbstractShape3D} from "./AbstractShape3D";
+
+export class UnitCubeShape3D extends AbstractShape3D {
+    static INSTANCE: UnitCubeShape3D
+}

package/core/geom/3d/shape/UnitCubeShape3D.js

@@ -58,7 +58,7 @@ export class UnitCubeShape3D extends AbstractShape3D {
     }
 
     signed_distance_gradient_at_point(result, point) {
-        return compute_signed_distance_gradient_by_sampling(result,this, point);
+        return compute_signed_distance_gradient_by_sampling(result, this, point);
     }
 
     signed_distance_at_point(point) {
@@ -98,4 +98,10 @@ export class UnitCubeShape3D extends AbstractShape3D {
     sample_random_point_in_volume(result, result_offset, random) {
         randomPointInBox(random, result, result_offset);
     }
+
+    hash() {
+        return 1;
+    }
 }
+
+UnitCubeShape3D.INSTANCE = new UnitCubeShape3D();

package/core/geom/3d/shape/UnitSphereShape3D.d.ts

@@ -0,0 +1,5 @@
+import {AbstractShape3D} from "./AbstractShape3D";
+
+export class UnitSphereShape3D extends AbstractShape3D {
+    static INSTANCE: UnitSphereShape3D
+}

package/core/geom/3d/shape/UnitSphereShape3D.js

@@ -30,7 +30,7 @@ export class UnitSphereShape3D extends AbstractShape3D {
     }
 
     signed_distance_gradient_at_point(result, point) {
-        return compute_signed_distance_gradient_by_sampling(result,this, point);
+        return compute_signed_distance_gradient_by_sampling(result, this, point);
     }
 
     signed_distance_at_point(point) {
@@ -52,4 +52,10 @@ export class UnitSphereShape3D extends AbstractShape3D {
     sample_random_point_in_volume(result, result_offset, random) {
         randomPointInSphere(random, result, result_offset);
     }
+
+    hash() {
+        return 13;
+    }
 }
+
+UnitSphereShape3D.INSTANCE = new UnitSphereShape3D();

package/core/geom/3d/shape/json/shape_from_json.js

@@ -0,0 +1,19 @@
+import { type_adapters } from "./type_adapters.js";
+
+/**
+ *
+ * @param {Object} j
+ * @returns {AbstractShape3D}
+ */
+export function shape_from_json(j) {
+    const type = j.type;
+
+    const adapter = type_adapters[type];
+
+    if (adapter === undefined) {
+        throw new Error(`Unsupported shape type '${type}'`);
+    }
+
+    return adapter.read(j);
+}
+

package/core/geom/3d/shape/json/shape_to_json.js

@@ -0,0 +1,21 @@
+import { shape_to_type } from "./shape_to_type.js";
+import { type_adapters } from "./type_adapters.js";
+
+/**
+ *
+ * @param {AbstractShape3D} shape
+ * @returns {Object}
+ */
+export function shape_to_json(shape) {
+    const type = shape_to_type(shape);
+
+    const adapter = type_adapters[type];
+
+    if (adapter === undefined) {
+        throw new Error(`Unsupported shape type '${type}'`);
+    }
+
+    const shape_json = adapter.write(shape);
+
+    return Object.assign({ type }, shape_json);
+}

package/core/geom/3d/shape/json/shape_to_type.js

@@ -0,0 +1,23 @@
+import { UnionShape3D } from "../UnionShape3D.js";
+import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
+import { UnitSphereShape3D } from "../UnitSphereShape3D.js";
+import { TransformedShape3D } from "../TransformedShape3D.js";
+
+/**
+ *
+ * @param {AbstractShape3D} shape
+ * @returns {string}
+ */
+export function shape_to_type(shape) {
+    if (shape instanceof UnionShape3D) {
+        return 'union';
+    } else if (shape instanceof UnitCubeShape3D) {
+        return 'cube';
+    } else if (shape instanceof UnitSphereShape3D) {
+        return 'sphere';
+    } else if (shape instanceof TransformedShape3D) {
+        return 'transform';
+    } else {
+        throw new Error('Unsupported shape');
+    }
+}

package/core/geom/3d/shape/json/type_adapters.js

@@ -0,0 +1,58 @@
+import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
+import { UnitSphereShape3D } from "../UnitSphereShape3D.js";
+import { TransformedShape3D } from "../TransformedShape3D.js";
+import { UnionShape3D } from "../UnionShape3D.js";
+import { shape_from_json} from "./shape_from_json.js";
+import { shape_to_json } from "./shape_to_json.js";
+
+export const type_adapters = {
+    'cube': {
+        read() {
+            return UnitCubeShape3D.INSTANCE;
+        },
+        write() {
+            return {};
+        }
+    },
+    'sphere': {
+        read() {
+            return UnitSphereShape3D.INSTANCE;
+        },
+        write() {
+            return {};
+        }
+    },
+    'transform': {
+        read({ transform, subject }) {
+            const subject_shape = shape_from_json(subject);
+
+            return TransformedShape3D.from_m4(subject_shape, transform);
+        },
+        /**
+         *
+         * @param {TransformedShape3D} object
+         */
+        write(object) {
+            return {
+                subject: shape_to_json(object.subject),
+                transform: Array.from(object.transform)
+            };
+        }
+    },
+    'union': {
+        read({ members }) {
+            const member_shapes = members.map(shape_from_json);
+
+            return UnionShape3D.from(member_shapes);
+        },
+        /**
+         *
+         * @param {UnionShape3D} object
+         */
+        write(object) {
+            return {
+                members: object.children.map(shape_to_json)
+            };
+        }
+    }
+};

package/core/math/MathUtils.spec.js

@@ -128,16 +128,6 @@ test("computeHashFloat", () => {
     expect(computeHashFloat(500)).not.toEqual(computeHashFloat(400))
 });
 
-test("computeHashFloatArray", () => {
-    expect(computeHashFloatArray([1, 2, 1.5], 1, 2)).toEqual(computeHashFloatArray([1, 2, 1.5], 1, 2));
-
-    expect(computeHashFloatArray([1, 2, 1.5], 1, 3)).not.toEqual(computeHashFloatArray([1, 2, 1.5], 1, 2));
-
-    expect(computeHashFloatArray([1, 2, 1.5], 2, 3)).not.toEqual(computeHashFloatArray([1, 2, 1.5], 1, 3));
-
-    expect(computeHashFloatArray([1, 2, 3], 1, 3)).not.toEqual(computeHashFloatArray([1, 2, 1.5], 1, 3));
-});
-
 
 test('sign', () => {
     expect(sign(1)).toBe(1);

package/core/math/hash/computeHashFloatArray.js

@@ -3,28 +3,17 @@ import { computeHashFloat } from "./computeHashFloat.js";
 /**
  *
  * @param {number[]|Float32Array|Float64Array} values
- * @param {number} min
- * @param {number} max
  */
-export function computeHashFloatArray(values, min, max) {
+export function computeHashFloatArray(values) {
     const dataLength = values.length;
 
-    const dataRange = max - min;
-
-    /*
-     hash min and max
-     */
-    const minHash = computeHashFloat(min);
-    const maxHash = computeHashFloat(min);
-
-    let hash = ((minHash << 5) - minHash) + maxHash;
+    let hash = dataLength;
 
     for (let i = 0; i < dataLength; i++) {
         const singleValue = values[i];
-        //normalize value
-        const valueNormalized = (singleValue - min) / dataRange;
+
         //scale value to integer range
-        const integerValue = valueNormalized * 4294967295;
+        const integerValue = computeHashFloat(singleValue);
 
         hash = ((hash << 5) - hash) + integerValue;
         hash |= 0; // Convert to 32bit integer

package/core/math/hash/computeHashFloatArray.spec.js

@@ -0,0 +1,11 @@
+import { computeHashFloatArray } from "./computeHashFloatArray.js";
+
+test("computeHashFloatArray", () => {
+    expect(computeHashFloatArray([1, 2, 1.5])).toEqual(computeHashFloatArray([1, 2, 1.5]));
+
+    expect(computeHashFloatArray([1, 2, 1.5])).not.toEqual(computeHashFloatArray([1, 3, 1.5]));
+
+    expect(computeHashFloatArray([1, 2, 1.5])).not.toEqual(computeHashFloatArray([1, 2, 2.5]));
+
+    expect(computeHashFloatArray([1, 2, 3])).not.toEqual(computeHashFloatArray([1, 2, 1.5]));
+});

package/core/model/object/read_property.js

@@ -16,7 +16,7 @@ export function read_property(root, parts, part_offset, part_count) {
 
         const part = parts[i + part_offset];
 
-        if (thing.hasOwnProperty(part)) {
+        if (typeof thing[part] !== 'undefined') {
             thing = thing[part];
         } else {
             const getter_name = `get${capitalize(part)}`;

package/core/model/object/write_property.js

@@ -17,8 +17,10 @@ export function write_property(root, parts, part_offset, part_count, value) {
 
         const part = parts[i + part_offset];
 
-        if (thing.hasOwnProperty(part)) {
-            thing = thing[part];
+        const thing_part = thing[part];
+
+        if (typeof thing_part !== 'undefined') {
+            thing = thing_part;
         } else {
 
             const getter_name = `get${capitalize(part)}`;
@@ -42,11 +44,9 @@ export function write_property(root, parts, part_offset, part_count, value) {
     if (typeof setter === "function") {
         // resolve via setter
         setter.call(thing, value);
-    } else if (thing.hasOwnProperty(last_part)) {
-        thing[last_part] = value;
     } else {
-        // no setter
-        throw new Error(`No no property or getter found for '${last_part}' on [${part_count - 1}]'${parts.slice(part_offset, part_offset + part_count).join('/')}'`);
+        // write directly to the field
+        thing[last_part] = value;
     }
 }
 

package/engine/animation/AnimationUtils.js

@@ -7,10 +7,8 @@ import { removeComponentsExcept } from "../ecs/util/removeComponentsExcept.js";
 import { createSound, createTimer } from "../EntityCreator.js";
 import Mesh from "../graphics/ecs/mesh/Mesh.js";
 import Trail2D, { Trail2DFlags } from "../graphics/ecs/trail2d/Trail2D.js";
-import { ParticleEmitterSystem } from "../graphics/particles/ecs/ParticleEmitterSystem.js";
 import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
 import { ParticleEmitterFlag } from "../graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js";
-import { distributeParticlesOnObject3D } from "../graphics/particles/particular/engine/utils/distributeParticlesOnObject3D.js";
 import { SequenceBehavior } from "../intelligence/behavior/composite/SequenceBehavior.js";
 import { BehaviorComponent } from "../intelligence/behavior/ecs/BehaviorComponent.js";
 import { ActionBehavior } from "../intelligence/behavior/primitive/ActionBehavior.js";
@@ -118,124 +116,6 @@ export function stopEmitterAndNotifyOnceFinished(entity, ecd) {
 }
 
 
-/**
- *
- * @param {EntityManager} entityManager
- * @param {EntityComponentDataset} ecd
- * @param {number} entity
- * @param {string} particles
- * @returns {Promise<any>}
- */
-export function removeEntityWithMeshParticlesEffect(
-    {
-        entityManager,
-        ecd,
-        entity,
-        particles = 'mesh-cloud-puff-0'
-    }
-) {
-
-    /**
-     *
-     * @type {ParticleEmitterSystem}
-     */
-    const sPE = entityManager.getSystem(ParticleEmitterSystem);
-
-    /**
-     *
-     * @type {ParticleEmitterLibrary}
-     */
-    const emitterLibrary = sPE.library;
-
-    const emitter = emitterLibrary.create(particles);
-
-    //get entity mesh
-
-    const cMesh = ecd.getComponent(entity, Mesh);
-
-    if (cMesh !== undefined) {
-        if (cMesh.mesh !== null) {
-            const randomSeed = Math.random() * 1000000;
-
-            distributeParticlesOnObject3D(emitter, randomSeed, cMesh.mesh);
-        }
-    }
-
-    //prevent further interactions
-    removeComponentsExcept(ecd, entity, [Mesh, ParticleEmitter, Trail2D, Transform]);
-
-    /**
-     *
-     * @type {Transform}
-     */
-    const originalTransform = ecd.getComponent(entity, Transform);
-
-    if (originalTransform === undefined) {
-        throw new Error(`entity ${entity} doesn't have Transform`);
-    }
-
-    //create particle emitter
-    const effectBuilder = new EntityBuilder();
-    const effectEntity = effectBuilder
-        .add(emitter)
-        .add(originalTransform.clone())
-        .build(ecd);
-
-    Promise.all([
-        stopEntityAndNotifyWhenStopped(effectEntity, ecd)
-    ])
-        .then(() => effectBuilder.destroy());
-
-    return stopEntityAndNotifyWhenStopped(entity, ecd)
-        .then(() => {
-            ecd.removeEntity(entity);
-        });
-
-}
-
-/**
- *
- * @param {Engine} engine
- * @param {EntityComponentDataset} ecd
- * @param {number} entity
- * @param {string} [particles]
- * @param {string} [sound]
- * @returns {Promise<any>}
- */
-export function removeEntityGenericEffect(
-    {
-        engine,
-        ecd,
-        entity,
-        particles = 'cloud-puff',
-        sound = "data/sounds/effects/Magic_Game_Essentials/Magic_Vanish_3.wav"
-    }
-) {
-
-    /**
-     *
-     * @type {ParticleEmitterSystem}
-     */
-    const sPE = engine.entityManager.getSystem(ParticleEmitterSystem);
-
-    /**
-     *
-     * @type {ParticleEmitterLibrary}
-     */
-    const emitterLibrary = sPE.library;
-
-    const emitter = emitterLibrary.create(particles);
-
-    const result = removeEntityWithEffect({
-        entity,
-        ecd,
-        emitter,
-        soundEffect: sound
-    });
-
-    return result;
-}
-
 /**
  *
  * @param {number} entity

package/engine/animation/removeEntityGenericEffect.js

@@ -0,0 +1,168 @@
+import { removeEntityWithEffect } from "./AnimationUtils.js";
+import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+
+const lib = {
+    'cloud-puff': {
+        "position": {
+            "x": 56.41791044776119,
+            "y": -8.887834661270745,
+            "z": 223.65671641791042
+        },
+        "scale": {
+            "x": 1,
+            "y": 1,
+            "z": 1
+        },
+        "rotation": {
+            "x": 0,
+            "y": 0,
+            "z": 0,
+            "w": 1
+        },
+        "parameters": [
+            {
+                "name": "scale",
+                "itemSize": 1,
+                "defaultTrackValue": {
+                    "itemSize": 1,
+                    "data": [
+                        1
+                    ],
+                    "positions": [
+                        0
+                    ]
+                }
+            },
+            {
+                "name": "color",
+                "itemSize": 4,
+                "defaultTrackValue": {
+                    "itemSize": 4,
+                    "data": [
+                        1,
+                        1,
+                        1,
+                        1
+                    ],
+                    "positions": [
+                        0
+                    ]
+                }
+            }
+        ],
+        "blendingMode": 0,
+        "layers": [
+            {
+                "imageURL": "data/textures/particle/smokeparticle.png",
+                "particleLife": {
+                    "min": 1.2,
+                    "max": 1.5
+                },
+                "particleSize": {
+                    "min": 1,
+                    "max": 1.2
+                },
+                "particleRotation": {
+                    "min": 0,
+                    "max": 0
+                },
+                "particleRotationSpeed": {
+                    "min": 0,
+                    "max": 0
+                },
+                "emissionShape": 1,
+                "emissionFrom": 1,
+                "emissionRate": 0,
+                "emissionImmediate": 25,
+                "parameterTracks": [
+                    {
+                        "name": "color",
+                        "track": {
+                            "itemSize": 4,
+                            "data": [
+                                0.9803921568627451,
+                                0.9803921568627451,
+                                0.9803921568627451,
+                                0.3,
+
+                                0.9882352941176471,
+                                0.9882352941176471,
+                                0.9882352941176471,
+                                0.9880952380952381,
+
+                                0.9882352941176471,
+                                0.9882352941176471,
+                                0.9882352941176471,
+                                0.5,
+
+                                0.9882352941176471,
+                                0.9882352941176471,
+                                0.9882352941176471,
+                                0
+                            ],
+                            "positions": [
+                                0,
+                                0.07,
+                                0.8097826086956522,
+                                1
+                            ]
+                        }
+                    }
+                ],
+                "position": {
+                    "x": 0,
+                    "y": 0.6,
+                    "z": 0
+                },
+                "scale": {
+                    "x": 0.9,
+                    "y": 0.5,
+                    "z": 0.65
+                },
+                "particleVelocityDirection": {
+                    "direction": {
+                        "x": 0,
+                        "y": 1,
+                        "z": 0
+                    },
+                    "angle": 1.5
+                },
+                "particleSpeed": {
+                    "min": 0.2,
+                    "max": 0.5
+                }
+            }
+        ]
+    }
+};
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} ecd
+ * @param {number} entity
+ * @param {string} [particles]
+ * @param {string} [sound]
+ * @returns {Promise<any>}
+ */
+export function removeEntityGenericEffect(
+    {
+        engine,
+        ecd,
+        entity,
+        particles = 'cloud-puff',
+        sound = "data/sounds/effects/Magic_Game_Essentials/Magic_Vanish_3.wav"
+    }
+) {
+
+    const emitter = ParticleEmitter.fromJSON(lib[particles]);
+
+    const result = removeEntityWithEffect({
+        entity,
+        ecd,
+        emitter,
+        soundEffect: sound
+    });
+
+    return result;
+}

package/engine/animation/removeEntityWithMeshParticlesEffect.js

@@ -0,0 +1,201 @@
+import Mesh from "../graphics/ecs/mesh/Mesh.js";
+import { distributeParticlesOnObject3D } from "../graphics/particles/particular/engine/utils/distributeParticlesOnObject3D.js";
+import { removeComponentsExcept } from "../ecs/util/removeComponentsExcept.js";
+import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+import Trail2D from "../graphics/ecs/trail2d/Trail2D.js";
+import { Transform } from "../ecs/transform/Transform.js";
+import EntityBuilder from "../ecs/EntityBuilder.js";
+import { stopEntityAndNotifyWhenStopped } from "./AnimatedActions.js";
+
+const lib = {
+    'mesh-cloud-puff-0': {
+        "position": {
+            "x": 9.17416,
+            "y": -1.90031,
+            "z": 12.06082
+        },
+        "scale": {
+            "x": 1,
+            "y": 1,
+            "z": 1
+        },
+        "rotation": {
+            "x": 0,
+            "y": 0,
+            "z": 0,
+            "w": 1
+        },
+        "parameters": [
+            {
+                "name": "scale",
+                "itemSize": 1,
+                "defaultTrackValue": {
+                    "itemSize": 1,
+                    "data": [
+                        1
+                    ],
+                    "positions": [
+                        0
+                    ]
+                }
+            },
+            {
+                "name": "color",
+                "itemSize": 4,
+                "defaultTrackValue": {
+                    "itemSize": 4,
+                    "data": [
+                        1,
+                        1,
+                        1,
+                        1
+                    ],
+                    "positions": [
+                        0
+                    ]
+                }
+            }
+        ],
+        "preWarm": false,
+        "readDepth": true,
+        "softDepth": true,
+        "blendingMode": 0,
+        "layers": [
+            {
+                "imageURL": "data/textures/particle/smokeparticle.png",
+                "particleLife": {
+                    "min": 0.6,
+                    "max": 1.2
+                },
+                "particleSize": {
+                    "min": 0.2,
+                    "max": 0.3
+                },
+                "particleRotation": {
+                    "min": 0,
+                    "max": 0
+                },
+                "particleRotationSpeed": {
+                    "min": 0,
+                    "max": 0
+                },
+                "emissionShape": 1,
+                "emissionFrom": 1,
+                "emissionRate": 0,
+                "emissionImmediate": 1200,
+                "parameterTracks": [
+                    {
+                        "name": "color",
+                        "track": {
+                            "itemSize": 4,
+                            "data": [
+                                0.9803921568627451,
+                                0.9803921568627451,
+                                0.9803921568627451,
+                                0.3,
+                                0.9882352941176471,
+                                0.9882352941176471,
+                                0.9882352941176471,
+                                0.265,
+                                0.9882352941176471,
+                                0.9882352941176471,
+                                0.9882352941176471,
+                                0
+                            ],
+                            "positions": [
+                                0,
+                                0.7957639171068672,
+                                1
+                            ]
+                        }
+                    }
+                ],
+                "position": {
+                    "x": 0,
+                    "y": 0.6,
+                    "z": 0
+                },
+                "scale": {
+                    "x": 0.9,
+                    "y": 0.5,
+                    "z": 0.65
+                },
+                "particleVelocityDirection": {
+                    "direction": {
+                        "x": 0,
+                        "y": 1,
+                        "z": 0
+                    },
+                    "angle": 0
+                },
+                "particleSpeed": {
+                    "min": 0.6,
+                    "max": 1.1
+                }
+            }
+        ]
+    }
+};
+
+/**
+ *
+ * @param {EntityManager} entityManager
+ * @param {EntityComponentDataset} ecd
+ * @param {number} entity
+ * @param {string} particles
+ * @returns {Promise<any>}
+ */
+export function removeEntityWithMeshParticlesEffect(
+    {
+        entityManager,
+        ecd,
+        entity,
+        particles = 'mesh-cloud-puff-0'
+    }
+) {
+
+    const emitter = ParticleEmitter.fromJSON(lib[particles]);
+
+    //get entity mesh
+
+    const cMesh = ecd.getComponent(entity, Mesh);
+
+    if (cMesh !== undefined) {
+        if (cMesh.mesh !== null) {
+            const randomSeed = Math.random() * 1000000;
+
+            distributeParticlesOnObject3D(emitter, randomSeed, cMesh.mesh);
+        }
+    }
+
+    //prevent further interactions
+    removeComponentsExcept(ecd, entity, [Mesh, ParticleEmitter, Trail2D, Transform]);
+
+    /**
+     *
+     * @type {Transform}
+     */
+    const originalTransform = ecd.getComponent(entity, Transform);
+
+    if (originalTransform === undefined) {
+        throw new Error(`entity ${entity} doesn't have Transform`);
+    }
+
+    //create particle emitter
+    const effectBuilder = new EntityBuilder();
+    const effectEntity = effectBuilder
+        .add(emitter)
+        .add(originalTransform.clone())
+        .build(ecd);
+
+    Promise.all([
+        stopEntityAndNotifyWhenStopped(effectEntity, ecd)
+    ])
+        .then(() => effectBuilder.destroy());
+
+    return stopEntityAndNotifyWhenStopped(entity, ecd)
+        .then(() => {
+            ecd.removeEntity(entity);
+        });
+
+}

package/engine/graphics/particles/ecs/ParticleEmitterSystem.js

@@ -4,7 +4,6 @@ import { ParticularEngine } from "../particular/engine/ParticularEngine.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { ParticleEmitterFlag } from "../particular/engine/emitter/ParticleEmitterFlag.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
-import { ParticleEmitterLibrary } from "../ParticleEmitterLibrary.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
 import { StandardFrameBuffers } from "../../StandardFrameBuffers.js";
 import { assert } from "../../../../core/assert.js";
@@ -15,18 +14,9 @@ import { assert } from "../../../../core/assert.js";
  * @returns {Group|Object3D}
  */
 function extractRenderable(emitter) {
-
-
     return emitter.mesh;
 }
 
-/**
- *
- * @param {ParticleEmitter} emitter
- */
-function putEmitterToSleep(emitter) {
-    emitter.setFlag(ParticleEmitterFlag.Sleeping);
-}
 
 export class ParticleEmitterSystem extends System {
     /**
@@ -73,20 +63,9 @@ export class ParticleEmitterSystem extends System {
          */
         this.bvh = null;
 
-        /**
-         * @deprecated Use "Effect" API to achieve the same results
-         * @type {ParticleEmitterLibrary}
-         */
-        this.__library = new ParticleEmitterLibrary(engine.assetManager);
-
         this.__handlers = [];
     }
 
-    get library() {
-        console.warn('Deprecated, use "Effect" API to achieve the same results');
-        return this.__library;
-    }
-
     get componentClass() {
         return ParticleEmitter;
     }
@@ -208,7 +187,7 @@ export class ParticleEmitterSystem extends System {
 
         graphicsEngine.on.preRender.add(preRenderHook);
 
-        this.library.load_from_registry_file('data/database/particles/data.json').then(readyCallback, errorCallback);
+        readyCallback();
     }
 
     shutdown(entityManager, readyCallback, errorCallback) {

package/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js

@@ -296,8 +296,8 @@ export class ParameterLookupTable {
             //special case, all values are the same
             return computeHashIntegerArray(valueMin);
         } else {
-            const dataHash = computeHashFloatArray(this.data, valueMin, valueMax);
-            const positionHash = computeHashFloatArray(this.positions, 0, 1);
+            const dataHash = computeHashFloatArray(this.data);
+            const positionHash = computeHashFloatArray(this.positions);
 
             return computeHashIntegerArray(dataHash, positionHash, this.itemSize);
         }

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

@@ -3,6 +3,7 @@ import { DataType2TypedArrayConstructorMapping } from "../../../../../../../core
 import { array_copy } from "../../../../../../../core/collection/array/copyArray.js";
 import { min2 } from "../../../../../../../core/math/min2.js";
 import { assert } from "../../../../../../../core/assert.js";
+import { ParameterLookupTable } from "../../parameter/ParameterLookupTable.js";
 
 export class AttributeValue {
     constructor() {
@@ -142,4 +143,57 @@ export class AttributeValue {
     read_value(destination) {
         array_copy(this.__value, 0, destination, 0, this.spec.itemSize);
     }
+
+    /**
+     *
+     * @param {number[]} [value]
+     * @param {Object} [lookup]
+     * @param {number} [lookup_value]
+     */
+    fromJSON({
+                 value,
+                 lookup,
+                 lookup_value
+             }) {
+
+        if (value !== undefined) {
+            if (Array.isArray(value)) {
+
+                if (lookup !== undefined) {
+                    console.warn("Both 'lookup' and 'value' were specified, expected one or the other. Ignoring the value attribute.");
+                } else {
+                    this.write_value(value);
+                }
+
+            } else {
+                throw new Error(`Expected 'value' to be an array, instead got something else (=${value})`);
+            }
+        } else {
+            this.__value = [];
+        }
+
+        if (lookup !== undefined) {
+            const lut = new ParameterLookupTable();
+
+            lut.fromJSON(lookup);
+
+            this.lookup = lut;
+        } else {
+            this.lookup = null;
+        }
+
+        if (lookup_value !== undefined) {
+            assert.isNumber(lookup_value, 'lookup_value');
+            assert.isFiniteNumber(lookup_value, 'lookup_value');
+
+            if (lookup === undefined) {
+                console.warn("found 'lookup_value' attribute, but no 'lookup' table. Ignoring lookup value");
+            } else {
+                this.lookup_value = lookup_value;
+            }
+        } else if (lookup !== undefined) {
+            // supply a default lookup value
+            this.lookup_value = 0;
+        }
+    }
 }

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

@@ -12,6 +12,7 @@ import { AttributeValue } from "./AttributeValue.js";
 import { PARTICULAR_PARTICLE_SPECIFICATION } from "../../emitter/PARTICULAR_PARTICLE_SPECIFICATION.js";
 import { SerializationMetadata } from "../../../../../../ecs/components/SerializationMetadata.js";
 import { UnitCubeShape3D } from "../../../../../../../core/geom/3d/shape/UnitCubeShape3D.js";
+import { shape_from_json } from "../../../../../../../core/geom/3d/shape/json/shape_from_json.js";
 
 /**
  *
@@ -154,28 +155,13 @@ export class ParticleVolume {
                             "track": {
                                 "itemSize": 4,
                                 "data": [
-                                    0.5764705882352941,
-                                    0.5764705882352941,
-                                    0.5764705882352941,
-                                    0,
-                                    0.803921568627451,
-                                    0.803921568627451,
-                                    0.803921568627451,
-                                    0.28160919540229884,
-                                    0.803921568627451,
-                                    0.803921568627451,
-                                    0.803921568627451,
-                                    0.21264367816091953,
-                                    0.803921568627451,
-                                    0.803921568627451,
-                                    0.803921568627451,
-                                    0
+                                    1,
+                                    1,
+                                    1,
+                                    1,
                                 ],
                                 "positions": [
-                                    0,
-                                    0.18085106382978725,
-                                    0.7074468085106383,
-                                    1
+                                    0
                                 ]
                             }
                         },
@@ -335,6 +321,50 @@ export class ParticleVolume {
         attributes.size.write_value_silent([particle_size]);
     }
 
+    /**
+     *
+     * @param {number} density
+     * @param {boolean} [is_density_size_adjusted]
+     * @param {number} [particle_size]
+     * @param {Object} shape
+     * @param {boolean} [is_sorted]
+     * @param {string} sprite
+     * @param {Object<Object>} [attributes]
+     */
+    fromJSON({
+                 density,
+                 is_density_size_adjusted = true,
+                 particle_size = 1,
+                 shape,
+                 is_sorted = true,
+                 sprite,
+                 attributes = {}
+             }) {
+
+        const shape_object = shape_from_json(shape);
+
+        const actual_density = is_density_size_adjusted ? density / particle_size : density;
+
+        this.from({
+            density: actual_density,
+            shape: shape_object,
+            particle_size,
+            sort: is_sorted,
+            sprite
+        });
+
+        for (const attributesKey in attributes) {
+            const attribute_object = this.attributes[attributesKey];
+
+            if (attribute_object === undefined) {
+                console.warn(`No '${attributesKey}' attribute, skipping`);
+            }
+
+            const attribute_json = attributes[attributesKey];
+            attribute_object.fromJSON(attribute_json);
+        }
+    }
+
     /**
      *
      * @private

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

@@ -328,9 +328,8 @@ async function sample_scene_0(engine) {
         ecd: ecd,
         lut: heatmap_lut_0,
         shape: UnionShape3D.from([
-            TransformedShape3D.from_m4(new UnitCubeShape3D(), [14.980091485108495, 0, 0, 0, 0, 2.812495250139616, 0, 0, 0, 0, 7.469446746375293, 0, 54.83080514238756, 1.568241402881399, 92.51937192481576, 1]),
-            TransformedShape3D.from_m4(new UnitCubeShape3D(), [6.644515553810907, 0, 0, 0, 0, 2.812495250139616, 0, 0, 0, 0, 5.507507223409315, 0, 46.95032009188344, 1.568241402881399, 95.54148649329517, 1]),
-            TransformedShape3D.from_m4(new UnitCubeShape3D(), [23.762890107594952, 0, 0, 0, 0, 2.812495250139616, 0, 0, 0, 0, 34.57956316503163, 0, 55.436098243647756, 1.568241402881399, 113.46988143189215, 1])
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), mat_from_aabb3(new AABB3(67.73, 0, 89, 115.84, 3, 118.34))),
+            TransformedShape3D.from_m4(new UnitCubeShape3D(), mat_from_aabb3(new AABB3(98, 0, 76.5, 109.5, 3, 89)))
         ]),
         particle_size: 2,
         density: 1,

package/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js

@@ -40,7 +40,7 @@ export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
         defines.PERSPECTIVE_CAMERA = 1;
 
         // More samples = better quality
-        defines.NUM_SAMPLES = 7;
+        defines.NUM_SAMPLES = 13;
 
         // More rings = better quality
         defines.NUM_RINGS = 4;

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.51",
+  "version": "2.33.55",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",