@woosh/meep-engine 3.14.6 → 3.16.0

package/src/engine/graphics3/MeshSystem.js

@@ -8,12 +8,13 @@ import {
     unregister_instance_animation
 } from "./register_instance_animation.js";
 import { System } from "../ecs/System.js";
-import { Transform } from "../ecs/transform/Transform.js";
-import { t64_copy_from_transform } from "../ecs/transform/t64_copy_from_transform.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
 import { ParentEntity } from "../ecs/parent/ParentEntity.js";
 import { ShadedGeometry } from "../graphics/ecs/mesh-v2/ShadedGeometry.js";
 import { SGMesh } from "../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
 import { shade_bundle_to_entity_composition } from "./shade_node_to_entity_composition.js";
+import { EventType } from "../ecs/EventType.js";
+import { t64_announce_change } from "../ecs/transform/t64_announce_change.js";
 
 /**
  * Puts entities into Shade's scene and keeps them where the ECS says they are.
@@ -134,7 +135,7 @@ export class MeshSystem extends System {
         this.#scene = scene;
         this.#load = load;
 
-        this.dependencies = [SGMesh, Transform];
+        this.dependencies = [SGMesh, Transform64];
     }
 
     /**
@@ -431,25 +432,29 @@ export class MeshSystem extends System {
 
     /**
      * @param {SGMesh} model
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     link(model, transform, entity) {
-        const entry = { nodes: [], bindings: [], instance: null, animation: null, composition: null };
+        const entry = { nodes: [], on_changed: null, instance: null, animation: null, composition: null };
 
         this.#entries.set(entity, entry);
 
         // The entity is placed the moment its transform moves, not on a poll: a transform that has
         // not changed costs nothing, which is the same bargain the scene database makes downstream.
-        const place = () => this.#place(entity, transform);
-
-        for (const component of [transform.position, transform.rotation, transform.scale]) {
-            const binding = new SignalBinding(component.onChanged, place);
+        // A Transform64 has no signals of its own, so the announcement comes from the dataset: the
+        // writer sends ComponentChanged and this wakes on it. Coarser than the three sub-object
+        // signals it replaces - a scale write wakes a placement that only reads the whole transform
+        // anyway - and #place already skips when nothing moved.
+        const on_changed = event => {
+            if (event.klass === Transform64) {
+                this.#place(entity, transform);
+            }
+        };
 
-            binding.link();
+        entry.on_changed = on_changed;
 
-            entry.bindings.push(binding);
-        }
+        this.entityManager.dataset.addEntityEventListener(entity, EventType.ComponentChanged, on_changed);
 
         if (model.url === null) {
             // nothing to show yet; {@link update} watches for the url arriving
@@ -463,7 +468,7 @@ export class MeshSystem extends System {
 
     /**
      * @param {SGMesh} model
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     unlink(model, transform, entity) {
@@ -475,7 +480,7 @@ export class MeshSystem extends System {
      *
      * @param {number} entity
      * @param {string} url
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
     async #attach(entity, url, transform) {
         /*
@@ -547,7 +552,7 @@ export class MeshSystem extends System {
      *
      * @param {number} entity
      * @param {SceneBundle} bundle
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
     #expand(entity, bundle, transform) {
         const entry = this.#entries.get(entity);
@@ -556,22 +561,46 @@ export class MeshSystem extends System {
 
         composition.entity.add(ParentEntity.from(entity));
 
-        const follow = () => composition.transform.copy(transform);
+        // Copying is only half of it: the composed entity is a writer like any other, so the
+        // systems placing ITS nodes wake on its own announcement, not on the source entity is.
+        // EntityNode.transform is the hierarchy pose, not the entity's component - the component is
+        // the world transform the node syncs down into. Under signals the copy alone triggered that
+        // sync; a Transform64 has none, so the sync is asked for explicitly.
+        const follow = () => {
+            composition.transform.copy(transform);
+
+            composition.transform_changed();
+        };
 
         follow();
 
         composition.build(this.entityManager.dataset);
 
-        transform.subscribe(follow);
+        // the build linked the composed entity's own systems; sync once more so they see the pose
+        follow();
 
-        composition.on.destroyed.addOne(() => transform.unsubscribe(follow));
+        // the composed entity follows the source transform, and a Transform64 has no signals of
+        // its own, so the follow rides the dataset announcement like every other consumer
+        const on_source_changed = event => {
+            if (event.klass === Transform64) {
+                follow();
+            }
+        };
+
+        const ecd = this.entityManager.dataset;
+
+        ecd.addEntityEventListener(entity, EventType.ComponentChanged, on_source_changed);
+
+        composition.on.destroyed.addOne(
+            () => ecd.removeEntityEventListener(entity, EventType.ComponentChanged, on_source_changed)
+        );
 
         entry.composition = composition;
     }
 
     /**
      * @param {number} entity
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
     #place(entity, transform) {
         const entry = this.#entries.get(entity);
@@ -585,7 +614,7 @@ export class MeshSystem extends System {
         for (let i = 0; i < nodes.length; i++) {
             const node = nodes[i];
 
-            t64_copy_from_transform(node.transform_local, transform);
+            node.transform_local.copy(transform);
 
             // recomputes transform_global down the subtree, and bumps the version the scene
             // database reads to decide what to upload
@@ -603,8 +632,10 @@ export class MeshSystem extends System {
             return;
         }
 
-        for (let i = 0; i < entry.bindings.length; i++) {
-            entry.bindings[i].unlink();
+        if (entry.on_changed !== null) {
+            this.entityManager.dataset.removeEntityEventListener(entity, EventType.ComponentChanged, entry.on_changed);
+
+            entry.on_changed = null;
         }
 
         for (let i = 0; i < entry.nodes.length; i++) {

package/src/engine/graphics3/ParticipatingMediaSystem.d.ts

@@ -7,27 +7,32 @@
  *
  * @param {ParticipatingMediaVolume} volume Shade's
  * @param {ParticipatingMedia} component meep's
- * @param {Transform} transform where the box is
+ * @param {Transform64} transform where the box is
  */
