@woosh/meep-engine 2.37.16 → 2.37.19

package/editor/view/ecs/EntityEditor.js

@@ -9,89 +9,14 @@ import ObservedValue from '../../../core/model/ObservedValue.js';
 import LabelView from '../../../view/common/LabelView.js';
 import ButtonView from '../../../view/elements/button/ButtonView.js';
 import DropDownSelectionView from '../../../view/elements/DropDownSelectionView.js';
-
-import TransformController from './components/TransformController.js';
-import MeshController from './components/MeshController.js';
-import { datify } from "../../../view/controller/dat/DatGuiUtils.js";
 import EmptyView from "../../../view/elements/EmptyView.js";
 import { EntityManager, EventType } from "../../../engine/ecs/EntityManager.js";
-import HighlightController from "./components/HighlightController.js";
-import { GridPositionController } from "./components/GridPositionController.js";
-import { ParticleEmitterController } from "./components/particles/ParticleEmitterController.js";
-import { TerrainController } from "./components/TerrainController.js";
-import { TagController } from "./components/TagController.js";
-import { ItemContainerController } from "./components/items/ItemContainerController.js";
-import { FogOfWarRevealerController } from "./components/FogOfWarRevealerController.js";
-import { FogOfWarController } from "./components/FogOfWarController.js";
-import { GeneratedArmyController } from "./components/GeneratedArmyController.js";
-import { ArmyController } from "./components/army/ArmyController.js";
-import { PathFollowerController } from "./components/PathFollowerController.js";
 import ComponentRemoveAction from "../../actions/concrete/ComponentRemoveAction.js";
 import ComponentAddAction from "../../actions/concrete/ComponentAddAction.js";
-import { StoryTriggerSetController } from "./components/story/StoryTriggerSetController.js";
-import { UnitShopController } from "./components/UnitShopController.js";
-import { SoundEmitterController } from "./components/sound/SoundEmitterController.js";
-import { GUIElementController } from "./components/gui/GUIElementController.js";
 import { LineView } from "./components/common/LineView.js";
 import { ComponentControlView } from "./ComponentControlView.js";
