@woosh/meep-engine 2.37.18 → 2.38.0

package/editor/Editor.js

@@ -23,7 +23,9 @@ import EditorEntitySystem from "./ecs/EditorEntitySystem.js";
 import EditorEntity from "./ecs/EditorEntity.js";
 import TopDownCameraController from "../engine/graphics/ecs/camera/topdown/TopDownCameraController.js";
 import { Transform } from "../engine/ecs/transform/Transform.js";
-import TopDownCameraControllerSystem, { setCameraControllerFromTransform } from "../engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import TopDownCameraControllerSystem, {
+    setCameraControllerFromTransform
+} from "../engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
 import { downloadAsFile } from "../core/binary/ByteArrayTools.js";
 import BinaryBufferSerializer from "../engine/ecs/storage/BinaryBufferSerializer.js";
 import { EncodingBinaryBuffer } from "../core/binary/EncodingBinaryBuffer.js";
@@ -31,6 +33,41 @@ import { EntityComponentDataset } from "../engine/ecs/EntityComponentDataset.js"
 import InputControllerSystem from "../engine/input/ecs/systems/InputControllerSystem.js";
 import { assert } from "../core/assert.js";
 import { resetSoundEmitterTracks } from "../../model/game/options/resetSoundEmitterTracks.js";
+import { NumberEditor } from "./ecs/component/editors/primitive/NumberEditor.js";
+import { BooleanEditor } from "./ecs/component/editors/primitive/BooleanEditor.js";
+import { StringEditor } from "./ecs/component/editors/primitive/StringEditor.js";
+import { FunctionEditor } from "./ecs/component/editors/primitive/FunctionEditor.js";
+import { ArrayEditor } from "./ecs/component/editors/primitive/ArrayEditor.js";
+import { ObjectEditor } from "./ecs/component/editors/primitive/ObjectEditor.js";
+import { NumericInterval } from "../core/math/interval/NumericInterval.js";
+import { NumericIntervalEditor } from "./ecs/component/editors/NumericIntervalEditor.js";
+import { ListEditor } from "./ecs/component/editors/collection/ListEditor.js";
+import ObservedBoolean from "../core/model/ObservedBoolean.js";
+import { ObservedBooleanEditor } from "./ecs/component/editors/ObservedBooleanEditor.js";
+import ObservedEnum from "../core/model/ObservedEnum.js";
+import { ObservedEnumEditor } from "./ecs/component/editors/ObservedEnumEditor.js";
+import { Color } from "../core/color/Color.js";
+import { ColorEditor } from "./ecs/component/editors/ColorEditor.js";
+import Vector4 from "../core/geom/Vector4.js";
+import { Vector4Editor } from "./ecs/component/editors/geom/Vector4Editor.js";
+import Vector3 from "../core/geom/Vector3.js";
+import { Vector3Editor } from "./ecs/component/editors/geom/Vector3Editor.js";
+import Vector2 from "../core/geom/Vector2.js";
+import { Vector2Editor } from "./ecs/component/editors/geom/Vector2Editor.js";
+import Vector1 from "../core/geom/Vector1.js";
+import { Vector1Editor } from "./ecs/component/editors/geom/Vector1Editor.js";
+import ObservedString from "../core/model/ObservedString.js";
+import { ObservedStringEditor } from "./ecs/component/editors/ObservedStringEditor.js";
+import Quaternion from "../core/geom/Quaternion.js";
+import { QuaternionEditor } from "./ecs/component/editors/geom/QuaternionEditor.js";
+import { Sampler2D } from "../engine/graphics/texture/sampler/Sampler2D.js";
+import { Sampler2DEditor } from "./ecs/component/editors/Sampler2DEditor.js";
+import { HTMLElementEditor } from "./ecs/component/editors/HTMLElementEditor.js";
+import WorkerProxy from "../core/process/worker/WorkerProxy.js";
+import { noEditor } from "./ecs/component/editors/common/noEditor.js";
+import Signal from "../core/events/signal/Signal.js";
+import ObservedInteger from "../core/model/ObservedInteger.js";
+import { ObservedIntegerEditor } from "./ecs/component/editors/ObservedIntegerEditor.js";
 
 
 /**
@@ -301,6 +338,57 @@ function activateEditorCamera(cameraEntity, dataset, editor) {
     camera.active.set(true);
 }
 
+/**
+ *
+ * @param {Map<any, TypeEditor>} registry
+ */
+function initialize_basic_registry(registry) {
+
+    registry.set(Number, new NumberEditor());
+    registry.set(Boolean, new BooleanEditor());
+    registry.set(String, new StringEditor());
+    registry.set(Function, new FunctionEditor());
+    registry.set(Array, new ArrayEditor());
+    registry.set(Object, new ObjectEditor());
+
+    registry.set(ObservedInteger, new ObservedIntegerEditor());
+    registry.set(ObservedBoolean, new ObservedBooleanEditor());
+    registry.set(ObservedEnum, new ObservedEnumEditor());
+    registry.set(ObservedString, new ObservedStringEditor());
+
+    registry.set(NumericInterval, new NumericIntervalEditor());
+    registry.set(List, new ListEditor());
+    registry.set(Color, new ColorEditor());
+
+    registry.set(Vector4, new Vector4Editor());
+    registry.set(Vector3, new Vector3Editor());
+    registry.set(Vector2, new Vector2Editor());
+    registry.set(Vector1, new Vector1Editor());
+    registry.set(Quaternion, new QuaternionEditor());
+
+    registry.set(Sampler2D, new Sampler2DEditor());
+
+    registry.set(HTMLElement, new HTMLElementEditor());
+    registry.set(HTMLCanvasElement, new HTMLElementEditor());
+
+    registry.set(WorkerProxy, noEditor());
+    registry.set(Signal, noEditor());
+
+    registry.set(Uint8Array, noEditor());
+    registry.set(Uint16Array, noEditor());
+    registry.set(Uint32Array, noEditor());
+
+    registry.set(Int8Array, noEditor());
+    registry.set(Int16Array, noEditor());
+    registry.set(Int32Array, noEditor());
+
+    registry.set(Float32Array, noEditor());
+    registry.set(Float64Array, noEditor());
+
+    registry.set(CanvasRenderingContext2D, noEditor());
+
+}
+
 /**
  *
  * @constructor
@@ -315,6 +403,14 @@ function Editor() {
     this.selectionVistualizer = new SelectionVisualizer(this);
     this.meshLibrary = new MeshLibrary();
 
+    /**
+     *
+     * @type {Map<any, TypeEditor>}
+     */
+    this.type_editor_registry = new Map();
+
+    initialize_basic_registry(this.type_editor_registry);
+
     this.cameraEntity = buildEditorCamera();
 
     this.editorEntitySystem = new EditorEntitySystem();

