@woosh/meep-engine 2.75.7 → 2.75.9

package/src/engine/ecs/components/SteeringSerializationAdapter.js

@@ -1,34 +0,0 @@
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
-import Steering from "./Steering.js";
-
-export class SteeringSerializationAdapter extends BinaryClassSerializationAdapter {
-
-    klass = Steering;
-    version = 0;
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {Steering} value
-     */
-    serialize(buffer, value) {
-        buffer.writeFloat32(value.maxSpeed);
-        buffer.writeFloat32(value.rotationSpeed);
-
-        value.destination.toBinaryBufferFloat32(buffer);
-        value.targetMargin.toBinaryBufferFloat32_EqualityEncoded(buffer);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {Steering} value
-     */
-    deserialize(buffer, value) {
-        value.maxSpeed = buffer.readFloat32();
-        value.rotationSpeed = buffer.readFloat32();
-
-        value.destination.fromBinaryBufferFloat32(buffer);
-        value.targetMargin.fromBinaryBufferFloat32_EqualityEncoded(buffer);
-    }
-}

package/src/engine/ecs/storage/json/Blueprint.js

@@ -1,129 +0,0 @@
-/**
- * Created by Alex on 30/04/2014.
- */
-
-
-import EntityFactory from './EntityFactory.js';
-import { FunctionCompiler } from "../../../../core/function/FunctionCompiler.js";
-
-function Blueprint() {
-    this.element = [];
-    /**
-     *
-     * @type {EntityFactory|null}
-     */
-    this.factory = null;
-    this.buildCallback = null;
-}
-
-/**
- *
- * @param settings
- * @param {function(problem:string)} problemCallback
- */
-Blueprint.prototype.verifyBuildSettings = function (settings, problemCallback) {
-    const factoryComponents = this.factory.components;
-
-    for (const typeName of Object.keys(settings)) {
-        const matchFound = factoryComponents.find(function (spec) {
-            return spec.componentClass.typeName === typeName;
-        });
-
-        if (!matchFound) {
-            problemCallback(`factory has no component '${typeName}', found in the settings`);
-        }
-    }
-};
-
-Blueprint.prototype.compile = function () {
-
-};
-
-/**
- *
- * @param {Object} settings
- * @returns {Number}
- */
-Blueprint.prototype.buildEntity = function (settings) {
-    return this.factory.create(this.buildCallback(settings, this.systemMap));
-};
-
-/**
- *
- * @param {EntityManager} entityManager
- * @returns {object}
- */
-function buildSystemMap(entityManager) {
-    const result = {};
-
-    const systems = entityManager.systems;
-    const systemCount = systems.length;
-
-    for (let i = 0; i < systemCount; i++) {
-        const system = systems[i];
-
-        const componentClass = system.componentClass;
-
-        if (componentClass === null) {
-            continue;
-        }
-
-        const typeName = componentClass.typeName;
-
-        if (typeName === undefined) {
-            console.error("Component class has no type name: ", componentClass);
-            continue;
-        }
-
-        if (result.hasOwnProperty(typeName)) {
-            console.error("Duplicate component class name: ", componentClass, result[typeName]);
-            continue;
-        }
-
-        result[typeName] = system;
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {object} json
- * @param {EntityManager} entityManager
- */
-Blueprint.prototype.fromJSON = function (json, entityManager) {
-    this.factory = new EntityFactory();
-
-    const dataset = entityManager.dataset;
-
-    this.factory.fromJSON(json.components, dataset);
-    this.factory.compile(dataset);
-
-    this.systemMap = buildSystemMap(entityManager);
-
-    //get setup function
-    const setupFunctionBody = json.setup !== undefined ? json.setup : "";
-
-
-    //make build callback
-    const buildCallbackParameters = this.factory.components.map(function (spec) {
-        return spec.componentClass.typeName;
-    });
-
-    let buildCallbackBody = this.factory.components.map(function (spec) {
-        const name = spec.componentClass.typeName;
-        const settingsVar = "$settings." + name;
-        const systemVar = "$systems." + name;
-
-        return "if(" + settingsVar + " !== undefined){ " + name + ".fromJSON(" + settingsVar + ", " + systemVar + ");}";
-    }).concat(setupFunctionBody).join('\n');
-
-    buildCallbackBody = "return function(" + buildCallbackParameters.join(', ') + "){\n" + buildCallbackBody + "\n};";
-
-    this.buildCallback = FunctionCompiler.INSTANCE.compile({
-        args: ['$settings', '$systems'],
-        code: buildCallbackBody
-    });
-};
-
-export default Blueprint;

package/src/engine/ecs/storage/json/EntityFactory.js

@@ -1,207 +0,0 @@
-/**
- * Created by Alex on 25/08/2015.
- */
-import { FunctionCompiler } from "../../../../core/function/FunctionCompiler.js";
-
-
-function ComponentSpec(options) {
-    this.componentClass = options.componentClass;
-    this.defaults = options.defaults;
-    this.systemId = null;
-}
-
-function EntityFactory() {
-    this.isCompiled = false;
-    this.components = [];
-    this.dataset = null;
-}
-
-/**
- * @param {EntityComponentDataset} dataset
- */
-EntityFactory.prototype.compile = function (dataset) {
-    this.dataset = dataset;
-
-    /**
-     * Signature of generated function:
-     * dataset, callback, ComponentClass0, ComponentClass1, ..., ComponentClassN, options0, options1, ... , optionsN
-     * where options0 to optionsN is a set of options for a specific component identified by N in the same order as they appear in EntityFactory.components
-     */
-    const generatedFunctionParameterNames = ["dataset", "callback"]
-        .concat(this.components.map(function (spec, index) {
-            return varNameComponentClass(index);
-        }))
-        .concat(this.components.map(function (spec, index) {
-            return varNameComponentOptions(index);
-        }));
-
-    //set systemIDs
-    this.components.forEach(function (spec) {
-        spec.systemId = dataset.computeComponentTypeIndex(spec.componentClass);
-    });
-
-    function varNameComponentInstance(index) {
-        return "componentInstance" + index;
-    }
-
-    function varNameComponentClass(index) {
-        return "ComponentClass" + index;
-    }
-
-    function varNameComponentOptions(index) {
-        return "options" + index;
-    }
-
-    const strShallowCopyWithDefaults = [
-        "function shallowCopyWithDefaults(options, defaults){",
-        "       var result = {};",
-        "       var propertyName;",
-        "       for(propertyName in options){",
-        "               if(options.hasOwnProperty(propertyName)){",
-        "                       result[propertyName] = options[propertyName];",
-        "               }",
-        "       }",
-        "       for(propertyName in defaults){",
-        "               if(defaults.hasOwnProperty(propertyName) && !result.hasOwnProperty(propertyName)){",
-        "                       result[propertyName] = defaults[propertyName];",
-        "               }",
-        "       }",
-        "}"
-    ].join("\n");
-
-    //create a function that would generate and populate entity
-    const snipComponentInstancing = this.components.map(function (spec, index) {
-        return "var " + varNameComponentInstance(index) + " = new " + varNameComponentClass(index) + "(" + varNameComponentOptions(index) + ");"
-    }).join("\n");
-
-    //TODO see if we might get some performance boost if we sort instantiation order based on what we know about systems
-    const snipComponentPopulation = this.components.map(function (spec, index) {
-        return "dataset.addComponentToEntityByIndex(entity, " + spec.systemId + ", " + varNameComponentInstance(index) + ");";
-    }).join("\n");
-
-    //
-    const snipComponentInvokeCallback = "if(callback !== void 0){ callback(" + this.components.map(function (spec, index) {
-        return varNameComponentInstance(index);
-    }).join(",") + ");}";
-
-    const snipFunctionBody = [
-        //header
-        strShallowCopyWithDefaults,
-        //instantiate all components with correct options
-        snipComponentInstancing,
-        snipComponentInvokeCallback,
-        //create entity
-        "var entity = dataset.createEntity();",
-        //populate with components
-        snipComponentPopulation,
-        //finaly return entity
-        "return entity;"
-    ].join("\n");
-
-    this.compiledFunction = FunctionCompiler.INSTANCE.compile({
-        args: generatedFunctionParameterNames,
-        code: snipFunctionBody
-    });
-
-    //pre-compute first part of parameters
-    this.compiledFunctionParams = [dataset, null]
-        .concat(this.components.map(function (spec) {
-            return spec.componentClass;
-        }))
-        .concat(this.components.map(function (spec) {
-            return spec.defaults;
-        }));
-
-    this.isCompiled = true;
-
-    return this;
-};
-
-EntityFactory.prototype.hasComponent = function (componentClass) {
-    return this.getComponentSpec(componentClass) !== void 0;
-};
-
-EntityFactory.prototype.getComponentSpec = function (componentClass) {
-    let i = 0;
-    const l = this.components.length;
-    for (; i < l; i++) {
-        const spec = this.components[i];
-        if (spec.componentClass === componentClass) {
-            return spec;
-        }
-    }
-};
-
-EntityFactory.prototype.setDefaults = function (componentClass, defaults) {
-    const spec = this.getComponentSpec(componentClass);
-    if (spec !== void 0) {
-        spec.defaults = defaults;
-    }
-};
-
-/**
- *
- * @param {function} componentClass
- * @param {*} [defaults]
- * @returns {EntityFactory}
- */
-EntityFactory.prototype.add = function (componentClass, defaults) {
-    let spec = this.getComponentSpec(componentClass);
-    if (spec === void 0) {
-        //component is not registered yet
-        spec = new ComponentSpec({
-            componentClass: componentClass,
-            defaults: defaults
-        });
-        this.components.push(spec);
-    } else {
-        //just set the defaults
-        spec.defaults = defaults;
-    }
-    return this;
-};
-
-/**
- *
- * @param {Object} json
- * @param {EntityComponentDataset} dataset
- */
-EntityFactory.prototype.fromJSON = function (json, dataset) {
-    let i = 0;
-    const l = json.length;
-    for (; i < l; i++) {
-        const element = json[i];
-        const typeName = element.type;
-        const componentClass = dataset.getComponentClassByName(typeName);
-
-        if (componentClass === null) {
-            throw new Error('Failed to find class with name "' + typeName + '"');
-        }
-
-        const parameters = element.parameters;
-
-        this.add(componentClass, parameters);
-    }
-};
-
-EntityFactory.prototype.__getComponentSpecIndexByClass = function (componentClass) {
-    let i = 0;
-    const l = this.components.length;
-    for (; i < l; i++) {
-        const spec = this.components[i];
-        if (spec.componentClass === componentClass) {
-            return i;
-        }
-    }
-};
-
-/**
- * @param {callback} callback
- */
-EntityFactory.prototype.create = function (callback) {
-    const params = this.compiledFunctionParams;
-    params[1] = callback;
-    return this.compiledFunction.apply(null, params);
-};
-
-export default EntityFactory;

package/src/engine/ecs/storage/json/JSONDeSerializer.js

@@ -1,148 +0,0 @@
-/**
- * Created by Alex on 12/10/2016.
- */
-
-
-import Blueprint from './Blueprint.js';
-import { assert } from "../../../../core/assert.js";
-import { countTask } from "../../../../core/process/task/util/countTask.js";
-import { emptyTask } from "../../../../core/process/task/util/emptyTask.js";
-
-/**
- *
- * @param {Object<string, Blueprint>} blueprints
- * @param {Object} descriptors
- * @param {EntityManager} entityManager
- * @returns {Task}
- */
-function loadEntitiesByBlueprints(blueprints, descriptors, entityManager) {
-    console.time("populateEntities");
-
-    let task;
-    if (descriptors === undefined) {
-        //return NO-OP equivalent of a task
-        task = emptyTask();
-    } else {
-        task = countTask(0, descriptors.length, function (i) {
-            const descriptor = descriptors[i];
-
-            const bluePrintName = descriptor.blueprint;
-
-            const blueprint = blueprints[bluePrintName];
-
-            if (blueprint === undefined) {
-                console.error(`Could not build build entity, blueprint '${bluePrintName}' not found. Descriptor: `, descriptor, 'skipping...');
-                return;
-            }
-
-            const entity = blueprint.buildEntity(descriptor.parameters);
-
-            //process mixins
-            const mixins = descriptor.mixins;
-            if (typeof mixins === "object") {
-                processMixins(entity, mixins, entityManager);
-            }
-        });
-    }
-
-    task.on.completed.add(function () {
-        console.timeEnd("populateEntities");
-    });
-
-    return task;
-}
-
-/**
- *
- * @param descriptor
- * @param {EntityManager} entityManager
- * @returns {Blueprint}
- */
-function buildBluePrint(descriptor, entityManager) {
-    const blueprint = new Blueprint();
-    blueprint.fromJSON(descriptor, entityManager);
-    blueprint.compile();
-    return blueprint;
-}
-
-/**
- *
- * @param {number} entity
- * @param {Object<string,Object>} mixins
- * @param {EntityManager} entityManager
- */
-function processMixins(entity, mixins, entityManager) {
-    for (let componentTypeName in mixins) {
-        const ComponentClass = entityManager.getComponentClassByName(componentTypeName);
-
-        assert.notEqual(ComponentClass, null, "Component class must not be null");
-        assert.notEqual(ComponentClass, undefined, "Component class must not be undefined");
-        assert.equal(typeof ComponentClass, "object", `Component class must be of type "object", instead was "${typeof ComponentClass}"`);
-
-
-        const component = new ComponentClass();
-        const options = mixins[componentTypeName];
-
-        component.fromJSON(options);
-
-        entityManager.addComponentToEntity(entity, component);
-    }
-}
-
-/**
- *
- * @param descriptors
- * @param {EntityManager} entityManager
- * @returns {Object<string,Blueprint>}
- */
-function buildBlueprints(descriptors, entityManager) {
-    assert.notEqual(descriptors, undefined, 'descriptors are undefined');
-    assert.notEqual(descriptors, null, 'descriptors are null');
-    assert.typeOf(descriptors, 'object', 'descriptors');
-
-    const result = {};
-
-    for (let name in descriptors) {
-        if (descriptors.hasOwnProperty(name)) {
-            const descriptor = descriptors[name];
-
-            let blueprint;
-            try {
-                blueprint = buildBluePrint(descriptor, entityManager);
-            } catch (e) {
-                console.error("Failed to build blueprint '" + name + "'", e);
-                throw e;
-            }
-
-            result[name] = blueprint;
-        }
-    }
-
-    return result;
-}
-
-function JSONDeSerializer() {
-
-}
-
-JSONDeSerializer.buildBluePrint = buildBluePrint;
-
-JSONDeSerializer.buildBlueprints = buildBlueprints;
-
-JSONDeSerializer.loadEntitiesByBlueprints = loadEntitiesByBlueprints;
-
-/**
- *
- * @param {Object} json
- * @param {EntityManager} entityManager
- * @returns {Task}
- */
-JSONDeSerializer.prototype.process = function (json, entityManager) {
-
-    const blueprints = buildBlueprints(json.blueprints, entityManager);
-    const taskLoadEntities = loadEntitiesByBlueprints(blueprints, json.objects, entityManager);
-
-    return taskLoadEntities;
-};
-
-export default JSONDeSerializer;

package/src/engine/ecs/storage/json/JSONSerializer.js

@@ -1,132 +0,0 @@
-/**
- * Created by Alex on 12/10/2016.
- */
-
-
-
-function JSONSerializer() {
-
-}
-
-/**
- *
- * @param {EntityComponentDataset} entityDataset
- * @returns {{blueprints, objects: Array}}
- */
-JSONSerializer.prototype.process = function (entityDataset) {
-    console.time('serializing');
-
-    const blueprintsHash = {};
-    const objects = [];
-
-    let blueprintCount = 0;
-
-    function computeBlueprintHash(components, componentCount) {
-        let hash = "";
-        let i = 0;
-        for (; i < componentCount; i++) {
-            const component = components[i];
-            hash += component.constructor.typeName + "#";
-
-        }
-        return hash;
-    }
-
-    function createBlueprint(components, componentCount) {
-        const blueprint = {};
-        const blueprintComponents = [];
-        let i = 0;
-        for (; i < componentCount; i++) {
-            const component = components[i];
-            const ComponentClass = component.constructor;
-            const typeName = ComponentClass.typeName;
-            if (typeName === undefined) {
-                console.error("typeName is not defined for component class " + ComponentClass);
-            }
-            blueprintComponents.push({
-                type: typeName
-            });
-        }
-        blueprint.components = blueprintComponents;
-        blueprint.id = (blueprintCount++);
-
-        return blueprint;
-    }
-
-    function obtainBlueprint(components, componentCount) {
-        const blueprintId = computeBlueprintHash(components, componentCount);
-
-        let blueprint = blueprintsHash[blueprintId];
-        if (blueprint === undefined) {
-            blueprint = createBlueprint(components, componentCount, blueprintId);
-            blueprintsHash[blueprintId] = blueprint;
-        }
-        return blueprint;
-    }
-
-    function isEmptyObject(o) {
-        let result = true;
-        if (typeof o === 'object') {
-            for (let p in o) {
-                if (o.hasOwnProperty(p)) {
-                    result = false;
-                    break;
-                }
-            }
-        } else {
-            result = false;
-        }
-        return result;
-    }
-
-    const serializableComponentTypes = entityDataset.getComponentTypeMap().filter(function (componentClass) {
-        return componentClass.serializable !== false;
-
-    });
-
-
-    entityDataset.traverseEntitiesCompactedFiltered(serializableComponentTypes, function (entity, components, componentCount) {
-        const blueprint = obtainBlueprint(components, componentCount);
-
-        const objectParameters = {};
-        const object = {
-            blueprint: blueprint.id
-        };
-
-        let i = 0;
-        for (; i < componentCount; i++) {
-            const component = components[i];
-            if (typeof component.toJSON !== 'function') {
-                console.error("toJSON is not a function", component);
-                continue;
-            }
-            const json = component.toJSON();
-            if (!isEmptyObject(json)) {
-                objectParameters[component.constructor.typeName] = json;
-            }
-        }
-        if (!isEmptyObject(objectParameters)) {
-            object.parameters = objectParameters;
-        }
-
-        objects.push(object);
-    });
-
-
-    //rebuild blueprints into ID based structure
-    const blueprints = {};
-    for (let h in blueprintsHash) {
-        const blueprint = blueprintsHash[h];
-        blueprints[blueprint.id] = blueprint;
-        //remove id
-        delete blueprint.id;
-    }
-
-    console.timeEnd('serializing');
-    return {
-        blueprints: blueprints,
-        objects: objects
-    };
-};
-
-export default JSONSerializer;

package/src/engine/ecs/storage/json/README.md

@@ -1,5 +0,0 @@
-This is a framework for json serialization/deserialization of `EntityComponentDataset`s
-
-Meep has been using binary format for datasets since ~2017
-
-This is largely obsolete.

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

@@ -1,51 +0,0 @@
-/**
- * Created by Alex on 19/03/2015.
- */
-import { System } from '../System.js';
-import AlignToVelocity from '../components/AlignToVelocity.js';
-import { Transform } from '../transform/Transform.js';
-import Motion from '../components/Motion.js';
-import Vector3 from "../../../core/geom/Vector3.js";
-
-
-class AlignToVelocitySystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [AlignToVelocity];
-    }
-
-    add(aabb, entity) {
-
-    }
-
-    remove(component) {
-    }
-
-    update(timeDelta) {
-        const em = this.entityManager;
-        const MotionType = em.getOwnerSystemIdByComponentClass(Motion);
-        const PhysicsBodyType = em.getOwnerSystemIdByComponentClass(PhysicsBody);
-        const velocity = new Vector3();
-        em.traverseEntities([AlignToVelocity, Transform], function (align, transform, entity) {
-            //find velocity
-            const motion = em.getComponentByType(entity, MotionType);
-            if (motion !== null) {
-                velocity.copy(motion.velocity);
-            } else {
-                const body = em.getComponentByType(entity, PhysicsBodyType);
-                if (body !== null) {
-                    velocity.copy(body.velocity);
-                } else {
-                    return;
-                }
-            }
-            const delta = velocity.sub(transform.position);
-            //set transform rotation based on velocity
-            Transform.adjustRotation(transform.rotation, delta, align.angularSpeed * timeDelta);
-        });
-    }
-}
-
-
-export default AlignToVelocitySystem;