@woosh/meep-engine 2.169.4 → 2.170.0

package/editor/persistence/scene_serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene_serialization.d.ts","sourceRoot":"","sources":["scene_serialization.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH,oDAFa,sBAAsB,CAwBlC;AAED;;;;;;;;;GASG;AACH,0DAHW,sBAAsB,GACpB,oBAAoB,CAehC;AAED;;;;;;;GAOG;AACH,qDAFa,oBAAoB,CAIhC;uCA5EsC,gDAAgD;qCAFlD,+CAA+C"}

package/editor/persistence/scene_serialization.js

@@ -0,0 +1,79 @@
+import { EncodingBinaryBuffer } from "../../src/core/binary/EncodingBinaryBuffer.js";
+import { EndianType } from "../../src/core/binary/EndianType.js";
+import { EntityComponentDataset } from "../../src/engine/ecs/EntityComponentDataset.js";
+import BinaryBufferSerializer from "../../src/engine/ecs/storage/BinaryBufferSerializer.js";
+import { Camera } from "../../src/engine/graphics/ecs/camera/Camera.js";
+import EditorEntity from "../ecs/EditorEntity.js";
+
+/**
+ * Editing-state dataset reduced to what a scene file should contain: editor-owned
+ * entities are stripped and every camera is replaced by an activated clone (the clone
+ * keeps the live scene's component instances untouched — the editing session continues
+ * with its own camera state).
+ *
+ * The copy shares component instances with the live dataset; callers must not mutate
+ * components of the returned dataset.
+ *
+ * @param {Engine} engine
+ * @returns {EntityComponentDataset}
+ */
+export function buildExportDataset(engine) {
+    const currentDataset = engine.entityManager.dataset;
+
+    const dataset = new EntityComponentDataset();
+    dataset.setComponentTypeMap(currentDataset.getComponentTypeMap());
+    dataset.maskedCopy(currentDataset, currentDataset.getComponentTypeMap());
+
+    //remove all Editor entities
+    dataset.traverseComponents(EditorEntity, function (c, entity) {
+        dataset.removeEntity(entity);
+    });
+
+    //clone and re-enable the camera
+    dataset.traverseComponents(Camera, function (c, entity) {
+        const clone = c.clone();
+        clone.active.set(true);
+
+        dataset.removeComponentFromEntity(entity, Camera);
+        dataset.addComponentToEntity(entity, clone);
+    });
+
+    return dataset;
+}
+
+/**
+ * Serialize a dataset into a level-file buffer (big-endian, string-interned).
+ * Throws when serialization itself fails — a truncated file is never produced silently.
+ * Component types without a registered adapter are skipped with a logged error
+ * (engine serializer behavior); register adapters for every type the scene must keep.
+ *
+ * @param {Engine} engine
+ * @param {EntityComponentDataset} dataset
+ * @returns {EncodingBinaryBuffer}
+ */
+export function serializeDataset(engine, dataset) {
+    const serializer = new BinaryBufferSerializer();
+    serializer.engine = engine;
+    serializer.registry = engine.binarySerializationRegistry;
+
+    const state = new EncodingBinaryBuffer();
+    state.endianness = EndianType.BigEndian;
+
+    serializer.process(state, dataset);
+
+    state.trim();
+
+    return state;
+}
+
+/**
+ * The standard scene export: {@link buildExportDataset} followed by
+ * {@link serializeDataset}. Hosts wanting extra scrubbing call the two primitives
+ * around their own step.
+ *
+ * @param {Engine} engine
+ * @returns {EncodingBinaryBuffer}
+ */
+export function exportSceneToBuffer(engine) {
+    return serializeDataset(engine, buildExportDataset(engine));
+}

package/editor/persistence/string_buffer_codec.d.ts

@@ -0,0 +1,20 @@
+/**
+ * URI-escaped ASCII string↔buffer codec, for the small JSON blobs the editor parks in
+ * {@link Storage} beside its binary scenes.
+ *
+ * Environment-free on purpose: TextEncoder/TextDecoder are absent in some DOM test
+ * environments, and percent-escaping keeps non-ASCII intact without them.
+ */
+/**
+ *
+ * @param {string} text
+ * @returns {ArrayBuffer}
+ */
+export function encode_string(text: string): ArrayBuffer;
+/**
+ *
+ * @param {ArrayBuffer} buffer
+ * @returns {string}
+ */
+export function decode_string(buffer: ArrayBuffer): string;
+//# sourceMappingURL=string_buffer_codec.d.ts.map

