@woosh/meep-engine 2.46.29 → 2.46.30

package/editor/actions/concrete/ModifyPatchTextureArray2DAction.js

@@ -0,0 +1,182 @@
+import { Action } from "../../../src/core/process/undo/Action.js";
+import { assert } from "../../../src/core/assert.js";
+import { texture_array_2d_copy } from "../../../src/engine/graphics/texture/texture_array_2d_copy.js";
+import { clamp } from "../../../src/core/math/clamp.js";
+
+export class ModifyPatchTextureArray2DAction extends Action {
+    /**
+     *
+     * @param {number[]|Uint8Array|Uint32Array|Float32Array} data
+     * @param {number[]} data_resolution
+     * @param {number[]} bounds
+     */
+    constructor(data, data_resolution, bounds) {
+        super();
+
+        assert.isArrayLike(data, 'data');
+
+        this.__data = data;
+        this.__data_resolution = data_resolution;
+        this.__bounds = bounds;
+
+
+        const width = this.__bounds[2] - this.__bounds[0];
+        const height = this.__bounds[3] - this.__bounds[1];
+
+        const depth = data_resolution[2];
+
+        const CTOR = Object.getPrototypeOf(data).constructor;
+
+        /**
+         * @type {ArrayLike<number>}
+         * @private
+         */
+        this.__patch_new = new CTOR(height * width * depth);
+        /**
+         * @type {ArrayLike<number>}
+         * @private
+         */
+        this.__patch_old = new CTOR(height * width * depth);
+    }
+
+    /**
+     *
+     * @param {number} center_x
+     * @param {number} center_y
+     * @param {Sampler2D} stamp
+     * @param {number} layer_index
+     * @param {number} weight
+     * @param {number} clamp_min
+     * @param {number} clamp_max
+     */
+    applyWeightStampToLayer(
+        center_x, center_y,
+        stamp, layer_index, weight,
+        clamp_min = Number.NEGATIVE_INFINITY, clamp_max = Number.POSITIVE_INFINITY
+    ) {
+
+        const bounds_x0 = this.__bounds[0];
+        const bounds_y0 = this.__bounds[1];
+
+        const bounds_x1 = this.__bounds[2];
+        const bounds_y1 = this.__bounds[3];
+
+        const width = bounds_x1 - bounds_x0;
+        const height = bounds_y1 - bounds_y0;
+
+        const center_offset_x = (bounds_x0 + bounds_x1) * 0.5 - center_x;
+        const center_offset_y = (bounds_y0 + bounds_y1) * 0.5 - center_y;
+
+        const source_data = this.__data;
+
+        const source_width = this.__data_resolution[0];
+        const source_height = this.__data_resolution[1];
+        const depth = this.__data_resolution[2];
+
+        for (let y = 0; y < height; y++) {
+            const marker_v = (y + center_offset_y) / (height - 1);
+
+            for (let x = 0; x < width; x++) {
+                const marker_u = (x + center_offset_x) / (width - 1);
+
+                const stamp_value = stamp.sampleChannelBilinearUV(marker_u, marker_v, 3);
+
+                if (Number.isNaN(stamp_value)) {
+                    continue;
+                }
+
+                const weighed_stamp_value = stamp_value * weight;
+
+                const source_x = (x + bounds_x0);
+                const source_y = (y + bounds_y0);
+
+                const weight_reciprocal = weighed_stamp_value / (depth - 1);
+
+                for (let i = 0; i < depth; i++) {
+                    const source_layer_address = source_width * source_height * i;
+                    const source_texel_address = source_layer_address + source_y * source_width + source_x;
+
+                    const destination_texel_address = width * height * i + y * width + x;
+
+                    const source_value = source_data[source_texel_address];
+
+                    let destination_value;
+                    if (i === layer_index) {
+                        // the channel that we are stamping
+                        destination_value = source_value + weighed_stamp_value;
+                    } else {
+                        destination_value = source_value - weight_reciprocal;
+                    }
+
+                    this.__patch_new[destination_texel_address] = clamp(destination_value, clamp_min, clamp_max);
+                }
+            }
+        }
+    }
+
+    get patch_data() {
+        return this.__patch_new;
+    }
+
+    computeByteSize() {
+        // TODO take size of array elements into account
+        return this.__patch_new.length + this.__patch_old.length + 280;
+    }
+
+    async apply(context) {
+        const data = this.__data;
+
+        const depth = this.__data_resolution[2];
+
+        const bounds_x0 = this.__bounds[0];
+        const bounds_y0 = this.__bounds[1];
+
+        const bounds_x1 = this.__bounds[2];
+        const bounds_y1 = this.__bounds[3];
+
+        const width = bounds_x1 - bounds_x0;
+        const height = bounds_y1 - bounds_y0;
+
+        const source_resolution_x = this.__data_resolution[0];
+        const source_resolution_y = this.__data_resolution[1];
+
+        // store old data
+        texture_array_2d_copy(
+            data, bounds_x0, bounds_y0, source_resolution_x, source_resolution_y,
+            this.__patch_old, 0, 0, width, height,
+            width, height, depth
+        );
+
+        texture_array_2d_copy(
+            this.__patch_new, 0, 0, width, height,
+            data, bounds_x0, bounds_y0, source_resolution_x, source_resolution_y,
+            width, height, depth
+        );
+
+    }
+
+    async revert(context) {
+
+        const data = this.__data;
+
+        const depth = this.__data_resolution[2];
+
+        const bounds_x0 = this.__bounds[0];
+        const bounds_y0 = this.__bounds[1];
+
+        const bounds_x1 = this.__bounds[2];
+        const bounds_y1 = this.__bounds[3];
+
+        const width = bounds_x1 - bounds_x0;
+        const height = bounds_y1 - bounds_y0;
+
+        const source_resolution_x = this.__data_resolution[0];
+        const source_resolution_y = this.__data_resolution[1];
+
+        texture_array_2d_copy(
+            this.__patch_old, 0, 0, width, height,
+            data, bounds_x0, bounds_y0, source_resolution_x, source_resolution_y,
+            width, height, depth
+        );
+    }
+}

