@woosh/meep-engine 2.37.16 → 2.37.19

package/core/geom/Quaternion.js

@@ -7,9 +7,8 @@ import { Matrix4 as ThreeMatrix4 } from "three";
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
-import { copysign } from "../math/copysign.js";
 import { lerp } from "../math/lerp.js";
-import { EPSILON, epsilonEquals, PI2, PI_HALF } from "../math/MathUtils.js";
+import { EPSILON, epsilonEquals, PI2 } from "../math/MathUtils.js";
 import Vector3 from "./Vector3.js";
 import { v3_dot } from "./v3_dot.js";
 
@@ -503,84 +502,33 @@ class Quaternion {
 
         // http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
 
-        const cos = Math.cos;
-        const sin = Math.sin;
-
-        const half_x = x * 0.5;
-        const half_y = y * 0.5;
-        const half_z = z * 0.5;
-
-        const c1 = cos(half_x);
-        const c2 = cos(half_y);
-        const c3 = cos(half_z);
-
-        const s1 = sin(half_x);
-        const s2 = sin(half_y);
-        const s3 = sin(half_z);
-
         if (order === 'XYZ') {
 
-            return this.set(
-                s1 * c2 * c3 + c1 * s2 * s3,
-                c1 * s2 * c3 - s1 * c2 * s3,
-                c1 * c2 * s3 + s1 * s2 * c3,
-                c1 * c2 * c3 - s1 * s2 * s3
-            );
+            this.fromEulerAnglesXYZ(x, y, z);
 
         } else if (order === 'YXZ') {
 
-
-            return this.set(
-                s1 * c2 * c3 + c1 * s2 * s3,
-                c1 * s2 * c3 - s1 * c2 * s3,
-                c1 * c2 * s3 - s1 * s2 * c3,
-                c1 * c2 * c3 + s1 * s2 * s3
-            );
-
-            // return this.set(
-            //     c1 * s2 * c3 + s1 * c2 * s3,
-            //     s1 * c2 * c3 - c1 * s2 * s3,
-            //     c1 * c2 * s3 - s1 * s2 * c3,
-            //     c1 * c2 * c3 + s1 * s2 * s3
-            // );
+            this.fromEulerAnglesYXZ(x, y, z);
 
         } else if (order === 'ZXY') {
 
-            return this.set(
-                s1 * c2 * c3 - c1 * s2 * s3,
-                c1 * s2 * c3 + s1 * c2 * s3,
-                c1 * c2 * s3 + s1 * s2 * c3,
-                c1 * c2 * c3 - s1 * s2 * s3
-            );
+            this.fromEulerAnglesZXY(x, y, z);
 
         } else if (order === 'ZYX') {
 
-            return this.set(
-                s1 * c2 * c3 - c1 * s2 * s3,
-                c1 * s2 * c3 + s1 * c2 * s3,
-                c1 * c2 * s3 - s1 * s2 * c3,
-                c1 * c2 * c3 + s1 * s2 * s3
-            );
+            this.fromEulerAnglesZYX(x, y, z);
 
         } else if (order === 'YZX') {
 
-            return this.set(
-                s1 * c2 * c3 + c1 * s2 * s3,
-                c1 * s2 * c3 + s1 * c2 * s3,
-                c1 * c2 * s3 - s1 * s2 * c3,
-                c1 * c2 * c3 - s1 * s2 * s3
-            );
+            this.fromEulerAnglesYZX(x, y, z);
 
         } else if (order === 'XZY') {
 
-            return this.set(
-                s1 * c2 * c3 - c1 * s2 * s3,
-                c1 * s2 * c3 - s1 * c2 * s3,
-                c1 * c2 * s3 + s1 * s2 * c3,
-                c1 * c2 * c3 + s1 * s2 * s3
-            );
+            this.fromEulerAnglesXZY(x, y, z);
 
         }
+
+        return this;
     }
 
     /**
@@ -599,9 +547,9 @@ class Quaternion {
         const y2 = y * y;
         const z2 = z * z;
 
-        const psi = Math.atan2(-2 * (x * w - y * z), (w2 - x2 - y2 + z2));
+        const psi = Math.atan2(2 * (x * w - y * z), (w2 - x2 - y2 + z2));
         const theta = Math.asin(2 * (x * z + y * w));
-        const phi = Math.atan2(-2 * (z * w - x * y), (w2 + x2 - y2 - z2));
+        const phi = Math.atan2(2 * (z * w - x * y), (w2 + x2 - y2 - z2));
 
         result.set(psi, theta, phi);
     }
@@ -727,64 +675,75 @@ class Quaternion {
     }
 
     /**
-     * Writes Pitch(Y), Yaw(Z), Roll(X) to a given vector
-     * @param {Vector3} result
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
      */
