@woosh/meep-engine 2.33.54 → 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.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.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
@@ -257,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.js

@@ -98,6 +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.js

@@ -52,6 +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/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";
 
 /**
  *
@@ -320,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/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.54",
+  "version": "2.33.55",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",