package/editor/actions/concrete/PaintTerrainOverlayAction.js

@@ -0,0 +1,45 @@
+import Vector4 from "../../../src/core/geom/Vector4.js";
+import { Action } from "../../../src/core/process/undo/Action.js";
+import { obtainTerrain } from "../../../src/engine/ecs/terrain/util/obtainTerrain.js";
+
+class PaintTerrainOverlayAction extends Action {
+    /**
+     *
+     * @param {number} entity
+     * @param {number} x
+     * @param {number} y
+     * @param {Vector4} color
+     * @constructor
+     */
+    constructor(entity, x, y, color) {
+        super();
+        this.entity = entity;
+        this.x = x;
+        this.y = y;
+        this.color = color;
+
+        this.overlay = null;
+        this.oldColor = new Vector4();
+    }
+
+    async apply(editor) {
+        const terrain = obtainTerrain(editor.engine.entityManager.dataset);
+        const overlay = this.overlay = terrain.overlay;
+
+        //remember old color
+        overlay.readPoint(this.x, this.y, this.oldColor);
+
+        overlay.clearPoint(this.x, this.y);
+        overlay.paintPoint(this.x, this.y, this.color);
+    }
+
+    async revert(editor) {
+        const overlay = this.overlay;
+
+        overlay.clearPoint(this.x, this.y);
+        overlay.paintPoint(this.x, this.y, this.oldColor);
+    }
+}
+
+
+export default PaintTerrainOverlayAction;

package/editor/actions/concrete/PatchTerrainHeightAction.js