package/editor/persistence/string_buffer_codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_buffer_codec.d.ts","sourceRoot":"","sources":["string_buffer_codec.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,oCAHW,MAAM,GACJ,WAAW,CAYvB;AAED;;;;GAIG;AACH,sCAHW,WAAW,GACT,MAAM,CAYlB"}

package/editor/persistence/string_buffer_codec.js

@@ -0,0 +1,41 @@
+/**
+ * URI-escaped ASCII string↔buffer codec, for the small JSON blobs the editor parks in
+ * {@link Storage} beside its binary scenes.
+ *
+ * Environment-free on purpose: TextEncoder/TextDecoder are absent in some DOM test
+ * environments, and percent-escaping keeps non-ASCII intact without them.
+ */
+
+/**
+ *
+ * @param {string} text
+ * @returns {ArrayBuffer}
+ */
+export function encode_string(text) {
+    const ascii = encodeURIComponent(text);
+
+    const bytes = new Uint8Array(ascii.length);
+
+    for (let i = 0; i < ascii.length; i++) {
+        bytes[i] = ascii.charCodeAt(i);
+    }
+
+    return bytes.buffer;
+}
+
+/**
+ *
+ * @param {ArrayBuffer} buffer
+ * @returns {string}
+ */
+export function decode_string(buffer) {
+    const bytes = new Uint8Array(buffer);
+
+    let ascii = '';
+
+    for (let i = 0; i < bytes.length; i++) {
+        ascii += String.fromCharCode(bytes[i]);
+    }
+
+    return decodeURIComponent(ascii);
+}

package/editor/process/DisableGameUIProcess.d.ts

@@ -1,8 +1,8 @@
-export class DisableGameUIProcess extends EditorProcess {
-    initialize(editor: any): void;
-}
-export namespace DisableGameUIProcess {
-    let Id: string;
-}
-import { EditorProcess } from "./EditorProcess.js";
+export class DisableGameUIProcess extends EditorProcess {
+    initialize(editor: any): void;
+}
+export namespace DisableGameUIProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
 //# sourceMappingURL=DisableGameUIProcess.d.ts.map

package/editor/process/DisableGameUIProcess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DisableGameUIProcess.d.ts","sourceRoot":"","sources":["DisableGameUIProcess.js"],"names":[],"mappings":"AAGA;IAQI,8BAEC;CAyBJ;;;;8BAtC6B,oBAAoB"}
+{"version":3,"file":"DisableGameUIProcess.d.ts","sourceRoot":"","sources":["DisableGameUIProcess.js"],"names":[],"mappings":"AAGA;IAII,8BAEC;CAyBJ;;;;8BAlC6B,oBAAoB"}

package/editor/process/DisableGameUIProcess.js

