@woosh/meep-engine 2.37.19 → 2.37.20

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}
@@ -81,10 +41,6 @@ export class PatchTerrainHeightAction extends Action {
          */
         const tiles = terrain.__tiles;
 
-        tiles.buildWorker.setHeightSampler(heightMap.data, heightMap.itemSize, heightMap.width, heightMap.height);
-
-        const terrainSize = terrain.size;
-
         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/createObjectEditor.js

@@ -67,6 +67,19 @@ function isReservedField(object, field_name) {
     return false;
 }
 
+/**
+ *
+ * @type {string[]}
+ */
+const reserved_prototype_names = [
+    "constructor"
+];
+
+const reserved_prototypes = [
+    Object,
+    Object.prototype
+];
+
 /**
  *
  * @param {Object} object
@@ -101,48 +114,58 @@ function extract_object_fields_reflection(object, result, object_proto) {
         result.push(descriptor);
     }
 
-    const descriptors = Object.getOwnPropertyDescriptors(object_proto);
+    if (!reserved_prototypes.includes(object_proto)) {
 
-    for (let d_name in descriptors) {
-        const d = descriptors[d_name];
+        const descriptors = Object.getOwnPropertyDescriptors(object_proto);
 
-        const adapter = new FieldValueAdapter();
+        for (let d_name in descriptors) {
 
-        if (d.get === undefined) {
-            adapter.readable = false;
-        }
+            if (reserved_prototype_names.includes(d_name)) {
+                // reserved name, skip
+                continue;
+            }
 
-        if (d.set === undefined) {
-            adapter.writable = false;
-        }
+            const d = descriptors[d_name];
 
-        if (!adapter.readable) {
-            continue;
-        }
+            const adapter = new FieldValueAdapter();
 
+            if (d.get === undefined && d.value === undefined) {
+                adapter.readable = false;
+            }
 
-        let field_value;
+            if (d.get !== undefined && d.set === undefined) {
+                adapter.writable = false;
+            }
 
-        try {
-            field_value = adapter.read(object, d_name);
-        } catch (e) {
-            console.warn(e);
-            continue;
-        }
+            if (!adapter.readable) {
+                continue;
+            }
 
-        const field_type = objectToClass(field_value);
 
-        if (field_type === undefined) {
-            continue;
-        }
+            let field_value;
 
-        const descriptor = new FieldDescriptor();
+            try {
+                field_value = adapter.read(object, d_name);
+            } catch (e) {
+                console.warn(e);
+                continue;
+            }
 
-        descriptor.name = d_name;
-        descriptor.type = field_type;
-        descriptor.adapter = adapter;
+            const field_type = objectToClass(field_value);
+
+            if (field_type === undefined) {
+                continue;
+            }
+
+            const descriptor = new FieldDescriptor();
+
+            descriptor.name = d_name;
+            descriptor.type = field_type;
+            descriptor.adapter = adapter;
+
+            result.push(descriptor);
+        }
 
-        result.push(descriptor);
     }
 }
 
@@ -153,6 +176,7 @@ function extract_object_fields_reflection(object, result, object_proto) {
  * @returns {FieldDescriptor[]}
  */
 function extractObjectFields(object, registry) {
+
     const result = [];
 
     const object_proto = Object.getPrototypeOf(object);

package/editor/ecs/component/editors/Sampler2DEditor.js

@@ -11,49 +11,96 @@ import { DataType } from "../../../../core/collection/table/DataType.js";
 import { min2 } from "../../../../core/math/min2.js";
 import { max2 } from "../../../../core/math/max2.js";
 import { isTypedArray } from "../../../../core/collection/array/typed/isTypedArray.js";
+import { FrameRunner } from "../../../../engine/graphics/FrameRunner.js";
+
+const UPDATE_DELAY = 200;
 
 export class Sampler2DEditor extends TypeEditor {
     build(parent, field, context) {
+
         /**
          * @type {Sampler2D}
          */
         const sampler = field.adapter.read(parent, field.name);
 
-        let dataType;
+        let last_version = -1;
+        let last_update_time = 0;
+        let last_update_duration = 0;
 
-        if (isTypedArray(sampler.data)) {
-            dataType = typedArrayToDataType(sampler.data);
-        } else {
-            dataType = DataType.Float32;
-        }
+        const view = new CanvasView();
+        view.css({
+            background: 'black'
+        });
 
-        const TypedArrayConstructor = typedArrayConstructorByInstance(sampler.data);
+        function draw() {
+            const draw_start_time = performance.now();
 
-        const res = 32;
-        const result_sampler = new Sampler2D(new TypedArrayConstructor(sampler.itemSize * res * res), sampler.itemSize, res, res);
+            let dataType;
 
-        scaleSampler2D(sampler, result_sampler);
+            if (isTypedArray(sampler.data)) {
+                dataType = typedArrayToDataType(sampler.data);
+            } else {
+                dataType = DataType.Float32;
+            }
 
-        const view = new CanvasView();
+            let TypedArrayConstructor = typedArrayConstructorByInstance(sampler.data);
+
+            if (TypedArrayConstructor === Uint8Array) {
+                // use clamped array to avoid filtering artifacts
+                TypedArrayConstructor = Uint8ClampedArray;
+            }
+
+            const res = 32;
+            const result_sampler = new Sampler2D(new TypedArrayConstructor(sampler.itemSize * res * res), sampler.itemSize, res, res);
+
+            scaleSampler2D(sampler, result_sampler);
+
+
+            let min = 0, max = 0;
+            if (dataType === DataType.Float32) {
+                min = Infinity;
+                max = -Infinity;
+                for (let i = 0; i < result_sampler.itemSize; i++) {
+
+                    min = min2(min, result_sampler.computeMin(i).value)
+                    max = max2(min, result_sampler.computeMax(i).value)
+                }
+            } else if (dataType === DataType.Uint8) {
+                min = 0;
+                max = 255;
+            }
+
+            const scale = 255 / (max - min);
+            const offset = min;
+
+            sampler2D2Canvas(result_sampler, scale, offset, view.el);
+
+            last_version = sampler.version;
+
+            const draw_end_time = performance.now();
+            last_update_duration = draw_end_time - draw_start_time;
+
+            last_update_time = draw_end_time;
+        }
+
+
+        view.on.linked.add(try_update);
+
+        function try_update() {
+            if (sampler.version !== last_version) {
 
-        let min = 0, max = 0;
-        if (dataType === DataType.Float32) {
-            min = Infinity;
-            max = -Infinity;
-            for (let i = 0; i < result_sampler.itemSize; i++) {
+                const time_now = performance.now();
 
-                min = min2(min, result_sampler.computeMin(i).value)
-                max = max2(min, result_sampler.computeMax(i).value)
+                if ((time_now - last_update_time) >= UPDATE_DELAY) {
+                    draw();
+                }
             }
-        } else if (dataType === DataType.Uint8) {
-            min = 0;
-            max = 255;
         }
 
-        const scale = 255 / (max - min);
-        const offset = min;
+        const frameRunner = new FrameRunner(try_update);
 
-        sampler2D2Canvas(result_sampler, scale, offset, view.el);
+        view.on.linked.add(frameRunner.startup, frameRunner);
+        view.on.unlinked.add(frameRunner.shutdown, frameRunner);
 
         return view;
     }

package/editor/ecs/component/editors/ecs/terrain/TerrainEditor.js

@@ -4,8 +4,49 @@ import { TerrainFlags } from "../../../../../../engine/ecs/terrain/ecs/TerrainFl
 import { ImagePathEditor } from "../../ImagePathEditor.js";
 import { EnumEditor } from "../../common/EnumEditor.js";
 import { GridTransformKind } from "../../../../../../engine/ecs/terrain/ecs/GridTransformKind.js";
+import { Texture } from "three";
 
 export class TerrainEditor extends ObjectEditor {
+    build(parent, field, registry) {
+        const view = super.build(parent, field, registry);
+
+        if (view) {
+
+            /**
+             * @type {Terrain}
+             */
+            const terrain = field.adapter.read(parent, field.name);
+
+            function updateLayers() {
+
+                terrain.layers.buildTexture();
+                terrain.layers.writeAllLayersDataIntoTexture();
+
+                terrain.updateMaterial();
+            }
+
+            // splats
+            view.bindSignal(terrain.layers.layers.on.added, () => {
+                terrain.splat.addWeightLayer();
+                updateLayers();
+            });
+            view.bindSignal(terrain.layers.layers.on.removed, (a, index) => {
+                terrain.splat.removeWeightLayer(index);
+
+                updateLayers();
+            });
+
+            // mapping sizes
+            view.bindSignal(terrain.splat.size.onChanged, (x, y) => {
+                terrain.splat.resize(x, y, terrain.splat.depth);
+
+                terrain.updateMaterial();
+            });
+        }
+
+        return view;
+    }
+
     get schema() {
         return {
             properties: {
@@ -35,6 +76,12 @@ export class TerrainEditor extends ObjectEditor {
                 },
                 heightTexture: {
                     transient: true
+                },
+                buildLightMap: {
+                    type: Function
+                },
+                aoMap: {
+                    type: Texture
                 }
             }
         };

package/editor/ecs/component/editors/primitive/FunctionEditor.js

@@ -3,6 +3,12 @@ import ButtonView from "../../../../../view/elements/button/ButtonView.js";
 
 export class FunctionEditor extends TypeEditor {
     build(parent, field, registry) {
+
+        if (field.schema === undefined) {
+            // no schema, function editors are only available for explicit schema
+            return undefined;
+        }
+
         /**
          * @type {Function}
          */
@@ -13,8 +19,6 @@ export class FunctionEditor extends TypeEditor {
             return undefined;
         }
 
-        // TODO check that function takes no parameters maybe?
-
         return new ButtonView({
             action: () => {
                 v.call(parent);

package/editor/tools/SelectionTool.js

@@ -270,7 +270,7 @@ export function pickingEntitySelection(point, engine, camera) {
      */
     const sgm = em.getSystem(ShadedGeometrySystem);
 
-    if (sgm !== undefined) {
+    if (sgm !== undefined && sgm !== null) {
         const hits = sgm.raycast(
             source.x, source.y, source.y,
             rayDirection.x, rayDirection.y, rayDirection.z