@woosh/meep-engine 2.48.1 → 2.48.5

package/src/engine/ecs/storage/binary/object/BinaryObjectSerializationAdapter2.js

@@ -1,48 +1,487 @@
+import { assert } from "../../../../../core/assert.js";
+
+const HEADER_TAG_NATIVE_CLASS = 0;
+const HEADER_TAG_REF_SCHEMA = 1;
+const HEADER_TAG_INLINE_SCHEMA = 2;
+
+const HEADER_TAG_NULL = 4;
+const HEADER_TAG_UNDEFINED = 5;
+const HEADER_TAG_BOOLEAN_TRUE = 6;
+const HEADER_TAG_BOOLEAN_FALSE = 7;
+const HEADER_TAG_POSITIVE_INTEGER = 8;
+const HEADER_TAG_NEGATIVE_INTEGER = 9;
+const HEADER_TAG_FLOAT = 20;
+const HEADER_TAG_STRING = 30;
+
+
+class SchemaRecord {
+    address = -1
+    /**
+     *
+     * @type {Object|null}
+     */
+    schema = null
+    /**
+     *
+     * @type {string|null}
+     */
+    typeName = null
+
+    /**
+     *
+     * @type {{name:string}[]}
+     */
+    fields = [];
+
+    /**
+     *
+     * @param {Object} schema
+     */
+    fromSchema(schema) {
+        this.schema = schema;
+
+        this.fields.splice(0, this.fields.length);
+
+        for (const schemaKey in schema) {
+            this.fields.push({
+                name: schemaKey
+            });
+        }
+    }
+
+    buildSchema() {
+        const schema = {};
+
+        const fields = this.fields;
+        const field_count = fields.length;
+        for (let i = 0; i < field_count; i++) {
+            const field = fields[i];
+
+            schema[field.name] = {};
+        }
+
+        this.schema = schema;
+    }
+}
+
+/**
+ * Generate a schema from a value object
+ * @param {Object} object
+ * @returns
+ */
+function autoSchema(object) {
+    const schema = {};
+    for (const objectKey in object) {
+        const field_value = object[objectKey];
+
+        let field_schema;
+
+        if (typeof field_value === "object") {
+            field_schema = autoSchema(field_value);
+        } else {
+            // no schema for primitives
+            field_schema = undefined;
+        }
+
+        schema[objectKey] = field_schema;
+    }
+
+    return schema;
+}
+
+class SchemaTable {
+    /**
+     *
+     * @type {Map<number, SchemaRecord>}
+     */
+    #address_map = new Map();
+    /**
+     *
+     * @type {Map<Object, SchemaRecord>}
+     */
+    #schema_map = new Map();
+
+
+    reset() {
+        this.#address_map.clear();
+        this.#schema_map.clear();
+    }
+
+    /**
+     *
+     * @param {number} address
+     * @returns {SchemaRecord|undefined}
+     */
+    getSchemaAt(address) {
+        return this.#address_map.get(address);
+    }
+
+    /**
+     *
+     * @param {Object} schema
+     * @returns {SchemaRecord}
+     */
+    getRecord(schema) {
+        return this.#schema_map.get(schema);
+    }
+
+    /**
+     *
+     * @param {Object} schema
+     * @returns {number} -1 if not found
+     */
+    getAddress(schema) {
+        const record = this.#schema_map.get(schema);
+
+        if (record === undefined) {
+            return -1;
+        }
+
+        return record.address;
+    }
+
+    /**
+     *
+     * @param {SchemaRecord} record
+     */
+    add(record) {
+        this.#schema_map.set(record.schema, record);
+        this.#address_map.set(record.address, record);
+    }
+}
+
 export class BinaryObjectSerializationAdapter2 {
     /**
      *
      * @type {BinarySerializationRegistry|null}
      */
-    #registry = null
+    #adapter_registry = null
+    /**
+     *
+     * @type {ModuleRegistry|null}
+     */
+    #class_registry = null
+
+    #schema_table = new SchemaTable();
+
+    set module_registry(v) {
+        this.#class_registry = v;
+    }
+
+    get module_registry() {
+        return this.#class_registry;
+    }
+
+    set adapter_registry(v) {
+        this.#adapter_registry = v;
+    }
+
+    get adapter_registry() {
+        return this.#adapter_registry;
+    }
+
+    reset() {
+        this.#schema_table.reset();
+    }
 
     /**
      *
      * @param {BinaryBuffer} buffer
-     * @param {Object} object
      * @param {Object} schema
+     * @param {string} typeName
+     * @returns {SchemaRecord}
+     */
+    #writeSchema(buffer, schema, typeName) {
+        const address = buffer.position;
+
+        const record = new SchemaRecord();
+
+        record.typeName = typeName;
+        record.address = address;
+
+        record.fromSchema(schema);
+
+        // write type name
+        buffer.writeUTF8String(typeName);
+
+        const fields = record.fields;
+        const field_count = fields.length;
+
+        buffer.writeUintVar(field_count);
+
+        for (let i = 0; i < field_count; i++) {
+            // write field
+            const field = fields[i];
+
+            buffer.writeUTF8String(field.name);
+        }
+
+        this.#schema_table.add(record);
+
+        return record;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @returns {SchemaRecord}
+     */
+    #readSchema(buffer) {
+        const address = buffer.position;
+
+        const record = new SchemaRecord();
+        record.address = address;
+
+        // read type name
+        const typeName = buffer.readUTF8String();
+
+        record.typeName = typeName;
+
+        const field_count = buffer.readUintVar();
+
+        for (let i = 0; i < field_count; i++) {
+            const field_name = buffer.readUTF8String();
+
+            record.fields[i] = {
+                name: field_name
+            };
+        }
+
+        record.buildSchema();
+
+        this.#schema_table.add(record);
+
+        return record;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {number|string|boolean|null|undefined|object} object
+     * @returns {boolean}
+     */
+    #trySerializePrimitive(buffer, object) {
+        if (object === null) {
+            // special case
+            buffer.writeUint8(HEADER_TAG_NULL);
+            return true;
+        }
+
+        const typeOfValue = typeof object;
+
+        if (typeOfValue === "object") {
+            return false;
+        }
+
+
+        switch (typeOfValue) {
+            case "undefined":
+                buffer.writeUint8(HEADER_TAG_UNDEFINED);
+                break;
+            case "boolean":
+                buffer.writeUint8(object ? HEADER_TAG_BOOLEAN_TRUE : HEADER_TAG_BOOLEAN_FALSE);
+                break;
+            case "number":
+                if (Number.isInteger(object)) {
+                    if (object >= 0) {
+                        // positive integer
+                        buffer.writeUint8(HEADER_TAG_POSITIVE_INTEGER);
+                        buffer.writeUintVar(object);
+                    } else {
+                        // negative integer
+                        buffer.writeUint8(HEADER_TAG_NEGATIVE_INTEGER);
+                        buffer.writeUintVar(-object);
+                    }
+                } else {
+                    // float
+                    buffer.writeUint8(HEADER_TAG_FLOAT);
+                    buffer.writeFloat64(object);
+                }
+                break;
+            case "string":
+                buffer.writeUint8(HEADER_TAG_STRING);
+                buffer.writeUTF8String(object);
+                break;
+            default:
+                throw new TypeError(`Unsupported value type '${typeOfValue}'`);
+        }
+
+        return true;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Object} object
+     * @param {Object} [schema]
      */
     serialize(buffer, object, schema) {
-        const typeName = object.constructor.typeName;
+        if (this.#trySerializePrimitive(buffer, object)) {
+            // was primitive, serialized
+            return;
+        }
+
+        const ctor = object.constructor;
+
+        const associatedNames = this.#class_registry.findNamesByModule(ctor);
 
-        const nativeAdapter = this.#registry.getAdapter(typeName);
+        let typeName;
 
-        // TODO write a header so we can reconstruct the serialization schema on the other side
+        if (associatedNames.length === 1) {
+            typeName = associatedNames[0];
+        } else {
+            // ambiguous, use type name from constructor
+            typeName = ctor.typeName
+        }
+
+        assert.isString(typeName, 'typeName');
+
+        const nativeAdapter = this.#adapter_registry.getAdapter(typeName);
+
+        const using_native_serializer = nativeAdapter !== undefined;
+
+        if (using_native_serializer) {
+
+            // write header indicating that native serializer is being used
+            buffer.writeUint8(HEADER_TAG_NATIVE_CLASS);
+
+            // name of the type
+            buffer.writeUTF8String(typeName);
 
-        if (nativeAdapter !== undefined) {
             // serialize with native
             nativeAdapter.serialize(buffer, object);
             return;
         }
 
-        for (const property in schema) {
 
-            const field_schema = schema[property];
+        if (schema === undefined) {
+            // no schema specified, generate one
+            schema = autoSchema(object);
+        }
+
+
+        let record = this.#schema_table.getRecord(schema);
+
+        if (record === undefined) {
+            // no record
+
+            // indicating that the full schema follows
+            buffer.writeUint8(HEADER_TAG_INLINE_SCHEMA);
+
+            record = this.#writeSchema(buffer, schema, typeName);
+
+
+        } else {
+            buffer.writeUint8(HEADER_TAG_REF_SCHEMA);
+            // write address of schema
+            buffer.writeUintVar(record.address);
+        }
+
+
+        // write data according to schema
 
-            const actual_value = object[field_schema];
+        const fields = record.fields;
+        const field_count = fields.length;
 
-            this.serialize(buffer, actual_value, field_schema);
+        for (let i = 0; i < field_count; i++) {
+            const field = fields[i];
+
+            const field_name = field.name;
+
+            const actual_value = object[field_name];
+
+            this.serialize(buffer, actual_value, schema[field_name]);
         }
 
     }
 
     /**
      *
+     * @template T
      * @param {BinaryBuffer} buffer
-     * @param {Object} object
+     * @param {number} tag
+     * @returns {T}
+     */
+    #deserializeObject(buffer, tag) {
+        let record;
+
+        if (tag === HEADER_TAG_INLINE_SCHEMA) {
+            // read full schema here
+            record = this.#readSchema(buffer);
+
+        } else if (tag === HEADER_TAG_REF_SCHEMA) {
+            // reference to the schema else-where
+            const schema_address = buffer.readUintVar();
+
+            record = this.#schema_table.getRecord(schema_address);
+        }
+
+        const typeName = record.typeName;
+
+        const Klass = this.#class_registry.get(typeName);
+
+        const object = new Klass();
+
+        const fields = record.fields;
+        const field_count = fields.length;
+
+        for (let i = 0; i < field_count; i++) {
+            const field = fields[i];
+
+            object[field.name] = this.deserialize(buffer);
+        }
+
+        return object;
+    }
+
+    /**
+     * @template T
+     * @param {BinaryBuffer} buffer
+     * @returns {T}
      */
-    deserialize(buffer, object) {
+    deserialize(buffer) {
 
         // read header
+        const header = buffer.readUint8();
+
+        switch (header) {
+            case HEADER_TAG_NATIVE_CLASS:
+                // native serializer being used
+                const typeName = buffer.readUTF8String();
+
+                const adapter = this.#adapter_registry.getAdapter(typeName);
+
+                const Klass = this.#class_registry.get(typeName);
+
+                const object = new Klass();
+
+                adapter.deserialize(buffer, object);
+
+                return object;
+            case HEADER_TAG_INLINE_SCHEMA:
+            case HEADER_TAG_REF_SCHEMA:
+                return this.#deserializeObject(buffer, header);
+
+            case HEADER_TAG_NULL:
+                return null;
+            case HEADER_TAG_UNDEFINED:
+                return undefined;
+            case HEADER_TAG_BOOLEAN_TRUE:
+                return true;
+            case HEADER_TAG_BOOLEAN_FALSE:
+                return false;
+            case HEADER_TAG_POSITIVE_INTEGER:
+                return buffer.readUintVar();
+            case HEADER_TAG_NEGATIVE_INTEGER:
+                return -buffer.readUintVar();
+            case HEADER_TAG_FLOAT:
+                return buffer.readFloat64();
+            case HEADER_TAG_STRING:
+                return buffer.readUTF8String();
+            default:
+                throw new Error(`Unsupported tag '${header}'`);
+        }
+
 
     }
 }

package/src/engine/ecs/storage/binary/object/BinaryObjectSerializationAdapter2.spec.js

@@ -0,0 +1,123 @@
+import { BinaryObjectSerializationAdapter2 } from "./BinaryObjectSerializationAdapter2.js";
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+import { BinarySerializationRegistry } from "../BinarySerializationRegistry.js";
+import { ModuleRegistry } from "../../../../../core/model/ModuleRegistry.js";
+
+
+/**
+ *
+ * @returns {BinaryObjectSerializationAdapter2}
+ */
+function sampleAdapter() {
+
+    const adapter = new BinaryObjectSerializationAdapter2();
+
+    adapter.adapter_registry = new BinarySerializationRegistry();
+    adapter.module_registry = new ModuleRegistry();
+
+    adapter.module_registry.add('object', Object);
+
+    return adapter;
+}
+
+test("primitive value", () => {
+
+    const adapter = sampleAdapter();
+
+    const bin = new BinaryBuffer();
+
+    function check(expected) {
+        // rewind
+        bin.position = 0;
+
+        adapter.serialize(bin, expected);
+
+        // rewind
+        bin.position = 0;
+
+        const actual = adapter.deserialize(bin);
+
+        expect(actual).toEqual(expected);
+    }
+
+    check(0);
+    check(1);
+    check(-1);
+    check(42.1);
+    check(true);
+    check(false);
+    check("hello");
+    check(undefined);
+    check(null);
+});
+
+test("empty object", () => {
+
+    const adapter = sampleAdapter();
+
+    const bin = new BinaryBuffer();
+
+    adapter.serialize(bin, {});
+
+    // rewind
+    bin.position = 0;
+
+    const result = adapter.deserialize(bin);
+
+    expect(typeof result).toBe("object");
+    expect(Object.keys(result)).toEqual([]);
+});
+
+test("multi-key flat object with different primitive values", () => {
+
+    const adapter = sampleAdapter();
+
+    const bin = new BinaryBuffer();
+
+    const expected = {
+        "test": undefined,
+        "hello": null,
+        "zero": 0,
+        "negative integer": -1,
+        "unsigned integer": 1,
+        "float": 0.01,
+        "empty string": "",
+        "string": "hello kitty",
+        "utf-8": "Ḽơᶉëᶆ ȋṕšᶙṁ",
+        "boolean true": true,
+        "boolean false": false,
+    };
+
+    adapter.serialize(bin, expected);
+
+    // rewind
+    bin.position = 0;
+
+    const actual = adapter.deserialize(bin);
+
+    expect(typeof actual).toBe("object");
+    expect(actual).toEqual(expected);
+});
+
+
+test("nested objects", () => {
+
+    const adapter = sampleAdapter();
+    const bin = new BinaryBuffer();
+
+    const expected = {
+        second: {
+            value: "hello there Mr bear"
+        }
+    };
+
+    adapter.serialize(bin, expected);
+
+    // rewind
+    bin.position = 0;
+
+    const actual = adapter.deserialize(bin);
+
+    expect(typeof actual).toBe("object");
+    expect(actual).toEqual(expected);
+});

package/src/engine/ecs/system/computeSystemComponentDependencyGraph.js

@@ -0,0 +1,71 @@
+import { Graph } from "../../../core/graph/v2/Graph.js";
+import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
+import { EdgeDirectionType } from "../../../core/graph/Edge.js";
+
+/**
+ *
+ * @param {number} system_count
+ * @param {System[]} systems
+ * @return {Graph}
+ */
+export function computeSystemComponentDependencyGraph(system_count, systems) {
+    const dependency_graph = new Graph();
+
+    for (let i = 0; i < system_count; i++) {
+        const system = systems[i];
+
+        const components = system.referenced_components;
+        const component_count = components.length;
+
+        // ensure that all components are registered
+        for (let j = 0; j < component_count; j++) {
+            const component = components[j];
+
+            dependency_graph.addNode(component)
+        }
+
+        for (let j = 0; j < component_count; j++) {
+            const component_a = components[j];
+
+            const access_a = system.getAccessForComponent(component_a);
+
+            if ((access_a & (ResourceAccessKind.Write | ResourceAccessKind.Create)) !== 0) {
+                // writing resource, create dependency on read resources
+
+
+                for (let k = 0; k < component_count; k++) {
+
+                    if (j === k) {
+                        // skip self
+                        continue;
+                    }
+
+                    const component_b = components[k];
+
+                    const access_b = system.getAccessForComponent(component_b);
+
+                    if ((access_b & ResourceAccessKind.Read) !== 0) {
+                        // read access
+
+                        if (dependency_graph.getAnyDirectedEdge(component_a, component_b) === undefined) {
+
+                            dependency_graph.createEdge(component_a, component_b, EdgeDirectionType.Forward);
+
+                        }
+
+                    }
+                }
+
+            }
+
+        }
+
+    }
+
+
+    // console.log("DEPENDENCY_GRAPH:", convertGraphToDotString({
+    //     graph: dependency_graph, nodeToDot: (node) => `[label="${node.typeName}"]`
+    // }));
+
+    return dependency_graph;
+}

package/src/engine/ecs/systems/RenderSystem.js

@@ -9,6 +9,8 @@ import { RenderableFlags } from "../components/RenderableFlags.js";
 import { rootObject3DFastMatrixUpdate } from "../../graphics/ecs/mesh/rootObject3DFastMatrixUpdate.js";
 import { updateNodeByTransformAndBBB } from "../../graphics/ecs/mesh/updateNodeByTransformAndBBB.js";
 import { three_computeObjectBoundingBox } from "../../graphics/three/three_computeObjectBoundingBox.js";
+import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
+import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
 
 
 /**
@@ -30,6 +32,10 @@ class RenderSystem extends System {
 
         this.dependencies = [Renderable, Transform];
 
+        this.components_used = [
+            ResourceAccessSpecification.from(Renderable, ResourceAccessKind.Read | ResourceAccessKind.Write)
+        ];
+
         this.entityData = [];
 
         /**