@@ -0,0 +1,67 @@
+import { ModifyPatchSampler2DAction } from "./ModifyPatchSampler2DAction.js";
+
+export class PatchTerrainHeightAction extends ModifyPatchSampler2DAction {
+    /**
+     *
+     * @param {Terrain} terrain
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(terrain, x, y, width, height) {
+        super(terrain.samplerHeight, [x, y, x + width, y + height]);
+
+        /**
+         *
+         * @type {Terrain}
+         */
+        this.terrain = terrain;
+    }
+
+    async updateTerrain() {
+        /**
+         *
+         * @type {Terrain}
+         */
+        const terrain = this.terrain;
+
+        terrain.updateHeightTexture();
+        terrain.updateWorkerHeights();
+
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        const heightMap = terrain.samplerHeight;
+
+        /**
+         *
+         * @type {TerrainTileManager}
+         */
+        const tiles = terrain.__tiles;
+
+        const x = this.x;
+        const y = this.y;
+
+        const u0 = x / heightMap.width;
+        const u1 = (x + this.patch.width) / heightMap.height;
+
+        const v0 = y / heightMap.height;
+        const v1 = (y + this.patch.height) / heightMap.height;
+
+        tiles.rebuildTilesByUV(u0, v0, u1, v1);
+    }
+
+    async apply(context) {
+        await super.apply(context);
+
+        await this.updateTerrain();
+    }
+
+    async revert(context) {
+        await super.revert(context);
+
+        await this.updateTerrain();
+    }
+}

package/editor/actions/concrete/PatchTerrainTextureAction.js

@@ -0,0 +1,152 @@
+import { max2 } from "../../../src/core/math/max2.js";
+import { min2 } from "../../../src/core/math/min2.js";
+import { Action } from "../../../src/core/process/undo/Action.js";
+import { Sampler2D } from "../../../src/engine/graphics/texture/sampler/Sampler2D.js";
+
+export class PatchTerrainTextureAction extends Action {
+
+    /**
+     *
+     * @param {Terrain} terrain
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(terrain, x, y, width, height) {
+        super();
+
+        /**
+         *
+         * @type {Terrain}
+         */
+        this.terrain = terrain;
+
+        const depth = terrain.splat.depth;
+
+        /**
+         *
+         * @type {Uint8Array}
+         */
+        this.patchWeight = new Uint8Array(width * height * depth);
+
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        this.patchMaterial = Sampler2D.uint8(4, width, height);
+
+        this.x = x;
+        this.y = y;
+
+        this.width = width;
+        this.height = height;
+
+        this.__oldPatchWeight = new Uint8Array(width * height * depth);
+        this.__oldPatchMaterial = Sampler2D.uint8(4, width, height);
+    }
+
+    /**
+     *
+     * @param {number[]|Uint8Array|Float32Array} source
+     * @param {number} sourceWidth
+     * @param {number} sourceHeight
+     */
+    readWeights(source, sourceWidth, sourceHeight) {
+        const depth = this.terrain.splat.depth;
+
+        const destinationWidth = this.width;
+        const destinationHeight = this.height;
+
+        const sourceX = this.x;
+        const sourceY = this.y;
+
+        const sourceLayerSize = sourceWidth * sourceHeight;
+        const destinationLayerSize = destinationWidth * destinationHeight;
+
+        const _w = max2(0, min2(destinationWidth, sourceWidth - sourceX));
+        const _h = max2(0, min2(destinationHeight, sourceHeight - sourceY));
+
+        const destination = this.patchWeight;
+
+        for (let i = 0; i < depth; i++) {
+
+            const dLayerAddress = destinationLayerSize * i;
+            const sLayerAddress = sourceLayerSize * i;
+
+            for (let y = 0; y < _h; y++) {
+                const dRowAddress = y * destinationWidth + dLayerAddress;
+
+                const sRowAddress = (y + sourceY) * sourceWidth + sLayerAddress;
+
+                for (let x = 0; x < _w; x++) {
+                    const dAddress = dRowAddress + x;
+
+                    const sAddress = sRowAddress + x + sourceX;
+
+                    destination[dAddress] = source[sAddress];
+                }
+            }
+
+        }
+    }
+
+    updateTerrain() {
+
+        this.terrain.splat.materialTexture.needsUpdate = true;
+        this.terrain.splat.weightTexture.needsUpdate = true;
+
+
+    }
+
+    async apply(context) {
+        /**
+         *
+         * @type {Terrain}
+         */
+        const terrain = this.terrain;
+
+
+        const splat = terrain.splat;
+
+        const samplerMaterials = splat.materialSampler;
+
+        //store old data from the patch
+        splat.readWeightData(this.__oldPatchWeight, this.x, this.y, this.width, this.height);
+
+        const oldPatchMaterial = this.__oldPatchMaterial;
+        oldPatchMaterial.copy_sameItemSize(samplerMaterials, this.x, this.y, 0, 0, oldPatchMaterial.width, oldPatchMaterial.height);
+
+        //apply the patch
+        splat.writeWeightData(this.patchWeight, this.x, this.y, this.width, this.height);
+
+        const patchMaterial = this.patchMaterial;
+        samplerMaterials.copy_sameItemSize(patchMaterial, 0, 0, this.x, this.y, patchMaterial.width, patchMaterial.height);
+
+        this.updateTerrain();
+    }
+
+    async revert(context) {
+        /**
+         *
+         * @type {Terrain}
+         */
+        const terrain = this.terrain;
+
+        const splat = terrain.splat;
+
+        const samplerMaterials = new Sampler2D(splat.materialData, 4, splat.size.x, splat.size.y);
+
+
+        //apply the patch
+        splat.writeWeightData(this.__oldPatchWeight, this.x, this.y, this.width, this.height);
+
+        const patchMaterial = this.__oldPatchMaterial;
+        samplerMaterials.copy_sameItemSize(patchMaterial, 0, 0, this.x, this.y, patchMaterial.width, patchMaterial.height);
+
+
+        this.updateTerrain();
+    }
+
+}
+