@@ -3,11 +3,7 @@ import GUIElementSystem from "../../src/engine/ecs/gui/GUIElementSystem.js";
 
 class DisableGameUIProcess extends EditorProcess {
 
-    constructor() {
-        super();
-
-        this.name = DisableGameUIProcess.Id;
-    }
+    name = DisableGameUIProcess.Id;
 
     initialize(editor) {
         super.initialize(editor);

package/editor/process/EditorProcess.d.ts

@@ -1,19 +1,19 @@
-export class EditorProcess extends BaseProcess {
-    /**
-     *
-     * @type {string}
-     */
-    name: string;
-    /**
-     *
-     * @type {Editor|null}
-     */
-    editor: Editor | null;
-    /**
-     *
-     * @param {Editor} editor
-     */
-    initialize(editor: Editor): void;
-}
-import { BaseProcess } from "../../src/core/process/BaseProcess.js";
+export class EditorProcess extends BaseProcess {
+    /**
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     *
+     * @type {Editor|null}
+     */
+    editor: Editor | null;
+    /**
+     *
+     * @param {Editor} editor
+     */
+    initialize(editor: Editor): void;
+}
+import { BaseProcess } from "../../src/core/process/BaseProcess.js";
 //# sourceMappingURL=EditorProcess.d.ts.map

package/editor/process/GridDisplayProcess.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Ground reference grid at y=0. Gives empty scenes a spatial anchor for navigation and
+ * mesh placement.
+ */
+export class GridDisplayProcess extends EditorProcess {
+    /**
+     * @type {GridHelper|null}
+     */
+    grid: GridHelper | null;
+}
+export namespace GridDisplayProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
+import { GridHelper } from "three";
+//# sourceMappingURL=GridDisplayProcess.d.ts.map

package/editor/process/GridDisplayProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GridDisplayProcess.d.ts","sourceRoot":"","sources":["GridDisplayProcess.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IAII;;OAEG;IACH,MAFU,UAAU,GAAC,IAAI,CAEb;CAkCf;;;;8BA/C6B,oBAAoB;2BADvB,OAAO"}

package/editor/process/GridDisplayProcess.js

@@ -0,0 +1,53 @@
+import { GridHelper } from "three";
+import { EditorProcess } from "./EditorProcess.js";
+
+/**
+ * Ground reference grid at y=0. Gives empty scenes a spatial anchor for navigation and
+ * mesh placement.
+ */
+class GridDisplayProcess extends EditorProcess {
+
+    name = GridDisplayProcess.Id;
+
+    /**
+     * @type {GridHelper|null}
+     */
+    grid = null;
+
+    startup() {
+        super.startup();
+
+        const graphics = this.editor.engine.graphics;
+
+        if (graphics === null) {
+            // headless engine
+            return;
+        }
+
+        if (this.grid === null) {
+            this.grid = new GridHelper(200, 200, 0x556677, 0x2e3338);
+            this.grid.material.transparent = true;
+            this.grid.material.opacity = 0.35;
+        }
+
+        graphics.scene.add(this.grid);
+    }
+
+    shutdown() {
+        super.shutdown();
+
+        const graphics = this.editor.engine.graphics;
+
+        if (graphics === null) {
+            return;
+        }
+
+        if (this.grid !== null) {
+            graphics.scene.remove(this.grid);
+        }
+    }
+}
+
+GridDisplayProcess.Id = 'grid-display';
+
+export { GridDisplayProcess };

package/editor/process/ObstacleGridDisplayProcess.d.ts

@@ -1,13 +1,13 @@
-export class ObstacleGridDisplayProcess extends EditorProcess {
-    /**
-     *
-     * @type {TerrainOverlay|null}
-     */
-    overlay: TerrainOverlay | null;
-    draw(): void;
-}
-export namespace ObstacleGridDisplayProcess {
-    let Id: string;
-}
-import { EditorProcess } from "./EditorProcess.js";
+export class ObstacleGridDisplayProcess extends EditorProcess {
+    /**
+     *
+     * @type {TerrainOverlay|null}
+     */
+    overlay: TerrainOverlay | null;
+    draw(): void;
+}
+export namespace ObstacleGridDisplayProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
 //# sourceMappingURL=ObstacleGridDisplayProcess.d.ts.map

package/editor/process/ObstacleGridDisplayProcess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObstacleGridDisplayProcess.d.ts","sourceRoot":"","sources":["ObstacleGridDisplayProcess.js"],"names":[],"mappings":"AAMA;IAIQ;;;OAGG;IACH,SAFU,iBAAe,IAAI,CAEV;IA4BvB,aAgEC;CASJ;;;;8BA/G6B,oBAAoB"}
+{"version":3,"file":"ObstacleGridDisplayProcess.d.ts","sourceRoot":"","sources":["ObstacleGridDisplayProcess.js"],"names":[],"mappings":"AAMA;IAEI;;;OAGG;IACH,SAFU,iBAAe,IAAI,CAEd;IA4Bf,aAgEC;CASJ;;;;8BA7G6B,oBAAoB"}

package/editor/process/ObstacleGridDisplayProcess.js

@@ -6,15 +6,13 @@ import { EditorProcess } from "./EditorProcess.js";
 
 class ObstacleGridDisplayProcess extends EditorProcess {
 
-    constructor() {
-        super();
-        /**
-         *
-         * @type {TerrainOverlay|null}
-         */
-        this.overlay = null;
-        this.name = ObstacleGridDisplayProcess.Id;
-    }
+    /**
+     *
+     * @type {TerrainOverlay|null}
+     */
+    overlay = null;
+
+    name = ObstacleGridDisplayProcess.Id;
 
     startup() {
         super.startup();

package/editor/process/ParticleEmitterRebuildProcess.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Keeps live particle emitters in sync with editing: rebuilds an emitter when its layer
+ * list changes or one of its parameter lookup tables is edited (curve/gradient editors
+ * announce those through {@link onParameterLutEdited}). Rebuilds are debounced — drags
+ * produce edit bursts.
+ */
+export class ParticleEmitterRebuildProcess extends EditorProcess {
+    /**
+     * emitter layer-list subscriptions, torn down on shutdown
+     * @type {Map<number, {emitter: ParticleEmitter, handler: function}>}
+     */
+    __watched: Map<number, {
+        emitter: ParticleEmitter;
+        handler: Function;
+    }>;
+    /**
+     * entities with a rebuild pending
+     * @type {Set<number>}
+     */
+    __pending: Set<number>;
+    /**
+     * @type {number|null}
+     */
+    __timer: number | null;
+    /**
+     * @type {boolean}
+     */
+    __running: boolean;
+    /**
+     * Map an edited lookup table back to its owning emitter
+     * @param {ParameterLookupTable} lut
+     */
+    __handleLutEdited(lut: ParameterLookupTable): void;
+    /**
+     *
+     * @param {number} entity
+     */
+    __handleEntityCreated(entity: number): void;
+    /**
+     *
+     * @param {number} entity
+     */
+    __handleEntityRemoved(entity: number): void;
+    /**
+     *
+     * @param {number} entity
+     */
+    __scheduleRebuild(entity: number): void;
+    /**
+     *
+     * @param {ParticleEmitter} emitter
+     * @param {number} entity
+     */
+    __watch(emitter: ParticleEmitter, entity: number): void;
+    /**
+     *
+     * @param {number} entity
+     */
+    __unwatch(entity: number): void;
+}
+export namespace ParticleEmitterRebuildProcess {
+    let Id: string;
+}
+import { EditorProcess } from "./EditorProcess.js";
+import { ParticleEmitter } from "../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+//# sourceMappingURL=ParticleEmitterRebuildProcess.d.ts.map

package/editor/process/ParticleEmitterRebuildProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleEmitterRebuildProcess.d.ts","sourceRoot":"","sources":["ParticleEmitterRebuildProcess.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH;IAII;;;OAGG;IACH,WAFU,IAAI,MAAM,EAAE;QAAC,OAAO,EAAE,eAAe,CAAC;QAAC,OAAO,WAAU;KAAC,CAAC,CAE9C;IAEtB;;;OAGG;IACH,WAFU,IAAI,MAAM,CAAC,CAEC;IAEtB;;OAEG;IACH,SAFU,MAAM,GAAC,IAAI,CAEN;IAEf;;OAEG;IACH,WAFU,OAAO,CAEC;IAwGlB;;;OAGG;IACH,mDAuBC;IA9DD;;;OAGG;IACH,8BAFW,MAAM,QAsBhB;IAED;;;OAGG;IACH,8BAFW,MAAM,QAKhB;IA5FD;;;OAGG;IACH,0BAFW,MAAM,QAoBhB;IAED;;;;OAIG;IACH,iBAHW,eAAe,UACf,MAAM,QAahB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAahB;CA4GJ;;;;8BAjN6B,oBAAoB;gCAHlB,kFAAkF"}

package/editor/process/ParticleEmitterRebuildProcess.js

@@ -0,0 +1,217 @@
+import { ParticleEmitter } from "../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+import { onParameterLutEdited } from "../particles/particleEditEvents.js";
+import { rebuildParticleEmitter } from "../particles/rebuildParticleEmitter.js";
+import { EditorProcess } from "./EditorProcess.js";
+
+const REBUILD_DELAY_MS = 250;
+
+/**
+ * Keeps live particle emitters in sync with editing: rebuilds an emitter when its layer
+ * list changes or one of its parameter lookup tables is edited (curve/gradient editors
+ * announce those through {@link onParameterLutEdited}). Rebuilds are debounced — drags
+ * produce edit bursts.
+ */
+class ParticleEmitterRebuildProcess extends EditorProcess {
+
+    name = ParticleEmitterRebuildProcess.Id;
+
+    /**
+     * emitter layer-list subscriptions, torn down on shutdown
+     * @type {Map<number, {emitter: ParticleEmitter, handler: function}>}
+     */
+    __watched = new Map();
+
+    /**
+     * entities with a rebuild pending
+     * @type {Set<number>}
+     */
+    __pending = new Set();
+
+    /**
+     * @type {number|null}
+     */
+    __timer = null;
+
+    /**
+     * @type {boolean}
+     */
+    __running = false;
+
+    constructor() {
+        super();
+
+        this.__handleLutEdited = this.__handleLutEdited.bind(this);
+        this.__handleEntityCreated = this.__handleEntityCreated.bind(this);
+        this.__handleEntityRemoved = this.__handleEntityRemoved.bind(this);
+    }
+
+    /**
+     *
+     * @param {number} entity
+     */
+    __scheduleRebuild(entity) {
+        this.__pending.add(entity);
+
+        if (this.__timer !== null) {
+            return;
+        }
+
+        this.__timer = setTimeout(() => {
+            this.__timer = null;
+
+            const entityManager = this.editor.engine.entityManager;
+
+            for (const pending of this.__pending) {
+                rebuildParticleEmitter(entityManager, pending);
+            }
+
+            this.__pending.clear();
+        }, REBUILD_DELAY_MS);
+    }
+
+    /**
+     *
+     * @param {ParticleEmitter} emitter
+     * @param {number} entity
+     */
+    __watch(emitter, entity) {
+        if (this.__watched.has(entity)) {
+            return;
+        }
+
+        const handler = () => this.__scheduleRebuild(entity);
+
+        emitter.layers.on.added.add(handler);
+        emitter.layers.on.removed.add(handler);
+
+        this.__watched.set(entity, { emitter, handler });
+    }
+
+    /**
+     *
+     * @param {number} entity
+     */
+    __unwatch(entity) {
+        const record = this.__watched.get(entity);
+
+        if (record === undefined) {
+            return;
+        }
+
+        record.emitter.layers.on.added.remove(record.handler);
+        record.emitter.layers.on.removed.remove(record.handler);
+
+        this.__watched.delete(entity);
+    }
+
+    /**
+     *
+     * @param {number} entity
+     */
+    __handleEntityCreated(entity) {
+        // components attach in the microtasks that follow creation (the action queue is
+        // microtask-chained), so the check must land in the NEXT macrotask
+        setTimeout(() => {
+            if (!this.__running) {
+                return;
+            }
+
+            const ecd = this.editor.engine.entityManager.dataset;
+
+            if (!ecd.entityExists(entity)) {
+                return;
+            }
+
+            const emitter = ecd.getComponent(entity, ParticleEmitter);
+
+            if (emitter !== undefined) {
+                this.__watch(emitter, entity);
+            }
+        }, 0);
+    }
+
+    /**
+     *
+     * @param {number} entity
+     */
+    __handleEntityRemoved(entity) {
+        this.__unwatch(entity);
+        this.__pending.delete(entity);
+    }
+
+    /**
+     * Map an edited lookup table back to its owning emitter
+     * @param {ParameterLookupTable} lut
+     */
+    __handleLutEdited(lut) {
+        const ecd = this.editor.engine.entityManager.dataset;
+
+        if (!ecd.isComponentTypeRegistered(ParticleEmitter)) {
+            return;
+        }
+
+        ecd.traverseComponents(ParticleEmitter, (emitter, entity) => {
+            const layer_count = emitter.layers.length;
+
+            for (let i = 0; i < layer_count; i++) {
+                const layer = emitter.layers.get(i);
+
+                const track_count = layer.parameterTracks.tracks.length;
+
+                for (let j = 0; j < track_count; j++) {
+                    if (layer.parameterTracks.tracks.get(j).track === lut) {
+                        this.__scheduleRebuild(entity);
+                        return;
+                    }
+                }
+            }
+        });
+    }
+
+    startup() {
+        super.startup();
+
+        this.__running = true;
+
+        const ecd = this.editor.engine.entityManager.dataset;
+
+        if (ecd.isComponentTypeRegistered(ParticleEmitter)) {
+            ecd.traverseComponents(ParticleEmitter, (emitter, entity) => {
+                this.__watch(emitter, entity);
+            });
+        }
+
+        ecd.onEntityCreated.add(this.__handleEntityCreated);
+        ecd.onEntityRemoved.add(this.__handleEntityRemoved);
+
+        onParameterLutEdited.add(this.__handleLutEdited);
+    }
+
+    shutdown() {
+        super.shutdown();
+
+        this.__running = false;
+
+        const ecd = this.editor.engine.entityManager.dataset;
+
+        ecd.onEntityCreated.remove(this.__handleEntityCreated);
+        ecd.onEntityRemoved.remove(this.__handleEntityRemoved);
+
+        onParameterLutEdited.remove(this.__handleLutEdited);
+
+        for (const entity of Array.from(this.__watched.keys())) {
+            this.__unwatch(entity);
+        }
+
+        if (this.__timer !== null) {
+            clearTimeout(this.__timer);
+            this.__timer = null;
+        }
+
+        this.__pending.clear();
+    }
+}
+
+ParticleEmitterRebuildProcess.Id = 'particle-emitter-rebuild';
+
+export { ParticleEmitterRebuildProcess };