-export function participating_media_volume_write(volume: ParticipatingMediaVolume, component: ParticipatingMedia, transform: Transform): void;
+export function participating_media_volume_write(volume: ParticipatingMediaVolume, component: ParticipatingMedia, transform: Transform64): void;
 /**
  * Whether the volume already says what the component and transform say.
  *
  * True on all but a handful of frames, which is the point of asking: a `false` here costs the whole
  * scene's volumetrics table a trip to the GPU.
  *
- * **The transform is compared by its matrix rather than by `Transform.equals`**, because the matrix
- * is the entire transform the GPU is given — the volume's position, rotation and scale are never
- * read on their own. That makes this exactly the question worth asking, "would the upload differ",
- * and it catches a transform posed by writing its matrix, which comparing position, rotation and
- * scale would not.
+ * **The transform is compared by its matrix rather than by its components**, because the matrix is
+ * the entire transform the GPU is given — the volume's position, rotation and scale are never read
+ * on their own. That makes this exactly the question worth asking, "would the upload differ", and it
+ * catches a transform posed by writing its matrix, which comparing position, rotation and scale
+ * would not.
+ *
+ * The volume's matrix is a `Float64Array` and the component's is a `Float32Array`, and the strict
+ * comparison across the two still holds: {@link participating_media_volume_write} copies the matrix
+ * across element by element, and every f32 value widens to f64 exactly. It is a recomposed matrix
+ * that would not compare equal, which is why the write does not recompose.
  *
  * @param {ParticipatingMediaVolume} volume
  * @param {ParticipatingMedia} component
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @returns {boolean}
  */
-export function participating_media_volume_is_current(volume: ParticipatingMediaVolume, component: ParticipatingMedia, transform: Transform): boolean;
+export function participating_media_volume_is_current(volume: ParticipatingMediaVolume, component: ParticipatingMedia, transform: Transform64): boolean;
 /**
  * Mirrors fog, smoke and cloud entities into Shade's volumetrics.
  *
@@ -63,25 +68,25 @@ export class ParticipatingMediaSystem extends System<any> {
      * @param {Scene} scene
      */
     constructor(graphics: GraphicsEngine, scene: Scene);
