@woosh/meep-engine 2.47.12 → 2.47.13

package/build/meep.module.js

@@ -73247,6 +73247,14 @@ BitSet.prototype.__resize = function (bitCapacity) {
     this.__capacity = uint32_capacity * 32;
 };
 
+BitSet.prototype.__updateLength = function () {
+    const found_length = this.previousSetBit(this.__length) + 1;
+
+    if (found_length < this.__length) {
+        this.__setLength(found_length);
+    }
+};
+
 /**
  *
  * @param {int} new_length
@@ -73470,12 +73478,8 @@ BitSet.prototype.set = function (bitIndex, value) {
         //clear
         this.__data_uint32[word_offset] &= ~word_mask;
 
-        if (bitIndex === this.__length - 1) {
-            // trim down set size potentially
-            // const newLastSetBit = this.previousSetBit(bitIndex);
-
-            this.__setLength(bitIndex );
-        }
+        // trim down set size potentially
+        this.__updateLength();
     }
 
     //DEBUG validate firstClearBit value
@@ -82231,11 +82235,11 @@ function isGroup(t) {
 class ConcurrentExecutor {
     /**
      *
-     * @param {number} quietTime in milliseconds
-     * @param {number} workTime in milliseconds
+     * @param {number} [quietTime] in milliseconds
+     * @param {number} [workTime] in milliseconds
      * @constructor
      */