package/editor/actions/concrete/ModifyPatchSampler2DAction.js

@@ -0,0 +1,118 @@
+import { Action } from "../../../core/process/undo/Action.js";
+import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
+
+export class ModifyPatchSampler2DAction extends Action {
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @param {number[]} bounds
+     */
+    constructor(sampler, bounds) {
+        super();
+
+        /**
+         *
+         * @type {Sampler2D}
+         * @private
+         */
+        this.__sampler = sampler;
+
+        /**
+         *
+         * @type {number[]}
+         * @private
+         */
+        this.__bounds = bounds;
+
+        const width = this.__bounds[2] - this.__bounds[0];
+        const height = this.__bounds[3] - this.__bounds[1];
+
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        this.__patch_new = Sampler2D.float32(sampler.itemSize, width, height);
+
+        /**
+         *
+         * @type {Sampler2D}
+         * @private
+         */
+        this.__patch_old = Sampler2D.float32(sampler.itemSize, width, height);
+    }
+
+    get patch() {
+        return this.__patch_new;
+    }
+
+    get x() {
+        return this.__bounds[0];
+    }
+
+    get y() {
+        return this.__bounds[1];
+    }
+
+    /**
+     *
+     * @param {number} x coordinate in global space
+     * @param {number} y coordinate in global space
+     * @param {number} [channel]
+     * @returns {number} delta between original value and the new one after the change
+     */
+    computeDelta(x, y, channel = 0) {
+        const _x = x - this.x;
+
+        if (_x < 0 || _x > this.__patch_new.width - 1) {
+            return 0;
+        }
+
+        const _y = y - this.y;
+
+        if (_y < 0 || _y > this.__patch_new.height - 1) {
+            return 0;
+        }
+
+        const value_old = this.__patch_old.sampleChannelBilinear(_x, _y, channel);
+        const value_new = this.__patch_new.sampleChannelBilinear(_x, _y, channel);
+
+        return value_new - value_old;
+    }
+
+    computeByteSize() {
+        return this.__patch_new.computeByteSize() + this.__patch_old.computeByteSize() + 280;
+    }
+
+
+    async apply(context) {
+
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        const source = this.__sampler;
+
+        //store old data from the patch
+        const patch_old = this.__patch_old;
+
+        patch_old.copy_sameItemSize(source, this.x, this.y, 0, 0, patch_old.width, patch_old.height);
+
+        const patch_new = this.__patch_new;
+
+        //apply the patch
+        source.copy_sameItemSize(patch_new, 0, 0, this.x, this.y, patch_new.width, patch_new.height);
+    }
+
+    async revert(context) {
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        const source = this.__sampler;
+
+        const patch_old = this.__patch_old;
+
+        //apply the patch
+        source.copy_sameItemSize(patch_old, 0, 0, this.x, this.y, patch_old.width, patch_old.height);
+    }
+}