-    toEulerAngles2(result) {
-        const x = this.x;
-        const y = this.y;
-        const z = this.z;
-        const w = this.w;
+    fromEulerAngles(x, y, z) {
+        return this.fromEulerAnglesXYZ(x, y, z);
+    }
 
-        const yy = y * y;
-        const xx = x * x;
-        const zz = z * z;
+    /**
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
+     */
+    fromEulerAnglesXYZ(x, y, z) {
+        const half_x = x * 0.5;
+        const half_y = y * 0.5;
+        const half_z = z * 0.5;
 
-        // roll (x-axis rotation)
-        const sinr_cosp = +2.0 * (w * x + y * z);
-        const cosr_cosp = +1.0 - 2.0 * (xx + yy);
-        const roll = Math.atan2(sinr_cosp, cosr_cosp);
+        const sin = Math.sin;
+        const cos = Math.cos;
 
-        let pitch;
-        // pitch (y-axis rotation)
-        const sinp = +2.0 * (w * y - z * x);
-        if (Math.abs(sinp) >= 1) {
-            pitch = copysign(Math.PI / 2, sinp); // use 90 degrees if out of range
-        } else {
-            pitch = Math.asin(sinp);
-        }
+        const s1 = sin(half_x);
+        const s2 = sin(half_y);
+        const s3 = sin(half_z);
 
-        // yaw (z-axis rotation)
-        const siny_cosp = +2.0 * (w * z + x * y);
-        const cosy_cosp = +1.0 - 2.0 * (yy + zz);
-        const yaw = Math.atan2(siny_cosp, cosy_cosp);
+        const c1 = cos(half_x);
+        const c2 = cos(half_y);
+        const c3 = cos(half_z);
+
+        const _x = s1 * c2 * c3 + c1 * s2 * s3;
+        const _y = c1 * s2 * c3 - s1 * c2 * s3;
+        const _z = c1 * c2 * s3 + s1 * s2 * c3;
+        const _w = c1 * c2 * c3 - s1 * s2 * s3;
 
-        result.set(roll, pitch, yaw);
+        this.set(_x, _y, _z, _w);
     }
 
     /**
      * XYZ order
      * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
      * @param {number} x angle in X axis in radians
      * @param {number} y angle in Y axis in radians
      * @param {number} z angle in Z axis in radians
      */
-    fromEulerAngles(x, y, z) {
+    fromEulerAnglesYXZ(x, y, z) {
         const scaled_x = x * 0.5;
         const scaled_y = y * 0.5;
         const scaled_z = z * 0.5;
 
-        const sx = Math.sin(scaled_x);
-        const cx = Math.cos(scaled_x);
-        const sy = Math.sin(scaled_y);
-        const cy = Math.cos(scaled_y);
-        const sz = Math.sin(scaled_z);
-        const cz = Math.cos(scaled_z);
+        const s1 = Math.sin(scaled_x);
+        const s2 = Math.sin(scaled_y);
+        const s3 = Math.sin(scaled_z);
+
+        const c1 = Math.cos(scaled_x);
+        const c2 = Math.cos(scaled_y);
+        const c3 = Math.cos(scaled_z);
 
-        const _x = sx * cy * cz - cx * sy * sz;
-        const _y = cx * sy * cz + sx * cy * sz;
-        const _z = cx * cy * sz - sx * sy * cz;
-        const _w = cx * cy * cz + sx * sy * sz;
+        const _x = s1 * c2 * c3 + c1 * s2 * s3;
+        const _y = c1 * s2 * c3 - s1 * c2 * s3;
+        const _z = c1 * c2 * s3 - s1 * s2 * c3;
+        const _w = c1 * c2 * c3 + s1 * s2 * s3;
 
         this.set(_x, _y, _z, _w);
     }
@@ -798,7 +757,7 @@ class Quaternion {
      * @param {number} y angle in Y axis in radians
      * @param {number} z angle in Z axis in radians
      */
-    fromEulerAnglesXYZ(x, y, z) {
+    fromEulerAnglesZXY(x, y, z) {
         const scaled_x = x * 0.5;
         const scaled_y = y * 0.5;
         const scaled_z = z * 0.5;
@@ -811,8 +770,8 @@ class Quaternion {
         const c2 = Math.cos(scaled_y);
         const c3 = Math.cos(scaled_z);
 
-        const _x = s1 * c2 * c3 + c1 * s2 * s3;
-        const _y = c1 * s2 * c3 - s1 * c2 * s3;
+        const _x = s1 * c2 * c3 - c1 * s2 * s3;
+        const _y = c1 * s2 * c3 + s1 * c2 * s3;
         const _z = c1 * c2 * s3 + s1 * s2 * c3;
         const _w = c1 * c2 * c3 - s1 * s2 * s3;
 
@@ -820,48 +779,93 @@ class Quaternion {
     }
 
     /**
-     * Writes Pitch(Y), Yaw(Z), Roll(X) to a given vector
-     * @source http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/
-     * @param {Vector3} result
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
      */
-    toEulerAngles(result) {
-        const x = this.x;
-        const y = this.y;
-        const z = this.z;
-        const w = this.w;
+    fromEulerAnglesZYX(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
 
-        const sqw = w * w;
-        const sqx = x * x;
-        const sqy = y * y;
-        const sqz = z * z;
+        const s1 = Math.sin(scaled_x);
+        const s2 = Math.sin(scaled_y);
+        const s3 = Math.sin(scaled_z);
 
-        const unit = sqx + sqy + sqz + sqw; // if normalised is one, otherwise is correction factor
+        const c1 = Math.cos(scaled_x);
+        const c2 = Math.cos(scaled_y);
+        const c3 = Math.cos(scaled_z);
 
-        const test = x * w - y * z;
+        const _x = s1 * c2 * c3 - c1 * s2 * s3;
+        const _y = c1 * s2 * c3 + s1 * c2 * s3;
+        const _z = c1 * c2 * s3 - s1 * s2 * c3;
+        const _w = c1 * c2 * c3 + s1 * s2 * s3;
 
+        this.set(_x, _y, _z, _w);
+    }
 
-        let yaw, pitch, roll;
+    /**
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
+     */
+    fromEulerAnglesYZX(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
 
-        if (test > 0.4995 * unit) { // singularity at north pole
-            yaw = 2 * Math.atan2(y, x);
-            pitch = PI_HALF;
-            roll = 0;
-        } else if (test < -0.4995 * unit) { // singularity at south pole
-            yaw = -2 * Math.atan2(y, x);
-            pitch = -PI_HALF;
-            roll = 0;
-        } else {
-            yaw = Math.atan2(2 * x * w + 2 * y * z, 1 - 2 * (sqz + sqw));
-            pitch = Math.asin(2 * (x * z - w * y));
-            roll = Math.atan2(2 * x * y - 2 * z * w, 1 - 2 * (sqy + sqz))
-        }
+        const s1 = Math.sin(scaled_x);
+        const s2 = Math.sin(scaled_y);
+        const s3 = Math.sin(scaled_z);
+
+        const c1 = Math.cos(scaled_x);
+        const c2 = Math.cos(scaled_y);
+        const c3 = Math.cos(scaled_z);
+
+        const _x = s1 * c2 * c3 + c1 * s2 * s3;
+        const _y = c1 * s2 * c3 + s1 * c2 * s3;
+        const _z = c1 * c2 * s3 - s1 * s2 * c3;
+        const _w = c1 * c2 * c3 - s1 * s2 * s3;
+
+        this.set(_x, _y, _z, _w);
+    }
+
+    /**
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
+     */
+    fromEulerAnglesXZY(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
+
+        const s1 = Math.sin(scaled_x);
+        const s2 = Math.sin(scaled_y);
+        const s3 = Math.sin(scaled_z);
+
+        const c1 = Math.cos(scaled_x);
+        const c2 = Math.cos(scaled_y);
+        const c3 = Math.cos(scaled_z);
 
-        //normalize angles
-        yaw = normalizeAngle(yaw);
-        pitch = normalizeAngle(pitch);
-        roll = normalizeAngle(roll);
+        const _x = s1 * c2 * c3 - c1 * s2 * s3;
+        const _y = c1 * s2 * c3 - s1 * c2 * s3;
+        const _z = c1 * c2 * s3 + s1 * s2 * c3;
+        const _w = c1 * c2 * c3 + s1 * s2 * s3;
 
-        result.set(pitch, yaw, roll);
+        this.set(_x, _y, _z, _w);
     }
 
     /**
@@ -1204,6 +1208,17 @@ class Quaternion {
         this.set(_x, _y, _z, _w);
     }
 
+    /**
+     * @see https://github.com/gareth-cross/quat/blob/master/include/quaternion.hpp
+     * TODO implement
+     * @param {Quaternion} a
+     * @param {Quaternion} b
+     * @param {number} t
+     */
+    quaternionsInterpolateRungeKutta4(a, b, t) {
+        throw new Error('Not Implemented');
+    }
+
     /**
      *
      * @param {function} handler

package/core/geom/Quaternion.spec.js

@@ -162,8 +162,8 @@ test('to/from euler YXZ consistency', () => {
 
         const u = new Vector3();
 
-        r.__setFromEuler(x, y, z, 'YXZ');
-        r.toEulerAnglesYXZ(u);
+        r.fromEulerAnglesXYZ(x, y, z);
+        r.toEulerAnglesXYZ(u);
 
         expect(u.x).toBeCloseTo(x);
         expect(u.y).toBeCloseTo(y);
@@ -177,4 +177,49 @@ test('to/from euler YXZ consistency', () => {
     check(1, 0, 1);
     check(1, 1, 0);
     check(1, 1, 1);
+
+    check(0, 0, -1);
+    check(0, -1, 0);
+    check(0, -1, -1);
+    check(-1, 0, 0);
+    check(-1, 0, -1);
+    check(-1, -1, 0);
+    check(-1, -1, -1);
+});
+
+
+/**
+ * See https://www.andre-gaschler.com/rotationconverter/
+ */
+test('toEulerAnglesXYZ', () => {
+
+    function check(quat, euler) {
+
+        const q = new Quaternion(...quat);
+
+        const r = new Vector3();
+        q.toEulerAnglesXYZ(r)
+
+        expect(r.x).toBeCloseTo(euler[0]);
+        expect(r.y).toBeCloseTo(euler[1]);
+        expect(r.z).toBeCloseTo(euler[2]);
+    }
+
+
+    check([0.4794255, 0, 0, 0.8775826], [1, 0, 0]);
+    check([0, 0.4794255, 0, 0.8775826], [0, 1, 0]);
+    check([0, 0, 0.4794255, 0.8775826], [0, 0, 1]);
+
+    check([0.4207355, 0.4207355, 0.2298488, 0.7701512], [1, 1, 0]);
+    check([0.2298488, 0.4207355, 0.4207355, 0.7701512], [0, 1, 1]);
+    check([0.4207355, -0.2298488, 0.4207355, 0.7701512], [1, 0, 1]);
+
+    check([0.5709415, 0.1675188, 0.5709415, 0.5656758], [1, 1, 1]);
+
+
+    check([-0.4794255, 0, 0, 0.8775826], [-1, 0, 0]);
+    check([0, -0.4794255, 0, 0.8775826], [0, -1, 0]);
+    check([0, 0, -0.4794255, 0.8775826], [0, 0, -1]);
+
+
 });

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);