@woosh/meep-engine 2.37.18 → 2.37.19

package/core/geom/Vector3.schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema",
+  "title": "Vector3",
+  "type": "object",
+  "properties": {
+    "x": {
+      "type": "number"
+    },
+    "y": {
+      "type": "number"
+    },
+    "z": {
+      "type": "number"
+    }
+  }
+}

package/core/json/JsonUtils.js

@@ -2,24 +2,7 @@
  * Created by Alex on 03/11/2016.
  */
 
-/**
- *
- * @param o
- * @returns {boolean}
- */
-function isTypedArray(o) {
-    return (
-        o instanceof Int8Array ||
-        o instanceof Uint8Array ||
-        o instanceof Uint8ClampedArray ||
-        o instanceof Int16Array ||
-        o instanceof Uint16Array ||
-        o instanceof Int32Array ||
-        o instanceof Uint32Array ||
-        o instanceof Float32Array ||
-        o instanceof Float64Array
-    );
-}
+import { isTypedArray } from "../collection/array/typed/isTypedArray.js";
 
 /**
  *
@@ -114,6 +97,5 @@ function stringify(json) {
 
 export {
     stringify,
-    stringifyStream,
-    isTypedArray
+    stringifyStream
 };

package/core/model/ObservedEnum.js

@@ -22,6 +22,14 @@ function ObservedEnum(value, validSet) {
     this.onChanged = new Signal();
 }
 
+/**
+ *
+ * @returns {Object<string, T>}
+ */
+ObservedEnum.prototype.getValidValueSet = function () {
+    return this.__validSet;
+}
+
 /**
  *
  * @param {T} value

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/PatchTerrainHeightAction.js

@@ -79,7 +79,7 @@ export class PatchTerrainHeightAction extends Action {
          *
          * @type {TerrainTileManager}
          */
-        const tiles = terrain.tiles;
+        const tiles = terrain.__tiles;
 
         tiles.buildWorker.setHeightSampler(heightMap.data, heightMap.itemSize, heightMap.width, heightMap.height);
 

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;
+}