package/editor/actions/concrete/ModifyPatchSampler2DAction.spec.js

@@ -0,0 +1,30 @@
+import { ModifyPatchSampler2DAction } from "./ModifyPatchSampler2DAction.js";
+import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
+
+test("apply patch size 0", async () => {
+    const sampler = Sampler2D.uint8(1, 1, 1);
+    sampler.data[0] = 123;
+
+    const action = new ModifyPatchSampler2DAction(sampler, [0, 0, 0, 0]);
+
+    await action.apply();
+
+    expect([...sampler.data]).toEqual([123]);
+});
+
+test("apply patch size 1, fill entire", async () => {
+    const sampler = Sampler2D.uint8(1, 1, 1);
+    sampler.data[0] = 123;
+
+    const action = new ModifyPatchSampler2DAction(sampler, [0, 0, 1, 1]);
+
+    action.patch.data[0] = 42;
+
+    await action.apply();
+
+    expect([...sampler.data]).toEqual([42]);
+
+    await action.revert();
+
+    expect([...sampler.data]).toEqual([123]);
+});

package/editor/actions/concrete/PatchTerrainHeightAction.js

@@ -1,7 +1,6 @@
-import { Action } from "../../../core/process/undo/Action.js";
-import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
+import { ModifyPatchSampler2DAction } from "./ModifyPatchSampler2DAction.js";
 
