@woosh/meep-engine 2.169.6 → 2.170.0

package/editor/actions/concrete/TransformModifyAction.js

@@ -2,6 +2,8 @@ import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
 import { Action } from "../../../src/core/process/undo/Action.js";
 
 class TransformModifyAction extends Action {
+    oldState = null;
+
     /**
      *
      * @param entity
@@ -11,7 +13,6 @@ class TransformModifyAction extends Action {
     constructor(entity, modified) {
         super();
 
-        this.oldState = null;
         this.modified = modified;
         this.entity = entity;
     }
@@ -25,19 +26,18 @@ class TransformModifyAction extends Action {
      * @param {Editor} editor
      */
     async apply(editor) {
-        const entityManager = editor.engine.entityManager;
-
-        const component = entityManager.getComponent(this.entity, Transform);
+        const component = editor.engine.entityManager.dataset.getComponent(this.entity, Transform);
 
-        this.oldState = component.clone();
+        if (this.oldState === null) {
+            // captured on first application only; redo must restore the original pre-modification state
+            this.oldState = component.clone();
+        }
 
         component.copy(this.modified);
     }
 
     async revert(editor) {
-        const entityManager = editor.engine.entityManager;
-
-        const component = entityManager.getComponent(this.entity, Transform);
+        const component = editor.engine.entityManager.dataset.getComponent(this.entity, Transform);
 
         component.copy(this.oldState);
     }

package/editor/actions/concrete/WriteGridValueAction.d.ts

@@ -1,15 +1,14 @@
-export default WriteGridValueAction;
-declare class WriteGridValueAction extends Action<any> {
-    constructor(entity: any, x: any, y: any, value: any);
-    entity: any;
-    x: any;
-    y: any;
-    value: any;
-    obstacle: GridObstacle;
-    oldValue: number;
-    apply(editor: any): Promise<void>;
-    revert(editor: any): Promise<void>;
-}
-import { Action } from "../../../src/core/process/undo/Action.js";
-import GridObstacle from "../../../src/engine/grid/obstacle/GridObstacle.js";
+export default WriteGridValueAction;
+declare class WriteGridValueAction extends Action<any> {
+    constructor(entity: any, x: any, y: any, value: any);
+    obstacle: any;
+    oldValue: any;
+    entity: any;
+    x: any;
+    y: any;
+    value: any;
+    apply(editor: any): Promise<void>;
+    revert(editor: any): Promise<void>;
+}
+import { Action } from "../../../src/core/process/undo/Action.js";
 //# sourceMappingURL=WriteGridValueAction.d.ts.map

package/editor/actions/concrete/WriteGridValueAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WriteGridValueAction.d.ts","sourceRoot":"","sources":["WriteGridValueAction.js"],"names":[],"mappings":";AAGA;IACI,qDAUC;IAPG,YAAoB;IACpB,OAAU;IACV,OAAU;IACV,WAAkB;IAElB,uBAAoB;IACpB,iBAAoB;IAGxB,kCAgBC;IAED,mCAGC;CACJ;uBArCsB,0CAA0C;yBADxC,mDAAmD"}
+{"version":3,"file":"WriteGridValueAction.d.ts","sourceRoot":"","sources":["WriteGridValueAction.js"],"names":[],"mappings":";AAGA;IAII,qDAOC;IAVD,cAAgB;IAChB,cAAgB;IAKZ,YAAoB;IACpB,OAAU;IACV,OAAU;IACV,WAAkB;IAGtB,kCAgBC;IAED,mCAGC;CACJ;uBArCsB,0CAA0C"}

package/editor/actions/concrete/WriteGridValueAction.js

@@ -2,6 +2,9 @@ import GridObstacle from "../../../src/engine/grid/obstacle/GridObstacle.js";
 import { Action } from "../../../src/core/process/undo/Action.js";
 
 class WriteGridValueAction extends Action {
+    obstacle = null;
+    oldValue = null;
+
     constructor(entity, x, y, value) {
         super();
 
@@ -9,9 +12,6 @@ class WriteGridValueAction extends Action {
         this.x = x;
         this.y = y;
         this.value = value;
-
-        this.obstacle = null;
-        this.oldValue = null;
     }
 
     async apply(editor) {

package/editor/camera/camera_framing.d.ts

@@ -0,0 +1,30 @@
+/**
+ * World-space bounds of everything the editor draws for an entity: its geometry and terrain
+ * grid, plus the origin its gizmo attaches to. The origin is part of the frame on purpose —
+ * an author pressing "frame" is usually about to grab the gizmo, and geometry modelled away
+ * from its own origin would otherwise put the handles off screen.
+ *
+ * Geometry components absent from the host's type registry read as absent from the entity,
+ * so a host that runs one mesh representation is not obliged to register the other.
+ *
+ * @param {EntityComponentDataset} ecd
+ * @param {number} entity
+ * @param {AABB3} result
+ * @returns {boolean} false when the entity has no spatial presence at all, leaving `result` untouched
+ */
+export function computeEntityWorldBounds(ecd: EntityComponentDataset, entity: number, result: AABB3): boolean;
+/**
+ * Orbit distance at which `bounds` fits inside a vertical field of view.
+ *
+ * The fit is computed against the sphere that circumscribes the box rather than the box
+ * itself, because the editor camera orbits: a distance that framed one face would clip the
+ * corners a quarter-turn later. The box therefore sits comfortably inside the frame, with
+ * the slack showing at the corners.
+ *
+ * @param {AABB3} bounds
+ * @param {number} fov vertical field of view, degrees
+ * @returns {number}
+ */
+export function computeFramingDistance(bounds: AABB3, fov: number): number;
+import { AABB3 } from "../../src/core/geom/3d/aabb/AABB3.js";
+//# sourceMappingURL=camera_framing.d.ts.map

package/editor/camera/camera_framing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera_framing.d.ts","sourceRoot":"","sources":["camera_framing.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;GAaG;AACH,8EAJW,MAAM,UACN,KAAK,GACH,OAAO,CA0CnB;AAED;;;;;;;;;;;GAWG;AACH,+CAJW,KAAK,OACL,MAAM,GACJ,MAAM,CAalB;sBAjGqB,sCAAsC"}

package/editor/camera/camera_framing.js

@@ -0,0 +1,98 @@
+import { AABB3 } from "../../src/core/geom/3d/aabb/AABB3.js";
+import { DEG_TO_RAD } from "../../src/core/math/DEG_TO_RAD.js";
+import { max2 } from "../../src/core/math/max2.js";
+import Terrain from "../../src/engine/ecs/terrain/ecs/Terrain.js";
+import { Transform } from "../../src/engine/ecs/transform/Transform.js";
+import Mesh from "../../src/engine/graphics/ecs/mesh/Mesh.js";
+import { ShadedGeometry } from "../../src/engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+
+const scratch_aabb3 = new AABB3();
+
+/**
+ * An entity that carries no geometry is not invisible in the editor — the symbolic displays
+ * draw lights, cameras and emitters as unit-scale helpers. Framing the helper is what the
+ * author sees; framing the mathematical point would drive the camera into the pivot.
+ * @type {number}
+ */
+const SYMBOL_RADIUS = 1;
+
+/**
+ * World-space bounds of everything the editor draws for an entity: its geometry and terrain
+ * grid, plus the origin its gizmo attaches to. The origin is part of the frame on purpose —
+ * an author pressing "frame" is usually about to grab the gizmo, and geometry modelled away
+ * from its own origin would otherwise put the handles off screen.
+ *
+ * Geometry components absent from the host's type registry read as absent from the entity,
+ * so a host that runs one mesh representation is not obliged to register the other.
+ *
+ * @param {EntityComponentDataset} ecd
+ * @param {number} entity
+ * @param {AABB3} result
+ * @returns {boolean} false when the entity has no spatial presence at all, leaving `result` untouched
+ */
+export function computeEntityWorldBounds(ecd, entity, result) {
+    const transform = ecd.getComponent(entity, Transform);
+
+    if (transform === undefined) {
+        return false;
+    }
+
+    const position = transform.position;
+
+    result.setBounds(position.x, position.y, position.z, position.x, position.y, position.z);
+
+    const mesh = ecd.getComponent(entity, Mesh);
+
+    // world bounds are written when the mesh loads; until then they read as a degenerate box
+    // at the world origin, which would drag the frame across the scene
+    if (mesh !== undefined && mesh.hasMesh()) {
+        mesh.getBoundingBox(scratch_aabb3);
+        result.expandToFit(scratch_aabb3);
+    }
+
+    const geometry = ecd.getComponent(entity, ShadedGeometry);
+
+    if (geometry !== undefined && geometry.geometry !== null) {
+        geometry.getBoundingBox(scratch_aabb3);
+        result.expandToFit(scratch_aabb3);
+    }
+
+    const terrain = ecd.getComponent(entity, Terrain);
+
+    // a terrain's grid extends from its own origin, and it is wider than it is tall by orders
+    // of magnitude — the horizontal extent is what a frame has to fit
+    if (terrain !== undefined) {
+        result._expandToFitPoint(
+            position.x + terrain.size.x * terrain.gridScale,
+            position.y,
+            position.z + terrain.size.y * terrain.gridScale
+        );
+    }
+
+    return true;
+}
+
+/**
+ * Orbit distance at which `bounds` fits inside a vertical field of view.
+ *
+ * The fit is computed against the sphere that circumscribes the box rather than the box
+ * itself, because the editor camera orbits: a distance that framed one face would clip the
+ * corners a quarter-turn later. The box therefore sits comfortably inside the frame, with
+ * the slack showing at the corners.
+ *
+ * @param {AABB3} bounds
+ * @param {number} fov vertical field of view, degrees
+ * @returns {number}
+ */
+export function computeFramingDistance(bounds, fov) {
+    const half_x = bounds.getHalfExtentsX();
+    const half_y = bounds.getHalfExtentsY();
+    const half_z = bounds.getHalfExtentsZ();
+
+    const radius = max2(
+        Math.sqrt(half_x * half_x + half_y * half_y + half_z * half_z),
+        SYMBOL_RADIUS
+    );
+
+    return radius / Math.sin(fov * DEG_TO_RAD / 2);
+}

package/editor/clipboard.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @template T
+ * @param {T} original
+ * @param {EntityManager} em
+ * @returns {T}
+ */
+export function cloneComponent<T>(original: T, em: EntityManager): T;
+/**
+ *
+ * @param {Editor} editor
+ */
+export function copySelectedEntities(editor: Editor): void;
+/**
+ *
+ * @param {Editor} editor
+ * @returns {Promise}
+ */
+export function pasteEntities(editor: Editor): Promise<any>;
+//# sourceMappingURL=clipboard.d.ts.map

package/editor/clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["clipboard.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,qEA2EC;AAED;;;GAGG;AACH,2DAwCC;AAED;;;;GAIG;AACH,4DA4CC"}

package/editor/clipboard.js

@@ -0,0 +1,184 @@
+import ComponentAddAction from "./actions/concrete/ComponentAddAction.js";
+import EntityCreateAction from "./actions/concrete/EntityCreateAction.js";
+import SelectionAddAction from "./actions/concrete/SelectionAddAction.js";
+import SelectionClearAction from "./actions/concrete/SelectionClearAction.js";
+
+/**
+ * @template T
+ * @param {T} original
+ * @param {EntityManager} em
+ * @returns {T}
+ */
+export function cloneComponent(original, em) {
+    function newInstance() {
+        return new original.constructor();
+    }
+
+    const cloneViaMethod = {
+        name: 'Clone Method',
+        check: function (original) {
+            return typeof original.clone === "function";
+        },
+        execute: function (original) {
+            return original.clone();
+        }
+    };
+
+    const cloneViaSerialization = {
+        name: 'Serialization',
+        check: function (original) {
+            return typeof original.toJSON === "function" && typeof original.fromJSON === "function";
+        },
+        execute: function (original) {
+            //use serialization to create a clone
+            const json = original.toJSON();
+
+            const clone = newInstance();
+
+            const system = em.getOwnerSystemByComponentClass(original.constructor);
+
+            clone.fromJSON(json, system);
+
+            return clone;
+        }
+    };
+    const cloneViaInstantiate = {
+        name: 'New Instance',
+        check: function (original) {
+            return true;
+        },
+        execute: function (original) {
+            //no clone method, that's a bummer
+            const typeName = original.constructor.typeName;
+
+            console.error(`Component '${typeName}' has no 'clone' method, creating a new instance instead..`);
+
+            return newInstance();
+        }
+    };
+
+
+    const cloners = [cloneViaMethod, cloneViaSerialization, cloneViaInstantiate];
+
+    for (let i = 0; i < cloners.length; i++) {
+        const cloner = cloners[i];
+        const applicable = cloner.check(original);
+
+        if (!applicable) {
+            continue;
+        }
+
+        let clone;
+        try {
+            clone = cloner.execute(original);
+        } catch (e) {
+            continue;
+        }
+
+        if (original.constructor !== clone.constructor) {
+            console.error(`Cloner ${cloner.name} produced instance with different constructor`, 'original=', original, 'clone=', clone);
+            continue;
+        }
+
+        return clone;
+    }
+
+    throw new Error(`Failed to clone, no cloners worked`);
+}
+
+/**
+ *
+ * @param {Editor} editor
+ */
+export function copySelectedEntities(editor) {
+    if (editor.selection.isEmpty()) {
+        //clear out copy buffer
+        editor.copyBuffer = [];
+        return;
+    }
+
+    /**
+     *
+     * @type {EntityManager}
+     */
+    const em = editor.engine.entityManager;
+
+    const ecd = em.dataset;
+
+    editor.copyBuffer = editor.selection.map(function (entity) {
+        const components = ecd.getAllComponents(entity);
+
+        //clone all components to preserve their status
+        const clonedComponents = [];
+        components.forEach(function (c) {
+            if (c === undefined) {
+                //skip undefined
+                return;
+            }
+
+            let clone;
+
+            try {
+                clone = cloneComponent(c, em);
+            } catch (e) {
+                console.error(`Failed to clone component, omitting`, c, e);
+                return;
+            }
+
+            clonedComponents.push(clone);
+        });
+
+        return clonedComponents;
+    });
+}
+
+/**
+ *
+ * @param {Editor} editor
+ * @returns {Promise}
+ */
+export async function pasteEntities(editor) {
+    const copyBuffer = editor.copyBuffer;
+    if (copyBuffer.length === 0) {
+        //copy buffer is empty, nothing to do
+        return;
+    }
+
+    const actions = editor.actions;
+
+    actions.mark('paste entities');
+
+    const createdEntities = [];
+
+    for (const components of copyBuffer) {
+        const entityCreateAction = new EntityCreateAction();
+
+        // the action assigns the created entity id during apply; it must complete before
+        // the component actions below can reference the entity
+        await actions.do(entityCreateAction);
+
+        //clone all components to preserve status of the buffer
+        const n = components.length;
+
+        for (let i = 0; i < n; i++) {
+
+            const c = components[i];
+
+            const clone = cloneComponent(c, editor.engine.entityManager);
+
+            const componentAddAction = new ComponentAddAction(entityCreateAction.entity, clone);
+
+            try {
+                await actions.do(componentAddAction);
+            } catch (e) {
+                console.warn(`Failed to add component.`, e, 'The component might have been added as a result of some EntityObserver');
+            }
+        }
+
+        createdEntities.push(entityCreateAction.entity);
+    }
+
+    //select newly created entities
+    actions.do(new SelectionClearAction());
+    actions.do(new SelectionAddAction(createdEntities));
+}

package/editor/ecs/EditorEntity.d.ts

@@ -1,16 +1,16 @@
-export default EditorEntity;
-declare class EditorEntity {
-    /**
-     * Marker component to distinguish editor-owned entities
-     * @constructor
-     */
-    constructor({ referenceEntity }?: {
-        referenceEntity?: number;
-    });
-    referenceEntity: number;
-}
-declare namespace EditorEntity {
-    let typeName: string;
-    let serializable: boolean;
-}
+export default EditorEntity;
+declare class EditorEntity {
+    /**
+     * Marker component to distinguish editor-owned entities
+     * @constructor
+     */
+    constructor({ referenceEntity }?: {
+        referenceEntity?: number;
+    });
+    referenceEntity: number;
+}
+declare namespace EditorEntity {
+    let typeName: string;
+    let serializable: boolean;
+}
 //# sourceMappingURL=EditorEntity.d.ts.map

package/editor/ecs/EditorEntitySystem.d.ts

@@ -1,8 +1,8 @@
-export default EditorEntitySystem;
-declare class EditorEntitySystem extends System<any, any, any, any, any> {
-    constructor();
-    dependencies: (typeof EditorEntity)[];
-}
-import { System } from "../../src/engine/ecs/System.js";
-import EditorEntity from "./EditorEntity.js";
+export default EditorEntitySystem;
+declare class EditorEntitySystem extends System<any> {
+    constructor();
+    dependencies: (typeof EditorEntity)[];
+}
+import { System } from "../../src/engine/ecs/System.js";
+import EditorEntity from "./EditorEntity.js";
 //# sourceMappingURL=EditorEntitySystem.d.ts.map

package/editor/ecs/EditorEntitySystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EditorEntitySystem.d.ts","sourceRoot":"","sources":["EditorEntitySystem.js"],"names":[],"mappings":";AAGA;IACI,cAIC;IADG,sCAAkC;CAGzC;uBAVsB,gCAAgC;yBAC9B,mBAAmB"}
+{"version":3,"file":"EditorEntitySystem.d.ts","sourceRoot":"","sources":["EditorEntitySystem.js"],"names":[],"mappings":";AAGA;;IACI,sCAA8B;CACjC;uBALsB,gCAAgC;yBAC9B,mBAAmB"}

package/editor/ecs/EditorEntitySystem.js

@@ -2,12 +2,7 @@ import { System } from "../../src/engine/ecs/System.js";
 import EditorEntity from "./EditorEntity.js";
 
 class EditorEntitySystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [EditorEntity];
-    }
-
+    dependencies = [EditorEntity];
 }
 
 

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

@@ -1,27 +1,27 @@
-/**
- * @template T
- */
-export class FieldDescriptor<T> {
-    /**
-     *
-     * @type {string}
-     */
-    name: string;
-    /**
-     * typeof field
-     * @type {Class<T>}
-     */
-    type: Class<T>;
-    /**
-     *
-     * @type {FieldValueAdapter|null}
-     */
-    adapter: FieldValueAdapter | null;
-    /**
-     *
-     * @type {{}|undefined}
-     */
-    schema: {} | undefined;
-    toString(): string;
-}
+/**
+ * @template T
+ */
+export class FieldDescriptor<T> {
+    /**
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     * typeof field
+     * @type {Class<T>}
+     */
+    type: Class<T>;
+    /**
+     *
+     * @type {FieldValueAdapter|null}
+     */
+    adapter: FieldValueAdapter | null;
+    /**
+     *
+     * @type {{}|undefined}
+     */
+    schema: {} | undefined;
+    toString(): string;
+}
 //# sourceMappingURL=FieldDescriptor.d.ts.map

package/editor/ecs/component/FieldDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FieldDescriptor.d.ts","sourceRoot":"","sources":["FieldDescriptor.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IAEQ;;;OAGG;IACH,MAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAAgB;IAEhB;;;OAGG;IACH,SAFU,oBAAkB,IAAI,CAEb;IAEnB;;;OAGG;IACH,QAFU,EAAE,GAAC,SAAS,CAEC;IAG3B,mBAEC;CACJ"}
+{"version":3,"file":"FieldDescriptor.d.ts","sourceRoot":"","sources":["FieldDescriptor.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IACI;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,eAAY;IAEZ;;;OAGG;IACH,SAFU,oBAAkB,IAAI,CAEjB;IAEf;;;OAGG;IACH,QAFU,EAAE,GAAC,SAAS,CAEH;IAEnB,mBAEC;CACJ"}

package/editor/ecs/component/FieldDescriptor.js

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

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

@@ -1,7 +1,7 @@
-export class FieldValueAdapter {
-    writable: boolean;
-    readable: boolean;
-    read(object: any, field_name: any): any;
-    write(object: any, field_name: any, value: any): void;
-}
+export class FieldValueAdapter {
+    writable: boolean;
+    readable: boolean;
+    read(object: any, field_name: any): any;
+    write(object: any, field_name: any, value: any): void;
+}
 //# sourceMappingURL=FieldValueAdapter.d.ts.map

package/editor/ecs/component/FieldValueAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FieldValueAdapter.d.ts","sourceRoot":"","sources":["FieldValueAdapter.js"],"names":[],"mappings":"AAEA;IAEQ,kBAAoB;IACpB,kBAAoB;IAIxB,wCAKC;IAED,sDAEC;CACJ"}
+{"version":3,"file":"FieldValueAdapter.d.ts","sourceRoot":"","sources":["FieldValueAdapter.js"],"names":[],"mappings":"AAEA;IACI,kBAAgB;IAChB,kBAAgB;IAEhB,wCAKC;IAED,sDAEC;CACJ"}

package/editor/ecs/component/FieldValueAdapter.js

@@ -1,11 +1,8 @@
 import { assert } from "../../../src/core/assert.js";
 
 export class FieldValueAdapter {
-    constructor() {
-        this.writable = true;
-        this.readable = true;
-
-    }
+    writable = true;
+    readable = true;
 
     read(object, field_name) {
         assert.isString(field_name, 'field_name');