-    dependencies: (typeof Transform | typeof ParticipatingMedia)[];
+    dependencies: (typeof Transform64 | typeof ParticipatingMedia)[];
     startup(entityManager: any): Promise<void>;
     shutdown(entityManager: any): Promise<void>;
     /**
      * @param {ParticipatingMedia} component
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    link(component: ParticipatingMedia, transform: Transform, entity: number): void;
+    link(component: ParticipatingMedia, transform: Transform64, entity: number): void;
     /**
      * @param {ParticipatingMedia} component
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    unlink(component: ParticipatingMedia, transform: Transform, entity: number): void;
+    unlink(component: ParticipatingMedia, transform: Transform64, entity: number): void;
     #private;
 }
 import { ParticipatingMediaVolume } from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
 import { ParticipatingMedia } from "./ParticipatingMedia.js";
-import { Transform } from "../ecs/transform/Transform.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
 import { System } from "../ecs/System.js";
 //# sourceMappingURL=ParticipatingMediaSystem.d.ts.map

package/src/engine/graphics3/ParticipatingMediaSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticipatingMediaSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSystem.js"],"names":[],"mappings":"AA6IA;;;;;;;;;;GAUG;AACH,yDAJW,wBAAwB,aACxB,kBAAkB,aAClB,SAAS,QASnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8DALW,wBAAwB,aACxB,kBAAkB,aAClB,SAAS,GACP,OAAO,CAOnB;AAhLD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAmBI;;;OAGG;IACH,oDASC;IA9BD,+DAA+C;IAgC/C,2CAIC;IAED,4CAIC;IAED;;;;OAIG;IACH,gBAJW,kBAAkB,aAClB,SAAS,UACT,MAAM,QAUhB;IAED;;;;OAIG;IACH,kBAJW,kBAAkB,aAClB,SAAS,UACT,MAAM,QAIhB;;CAmCJ;yCAzIwC,8DAA8D;mCAGpE,yBAAyB;0BADlC,+BAA+B;uBADlC,kBAAkB"}
+{"version":3,"file":"ParticipatingMediaSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSystem.js"],"names":[],"mappings":"AA6IA;;;;;;;;;;GAUG;AACH,yDAJW,wBAAwB,aACxB,kBAAkB,aAClB,WAAW,QAkBrB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8DALW,wBAAwB,aACxB,kBAAkB,aAClB,WAAW,GACT,OAAO,CAOnB;AA9LD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAmBI;;;OAGG;IACH,oDASC;IA9BD,iEAAiD;IAgCjD,2CAIC;IAED,4CAIC;IAED;;;;OAIG;IACH,gBAJW,kBAAkB,aAClB,WAAW,UACX,MAAM,QAUhB;IAED;;;;OAIG;IACH,kBAJW,kBAAkB,aAClB,WAAW,UACX,MAAM,QAIhB;;CAmCJ;yCAzIwC,8DAA8D;mCAGpE,yBAAyB;4BADhC,iCAAiC;uBADtC,kBAAkB"}

package/src/engine/graphics3/ParticipatingMediaSystem.js

@@ -1,184 +1,198 @@
-import { assert } from "../../core/assert.js";
-import { isArrayEqualStrict } from "../../core/collection/array/isArrayEqualStrict.js";
-import { ParticipatingMediaVolume } from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
-import { System } from "../ecs/System.js";
-import { Transform } from "../ecs/transform/Transform.js";
-import { ParticipatingMedia } from "./ParticipatingMedia.js";
-
-/**
- * Mirrors fog, smoke and cloud entities into Shade's volumetrics.
- *
- * The same shape as {@link LightSystem}: the ECS says what exists and where, and this keeps the
- * renderer's own objects in step. A {@link ParticipatingMediaVolume} is a unit cube posed by a
- * transform, so an entity's `Transform` is the volume — position, size and orientation with no
- * translation step in between.
- *
- * **The transform is taken as world-space, with no hierarchy applied**, which is what the volume
- * model can express: a volume is an oriented box in the scene and Shade has no parent chain to walk
- * for it. Parenting a fog volume to a moving entity therefore leaves the fog where the child's own
- * transform puts it. The lights are placed the same way, for the same reason.
- *
- * **Changes are polled once a frame rather than subscribed to.** A `Transform` announces itself and
- * nothing else here does — a density tuned by an editor slider, a particle spec swapped wholesale
- * for a different Mie solution — so subscribing would cover one field in three and the other two
- * would still have to be polled. Two paths that have to agree, where one does the whole job. It
- * costs about two dozen float comparisons per volume per frame and a scene holds volumes in the
- * tens, so the comparison is cheaper than the signal plumbing it replaces. The price is latency: a
- * change is visible within a frame rather than instantly.
- *
- * **Nothing is uploaded unless something actually changed.** The GPU table is repacked whole
- * whenever {@link SceneVolumetrics.version} moves, so an unconditional copy every frame would
- * re-upload every volume in the scene forever. The comparison is what decides, and on almost every
- * frame it decides nothing has to happen.
- *
- * @see ParticipatingMedia the component
- * @see SceneVolumetrics what the volumes are handed to
- */
-export class ParticipatingMediaSystem extends System {
-
-    dependencies = [ParticipatingMedia, Transform];
-
-    /**
-     * @type {GraphicsEngine}
-     */
-    #graphics;
-
-    /**
-     * @type {Scene}
-     */
-    #scene;
-
-    /**
-     * @type {Map<number, {component: ParticipatingMedia, transform: Transform, volume: ParticipatingMediaVolume}>}
-     */
-    #entries = new Map();
-
-    /**
-     * @param {GraphicsEngine} graphics
-     * @param {Scene} scene
-     */
-    constructor(graphics, scene) {
-        super();
-
-        assert.defined(graphics, 'graphics');
-        assert.defined(scene, 'scene');
-        assert.equal(scene.isScene, true, 'scene.isScene !== true');
-
-        this.#graphics = graphics;
-        this.#scene = scene;
-    }
-
-    async startup(entityManager) {
-        this.entityManager = entityManager;
-
-        this.#graphics.set_scene(this.#scene);
-    }
-
-    async shutdown(entityManager) {
-        for (const entity of Array.from(this.#entries.keys())) {
-            this.#drop(entity);
-        }
-    }
-
-    /**
-     * @param {ParticipatingMedia} component
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    link(component, transform, entity) {
-        const volume = new ParticipatingMediaVolume();
-
-        participating_media_volume_write(volume, component, transform);
-
-        this.#scene.volumetrics.add(volume);
-
-        this.#entries.set(entity, { component, transform, volume });
-    }
-
-    /**
-     * @param {ParticipatingMedia} component
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    unlink(component, transform, entity) {
-        this.#drop(entity);
-    }
-
-    /**
-     * @param {number} time_delta_seconds
-     */
-    update(time_delta_seconds) {
-        const volumetrics = this.#scene.volumetrics;
-
-        for (const entry of this.#entries.values()) {
-            const volume = entry.volume;
-
-            if (participating_media_volume_is_current(volume, entry.component, entry.transform)) {
-                continue;
-            }
-
-            participating_media_volume_write(volume, entry.component, entry.transform);
-
-            volumetrics.invalidate();
-        }
-    }
-
-    /**
-     * @param {number} entity
-     */
-    #drop(entity) {
-        const entry = this.#entries.get(entity);
-
-        if (entry === undefined) {
-            return;
-        }
-
-        this.#scene.volumetrics.remove(entry.volume);
-
-        this.#entries.delete(entity);
-    }
-}
-
-/**
- * Copy what the component and its transform say onto the volume Shade will render.
- *
- * The particle spec is **copied, not referenced**: two entities are routinely built from the same
- * blueprint and would otherwise share one spec, so tuning one volume's particle would silently
- * retune the other's.
- *
- * @param {ParticipatingMediaVolume} volume Shade's
- * @param {ParticipatingMedia} component meep's
- * @param {Transform} transform where the box is
- */
-export function participating_media_volume_write(volume, component, transform) {
-    volume.density = component.density;
-    volume.fade_distance = component.fade_distance;
-
-    volume.particle_spec.copy(component.particle_spec);
-
-    volume.transform.copy(transform);
-}
-
-/**
- * Whether the volume already says what the component and transform say.
- *
- * True on all but a handful of frames, which is the point of asking: a `false` here costs the whole
- * scene's volumetrics table a trip to the GPU.
- *
- * **The transform is compared by its matrix rather than by `Transform.equals`**, because the matrix
- * is the entire transform the GPU is given — the volume's position, rotation and scale are never
- * read on their own. That makes this exactly the question worth asking, "would the upload differ",
- * and it catches a transform posed by writing its matrix, which comparing position, rotation and
- * scale would not.
- *
- * @param {ParticipatingMediaVolume} volume
- * @param {ParticipatingMedia} component
- * @param {Transform} transform
- * @returns {boolean}
- */
-export function participating_media_volume_is_current(volume, component, transform) {
-    return volume.density === component.density
-        && volume.fade_distance === component.fade_distance
-        && isArrayEqualStrict(volume.transform.matrix, transform.matrix)
-        && volume.particle_spec.equals(component.particle_spec);
-}
+import { assert } from "../../core/assert.js";
+import { isArrayEqualStrict } from "../../core/collection/array/isArrayEqualStrict.js";
+import { ParticipatingMediaVolume } from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
+import { System } from "../ecs/System.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
+import { ParticipatingMedia } from "./ParticipatingMedia.js";
+
+/**
+ * Mirrors fog, smoke and cloud entities into Shade's volumetrics.
+ *
+ * The same shape as {@link LightSystem}: the ECS says what exists and where, and this keeps the
+ * renderer's own objects in step. A {@link ParticipatingMediaVolume} is a unit cube posed by a
+ * transform, so an entity's `Transform` is the volume — position, size and orientation with no
+ * translation step in between.
+ *
+ * **The transform is taken as world-space, with no hierarchy applied**, which is what the volume
+ * model can express: a volume is an oriented box in the scene and Shade has no parent chain to walk
+ * for it. Parenting a fog volume to a moving entity therefore leaves the fog where the child's own
+ * transform puts it. The lights are placed the same way, for the same reason.
+ *
+ * **Changes are polled once a frame rather than subscribed to.** A `Transform` announces itself and
+ * nothing else here does — a density tuned by an editor slider, a particle spec swapped wholesale
+ * for a different Mie solution — so subscribing would cover one field in three and the other two
+ * would still have to be polled. Two paths that have to agree, where one does the whole job. It
+ * costs about two dozen float comparisons per volume per frame and a scene holds volumes in the
+ * tens, so the comparison is cheaper than the signal plumbing it replaces. The price is latency: a
+ * change is visible within a frame rather than instantly.
+ *
+ * **Nothing is uploaded unless something actually changed.** The GPU table is repacked whole
+ * whenever {@link SceneVolumetrics.version} moves, so an unconditional copy every frame would
+ * re-upload every volume in the scene forever. The comparison is what decides, and on almost every
+ * frame it decides nothing has to happen.
+ *
+ * @see ParticipatingMedia the component
+ * @see SceneVolumetrics what the volumes are handed to
+ */
+export class ParticipatingMediaSystem extends System {
+
+    dependencies = [ParticipatingMedia, Transform64];
+
+    /**
+     * @type {GraphicsEngine}
+     */
+    #graphics;
+
+    /**
+     * @type {Scene}
+     */
+    #scene;
+
+    /**
+     * @type {Map<number, {component: ParticipatingMedia, transform: Transform, volume: ParticipatingMediaVolume}>}
+     */
+    #entries = new Map();
+
+    /**
+     * @param {GraphicsEngine} graphics
+     * @param {Scene} scene
+     */
+    constructor(graphics, scene) {
+        super();
+
+        assert.defined(graphics, 'graphics');
+        assert.defined(scene, 'scene');
+        assert.equal(scene.isScene, true, 'scene.isScene !== true');
+
+        this.#graphics = graphics;
+        this.#scene = scene;
+    }
+
+    async startup(entityManager) {
+        this.entityManager = entityManager;
+
+        this.#graphics.set_scene(this.#scene);
+    }
+
+    async shutdown(entityManager) {
+        for (const entity of Array.from(this.#entries.keys())) {
+            this.#drop(entity);
+        }
+    }
+
+    /**
+     * @param {ParticipatingMedia} component
+     * @param {Transform64} transform
+     * @param {number} entity
+     */
+    link(component, transform, entity) {
+        const volume = new ParticipatingMediaVolume();
+
+        participating_media_volume_write(volume, component, transform);
+
+        this.#scene.volumetrics.add(volume);
+
+        this.#entries.set(entity, { component, transform, volume });
+    }
+
+    /**
+     * @param {ParticipatingMedia} component
+     * @param {Transform64} transform
+     * @param {number} entity
+     */
+    unlink(component, transform, entity) {
+        this.#drop(entity);
+    }
+
+    /**
+     * @param {number} time_delta_seconds
+     */
+    update(time_delta_seconds) {
+        const volumetrics = this.#scene.volumetrics;
+
+        for (const entry of this.#entries.values()) {
+            const volume = entry.volume;
+
+            if (participating_media_volume_is_current(volume, entry.component, entry.transform)) {
+                continue;
+            }
+
+            participating_media_volume_write(volume, entry.component, entry.transform);
+
+            volumetrics.invalidate();
+        }
+    }
+
+    /**
+     * @param {number} entity
+     */
+    #drop(entity) {
+        const entry = this.#entries.get(entity);
+
+        if (entry === undefined) {
+            return;
+        }
+
+        this.#scene.volumetrics.remove(entry.volume);
+
+        this.#entries.delete(entity);
+    }
+}
+
+/**
+ * Copy what the component and its transform say onto the volume Shade will render.
+ *
+ * The particle spec is **copied, not referenced**: two entities are routinely built from the same
+ * blueprint and would otherwise share one spec, so tuning one volume's particle would silently
+ * retune the other's.
+ *
+ * @param {ParticipatingMediaVolume} volume Shade's
+ * @param {ParticipatingMedia} component meep's
+ * @param {Transform64} transform where the box is
+ */
+export function participating_media_volume_write(volume, component, transform) {
+    volume.density = component.density;
+    volume.fade_distance = component.fade_distance;
+
+    volume.particle_spec.copy(component.particle_spec);
+
+    // By the MATRIX, not by the components. The volume is defined by the matrix the GPU is
+    // handed, and a transform can be posed by writing that matrix directly - with automatic change
+    // detection off, position, rotation and scale know nothing about it. `fromMatrix` copies the
+    // sixteen elements and then decomposes them, leaving the matrix bit-identical, so the volume
+    // carries the authored matrix exactly and gets usable components besides.
+    //
+    // Nothing is gained by recomposing in f64 here, the way t64_copy_from_transform would: the
+    // source matrix is f32, and precision the input never had cannot be recovered. This becomes a
+    // plain buffer copy, f64 end to end, once the entity's own transform is a Transform64.
+    volume.transform.fromMatrix(transform.matrix);
+}
+
+/**
+ * Whether the volume already says what the component and transform say.
+ *
+ * True on all but a handful of frames, which is the point of asking: a `false` here costs the whole
+ * scene's volumetrics table a trip to the GPU.
+ *
+ * **The transform is compared by its matrix rather than by its components**, because the matrix is
+ * the entire transform the GPU is given — the volume's position, rotation and scale are never read
+ * on their own. That makes this exactly the question worth asking, "would the upload differ", and it
+ * catches a transform posed by writing its matrix, which comparing position, rotation and scale
+ * would not.
+ *
+ * The volume's matrix is a `Float64Array` and the component's is a `Float32Array`, and the strict
+ * comparison across the two still holds: {@link participating_media_volume_write} copies the matrix
+ * across element by element, and every f32 value widens to f64 exactly. It is a recomposed matrix
+ * that would not compare equal, which is why the write does not recompose.
+ *
+ * @param {ParticipatingMediaVolume} volume
+ * @param {ParticipatingMedia} component
+ * @param {Transform64} transform
+ * @returns {boolean}
+ */
+export function participating_media_volume_is_current(volume, component, transform) {
+    return volume.density === component.density
+        && volume.fade_distance === component.fade_distance
+        && isArrayEqualStrict(volume.transform.matrix, transform.matrix)
+        && volume.particle_spec.equals(component.particle_spec);
+}