@woosh/meep-engine 3.46.0 → 3.49.0

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

@@ -1 +1 @@
-{"version":3,"file":"TransformModifyAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/TransformModifyAction.js"],"names":[],"mappings":";AAGA;IAGI;;;;;OAKG;IACH,mCAHW,WAAW,EAQrB;IAbD,cAAgB;IAWZ,sBAAwB;IACxB,YAAoB;IAOxB,8CAEC;IAiBD,mCAIC;CACJ;uBA9CsB,0CAA0C;4BADrC,kDAAkD"}
+{"version":3,"file":"TransformModifyAction.d.ts","sourceRoot":"","sources":["../../../../editor/actions/concrete/TransformModifyAction.js"],"names":[],"mappings":";AAIA;IAGI;;;;;OAKG;IACH,mCAHW,WAAW,EAQrB;IAbD,cAAgB;IAWZ,sBAAwB;IACxB,YAAoB;IAOxB,8CAEC;IAqBD,mCAOC;CACJ;uBArDsB,0CAA0C;4BADrC,kDAAkD"}

package/editor/actions/concrete/TransformModifyAction.js

@@ -1,3 +1,4 @@
+import { t64_announce_change } from "../../../src/engine/ecs/transform/t64_announce_change.js";
 import { Transform64 } from "../../../src/engine/ecs/transform/Transform64.js";
 import { Action } from "../../../src/core/process/undo/Action.js";
 