-    constructor(quietTime, workTime) {
+    constructor(quietTime=1, workTime=15) {
         /**
          *
          * @type {number}

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.47.12",
+  "version": "2.47.13",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/BitSet.js

@@ -162,6 +162,14 @@ BitSet.prototype.__resize = function (bitCapacity) {
     this.__capacity = uint32_capacity * 32;
 };
 
+BitSet.prototype.__updateLength = function () {
+    const found_length = this.previousSetBit(this.__length) + 1;
+
+    if (found_length < this.__length) {
+        this.__setLength(found_length);
+    }
+}
+
 /**
  *
  * @param {int} new_length
@@ -385,12 +393,8 @@ BitSet.prototype.set = function (bitIndex, value) {
         //clear
         this.__data_uint32[word_offset] &= ~word_mask;
 
-        if (bitIndex === this.__length - 1) {
-            // trim down set size potentially
-            // const newLastSetBit = this.previousSetBit(bitIndex);
-
-            this.__setLength(bitIndex );
-        }
+        // trim down set size potentially
+        this.__updateLength();
     }
 
     //DEBUG validate firstClearBit value

package/src/core/json/abstractJSONDeserializer.js

@@ -0,0 +1,25 @@
+/**
+ * @template T
+ * @param {T} json
+ * @param {Map<string, function>} deserializers
+ */
+export function abstractJSONDeserializer(json, deserializers) {
+    if (typeof json !== "object") {
+        // primitive type
+        return json;
+    }
+
+    const typeName = json.type;
+
+    if (typeof typeName !== "string") {
+        throw new Error(`Expected json.typeName to be a string, instead was '${typeof typeName}'(=${typeName})`);
+    }
+
+    const deserializer = deserializers.get(typeName);
+
+    if (deserializer === undefined) {
+        throw new Error(`No deserializer found for type '${typeName}'`);
+    }
+
+    return deserializer(json.data);
+}

package/src/core/json/abstractJSONSerializer.js

@@ -0,0 +1,48 @@
+/**
+ * @template T
+ * @param {T} source
+ * @param {Map<string, function(v:Object):Object>} serializers
+ * @param {Map<*,string>} classNames
+ */
+export function abstractJSONSerializer(source, serializers, classNames) {
+
+
+    if (typeof source !== "object") {
+        // primitive type
+        return source;
+    }
+
+        // parameter is an object
+
+        // extract type name
+        const Klass = source.constructor;
+        let typeName = classNames.get(Klass);
+
+        if (typeName === undefined) {
+            // try fallback to "typeName" field on constructor
+            typeName = Klass.typeName;
+        }
+
+        if (typeName === undefined) {
+            throw new Error(`Failed to resolve type name for parameter '${key}'. No name found in classNames registry and no .typeName field on the constructor`);
+        }
+
+        let serializer = serializers.get(typeName);
+        let serializerContext = undefined;
+
+        if (serializer === undefined) {
+            serializer = source.toJSON;
+            serializerContext = source;
+        }
+
+        if (serializer === undefined) {
+            throw new Error(`Failed to resolve serializer for object type '${typeName}'. No serializer found in serializers registry and no .toJSON method on object itself`);
+        }
+
+        return {
+            type: typeName,
+            data: serializer.call(serializerContext, source)
+        };
+
+
+}

package/src/core/model/node-graph/json/deserializeNodeGraphFromJSON.js

@@ -0,0 +1,118 @@
+import { assert } from "../../../assert.js";
+import { NodeInstance } from "../node/NodeInstance.d.ts";
+import { abstractJSONDeserializer } from "../../../json/abstractJSONDeserializer.js";
+import { NodeRegistry } from "../node/NodeRegistry.js";
+
+/**
+ *
+ * @param {NodeInstance} node
+ * @param {*} json
+ * @param {Map<string, function>} deserializers
+ */
+function nodeParametersFromJSON(node, json, deserializers) {
+
+    for (const key in json) {
+
+        const jParameter = json[key];
+
+        const value = abstractJSONDeserializer(jParameter, deserializers);
+
+        node.setParameterValue(key, value);
+
+    }
+
+}
+
+/**
+ *
+ * @param {NodeGraph} graph
+ * @param {{nodes:[], connections:[], descriptions:[]}} json
+ * @param {NodeRegistry} [node_registry]
+ * @param {Map<string, function>} [deserializers]
+ */
+export function deserializeNodeGraphFromJSON({
+                                                 graph,
+                                                 json,
+                                                 node_registry = new NodeRegistry(),
+                                                 deserializers = new Map()
+                                             }) {
+
+    const j_nodes = json.nodes;
+    const j_connections = json.connections;
+    const j_descriptions = json.descriptions;
+
+
+    assert.defined(j_nodes, 'json.nodes');
+    assert.defined(j_connections, 'json.connections');
+    assert.defined(j_descriptions, 'json.descriptions');
+
+    graph.reset();
+
+    /**
+     *
+     * @type {NodeDescription[]}
+     */
+    const descriptions = [];
+
+    // parse node descriptions
+    for (let i = 0; i < j_descriptions.length; i++) {
+        const jDescription = j_descriptions[i];
+
+        const nodeDescription = abstractJSONDeserializer(jDescription, deserializers);
+
+        if (
+            typeof nodeDescription !== "object"
+            || nodeDescription.isNodeDescription !== true
+        ) {
+            throw new Error(`Deserialized object was expected to be a NodeDescription, instead got something else. Source JSON[${i}]: ${jDescription}`);
+        }
+
+        descriptions[i] = nodeDescription;
+
+        // make sure to register the node
+        node_registry.addNode(nodeDescription);
+    }
+
+    // parse nodes
+    const node_count = j_nodes.length;
+
+    for (let i = 0; i < node_count; i++) {
+        const jNode = j_nodes[i];
+
+        const node_id = jNode.id;
+
+        assert.isNonNegativeInteger(node_id, 'node.id');
+
+        const description_index = jNode.description;
+
+        const jParameters = jNode.parameters;
+
+        // get node description
+        const node_description = descriptions[description_index];
+
+        if (node_description === undefined) {
+            throw new Error(`Index ${description_index} not found in .description`);
+        }
+
+        const nodeInstance = new NodeInstance();
+
+        nodeInstance.id = node_id;
+        nodeInstance.setDescription(node_description);
+
+        nodeParametersFromJSON(nodeInstance, jParameters, deserializers);
+
+        graph.addNode(nodeInstance);
+    }
+
+    // parse connections
+    const connection_count = j_connections.length;
+
+    for (let i = 0; i < connection_count; i++) {
+        const jConnection = j_connections[i];
+
+        const jSource = jConnection.source;
+        const jTarget = jConnection.target;
+
+        graph.createConnection(jSource.instance, jSource.port, jTarget.instance, jTarget.port);
+    }
+}

package/src/core/model/node-graph/json/serializeNodeGraphToJSON.js

@@ -0,0 +1,106 @@
+import { abstractJSONSerializer } from "../../../json/abstractJSONSerializer.js";
+
+/**
+ *
+ * @param {NodeInstance} node
+ * @param {Map<string, function(v:Object):Object>} serializers
+ * @param {Map<*,string>} classNames
+ */
+function nodeParametersToJSON(node, serializers, classNames) {
+    const result = {};
+
+    const parameters = node.parameters;
+
+    for (const key in parameters) {
+
+        const source = parameters[key];
+
+
+        result[key] = abstractJSONSerializer(source, serializers, classNames);
+
+    }
+
+    return result;
+}
+
+
+/**
+ *
+ * @param {NodeGraph} graph
+ * @param {Map<string, function(v:Object):Object>} [serializers]
+ * @param {Map<*,string>} [classNames]
+ */
+export function serializeNodeGraphToJSON({ graph, serializers = new Map(), classNames = new Map() }) {
+    /**
+     *
+     * @type {NodeDescription[]}
+     */
+    const description_objects = [];
+    /**
+     *
+     * @type {Map<NodeDescription, number>}
+     */
+    const description_to_index_map = new Map();
+
+    /**
+     * JSON versions of descriptions
+     * @type {Object[]}
+     */
+    const descriptions = [];
+
+    // extract node descriptions
+    graph.traverseNodes(node => {
+
+        const description = node.description;
+
+        let index = description_objects.indexOf(description);
+
+        if (index !== -1) {
+            // already recorded
+            return;
+        }
+
+        index = description_objects.length;
+        description_objects.push(description);
+
+        description_to_index_map.set(description, index);
+
+        descriptions[index] = abstractJSONSerializer(description, serializers, classNames);
+    });
+
+    const nodes = [];
+
+    graph.traverseNodes(node => {
+
+        nodes.push({
+            id: node.id,
+            description: description_to_index_map.get(node.description),
+            parameters: nodeParametersToJSON(node, serializers, classNames)
+        });
+
+    });
+
+    const connections = [];
+
+    graph.traverseConnections(connection => {
+
+        connections.push({
+            source: {
+                instance: connection.source.instance.id,
+                port: connection.source.port.id
+            },
+            target: {
+                instance: connection.target.instance.id,
+                port: connection.target.port.id
+            }
+        });
+
+    });
+
+    return {
+        nodes,
+        connections,
+        descriptions
+    };
+}
+

package/src/core/model/node-graph/node/NodeDescription.js

@@ -315,6 +315,14 @@ export class NodeDescription {
     getPorts() {
         return this.ports
     }
+
+    toJSON() {
+        throw new Error('Not Implemented');
+    }
+
+    fromJSON() {
+        throw new Error('Not Implemented');
+    }
 }
 
 /**

package/src/core/process/executor/ConcurrentExecutor.d.ts

@@ -2,7 +2,7 @@ import Task from "../task/Task";
 import TaskGroup from "../task/TaskGroup";
 
 export default class ConcurrentExecutor {
-    constructor(quietTime: number, workTime: number)
+    constructor(quietTime?: number, workTime?: number)
 
     runGroup(t: TaskGroup): void
 

package/src/core/process/executor/ConcurrentExecutor.js

@@ -24,11 +24,11 @@ function isGroup(t) {
 class ConcurrentExecutor {
     /**
      *
-     * @param {number} quietTime in milliseconds
-     * @param {number} workTime in milliseconds
+     * @param {number} [quietTime] in milliseconds
+     * @param {number} [workTime] in milliseconds
      * @constructor
      */
-    constructor(quietTime, workTime) {
+    constructor(quietTime=1, workTime=15) {
         /**
          *
          * @type {number}

package/src/engine/asset/AssetManager.d.ts

@@ -15,6 +15,10 @@ export class AssetManager {
 
     load_concurrency: number
 
+    startup(): void
+
+    shutdown(immediate?: boolean): Promise<void>
+
     promise<T>(path: string, type: string, options?: PromiseOptions): Promise<Asset<T>>
 
     remove(path: string, type: string): boolean

package/src/engine/asset/AssetManager.spec.js

@@ -1,13 +1,18 @@
 import { Asset } from "./Asset.js";
 import { AssetManager } from "./AssetManager.js";
 import { AssetLoader } from "./loaders/AssetLoader.js";
+import ConcurrentExecutor from "../../core/process/executor/ConcurrentExecutor.js";
 
 /**
  *
  * @return {Engine}
  */
 function dummyEngine() {
-    return {};
+    const executor = new ConcurrentExecutor();
+
+    return {
+        executor: executor
+    };
 }
 
 class DummyLoader extends AssetLoader {
@@ -16,11 +21,12 @@ class DummyLoader extends AssetLoader {
     }
 }
 
-test('successful get', () => {
+test('successful get', async () => {
     const am = new AssetManager(dummyEngine());
 
-    am.registerLoader('a', new DummyLoader());
+    await am.registerLoader('a', new DummyLoader());
 
+    am.startup();
 
     return new Promise(function (resolve, reject) {
         am.get('bla', 'a', resolve, reject);
@@ -30,7 +36,9 @@ test('successful get', () => {
 test('tryGet loaded resource', async () => {
     const am = new AssetManager(dummyEngine());
 
-    am.registerLoader('a', new DummyLoader());
+    am.startup();
+
+    await am.registerLoader('a', new DummyLoader());
 
     await am.promise('bla', 'a');
 

package/src/engine/graphics/particles/node-based/editor/ParticleSpecificationEditorView.js

@@ -7,9 +7,11 @@ import LabelView from "../../../../../view/common/LabelView.js";
 import { MouseEvents } from "../../../../input/devices/events/MouseEvents.js";
 import InterfaceCommand from "../../../../../view/interaction/InterfaceCommand.js";
 import { InteractionCommand } from "../../../../../view/interaction/InteractionCommand.js";
-import { serializeNodeGraphToJSON } from "../../../../../core/model/node-graph/serializeNodeGraphToJSON.js";
+import { serializeNodeGraphToJSON } from "../../../../../core/model/node-graph/json/serializeNodeGraphToJSON.js";
 import { downloadAsFile } from "../../../../../core/binary/ByteArrayTools.js";
-import { deserializeNodeGraphFromJSON } from "../../../../../core/model/node-graph/deserializeNodeGraphFromJSON.js";
+import {
+    deserializeNodeGraphFromJSON
+} from "../../../../../core/model/node-graph/json/deserializeNodeGraphFromJSON.js";
 
 export class ParticleSpecificationEditorView extends View {
     constructor() {
@@ -78,7 +80,7 @@ export class ParticleSpecificationEditorView extends View {
                     command: new InteractionCommand({
                         id: 'serialize-json',
                         action() {
-                            const json = serializeNodeGraphToJSON(nodeGraph);
+                            const json = serializeNodeGraphToJSON({ graph: nodeGraph });
 
 
                             downloadAsFile(JSON.stringify(json, 3, 3), 'graph.json', 'application/json');
@@ -105,7 +107,7 @@ export class ParticleSpecificationEditorView extends View {
 
                     const json = JSON.parse(fr.result);
 
-                    deserializeNodeGraphFromJSON(nodeGraph, json, nodeRegistry);
+                    deserializeNodeGraphFromJSON({ graph: nodeGraph, json: json, node_registry: nodeRegistry });
 
                     visual.layout(nodeGraph);
                 };

package/src/generation/markers/transform/MarkerNodeTransformerYRotateByFilterGradient.spec.js

@@ -78,7 +78,7 @@ test('left to right', () => {
         1, 0, 0,
         1, 0, 0,
         1, 0, 0
-    ])).toBeCloseTo(180);
+    ])).toBeCloseTo(-180);
 });
 
 test('right to left', () => {
@@ -94,7 +94,7 @@ test('top to bottom', () => {
         1, 1, 1,
         0, 0, 0,
         0, 0, 0
-    ])).toBeCloseTo(-90);
+    ])).toBeCloseTo(90);
 });
 
 test('bottom to top', () => {
@@ -102,5 +102,5 @@ test('bottom to top', () => {
         0, 0, 0,
         0, 0, 0,
         1, 1, 1
-    ])).toBeCloseTo(90);
+    ])).toBeCloseTo(-90);
 });

package/src/core/model/node-graph/deserializeNodeGraphFromJSON.js

@@ -1,62 +0,0 @@
-import { assert } from "../../assert.js";
-import { NodeInstance } from "./node/NodeInstance.js";
-
-/**
- *
- * @param {NodeGraph} graph
- * @param {{nodes:[], connections:[]}} json
- * @param {NodeRegistry} node_registry
- */
-export function deserializeNodeGraphFromJSON(graph, json, node_registry) {
-
-    const nodes = json.nodes;
-    const connections = json.connections;
-
-
-    assert.defined(nodes, 'json.nodes');
-    assert.defined(connections, 'json.connections');
-
-    graph.reset();
-
-    // parse nodes
-    const node_count = nodes.length;
-
-    for (let i = 0; i < node_count; i++) {
-        const jNode = nodes[i];
-
-        const node_id = jNode.id;
-
-        assert.isNonNegativeInteger(node_id, 'node.id');
-
-        const description = jNode.description;
-
-        const parameters = jNode.parameters;
-
-        // get node description
-        const node_description = node_registry.getNode(description);
-
-        if (node_description === undefined) {
-            throw new Error(`Node ${description} not found in the registry`);
-        }
-
-        const nodeInstance = new NodeInstance();
-
-        nodeInstance.id = node_id;
-        nodeInstance.setDescription(node_description);
-        nodeInstance.setParameters(parameters);
-
-        graph.addNode(nodeInstance);
-    }
-
-    // parse connections
-    const connection_count = connections.length;
-
-    for (let i = 0; i < connection_count; i++) {
-        const jConnection = connections[i];
-
-        const jSource = jConnection.source;
-        const jTarget = jConnection.target;
-
-        graph.createConnection(jSource.instance, jSource.port, jTarget.instance, jTarget.port);
-    }
-}

package/src/core/model/node-graph/serializeNodeGraphToJSON.js

@@ -1,40 +0,0 @@
-/**
- *
- * @param {NodeGraph} graph
- */
-export function serializeNodeGraphToJSON(graph) {
-    const nodes = [];
-
-    graph.traverseNodes(node => {
-
-        nodes.push({
-            id: node.id,
-            description: node.description.id,
-            parameters: node.parameters
-        });
-
-    });
-
-    const connections = [];
-
-    graph.traverseConnections(connection => {
-
-        connections.push({
-            source: {
-                instance: connection.source.instance.id,
-                port: connection.source.port.id
-            },
-            target: {
-                instance: connection.target.instance.id,
-                port: connection.target.port.id
-            }
-        });
-
-    });
-
-    return {
-        nodes,
-        connections
-    };
-}
-