package/editor/actions/concrete/SelectionAddAction.js

@@ -0,0 +1,36 @@
+/**
+ * Created by Alex on 16/01/2017.
+ */
+import { Action } from "../../../src/core/process/undo/Action.js";
+
+
+class SelectionAddAction extends Action {
+    /**
+     *
+     * @param {int[]} entities
+     * @constructor
+     */
+    constructor(entities) {
+        super();
+        this.oldState = null;
+        /**
+         *
+         * @type {int[]}
+         */
+        this.entities = entities;
+    }
+
+    async apply(editor) {
+        this.oldState = editor.selection.clone();
+
+        const selection = editor.selection;
+
+        selection.addAllUnique(this.entities);
+    }
+
+    async revert(editor) {
+        editor.selection.copy(this.oldState);
+    }
+}
+
+export default SelectionAddAction;

package/editor/actions/concrete/SelectionClearAction.js

@@ -0,0 +1,22 @@
+import { Action } from "../../../src/core/process/undo/Action.js";
+
+class SelectionClearAction extends Action {
+    /**
+     * Created by Alex on 16/01/2017.
+     */
+    constructor() {
+        super();
+        this.oldState = null;
+    }
+
+    async apply(editor) {
+        this.oldState = editor.selection.clone();
+        editor.selection.reset();
+    }
+
+    async revert(editor) {
+        editor.selection.copy(this.oldState);
+    }
+}
+
+export default SelectionClearAction;

package/editor/actions/concrete/SelectionRemoveAction.js