-import { HeadsUpDisplayController } from "./components/HeadsUpDisplayController.js";
-import { BlackboardController } from "./components/BlackboardController.js";
-import { GridObstacleController } from "./components/GridObstacleController.js";
-import { AttachmentSocketsController } from "./components/sockets/AttachmentSocketsController.js";
-import { ParticleEmitterSystem } from "../../../engine/graphics/particles/ecs/ParticleEmitterSystem.js";
-
-/**
- *
- * @param {ComponentControlFactory} factory
- * @param {Editor} editor
- */
-function prepareComponentFactory(factory, editor) {
-    factory
-        .register('Transform', () => new TransformController())
-        .register('Mesh', () => new MeshController(editor.engine.assetManager))
-        .register('GridPosition', () => new GridPositionController())
-        .register('Name', datify)
-        .register('Tag', () => new TagController())
-        .register('Team', datify)
-        .register('HeadsUpDisplay', () => new HeadsUpDisplayController())
-        .register('GeneratedArmy', () => new GeneratedArmyController())
-        .register('Army', () => new ArmyController({
-            localization: editor.engine.localization,
-            afflictionDatabase: editor.engine.staticKnowledge.afflictions
-        }))
-        .register('ClingToTerrain', datify)
-        .register('Commander', datify)
-        .register('MinimapMarker', datify)
-        .register('Camera', datify)
-        .register('FacingDirection', datify)
-        .register('GridObstacle', () => new GridObstacleController())
-        .register('Terrain', () => new TerrainController(editor.engine.assetManager))
-        .register('TopDownCameraController', datify)
-        .register('Light', datify)
-        .register('FogOfWar', () => new FogOfWarController(editor.engine.entityManager))
-        .register('FogOfWarRevealer', () => new FogOfWarRevealerController())
-        .register('PathFollower', () => new PathFollowerController())
-        .register('Highlight', () => new HighlightController())
-        .register('Blackboard', () => new BlackboardController())
-        .register('StoryTriggerSet', () => new StoryTriggerSetController())
-        .register('UnitShop', () => new UnitShopController())
-        .register('ItemContainer', () => new ItemContainerController({
-            localization: editor.engine.localization,
-            itemDatabase: editor.engine.staticKnowledge.items
-        }))
-        .register('ParticleEmitter', () => {
-            const em = editor.engine.entityManager;
-
-            const particleEmitterSystem = em.getSystem(ParticleEmitterSystem);
-
-            return new ParticleEmitterController(particleEmitterSystem);
-        })
-        .register('SoundEmitter', () => new SoundEmitterController(editor.engine))
-        .register('GUIElement', () => new GUIElementController())
-        .register('ViewportPosition', datify)
-        .register('AttachmentSockets', () => new AttachmentSocketsController())
-    ;
-}
+import { buildObjectEditorFromRegistry } from "../../ecs/component/createObjectEditor.js";
+import { isDefined } from "../../../core/process/matcher/Matchers.js";
 
 
 class EntityEditor extends View {
@@ -122,7 +47,11 @@ class EntityEditor extends View {
 
         const vComponentList = new EmptyView({ classList: ['component-list'] });
 
-        prepareComponentFactory(componentControlFactory, editor);
+        /**
+         *
+         * @type {Map<any, TypeEditor>}
+         */
+        const registry = editor.type_editor_registry;
 
         /**
          *
@@ -130,6 +59,14 @@ class EntityEditor extends View {
          */
         this.componentControllers = new Map();
 
+        /**
+         *
+         * @returns {EntityComponentDataset}
+         */
+        function get_dataset() {
+            return self.entityManager.get().dataset;
+        }
+
         function addComponent(event) {
             if (event.instance === undefined) {
                 return;
@@ -153,13 +90,8 @@ class EntityEditor extends View {
         }
 
         function watchEntity(entity) {
-            /**
-             *
-             * @type {EntityManager}
-             */
-            const entityManager = self.entityManager.get();
 
-            const dataset = entityManager.dataset;
+            const dataset = get_dataset();
 
             if (!dataset.entityExists(entity)) {
                 //doesn't exist, nothing to do
@@ -172,13 +104,8 @@ class EntityEditor extends View {
         }
 
         function unwatchEntity(entity) {
-            /**
-             *
-             * @type {EntityManager}
-             */
-            const entityManager = self.entityManager.get();
 
-            const dataset = entityManager.dataset;
+            const dataset = get_dataset();
 
             if (!dataset.entityExists(entity)) {
                 //doesn't exist, nothing to do
@@ -198,13 +125,15 @@ class EntityEditor extends View {
 
             self.components.reset();
 
-            const entityManager = self.entityManager.get();
 
             /**
              *
              * @type {EntityComponentDataset}
              */
-            const dataset = entityManager.dataset;
+            const dataset = get_dataset();
+
+            unattachedTypes.reset();
+            unattachedTypes.addAll(dataset.getComponentTypeMap().map(a => a.typeName).filter(isDefined));
 
             const components = dataset.getAllComponents(entity);
             components.forEach(function (c) {
@@ -221,74 +150,67 @@ class EntityEditor extends View {
 
         const unattachedTypes = new List();
 
-        function updateList() {
+        /**
+         * @template T
+         * @param {T} component
+         */
+        function handleComponentAdded(component) {
+            let view;
+
+            try {
+                view = buildObjectEditorFromRegistry(component, registry);
+            } catch (e) {
+                view = new LabelView(`ERROR: ${e.message}\n${e.stack}`);
+
+                console.warn('Failed to build editor', e);
+            }
+
+            if (!view) {
+                view = new LabelView('EMPTY');
+            }
+
             /**
              *
              * @type {EntityManager}
              */
-            const em = self.entityManager.get();
-
-            //all systems
-            const allTypeNames = em.getComponentTypeMap()
-                .map(c => c.typeName)
-                .filter(typeName => typeof typeName === "string")
-                .sort();
-
-            function has(typeName) {
-                let result = false;
-
-                self.components.visitFirstMatch(c => c.constructor.typeName === typeName, () => result = true);
+            const entityManager = self.entityManager.getValue();
 
-                return result;
-            }
+            const entityId = self.model.getValue();
 
-            //remove already attached
-            const unattachedTypeNames = allTypeNames.filter(typeName => !has(typeName));
+            const vBody = new EmptyView({
+                classList: ['body']
+            });
+            vBody.addChild(view);
 
-            unattachedTypes.reset();
-            unattachedTypes.addAll(unattachedTypeNames);
-        }
+            const controlView = new ComponentControlView(entityId, component, entityManager, vBody);
 
-        /**
-         * @template T
-         * @param {T} component
-         */
-        function handleComponentAdded(component) {
-            // console.log("handleComponentAdded",c);
             const Klass = component.constructor;
-            if (!self.componentControllers.has(Klass)) {
-                /**
-                 *
-                 * @type {EntityManager}
-                 */
-                const entityManager = self.entityManager.getValue();
 
-                const entityId = self.model.getValue();
+            controlView.signal.remove.add(function () {
 
-                const controlView = new ComponentControlView(entityId, component, entityManager, componentControlFactory);
+                editor.actions.mark('Remove Component');
+                editor.actions.do(new ComponentRemoveAction(entityId, Klass));
+            });
 
-                controlView.signal.remove.add(function () {
 
-                    editor.actions.mark('Remove Component');
-                    editor.actions.do(new ComponentRemoveAction(entityId, Klass));
-                });
+            vComponentList.addChild(controlView);
+            self.componentControllers.set(component, controlView);
 
+            unattachedTypes.removeOneOf(Klass.typeName);
 
-                self.componentControllers.set(Klass, controlView);
-                vComponentList.addChild(controlView);
-            }
-            updateList();
         }
 
         function handleComponentRemoved(c) {
             // console.log("handleComponentRemoved",c);
-            const key = c.constructor;
-            if (self.componentControllers.has(key)) {
-                const controlView = self.componentControllers.get(key);
-                self.componentControllers.delete(key);
+            if (self.componentControllers.has(c)) {
+                const controlView = self.componentControllers.get(c);
+                self.componentControllers.delete(c);
                 vComponentList.removeChild(controlView);
+
+                const Klass = c.constructor;
+
+                unattachedTypes.add(Klass.typeName);
             }
-            updateList();
         }
 
         this.components.on.added.add(handleComponentAdded);

package/editor/view/ecs/components/GridObstacleController.js

@@ -12,7 +12,7 @@ import Vector2 from "../../../../core/geom/Vector2.js";
  * @param {GridObstacle} grid
  * @param {HTMLCanvasElement} canvas
  */
-function buildPreview(grid, canvas) {
+export function buildGridObstaclePreview(grid, canvas) {
     const source = new Sampler2D(grid.data, 1, grid.size.x, grid.size.y);
 
     const target = Sampler2D.uint8(1, canvas.width, canvas.height);
@@ -43,7 +43,7 @@ export class GridObstacleController extends View {
 
             vPreview.size.set(200, 200);
 
-            buildPreview(model, vPreview.el);
+            buildGridObstaclePreview(model, vPreview.el);
 
             self.addChild(vPreview);
 
@@ -57,13 +57,13 @@ export class GridObstacleController extends View {
 
             controller.add(proxy, 'size');
             controller.addAction(() => {
-                buildPreview(model, vPreview.el);
+                buildGridObstaclePreview(model, vPreview.el);
             }, 'update preview');
 
             proxy.size.onChanged.add((x, y) => {
                 model.resize(x, y);
 
-                buildPreview(model, vPreview.el);
+                buildGridObstaclePreview(model, vPreview.el);
             });
         }
 

package/editor/view/ecs/components/TerrainController.js

@@ -170,7 +170,7 @@ export class TerrainController extends View {
 
             if (model !== null) {
                 controller.addAction(() => {
-                    model.tiles.rebuild();
+                    model.__tiles.rebuild();
                 }, 'Rebuild');
 
                 controller.addAction(() => {

package/editor/view/ecs/components/common/NumberController.js

@@ -5,17 +5,19 @@ export class NumberController extends View {
     /**
      *
      * @param {string[]} [classList]
+     * @param {number} [value]
+     * @param figures
      */
-    constructor({ classList = [] } = {}) {
+    constructor({ classList = [], value = 0, figures = 6 } = {}) {
         super();
 
-        const value = new Vector1(0);
+        const _value = new Vector1(value);
 
         /**
          *
          * @type {Vector1}
          */
-        this.value = value;
+        this.value = _value;
 
         const el = document.createElement('input');
         this.el = el;
@@ -23,6 +25,8 @@ export class NumberController extends View {
         classList.forEach(c => this.addClass(c));
 
         el.setAttribute('type', 'text');
+        el.setAttribute('spellcheck', false);
+        el.setAttribute('size', 2);
 
         el.classList.add('ui-number-controller');
 
@@ -30,23 +34,31 @@ export class NumberController extends View {
 
         function data2view() {
 
-            if(lockForward){
+            if (lockForward) {
                 return;
             }
 
-            el.value = value.getValue();
+            const num_value = _value.getValue();
+
+            let str = num_value;
+
+            if (Math.abs(num_value) > 0 && Math.abs(num_value % 1).toString().length > (figures + 2)) {
+                str = num_value.toFixed(figures);
+            }
+
+            el.value = str;
 
         }
 
         function view2data() {
             lockForward = true;
 
-            value.set(parseFloat(el.value));
+            _value.set(parseFloat(el.value));
 
             lockForward = false;
         }
 
-        value.process(data2view);
+        _value.process(data2view);
 
         el.addEventListener('input', view2data);
     }

package/engine/animation/keyed2/AnimationTrack.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import { isTypedArray } from "../../../core/json/JsonUtils.js";
+import { isTypedArray } from "../../../core/collection/array/typed/isTypedArray.js";
 
 /**
  *

package/engine/asset/AssetManager.js

@@ -409,7 +409,7 @@ AssetManager.prototype.registerLoader = async function (type, loader) {
         if (existing_loader === loader) {
             // all is well, already registered
             return existing_loader;
-        } else if (existing_loader.__proto__ === loader.__proto__) {
+        } else if (Object.getPrototypeOf(existing_loader) === Object.getPrototypeOf(loader)) {
             console.warn(`Another instance of this loader is already registered for type '${type}'. Ignoring.`);
             return existing_loader;
         } else {

package/engine/ecs/EntityBlueprint.js

@@ -87,7 +87,7 @@ export class EntityBlueprint {
      * @param {Object} component
      */
     add(component) {
-        const constructor = component.__proto__.constructor;
+        const constructor = Object.getPrototypeOf(component).constructor;
 
         this.addJSON(constructor, component.toJSON());
     }

package/engine/ecs/EntityBuilder.js

@@ -118,7 +118,7 @@ class EntityBuilder {
         for (let i = n - 1; i >= 0; i--) {
             const component = elements[i];
 
-            this.removeComponent(component.__proto__.constructor);
+            this.removeComponent(Object.getPrototypeOf(component).constructor);
         }
     }
 
@@ -132,7 +132,7 @@ class EntityBuilder {
             throw new Error("Can not add " + componentInstance + " to EntityBuilder");
         }
 
-        assert.notOk(this.getComponent(componentInstance.__proto__.constructor) !== null, 'Component of this type already exists');
+        assert.notOk(this.getComponent(Object.getPrototypeOf(componentInstance).constructor) !== null, 'Component of this type already exists');
 
         this.element.push(componentInstance);
 

package/engine/ecs/EntityManager.js

@@ -478,7 +478,7 @@ EntityManager.prototype.addSystem = async function (system) {
     assert.defined(system, "system");
     assert.isInstanceOf(system, System, 'system', 'System');
 
-    const existing = this.getSystem(system.__proto__.constructor);
+    const existing = this.getSystem(Object.getPrototypeOf(system).constructor);
 
     if (existing !== null) {
         if (existing === system) {

package/engine/ecs/components/TagEditor.js

@@ -0,0 +1,15 @@
+import { ObjectEditor } from "../../../editor/ecs/component/editors/primitive/ObjectEditor.js";
+
+export class TagEditor extends ObjectEditor {
+    get schema() {
+        return {
+            additionalProperties: false,
+            properties: {
+                values: {
+                    type: Array,
+                    type_parameters: [String]
+                }
+            }
+        };
+    }
+}

package/engine/ecs/parent/EntityNode.js

@@ -253,6 +253,7 @@ export class EntityNode {
      * @param {EntityComponentDataset} ecd
      */
     build(ecd) {
+        assert.notOk(this.__entity.isBuilt, 'Already built');
 
         // assume that parent is built
         const parent = this.__parent;
@@ -305,6 +306,8 @@ export class EntityNode {
     }
 
     destroy() {
+        assert.ok(this.__entity.isBuilt, 'Not built');
+
         // remove listeners
         this.__transform.position.onChanged.remove(this.__transform_sync_down, this);
         this.__transform.scale.onChanged.remove(this.__transform_sync_down, this);

package/engine/ecs/storage/binary/object/BinaryObjectSerializationAdapter.js

@@ -56,7 +56,7 @@ export class BinaryObjectSerializationAdapter {
         if (className === undefined) {
             //class name is not specified, try to infer it
 
-            const Klass = object.__proto__.constructor;
+            const Klass = Object.getPrototypeOf(object).constructor;
 
             const typeName = Klass.typeName;
 

package/engine/ecs/terrain/ecs/Terrain.js

@@ -173,16 +173,16 @@ class Terrain {
          *
          * @type {WorkerProxy}
          */
-        this.buildWorker = makeTerrainWorkerProxy();
+        this.__buildWorker = makeTerrainWorkerProxy();
 
-        this.tiles = new TerrainTileManager({
+        this.__tiles = new TerrainTileManager({
             material: this.material,
-            buildWorker: this.buildWorker
+            buildWorker: this.__buildWorker
         });
 
-        this.tiles.tileSize.set(TILE_SIZE, TILE_SIZE);
+        this.__tiles.tileSize.set(TILE_SIZE, TILE_SIZE);
 
-        this.tiles.material.set(this.material);
+        this.__tiles.material.set(this.material);
 
         /**
          *
@@ -285,7 +285,7 @@ class Terrain {
         const material = material_handle.getValue();
         this.clouds.addMaterial(material);
 
-        this.tiles.material.set(material);
+        this.__tiles.material.set(material);
 
         this.updateMaterial();
 
@@ -314,7 +314,7 @@ class Terrain {
         // release material handle
         this.__material_reference.release();
 
-        this.tiles.dispose();
+        this.__tiles.dispose();
         this.splat.dispose();
         this.layers.dispose();
 
@@ -428,11 +428,11 @@ class Terrain {
      * @returns {boolean}
      */
     raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ) {
-        if (this.tiles === undefined) {
+        if (this.__tiles === undefined) {
             return false;
         }
 
-        return this.tiles.raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ);
+        return this.__tiles.raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ);
     }
 
     /**
@@ -443,7 +443,7 @@ class Terrain {
      * @param {function} missCallback
      */
     raycast(origin, direction, callback, missCallback) {
-        this.tiles.raycast(origin, direction, callback, missCallback);
+        this.__tiles.raycast(origin, direction, callback, missCallback);
     }
 
     /**
@@ -459,7 +459,7 @@ class Terrain {
         assert.typeOf(missCallback, 'function', 'missCallback');
         assert.typeOf(errorCallback, 'function', 'errorCallback');
 
-        this.tiles.raycastVertical(x, y, callback, missCallback);
+        this.__tiles.raycastVertical(x, y, callback, missCallback);
     }
 
     /**
@@ -470,12 +470,12 @@ class Terrain {
      * @return {boolean}
      */
     raycastVerticalFirstSync(contact, x, y) {
-        if (this.tiles === undefined) {
+        if (this.__tiles === undefined) {
             //tiles don't exist
             return false;
         }
 
-        return this.tiles.raycastVerticalFirstSync(contact, x, y);
+        return this.__tiles.raycastVerticalFirstSync(contact, x, y);
     }
 
     /**
@@ -643,7 +643,7 @@ class Terrain {
          *
          * @type {TerrainTileManager}
          */
-        const tiles = this.tiles;
+        const tiles = this.__tiles;
 
         const promisedTiles = [];
 
@@ -660,25 +660,6 @@ class Terrain {
         return Promise.all(promisedTiles);
     }
 
-    /**
-     * @deprecated use {@link #samplerHeight} instead
-     * @param {Sampler2D} v
-     */
-    set heightMap(v) {
-        this.samplerHeight = v;
-        this.updateHeightTexture();
-
-        console.warn('Deprecated');
-    }
-
-    /**
-     * @deprecated use {@link #samplerHeight} instead
-     * @return {Sampler2D}
-     */
-    get heightMap() {
-        return this.samplerHeight;
-    }
-
     updateMaterial() {
         let m = this.material;
 
@@ -753,24 +734,24 @@ class Terrain {
     }
 
     startBuildService() {
-        this.buildWorker.start();
+        this.__buildWorker.start();
         this.updateWorkerHeights();
     }
 
     async updateWorkerHeights() {
         const s = this.samplerHeight;
-        const worker = this.buildWorker;
+        const worker = this.__buildWorker;
 
         await worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
 
         return await worker.computeHeightRange()
             .then(({ min, max }) => {
-                this.tiles.setHeightRange(min, max);
+                this.__tiles.setHeightRange(min, max);
             });
     }
 
     stopBuildService() {
-        this.buildWorker.stop();
+        this.__buildWorker.stop();
     }
 
     buildGridTransform() {
@@ -816,9 +797,9 @@ class Terrain {
 
         this.overlay.tileImage.set(MeepSettings.ecs.Terrain['tile-decal']);
 
-        this.tiles.totalSize.copy(this.size);
-        this.tiles.scale.set(this.gridScale, this.gridScale);
-        this.tiles.resolution.set(this.resolution);
+        this.__tiles.totalSize.copy(this.size);
+        this.__tiles.scale.set(this.gridScale, this.gridScale);
+        this.__tiles.resolution.set(this.resolution);
 
         if (this.__legacyMaterialSpec !== null) {
             this.buildFromLegacy(assetManager);
@@ -855,9 +836,9 @@ class Terrain {
          * @type {Promise<TerrainTileManager>}
          * @deprecated
          */
-        this.pTiles = Promise.resolve(this.tiles);
+        this.pTiles = Promise.resolve(this.__tiles);
 
-        this.tiles.initialize();
+        this.__tiles.initialize();
 
         this.updateMaterial();