@@ -30,7 +31,8 @@ class TransformModifyAction extends Action {
      * @param {Editor} editor
      */
     async apply(editor) {
-        const component = editor.engine.entityManager.dataset.getComponent(this.entity, Transform64);
+        const dataset = editor.engine.entityManager.dataset;
+        const component = dataset.getComponent(this.entity, Transform64);
 
         if (this.oldState === null) {
             // captured on first application only; redo must restore the original pre-modification state
@@ -38,12 +40,18 @@ class TransformModifyAction extends Action {
         }
 
         component.copy(this.modified);
+
+        // a Transform64 cannot say it was written, so the writer does, on redo as on the first apply
+        t64_announce_change(dataset, this.entity);
     }
 
     async revert(editor) {
-        const component = editor.engine.entityManager.dataset.getComponent(this.entity, Transform64);
+        const dataset = editor.engine.entityManager.dataset;
+        const component = dataset.getComponent(this.entity, Transform64);
 
         component.copy(this.oldState);
+
+        t64_announce_change(dataset, this.entity);
     }
 }
 

package/editor/ecs/component/FieldDescriptor.js

@@ -26,6 +26,21 @@ export class FieldDescriptor {
      */
     schema = undefined;
 
+    /**
+     * When the value is an entity's component, the dataset holding that entity; null otherwise.
+     *
+     * For a component with no change signal of its own, which an editor writing it has to announce on
+     * the entity: a `Transform64` (`TRANSFORM64_EVENT_CHANGE`). Set by {@link buildComponentEditorFromRegistry}.
+     * @type {EntityComponentDataset|null}
+     */
+    owner_dataset = null;
+
+    /**
+     * The entity whose component the value is, in {@link owner_dataset}; -1 when it is not one.
+     * @type {number}
+     */
+    owner_entity = -1;
+
     toString() {
         return `FieldDescriptor[name='${this.name}']`;
     }

package/editor/ecs/component/createObjectEditor.js

@@ -277,27 +277,56 @@ export function buildObjectEditorFromRegistry(object, registry, field_descriptor
 
     const editor = findNearestRegisteredType(registry, object);
 
-    let fd;
+    const fd = field_descriptor === undefined
+        ? root_field_descriptor(object, editor)
+        : field_descriptor;
 
-    if (field_descriptor === undefined) {
+    return editor.build(null, fd, registry);
+}
 
-        fd = new FieldDescriptor();
-        fd.adapter = new FieldValueAdapter();
+/**
+ * {@link buildObjectEditorFromRegistry} for an entity's component, which the editor is told is one: the
+ * field descriptor carries the entity and its dataset, so an editor writing a component with no change
+ * signal of its own can announce the write on the entity.
+ *
+ * @param {Object} component
+ * @param {EntityComponentDataset} dataset
+ * @param {number} entity
+ * @param {Map<*, TypeEditor>} registry
+ */
+export function buildComponentEditorFromRegistry(component, dataset, entity, registry) {
 
-        fd.adapter.read = () => object;
-        fd.adapter.writable = false;
+    const editor = findNearestRegisteredType(registry, component);
 
-        if (editor.schema) {
-            fd.schema = editor.schema;
-        }
+    const fd = root_field_descriptor(component, editor);
 
-    } else {
-        fd = field_descriptor;
-    }
+    fd.owner_dataset = dataset;
+    fd.owner_entity = entity;
 
     return editor.build(null, fd, registry);
 }
 
+/**
+ * The descriptor of a value edited as a whole, rather than as a field of something.
+ *
+ * @param {Object} object
+ * @param {TypeEditor} editor
+ * @returns {FieldDescriptor}
+ */
+function root_field_descriptor(object, editor) {
+    const fd = new FieldDescriptor();
+    fd.adapter = new FieldValueAdapter();
+
+    fd.adapter.read = () => object;
+    fd.adapter.writable = false;
+
+    if (editor.schema) {
+        fd.schema = editor.schema;
+    }
+
+    return fd;
+}
+
 const MAX_DEPTH = 7;
 
 /**

package/editor/ecs/component/editors/ecs/Transform64Editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transform64Editor.d.ts","sourceRoot":"","sources":["../../../../../../editor/ecs/component/editors/ecs/Transform64Editor.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH;;IACI,+GA+CC;CACJ;2BAlE0B,qBAAqB"}
+{"version":3,"file":"Transform64Editor.d.ts","sourceRoot":"","sources":["../../../../../../editor/ecs/component/editors/ecs/Transform64Editor.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH;;IACI,+GAqDC;CACJ;2BAxE0B,qBAAqB"}

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

@@ -1,70 +1,77 @@
-import Quaternion from "../../../../../src/core/geom/Quaternion.js";
-import Vector3 from "../../../../../src/core/geom/Vector3.js";
-import { createObjectEditor } from "../../createObjectEditor.js";
-import { TypeEditor } from "../../TypeEditor.js";
-import { two_way_sync } from "../common/two_way_sync.js";
-
-/**
- * Inspector for a {@link Transform64}.
- *
- * The component is 23 numbers in one array, with no sub-objects and no signals, so the inspector
- * cannot bind to it the way {@link TransformEditor} binds to a {@link Transform} - there is nothing
- * on it to bind to. Instead the editor keeps a mirror: a live {@link Vector3} / {@link Quaternion} /
- * {@link Vector3} triple that the ordinary field editors know how to draw and edit, bridged to the
- * component in both directions.
- *
- * The one thing the mirror cannot do is notice a change made elsewhere. A signalling transform woke
- * its editor when physics moved it; this one refreshes when the view links and whenever the user
- * touches it. That is the cost of the component having no change channel of its own, and it is the
- * same cost every other reader of a Transform64 pays.
- */
-export class Transform64Editor extends TypeEditor {
-    build(parent, field, registry) {
-        /**
-         * @type {Transform64}
-         */
-        const transform = field.adapter.read(parent, field.name);
-
-        const mirror = {
-            translation: new Vector3(),
-            rotation: new Quaternion(),
-            scale: new Vector3()
-        };
-
-        const { sync_up, sync_down } = two_way_sync(
-            () => {
-                mirror.translation.set(
-                    transform.translation_x, transform.translation_y, transform.translation_z
-                );
-                mirror.rotation.set(
-                    transform.rotation_x, transform.rotation_y,
-                    transform.rotation_z, transform.rotation_w
-                );
-                mirror.scale.set(transform.scale_x, transform.scale_y, transform.scale_z);
-            },
-            () => {
-                const { translation, rotation, scale } = mirror;
-
-                transform.setTranslation(translation.x, translation.y, translation.z);
-                transform.setRotation(rotation.x, rotation.y, rotation.z, rotation.w);
-                transform.setScale(scale.x, scale.y, scale.z);
-
-                // a rotation or a scale write leaves the matrix describing the previous pose
-                transform.updateMatrix();
-            }
-        );
-
-        // the mirror has to hold the current pose before the field editors read it
-        sync_up();
-
-        const view = createObjectEditor(mirror, registry);
-
-        view.bindSignal(mirror.translation.onChanged, sync_down);
-        view.bindSignal(mirror.rotation.onChanged, sync_down);
-        view.bindSignal(mirror.scale.onChanged, sync_down);
-
-        view.on.linked.add(sync_up);
-
-        return view;
-    }
-}
+import Quaternion from "../../../../../src/core/geom/Quaternion.js";
+import Vector3 from "../../../../../src/core/geom/Vector3.js";
+import { t64_announce_change } from "../../../../../src/engine/ecs/transform/t64_announce_change.js";
+import { createObjectEditor } from "../../createObjectEditor.js";
+import { TypeEditor } from "../../TypeEditor.js";
+import { two_way_sync } from "../common/two_way_sync.js";
+
+/**
+ * Inspector for a {@link Transform64}.
+ *
+ * The component is 23 numbers in one array, with no sub-objects and no signals, so the inspector
+ * cannot bind to it the way {@link TransformEditor} binds to a {@link Transform} - there is nothing
+ * on it to bind to. Instead the editor keeps a mirror: a live {@link Vector3} / {@link Quaternion} /
+ * {@link Vector3} triple that the ordinary field editors know how to draw and edit, bridged to the
+ * component in both directions.
+ *
+ * The one thing the mirror cannot do is notice a change made elsewhere. A signalling transform woke
+ * its editor when physics moved it; this one refreshes when the view links and whenever the user
+ * touches it. That is the cost of the component having no change channel of its own, and it is the
+ * same cost every other reader of a Transform64 pays.
+ */
+export class Transform64Editor extends TypeEditor {
+    build(parent, field, registry) {
+        /**
+         * @type {Transform64}
+         */
+        const transform = field.adapter.read(parent, field.name);
+
+        const mirror = {
+            translation: new Vector3(),
+            rotation: new Quaternion(),
+            scale: new Vector3()
+        };
+
+        const { sync_up, sync_down } = two_way_sync(
+            () => {
+                mirror.translation.set(
+                    transform.translation_x, transform.translation_y, transform.translation_z
+                );
+                mirror.rotation.set(
+                    transform.rotation_x, transform.rotation_y,
+                    transform.rotation_z, transform.rotation_w
+                );
+                mirror.scale.set(transform.scale_x, transform.scale_y, transform.scale_z);
+            },
+            () => {
+                const { translation, rotation, scale } = mirror;
+
+                transform.setTranslation(translation.x, translation.y, translation.z);
+                transform.setRotation(rotation.x, rotation.y, rotation.z, rotation.w);
+                transform.setScale(scale.x, scale.y, scale.z);
+
+                // a rotation or a scale write leaves the matrix describing the previous pose
+                transform.updateMatrix();
+
+                // A Transform64 cannot say it was written, so the writer does. Only an entity's own
+                // transform has anyone to tell: a transform edited as a field of something has no owner.
+                if (field.owner_dataset !== null) {
+                    t64_announce_change(field.owner_dataset, field.owner_entity);
+                }
+            }
+        );
+
+        // the mirror has to hold the current pose before the field editors read it
+        sync_up();
+
+        const view = createObjectEditor(mirror, registry);
+
+        view.bindSignal(mirror.translation.onChanged, sync_down);
+        view.bindSignal(mirror.rotation.onChanged, sync_down);
+        view.bindSignal(mirror.scale.onChanged, sync_down);
+
+        view.on.linked.add(sync_up);
+
+        return view;
+    }
+}

package/editor/particles/effect/ParticleReferenceSimulation.d.ts

@@ -94,7 +94,7 @@ export class ParticleReferenceSimulation {
      * array of objects: this runs per frame, and the preview has nothing to do with the values after
      * it has drawn them.
      *
-     * @param {function({x: number, y: number, z: number, size: number, r: number, g: number, b: number, a: number, rotation: number, frame: number})} visitor
+     * @param {function({x: number, y: number, z: number, size: number, r: number, g: number, b: number, a: number, frame: number})} visitor
      */
     forEachParticle(visitor: (arg0: {
         x: number;
@@ -105,7 +105,6 @@ export class ParticleReferenceSimulation {
         g: number;
         b: number;
         a: number;
-        rotation: number;
         frame: number;
     }) => any): void;
     #private;

package/editor/particles/effect/ParticleReferenceSimulation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleReferenceSimulation.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleReferenceSimulation.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE8B;AAE9C;IAgGI;;;OAGG;IACH;QAF4B,QAAQ,GAAzB,MAAM;OAiBhB;IAjHD;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;OAGG;IACH,KAFU,WAAW,CAEI;IAQzB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEP;IAoDL;;OAEG;IACH,UAFU,MAAM,CAEQ;IAa5B;;OAEG;IACH,cAYC;IAED;;;;;;;;;;;;OAYG;IACH;QAJ0G,OAAO,EAAtG,OAAO,8DAA8D,EAAE,eAAe;QACU,MAAM,EAAtG,OAAO,gEAAgE,EAAE,cAAc;QACxE,OAAO,EAAtB,MAAM;aAsBhB;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,SAFW,MAAM,QAmBhB;IA0KD;;;;;;;;;OASG;IACH,gCAFoB;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,gBA6C/I;;CACJ"}
+{"version":3,"file":"ParticleReferenceSimulation.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleReferenceSimulation.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE8B;AAE9C;IAgGI;;;OAGG;IACH;QAF4B,QAAQ,GAAzB,MAAM;OAiBhB;IAjHD;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;OAGG;IACH,KAFU,WAAW,CAEI;IAQzB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEP;IAoDL;;OAEG;IACH,UAFU,MAAM,CAEQ;IAa5B;;OAEG;IACH,cAYC;IAED;;;;;;;;;;;;OAYG;IACH;QAJ0G,OAAO,EAAtG,OAAO,8DAA8D,EAAE,eAAe;QACU,MAAM,EAAtG,OAAO,gEAAgE,EAAE,cAAc;QACxE,OAAO,EAAtB,MAAM;aAsBhB;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,SAFW,MAAM,QAmBhB;IA0KD;;;;;;;;;OASG;IACH,gCAFoB;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,gBA2C7H;;CACJ"}

package/editor/particles/effect/ParticleReferenceSimulation.js

@@ -422,7 +422,7 @@ export class ParticleReferenceSimulation {
      * array of objects: this runs per frame, and the preview has nothing to do with the values after
      * it has drawn them.
      *
-     * @param {function({x: number, y: number, z: number, size: number, r: number, g: number, b: number, a: number, rotation: number, frame: number})} visitor
+     * @param {function({x: number, y: number, z: number, size: number, r: number, g: number, b: number, a: number, frame: number})} visitor
      */
     forEachParticle(visitor) {
         if (this.#layout === null) {
@@ -441,12 +441,11 @@ export class ParticleReferenceSimulation {
         const position = offset("position");
         const size = offset("size");
         const color = offset("color");
-        const rotation = offset("rotation");
         const frame = offset("frame");
 
         const words = this.#pool_f32;
 
-        const particle = { x: 0, y: 0, z: 0, size: 1, r: 1, g: 1, b: 1, a: 1, rotation: 0, frame: 0 };
+        const particle = { x: 0, y: 0, z: 0, size: 1, r: 1, g: 1, b: 1, a: 1, frame: 0 };
 
         for (const slot of this.alive) {
             const base = slot * PARTICLE_RECORD_WORD_COUNT;
@@ -462,7 +461,6 @@ export class ParticleReferenceSimulation {
             particle.b = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color + 2];
             particle.a = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color + 3];
 
-            particle.rotation = rotation === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + rotation];
             particle.frame = frame === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + frame];
 
             visitor(particle);

package/editor/tools/TransformToolV2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformToolV2.d.ts","sourceRoot":"","sources":["../../../editor/tools/TransformToolV2.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;GAWG;AACH;IACI,aAA2B;IAE3B;;OAEG;IACH,MAFU,cAAc,MAAM,CAAC,CAEmB;IAElD;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEd;IAElB;;;OAGG;IACH,gBAFU,OAAO,CAEM;IAuBnB;;;OAGG;IACH,kBAFU,IAAI,MAAM,EAAE,WAAW,CAAC,CAED;IAGrC;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,wCAEC;IAED;;;OAGG;IACH,mBAFa,MAAM,CAclB;IAED,iCAUC;IAED,0BAkCC;IAED;;OAEG;IACH,6BAgFC;IAED;;OAEG;IACH,wBA+BC;IA2DD,6BAgCC;IAED,4BAEC;IAED,6BAEC;IAED,4BAQC;IAED;;;OAGG;IACH,2BAFW,aAAa,QAuBvB;CACJ;iBAzZgB,kBAAkB;0BAJT,uCAAuC;kCAK/B,2BAA2B;4BAJjC,+CAA+C"}
+{"version":3,"file":"TransformToolV2.d.ts","sourceRoot":"","sources":["../../../editor/tools/TransformToolV2.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;GAWG;AACH;IACI,aAA2B;IAE3B;;OAEG;IACH,MAFU,cAAc,MAAM,CAAC,CAEmB;IAElD;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEd;IAElB;;;OAGG;IACH,gBAFU,OAAO,CAEM;IAuBnB;;;OAGG;IACH,kBAFU,IAAI,MAAM,EAAE,WAAW,CAAC,CAED;IAGrC;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,wCAEC;IAED;;;OAGG;IACH,mBAFa,MAAM,CAclB;IAED,iCAUC;IAED,0BAkCC;IAED;;OAEG;IACH,6BAmFC;IAED;;OAEG;IACH,wBA+BC;IA2DD,6BAgCC;IAED,4BAEC;IAED,6BAEC;IAED,4BAQC;IAED;;;OAGG;IACH,2BAFW,aAAa,QAuBvB;CACJ;iBA5ZgB,kBAAkB;0BALT,uCAAuC;kCAM/B,2BAA2B;4BAJjC,+CAA+C"}

package/editor/tools/TransformToolV2.js

@@ -2,6 +2,7 @@ import Quaternion from "../../src/core/geom/Quaternion.js";
 import Vector1 from "../../src/core/geom/Vector1.js";
 import Vector3 from "../../src/core/geom/Vector3.js";
 import ObservedValue from "../../src/core/model/ObservedValue.js";
+import { t64_announce_change } from "../../src/engine/ecs/transform/t64_announce_change.js";
 import { Transform64 } from "../../src/engine/ecs/transform/Transform64.js";
 import { KeyCodes } from "../../src/engine/input/devices/KeyCodes.js";
 import TransformModifyAction from "../actions/concrete/TransformModifyAction.js";
@@ -240,6 +241,9 @@ export class TransformToolV2 extends Tool {
 
                 transform.updateMatrix();
             }
+
+            // the controls announce the primary they move; the entities carried along are this tool's
+            t64_announce_change(ecd, entity);
         }
     }
 

package/editor/tools/v2/TransformControls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformControls.d.ts","sourceRoot":"","sources":["../../../../editor/tools/v2/TransformControls.js"],"names":[],"mappings":"AA4EA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAsNI;;;;;OAKG;IACH,sBALW,+BAA6B,cAE7B,WAAW,eACX,OAAO,EAgCjB;IAzPD;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ,6BAA2B;IAE3B;;OAEG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;OAKG;IACH,MAFU,MAAM,GAAC,IAAI,CAET;IAEZ;;OAEG;IACH,MAFU,MAAM,CAEe;IAE/B;;OAEG;IACH,OAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;OAEG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;OAIG;IACH,iBAFU,MAAM,GAAC,IAAI,CAEE;IAEvB;;;;OAIG;IACH,cAFU,MAAM,GAAC,IAAI,CAED;IAEpB;;OAEG;IACH,WAFU,MAAM,GAAC,IAAI,CAEJ;IAEjB;;OAEG;IACH,eAFU,OAAO,CAEa;IAE9B;;OAEG;IACH,iBAFU,UAAU,CAEe;IAEnC;;;;;OAKG;IACH,oBAFU,OAAO,CAEkB;IAEnC;;OAEG;IACH,sBAFU,UAAU,CAEoB;IAExC;;OAEG;IACH,kBAFU,OAAO,CAEuB;IAExC;;OAEG;IACH,aAFU,OAAO,CAEkB;IAEnC;;OAEG;IACH,qBAFU,UAAU,CAEmB;IAEvC;;OAEG;IACH,gBAFU,OAAO,CAEc;IAE/B;;OAEG;IACH,kBAFU,UAAU,CAEgB;IAEpC;;OAEG;IACH,aAFU,OAAO,CAEkB;IAEnC;;;;OAIG;IACH,YAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,UAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH,SAFU,OAAO,CAEO;IAExB;;OAEG;IACH,YAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,UAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH,cAFU,OAAO,CAEY;IAE7B;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,gBAFU,OAAO,CAEc;IAE/B;;OAEG;IACH,KAFU,OAAO,CAEU;IA+DvB,cAAwB;IACxB,wBAA4B;IAM5B,iBAAwC;IACxC,oBAA8C;IAC9C,qBAAgD;IAChD,oBAA8C;IAC9C,kBAA0C;IAe9C;;OAEG;IACH,yCAIC;IAmGD,iCAYC;IAED,gCAuCC;IAED;;;OAGG;IACH,qBAFW;QAAC,IAAI,EAAC,MAAM,CAAA;KAAC,QAIvB;IAED,gCAsPC;IAED,8BAcC;IAED,gBASC;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,iBAAiB,CAW7B;IAED;;;OAGG;IACH,oCAIC;IAGD,eAYC;IAED,cAuBC;IAID,kBAIC;IAED,yBAIC;IAED,+CAIC;IAED,yCAIC;IAED,mCAIC;IAED,yBAIC;IAED,2BAIC;;CAEJ;0BAx4ByB,gBAAgB;oBAHtB,mCAAmC;uBADhC,sCAAsC;4BAEjC,kDAAkD"}
+{"version":3,"file":"TransformControls.d.ts","sourceRoot":"","sources":["../../../../editor/tools/v2/TransformControls.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAsNI;;;;;OAKG;IACH,sBALW,+BAA6B,cAE7B,WAAW,eACX,OAAO,EAgCjB;IAzPD;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ,6BAA2B;IAE3B;;OAEG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;OAKG;IACH,MAFU,MAAM,GAAC,IAAI,CAET;IAEZ;;OAEG;IACH,MAFU,MAAM,CAEe;IAE/B;;OAEG;IACH,OAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;OAEG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;OAIG;IACH,iBAFU,MAAM,GAAC,IAAI,CAEE;IAEvB;;;;OAIG;IACH,cAFU,MAAM,GAAC,IAAI,CAED;IAEpB;;OAEG;IACH,WAFU,MAAM,GAAC,IAAI,CAEJ;IAEjB;;OAEG;IACH,eAFU,OAAO,CAEa;IAE9B;;OAEG;IACH,iBAFU,UAAU,CAEe;IAEnC;;;;;OAKG;IACH,oBAFU,OAAO,CAEkB;IAEnC;;OAEG;IACH,sBAFU,UAAU,CAEoB;IAExC;;OAEG;IACH,kBAFU,OAAO,CAEuB;IAExC;;OAEG;IACH,aAFU,OAAO,CAEkB;IAEnC;;OAEG;IACH,qBAFU,UAAU,CAEmB;IAEvC;;OAEG;IACH,gBAFU,OAAO,CAEc;IAE/B;;OAEG;IACH,kBAFU,UAAU,CAEgB;IAEpC;;OAEG;IACH,aAFU,OAAO,CAEkB;IAEnC;;;;OAIG;IACH,YAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,UAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH,SAFU,OAAO,CAEO;IAExB;;OAEG;IACH,YAFU,OAAO,CAEU;IAE3B;;OAEG;IACH,UAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH,cAFU,OAAO,CAEY;IAE7B;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,gBAFU,OAAO,CAEc;IAE/B;;OAEG;IACH,KAFU,OAAO,CAEU;IA+DvB,cAAwB;IACxB,wBAA4B;IAM5B,iBAAwC;IACxC,oBAA8C;IAC9C,qBAAgD;IAChD,oBAA8C;IAC9C,kBAA0C;IAe9C;;OAEG;IACH,yCAIC;IAmGD,iCAYC;IAED,gCAuCC;IAED;;;OAGG;IACH,qBAFW;QAAC,IAAI,EAAC,MAAM,CAAA;KAAC,QAIvB;IAED,gCA0PC;IAED,8BAcC;IAED,gBASC;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,iBAAiB,CAW7B;IAED;;;OAGG;IACH,oCAIC;IAGD,eAYC;IAED,cAyBC;IAID,kBAIC;IAED,yBAIC;IAED,+CAIC;IAED,yCAIC;IAED,mCAIC;IAED,yBAIC;IAED,2BAIC;;CAEJ;0BA94ByB,gBAAgB;oBAJtB,mCAAmC;uBADhC,sCAAsC;4BAGjC,kDAAkD"}

package/editor/tools/v2/TransformControls.js

@@ -1,6 +1,7 @@
 import { assert } from "../../../src/core/assert.js";
 import Quaternion from "../../../src/core/geom/Quaternion.js";
 import Vector3 from "../../../src/core/geom/Vector3.js";
+import { t64_announce_change } from "../../../src/engine/ecs/transform/t64_announce_change.js";
 import { Transform64 } from "../../../src/engine/ecs/transform/Transform64.js";
 import { FrameRunner } from "../../../src/engine/graphics/FrameRunner.js";
 import { GizmoNode } from "./GizmoNode.js";
@@ -765,6 +766,10 @@ class TransformControls extends GizmoNode {
             object_transform.updateMatrix();
         }
 
+        // a Transform64 cannot say it was written, so the writer does: this is what moves the entity's
+        // rendered row, its sound, and whatever else follows it by its transform
+        t64_announce_change(this.entity.dataset, object);
+
         this.dispatchEvent(_changeEvent);
         this.dispatchEvent(_objectChangeEvent);
 
@@ -854,6 +859,8 @@ class TransformControls extends GizmoNode {
             );
             this.object_transform.updateMatrix();
 
+            t64_announce_change(this.entity.dataset, this.object);
+
             this.dispatchEvent(_changeEvent);
             this.dispatchEvent(_objectChangeEvent);
 

package/editor/view/ecs/EntityEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityEditor.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/EntityEditor.js"],"names":[],"mappings":";AAkBA;IAYI,yBA2OC;IAlOG,YAAkB;IAGlB,0BAAoC;IACpC;;OAEG;IACH,eAFU,cAAc,aAAa,CAAC,CAEM;IAC5C,sBAA4B;IAU5B;;;OAGG;IACH,sBAFU,mCAAiC,CAEN;IAwGrC,wBAEE;IAiGF,aAAkB;;CAazB;iBA3QgB,2BAA2B;0BATlB,0CAA0C;8BAEtC,0CAA0C;iBAHvD,2CAA2C;qCAcvB,2BAA2B;sBAT1C,uCAAuC"}
+{"version":3,"file":"EntityEditor.d.ts","sourceRoot":"","sources":["../../../../editor/view/ecs/EntityEditor.js"],"names":[],"mappings":";AAkBA;IAYI,yBA6OC;IApOG,YAAkB;IAGlB,0BAAoC;IACpC;;OAEG;IACH,eAFU,cAAc,aAAa,CAAC,CAEM;IAC5C,sBAA4B;IAU5B;;;OAGG;IACH,sBAFU,mCAAiC,CAEN;IAwGrC,wBAEE;IAmGF,aAAkB;;CAazB;iBA7QgB,2BAA2B;0BATlB,0CAA0C;8BAEtC,0CAA0C;iBAHvD,2CAA2C;qCAcvB,2BAA2B;sBAT1C,uCAAuC"}

package/editor/view/ecs/EntityEditor.js

@@ -11,7 +11,7 @@ import EmptyView from "../../../src/view/elements/EmptyView.js";
 import View from "../../../src/view/View.js";
 import ComponentAddAction from "../../actions/concrete/ComponentAddAction.js";
 import ComponentRemoveAction from "../../actions/concrete/ComponentRemoveAction.js";
-import { buildObjectEditorFromRegistry } from "../../ecs/component/createObjectEditor.js";
+import { buildComponentEditorFromRegistry } from "../../ecs/component/createObjectEditor.js";
 import { ComponentControlView } from "./ComponentControlView.js";
 import { LineView } from "./components/common/LineView.js";
 
@@ -180,7 +180,9 @@ class EntityEditor extends View {
             let view;
 
             try {
-                view = buildObjectEditorFromRegistry(component, registry);
+                // told whose component it is, so an edit to one with no change signal of its own (a
+                // Transform64) can be announced on the entity
+                view = buildComponentEditorFromRegistry(component, get_dataset(), self.model.getValue(), registry);
             } catch (e) {
                 view = new LabelView(`ERROR: ${e.message}\n${e.stack}`);
 

package/editor/view/particles/effect/ParticleGraphEditorView.js

@@ -145,7 +145,7 @@ const PALETTE_CATEGORIES = [
     { name: "math", types: ["neg", "abs", "floor", "fract", "round", "ceil", "sqrt", "rsqrt", "sin", "cos", "tan", "asin", "acos", "atan2", "exp", "log"] },
     { name: "vector", types: ["vec2", "vec3", "vec4", "decompose2", "decompose3", "decompose4", "swizzle", "dot", "cross", "length", "normalize", "distance", "angleBetween2", "angleBetween3"] },
     { name: "logic", types: ["compare", "select"] },
-    { name: "rotation", types: ["quatFromAxisAngle", "quatLookRotation", "quatRotate"] },
+    { name: "rotation", types: ["quatFromAxisAngle", "quatLookRotation", "quatRotate", "quatMultiply", "quatIntegrate", "sampleRotation", "emitterRotation"] },
     { name: "sampling", types: ["sampleSphereSurface", "sampleSphereVolume"] },
     { name: "noise", types: ["simplex3", "simplex4", "curl3", "curl4", "srdnoise3", "psrdnoise3"] },
 ];

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.46.0",
+  "version": "3.49.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/collection/array/array_insert_at.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Insert `value` at `index`, keeping the order of the rest: what `array.splice(index, 0, value)` does to
+ * the array, in place, without the empty array `splice` builds and returns every call.
+ *
+ * The elements from `index` on move up one slot each, and the array ends one longer.
+ *
+ * @template T
+ * @param {T[]} array
+ * @param {number} index where `value` lands, `0 <= index <= array.length`
+ * @param {T} value
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function array_insert_at<T>(array: T[], index: number, value: T): void;
+//# sourceMappingURL=array_insert_at.d.ts.map

package/src/core/collection/array/array_insert_at.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_insert_at.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_insert_at.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,sDANW,MAAM,kBAqBhB"}

package/src/core/collection/array/array_insert_at.js

@@ -0,0 +1,32 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Insert `value` at `index`, keeping the order of the rest: what `array.splice(index, 0, value)` does to
+ * the array, in place, without the empty array `splice` builds and returns every call.
+ *
+ * The elements from `index` on move up one slot each, and the array ends one longer.
+ *
+ * @template T
+ * @param {T[]} array
+ * @param {number} index where `value` lands, `0 <= index <= array.length`
+ * @param {T} value
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function array_insert_at(array, index, value) {
+    // past the end, splice appends, and this would leave a hole; below 0 it writes a "-1" property
+    assert.isNonNegativeInteger(index, 'index');
+    assert.lessThanOrEqual(index, array.length, 'index');
+
+    let i = array.length;
+
+    // grow by one first, through push, so the store grows the way an append grows it
+    array.push(value);
+
+    for (; i > index; i--) {
+        array[i] = array[i - 1];
+    }
+
+    array[index] = value;
+}

package/src/core/collection/array/array_remove_at.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Remove the element at `index`, keeping the order of the rest: what `array.splice(index, 1)` does to
+ * the array, in place, without the array of removed elements `splice` builds and returns every call.
+ *
+ * The elements after `index` move down one slot each, and the array ends one shorter.
+ *
+ * @template T
+ * @param {T[]} array
+ * @param {number} index an index into `array`, `0 <= index < array.length`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function array_remove_at<T>(array: T[], index: number): void;
+//# sourceMappingURL=array_remove_at.d.ts.map

package/src/core/collection/array/array_remove_at.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_remove_at.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_remove_at.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,sDALW,MAAM,QAmBhB"}

package/src/core/collection/array/array_remove_at.js

@@ -0,0 +1,30 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Remove the element at `index`, keeping the order of the rest: what `array.splice(index, 1)` does to
+ * the array, in place, without the array of removed elements `splice` builds and returns every call.
+ *
+ * The elements after `index` move down one slot each, and the array ends one shorter.
+ *
+ * @template T
+ * @param {T[]} array
+ * @param {number} index an index into `array`, `0 <= index < array.length`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function array_remove_at(array, index) {
+    // outside the array, splice removes nothing, and this would drop the last element instead
+    assert.isNonNegativeInteger(index, 'index');
+    assert.lessThan(index, array.length, 'index');
+
+    const last = array.length - 1;
+
+    for (let i = index; i < last; i++) {
+        array[i] = array[i + 1];
+    }
+
+    // pop rather than `length = last`: setting the length lets V8 trim the store, which a pool removing and
+    // inserting every frame would only grow back
+    array.pop();
+}

package/src/core/geom/3d/quaternion/quat3_look_rotation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The rotation that points local +Z along `forward`, with local +Y turned as close to `up` as it can be:
+ * the orientation of a camera, a turret or a walking body told where to face.
+ *
+ * Neither vector has to be unit length, within what their squares can hold: lanes from about 1e-154
+ * to 1e154. Below that a square is 0 and the vector reads as zero, above it Infinity. The frame is built
+ * from them the usual way — `right = up × forward` and `up' = forward × right`, each normalised — and the
+ * rotation is read off that matrix, so it maps +X to `right`, +Y to `up'` and +Z to `forward`.
+ *
+ * **When `up` is parallel to `forward` there is no frame to build**: their cross product is the zero
+ * vector, and any roll about `forward` would do. The forward direction is then nudged by 0.001 along X
+ * when `up` is ±Z, and along Z otherwise, and renormalised. For a unit `up` the answer is then a unit
+ * rotation within about a milliradian of `forward`, rolled however the nudge leaves it; do not rely on
+ * the roll there. The ±Z test reads `|uz| === 1`, so a longer `up` along Z is nudged along Z, stays
+ * parallel, and gets a rotation that is not unit length. Pass a unit `up` where it can be parallel.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * Everything is worked in locals and only the result is written, so it allocates nothing, and a caller
+ * that hands its own parameters straight on boxes nothing either. {@link Quaternion#_lookRotation} and
+ * `t64_look_rotation` both answer through this.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number} fx forward, any length
+ * @param {number} fy
+ * @param {number} fz
+ * @param {number} ux up, any length
+ * @param {number} uy
+ * @param {number} uz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quat3_look_rotation(out: number[] | Float32Array | Float64Array, out_offset: number, fx: number, fy: number, fz: number, ux: number, uy: number, uz: number): void;
+//# sourceMappingURL=quat3_look_rotation.d.ts.map

package/src/core/geom/3d/quaternion/quat3_look_rotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_look_rotation.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_look_rotation.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,yCAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkIhB"}