@@ -0,0 +1,30 @@
+import { Action } from "../../../src/core/process/undo/Action.js";
+
+class SelectionRemoveAction extends Action {
+    /**
+     * Created by Alex on 16/01/2017.
+     */
+    constructor(entities) {
+        super();
+        this.oldState = null;
+        this.entities = entities;
+    }
+
+    async apply(editor) {
+        const selection = editor.selection;
+        this.oldState = selection.clone();
+        for (let i = 0; i < this.entities.length; i++) {
+            const entity = this.entities[i];
+            const index = selection.indexOf(entity);
+            if (index !== -1) {
+                selection.remove(index);
+            }
+        }
+    }
+
+    async revert(editor) {
+        editor.selection.copy(this.oldState);
+    }
+}
+
+export default SelectionRemoveAction;

package/editor/actions/concrete/TransformModifyAction.js

@@ -0,0 +1,46 @@
+import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { Action } from "../../../src/core/process/undo/Action.js";
+
+class TransformModifyAction extends Action {
+    /**
+     *
+     * @param entity
+     * @param {Transform} modified
+     * @constructor
+     */
+    constructor(entity, modified) {
+        super();
+
+        this.oldState = null;
+        this.modified = modified;
+        this.entity = entity;
+    }
+
+    computeByteSize() {
+        return 280;
+    }
+
+    /**
+     *
+     * @param {Editor} editor
+     */
+    async apply(editor) {
+        const entityManager = editor.engine.entityManager;
+
+        const component = entityManager.getComponent(this.entity, Transform);
+
+        this.oldState = component.clone();
+
+        component.copy(this.modified);
+    }
+
+    async revert(editor) {
+        const entityManager = editor.engine.entityManager;
+
+        const component = entityManager.getComponent(this.entity, Transform);
+
+        component.copy(this.oldState);
+    }
+}
+
+export default TransformModifyAction;

package/editor/actions/concrete/WriteGridValueAction.js

@@ -0,0 +1,46 @@
+import GridField from "../../../src/engine/navigation/grid/GridField.js";
+import GridObstacle from "../../../src/engine/grid/components/GridObstacle.js";
+import { Action } from "../../../src/core/process/undo/Action.js";
+
+class WriteGridValueAction extends Action {
+    constructor(entity, x, y, value) {
+        super();
+
+        this.entity = entity;
+        this.x = x;
+        this.y = y;
+        this.value = value;
+
+        this.obstacle = null;
+        this.oldValue = null;
+    }
+
+    async apply(editor) {
+        const obstacle = editor.engine.entityManager.getComponent(this.entity, GridObstacle);
+        this.obstacle = obstacle;
+
+
+        const gridField = obstacle2grid(obstacle);
+
+        this.oldValue = gridField.read(this.x, this.y);
+        gridField.pointSet(this.x, this.y, this.value);
+    }
+
+    async revert(editor) {
+        const gridField = obstacle2grid(this.obstacle);
+
+        gridField.pointSet(this.x, this.y, this.oldValue);
+    }
+}
+
+function obstacle2grid(obstacle) {
+    const gridField = new GridField();
+
+    gridField.width = obstacle.size.x;
+    gridField.height = obstacle.size.y;
+    gridField.data = obstacle.data;
+
+    return gridField;
+}
+
+export default WriteGridValueAction;

package/editor/ecs/EditorEntity.js

@@ -0,0 +1,12 @@
+/**
+ * Marker component to distinguish editor-owned entities
+ * @constructor
+ */
+function EditorEntity({ referenceEntity = -1 } = {}) {
+    this.referenceEntity = referenceEntity;
+}
+
+EditorEntity.typeName = "EditorEntity";
+EditorEntity.serializable = false;
+
+export default EditorEntity;

package/editor/ecs/EditorEntitySystem.js

@@ -0,0 +1,14 @@
+import { System } from "../../src/engine/ecs/System.js";
+import EditorEntity from "./EditorEntity.js";
+
+class EditorEntitySystem extends System {
+    constructor() {
+        super();
+
+        this.dependencies = [EditorEntity];
+    }
+
+}
+
+
+export default EditorEntitySystem;

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}']`;
+    }
+}