-export class PatchTerrainHeightAction extends Action {
+export class PatchTerrainHeightAction extends ModifyPatchSampler2DAction {
     /**
      *
      * @param {Terrain} terrain
@@ -11,64 +10,25 @@ export class PatchTerrainHeightAction extends Action {
      * @param {number} height
      */
     constructor(terrain, x, y, width, height) {
-        super();
+        super(terrain.samplerHeight, [x, y, x + width, y + height]);
 
         /**
          *
          * @type {Terrain}
          */
         this.terrain = terrain;
-
-        /**
-         *
-         * @type {Sampler2D}
-         */
-        this.patch = Sampler2D.float32(1, width, height);
-
-        this.x = x;
-        this.y = y;
-
-        this.__oldPatch = Sampler2D.float32(1, width, height);
     }
 
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @returns {number}
-     */
-    computeDelta(x, y) {
-
-        const _x = x - this.x;
-
-        if (_x < 0 || _x > this.patch.width - 1) {
-            return 0;
-        }
-
-        const _y = y - this.y;
-
-        if (_y < 0 || _y > this.patch.height - 1) {
-            return 0;
-        }
-
-        const sourceValue = this.__oldPatch.sampleChannelBilinear(_x, _y, 0);
-        const targetValue = this.patch.sampleChannelBilinear(_x, _y, 0);
-
-
-        return targetValue - sourceValue;
-    }
-
-    computeByteSize() {
-        return this.patch.computeByteSize() + this.__oldPatch.computeByteSize() + 280;
-    }
-
-    updateTerrain() {
+    async updateTerrain() {
         /**
          *
          * @type {Terrain}
          */
         const terrain = this.terrain;
 
+        terrain.updateHeightTexture();
+        terrain.updateWorkerHeights();
+
         /**
          *
          * @type {Sampler2D}
@@ -79,11 +39,7 @@ export class PatchTerrainHeightAction extends Action {
          *
          * @type {TerrainTileManager}
          */
-        const tiles = terrain.tiles;
-
-        tiles.buildWorker.setHeightSampler(heightMap.data, heightMap.itemSize, heightMap.width, heightMap.height);
-
-        const terrainSize = terrain.size;
+        const tiles = terrain.__tiles;
 
         const x = this.x;
         const y = this.y;
@@ -94,66 +50,18 @@ export class PatchTerrainHeightAction extends Action {
         const v0 = y / heightMap.height;
         const v1 = (y + this.patch.height) / heightMap.height;
 
-        const tx0 = u0 * terrainSize.x;
-        const tx1 = u1 * terrainSize.x;
-
-        const ty0 = v0 * terrainSize.y;
-        const ty1 = v1 * terrainSize.y;
-
-        const dirtyTiles = tiles.getRawTilesOverlappingRectangle(tx0 - 1, ty0 - 1, tx1 + 1, ty1 + 1);
-
-        dirtyTiles.forEach(tile => {
-            tile.isBuilt = false;
-        });
-
-        terrain.heightTexture.needsUpdate = true;
+        tiles.rebuildTilesByUV(u0, v0, u1, v1);
     }
 
     async apply(context) {
+        await super.apply(context);
 
-        /**
-         *
-         * @type {Terrain}
-         */
-        const terrain = this.terrain;
-
-        /**
-         *
-         * @type {Sampler2D}
-         */
-        const heightMap = terrain.heightMap;
-
-        //store old data from the patch
-        const oldPatch = this.__oldPatch;
-
-        oldPatch.copy_sameItemSize(heightMap, this.x, this.y, 0, 0, oldPatch.width, oldPatch.height);
-
-        const patch = this.patch;
-        //apply the patch
-        heightMap.copy_sameItemSize(patch, 0, 0, this.x, this.y, patch.width, patch.height);
-
-        this.updateTerrain();
+        await this.updateTerrain();
     }
 
     async revert(context) {
+        await super.revert(context);
 
-        /**
-         *
-         * @type {Terrain}
-         */
-        const terrain = this.terrain;
-
-        /**
-         *
-         * @type {Sampler2D}
-         */
-        const heightMap = terrain.heightMap;
-
-        const patch = this.__oldPatch;
-
-        //apply the patch
-        heightMap.copy_sameItemSize(patch, 0, 0, this.x, this.y, patch.width, patch.height);
-
-        this.updateTerrain();
+        await this.updateTerrain();
     }
 }

package/editor/ecs/component/FieldDescriptor.js

@@ -0,0 +1,34 @@
+/**
+ * @template T
+ */
+export class FieldDescriptor {
+    constructor() {
+        /**
+         *
+         * @type {string}
+         */
+        this.name = "";
+
+        /**
+         * typeof field
+         * @type {Class<T>}
+         */
+        this.type = null;
+
+        /**
+         *
+         * @type {FieldValueAdapter|null}
+         */
+        this.adapter = null;
+
+        /**
+         *
+         * @type {{}|undefined}
+         */
+        this.schema = undefined;
+    }
+
+    toString() {
+        return `FieldDescriptor[name='${this.name}']`;
+    }
+}

package/editor/ecs/component/FieldValueAdapter.js

@@ -0,0 +1,20 @@
+import { assert } from "../../../core/assert.js";
+
+export class FieldValueAdapter {
+    constructor() {
+        this.writable = true;
+        this.readable = true;
+
+    }
+
+    read(object, field_name) {
+        assert.isString(field_name, 'field_name');
+
+
+        return object[field_name];
+    }
+
+    write(object, field_name, value) {
+        object[field_name] = value;
+    }
+}

package/editor/ecs/component/TypeEditor.js

@@ -0,0 +1,33 @@
+/**
+ * @class
+ * @template T
+ */
+export class TypeEditor {
+    inline = true;
+
+    /**
+     * Class is hidden and editor should not be displayed
+     * @returns {boolean}
+     */
+    get hidden() {
+        return false;
+    }
+
+    /**
+     *
+     * @returns {TypeSchema|undefined}
+     */
+    get schema() {
+        return undefined;
+    }
+
+    /**
+     * @param {*} parent
+     * @param {FieldDescriptor} field
+     * @param {Map<*, TypeEditor>} registry
+     * @returns {View|void}
+     */
+    build(parent, field, registry) {
+        throw new Error('Not Implemented');
+    }
+}

package/editor/ecs/component/TypeSchema.d.ts

@@ -0,0 +1,38 @@
+import {DataType} from "../../../core/parser/simple/DataType";
+
+interface Type<T> extends Function {
+    new(...args: any[]): T;
+}
+
+interface PropertiesSchema {
+    [key: string]: FieldSchema<any>;
+}
+
+export interface TypeSchema {
+    additionalProperties?: boolean
+    properties: PropertiesSchema
+}
+
+interface TypeEditor {
+
+}
+
+export interface FieldSchema<T> {
+    type: Type<T>
+    type_parameters?: any[]
+    transient?: boolean
+    description?: string,
+    editor?: TypeEditor
+    deprecated?: boolean,
+    enum?: T[],
+    numeric_type: DataType,
+    /**
+     * Small image to be displayed next to field name
+     */
+    thumbnail: string,
+    /**
+     * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#section-6.2.2
+     */
+    maximum?: number,
+    minimum?: number
+}

package/editor/ecs/component/createFieldEditor.js

@@ -0,0 +1,90 @@
+import EmptyView from "../../../view/elements/EmptyView.js";
+import LabelView from "../../../view/common/LabelView.js";
+
+function format_field_name(name) {
+    return name
+        .replace(/([a-z])([A-Z])/g, '$1 $2') // break up camel case
+        .replace(/([^.])_([^.])/g, '$1 $2') // break up underscore case
+        .replace(/(^\w{1})|(\s+\w{1})/g, letter => letter.toUpperCase()); // capitalize every word
+}
+
+/**
+ * @template CTX
+ * @param {Object} object
+ * @param {FieldDescriptor} field
+ * @param {Map<*, TypeEditor>} registry
+ */
+export function createFieldEditor(object, field, registry) {
+
+    const field_schema = field.schema;
+
+    let vValue;
+
+    /**
+     * @type {TypeEditor}
+     */
+    let factory;
+    if (field_schema !== undefined) {
+        const specific_field_editor = field_schema.editor;
+
+        if (specific_field_editor !== undefined) {
+            // field has a dedicated editor
+            factory = specific_field_editor;
+        }
+    }
+
+    if (factory === undefined) {
+        factory = registry.get(field.type);
+    }
+
+    let orientation_inline = true;
+
+    if (factory !== undefined) {
+        if (factory.hidden) {
+            // hidden class
+            return null;
+        }
+
+        vValue = factory.build(object, field, registry);
+
+        if (vValue) {
+            orientation_inline = factory.inline;
+        }
+    }
+
+    if (vValue === null || vValue === undefined) {
+        // no view
+        return null;
+    }
+
+    const vResult = new EmptyView({
+        classList: ['auto-field-editor']
+    });
+
+    if (orientation_inline) {
+        vResult.addClass('orientation-inline');
+    }
+
+    const field_formatted_name = format_field_name(field.name);
+
+    const vLabel = new LabelView(field_formatted_name, { classList: ['field-name'] });
+
+    vResult.addChild(vLabel);
+    vResult.addChild(vValue);
+
+
+    if (field_schema !== undefined) {
+        if (field_schema.description !== undefined && field_schema.description.length > 0) {
+            // add tooltip
+            vLabel.attr({
+                title: field_schema.description
+            });
+        }
+
+        if (field_schema.deprecated) {
+            vResult.addClass('field-deprecated');
+        }
+    }
+
+    return vResult;
+}