@woosh/meep-engine 2.165.0 → 2.165.2

package/src/engine/ecs/EntityManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAgBU,MAAM;;;;;;;;;AAiBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,iCAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;qBADO,uCAAc;;MAI1B;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IAEf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BAmFC;IAED;;;OAGG;IACH,uBAFa,OAAO,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,IAAI,aAAS,CAiBzB;IAGD;;;OAGG;IACH,6BAFW,MAAM,QA8EhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,iEA2DC;IAED;;;;OAIG;IACH,uDAFa,QAAQ,OAAO,CAAC,CAyC5B;IAED;;;;;OAKG;IACH,mBAmCC;IAED;;;;;OAKG;IACH,oBAqFC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,mCAFa,wCAAgB,CA0B5B;IAED;;;;OAIG;IACH,8DAFa,wCAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAoFC;IAGL;;OAEG;IACH,yBAjtBe,sBAAsB,UAitBA;IACrC;;OAEG;IACH,0BAAqC;CATpC;uBA59BmC,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B"}
+{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAgBU,MAAM;;;;;;;;;AAiBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,iCAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;qBADO,uCAAc;;MAI1B;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IAEf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BAmFC;IAED;;;OAGG;IACH,uBAFa,OAAO,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,IAAI,aAAS,CAiBzB;IAGD;;;OAGG;IACH,6BAFW,MAAM,QA8EhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,iEA6DC;IAED;;;;OAIG;IACH,uDAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAmCC;IAED;;;;;OAKG;IACH,oBAqFC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,mCAFa,wCAAgB,CA0B5B;IAED;;;;OAIG;IACH,8DAFa,wCAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAoFC;IAGL;;OAEG;IACH,yBArtBe,sBAAsB,UAqtBA;IACrC;;OAEG;IACH,0BAAqC;CATpC;uBAh+BmC,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B"}

package/src/engine/ecs/EntityManager.js

@@ -354,7 +354,7 @@ export class EntityManager {
                 continue;
             }
 
-            system.handleDatasetAttached(dataset);
+            system.handleDatasetDetached(dataset);
         }
 
         this.dataset = null;
@@ -557,9 +557,11 @@ export class EntityManager {
         systems[systemIndex] = system;
 
 
-        //build observer
-        const entityObserver = new EntityObserver(system.dependencies, system.link, system.unlink, system);
-        this.systemObservers.set(system, entityObserver);
+        //build observer; a dependency-less system observes no entity tuple and never links
+        if (system.dependencies.length > 0) {
+            const entityObserver = new EntityObserver(system.dependencies, system.link, system.unlink, system);
+            this.systemObservers.set(system, entityObserver);
+        }
 
         let result_promise;
         if (this.state === EntityManagerState.Running) {
@@ -596,11 +598,11 @@ export class EntityManager {
             return false;
         }
 
-        //unlink system observer
+        //unlink system observer, dependency-less systems don't have one
         const systemObserver = this.systemObservers.get(system);
         this.systemObservers.delete(system);
 
-        assert.notEqual(systemObserver, undefined, "System observer is undefined, it was possibly removed illegally or was not created");
+        assert.ok(systemObserver !== undefined || system.dependencies.length === 0, "System observer is undefined, it was possibly removed illegally or was not created");
 
         //shutdown system
         this.systems.splice(systemIndex, 1);
@@ -609,8 +611,10 @@ export class EntityManager {
         this.__execution_order_needs_update = true;
 
         if (this.dataset !== null) {
-            // remove observed and unlink entities
-            this.dataset.removeObserver(systemObserver, true);
+            if (systemObserver !== undefined) {
+                // remove observed and unlink entities
+                this.dataset.removeObserver(systemObserver, true);
+            }
             system.handleDatasetDetached(this.dataset);
         }
 

package/src/engine/ecs/EntityObserver.js

@@ -127,7 +127,7 @@ export class EntityObserver {
      * @return {boolean}
      */
     get isConnected() {
-        return this.dataset === null;
+        return this.dataset !== null;
     }
 
     /**

package/src/engine/ecs/System.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,uCAAqB;IAErB;;;;OAIG;IACH,oBAA+C;IAE/C;;;;;;;OAOG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,6BAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uCAHa,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wCAHa,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;OAIG;IACH,wCAEC;IAED;;;;OAIG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,2CAFsC,MAAM,CAEhB;IAG5B;;;;;;OAMG;IACH,sCAFsC,MAAM,CAErB;CAvBtB;0BA2BS,MAAM"}
+{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,uCAAqB;IAErB;;;;OAIG;IACH,oBAA+C;IAE/C;;;;;;;;;OASG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,6BAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uCAHa,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wCAHa,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;;OAKG;IACH,wCAEC;IAED;;;;;OAKG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,2CAFsC,MAAM,CAEhB;IAG5B;;;;;;OAMG;IACH,sCAFsC,MAAM,CAErB;CAvBtB;0BA2BS,MAAM"}

package/src/engine/ecs/System.js

@@ -53,6 +53,8 @@ export class System {
 
     /**
      * Component classes which have to be present before the system links an entity.
+     * May be left empty: such a system observes no entity tuple, {@link link}/{@link unlink} are never invoked,
+     * and it is driven purely by {@link startup}/{@link shutdown} and the {@link update}/{@link fixedUpdate} methods.
      * NOTE: do not modify this while the system is running.
      * @see link
      * @see unlink
@@ -157,6 +159,7 @@ export class System {
     /**
      * Called automatically when an entity gets a complete component tuple {@link this.dependencies}.
      * Inputs are the same as dependencies, only instances instead of classes, plus there is an extra argument at the end, which is the entity ID.
+     * Never invoked when {@link this.dependencies} is empty.
      * see {@link EntityObserver} for more implementation detail
      */
     link(component, entity) {
@@ -166,6 +169,7 @@ export class System {
     /**
      * Called automatically when an entity breaks component tuple {@link this.dependencies}.
      * Inputs are the same as dependencies, only instances instead of classes, plus there is an extra argument at the end, which is the entity ID.
+     * Never invoked when {@link this.dependencies} is empty.
      * see {@link EntityObserver} for more implementation detail
      */
     unlink(component, entity) {

package/src/engine/ecs/animation/AnimationClip.js

@@ -83,7 +83,7 @@ export class AnimationClip {
         if (typeof json.repeatCount === "number") {
             this.repeatCount.fromJSON(json.repeatCount);
         } else {
-            this.repeatCount.set(Number.POSITIVE_INFINITY);
+            this.repeatCount.set(1);
         }
 
         if (typeof json.weight === "number") {

package/src/engine/ecs/attachment/AttachmentSystem.js

@@ -75,9 +75,9 @@ export class AttachmentSystem extends System {
         let numRecords = waiting.length;
 
         for (let i = 0; i < numRecords; i++) {
-            const entity = waiting[i];
+            const record = waiting[i];
 
-            if (entity === entity) {
+            if (record === entity) {
                 waiting.splice(i, 1);
                 removedCount++;
 

package/src/engine/ecs/attachment/TransformAttachmentBinding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformAttachmentBinding.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/attachment/TransformAttachmentBinding.js"],"names":[],"mappings":"AAOA;CAgCC;kCAtCiC,wBAAwB"}
+{"version":3,"file":"TransformAttachmentBinding.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/attachment/TransformAttachmentBinding.js"],"names":[],"mappings":"AAOA;CA2CC;kCAjDiC,wBAAwB"}

package/src/engine/ecs/attachment/TransformAttachmentBinding.js

@@ -30,11 +30,22 @@ export class TransformAttachmentBinding extends AttachmentBinding {
         this.parentTransform.position.onChanged.add(this.update, this);
         this.parentTransform.rotation.onChanged.add(this.update, this);
         this.parentTransform.scale.onChanged.add(this.update, this);
+
+        // update() also composes the attachment's local socket offset, so changes
+        // to it must trigger a recompute too — otherwise a moved socket offset only
+        // takes effect the next time the parent transform happens to change.
+        this.attachment.transform.position.onChanged.add(this.update, this);
+        this.attachment.transform.rotation.onChanged.add(this.update, this);
+        this.attachment.transform.scale.onChanged.add(this.update, this);
     }
 
     unlink() {
         this.parentTransform.position.onChanged.remove(this.update, this);
         this.parentTransform.rotation.onChanged.remove(this.update, this);
         this.parentTransform.scale.onChanged.remove(this.update, this);
+
+        this.attachment.transform.position.onChanged.remove(this.update, this);
+        this.attachment.transform.rotation.onChanged.remove(this.update, this);
+        this.attachment.transform.scale.onChanged.remove(this.update, this);
     }
 }

package/src/engine/ecs/fow/FogOfWar.js

@@ -559,8 +559,8 @@ export class FogOfWar {
     rebuildSampler() {
 
         //resize the sampler
-        const samplerHeight = this.size.x + 2;
-        const samplerWidth = this.size.y + 2;
+        const samplerWidth = this.size.x + 2;
+        const samplerHeight = this.size.y + 2;
         const uint8Array = new Uint8Array(samplerWidth * samplerHeight);
 
         uint8Array.fill(255);

package/src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screenSpaceFogOfWarShader.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,kDAFW,cAAc,CAiJxB;+BAtJyE,OAAO"}
+{"version":3,"file":"screenSpaceFogOfWarShader.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,kDAFW,cAAc,CAmKxB;+BAxKyE,OAAO"}

package/src/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js

@@ -28,16 +28,20 @@ export function buildScreenSpaceFogOfWarShader() {
         const float   c_samplesX    = 5.0;
         const float   c_samplesY    = 5.0;
 
-        const float   c_halfSamplesX = c_samplesX / 2.0;
-        const float   c_halfSamplesY = c_samplesY / 2.0;
+        // True kernel centre is (N-1)/2, so a 5-tap kernel is centred on index 2.
+        const float   c_halfSamplesX = (c_samplesX - 1.0) / 2.0;
+        const float   c_halfSamplesY = (c_samplesY - 1.0) / 2.0;
         
-        const vec2 sigma = vec2(23.0, 23.0);
+        // Std-dev in *sample-index* units (kernel is only c_samples wide), NOT
+        // fog-resolution units. ~1.2 gives a real bell over the 5 taps.
+        const vec2 sigma = vec2(1.2, 1.2);
         
         const vec2 sigma2_sq = sigma*sigma*2.0;
         
-        const float radius = 0.9;
-        
-        const vec2 samplingBias = vec2(c_halfSamplesX,c_halfSamplesY)/ vec2( radius );
+        // Spacing between adjacent taps, in fog texels. Controls blur width and
+        // therefore how strongly the coarse fog grid is smoothed. 1.0 = one texel
+        // per tap, so a 5-tap kernel reaches +/-2 texels either side of centre.
+        const float texelSpacing = 1.0;
         
 	     vec3 computeWorldPosition(){
                 // Convert screen coordinates to normalized device coordinates (NDC)
@@ -64,10 +68,16 @@ export function buildScreenSpaceFogOfWarShader() {
 	     float Gaussian(float sigma2_sq, float x){
            return exp(-(x*x) / sigma2_sq);
          }
+
+	     // interleaved gradient noise (Jimenez 2014, "Next Generation Post Processing in Call of Duty")
+	     float gradientNoise(const in vec2 fragCoord){
+	       return fract(52.9829189 * fract(dot(fragCoord, vec2(0.06711056, 0.00583715))));
+	     }
 	     
 	     float getFog(const in vec2 uv){
 	        
-	        vec2 texelSize = samplingBias * uResolution;
+	        // size of one fog texel, in UV space, scaled by the desired tap spacing
+	        vec2 texelSize = texelSpacing / uResolution;
 	     
 			float total = 0.0;
             
@@ -76,12 +86,12 @@ export function buildScreenSpaceFogOfWarShader() {
             for (float iy = 0.0; iy < c_samplesY; ++iy){
             
                 float fy = Gaussian(sigma2_sq.y, iy - c_halfSamplesY);
-                float offsety = (iy-c_halfSamplesY) / texelSize.y;
+                float offsety = (iy - c_halfSamplesY) * texelSize.y;
                 
                 for (float ix = 0.0; ix < c_samplesX; ++ix){
                 
                     float fx = Gaussian(sigma2_sq.x, ix - c_halfSamplesX);
-                    float offsetx = (ix-c_halfSamplesX) / texelSize.x;
+                    float offsetx = (ix - c_halfSamplesX) * texelSize.x;
                     
                     float weight = fx * fy;
                     
@@ -104,6 +114,14 @@ export function buildScreenSpaceFogOfWarShader() {
             
             gl_FragColor = uColor;
             gl_FragColor.a *= fogValue;
+
+            // The fog is written to an 8-bit intermediate layer target; both channels of
+            // that target carry a quantized ramp: alpha holds fogValue, rgb holds
+            // uColor.rgb * alpha (multiplied by ROP blending). Dither each at +/-0.5 LSB
+            // of its own quantizer to break up banding. The rgb noise is attenuated by
+            // alpha in the blend, exactly matching how the rgb band amplitude scales.
+            gl_FragColor.a += gradientNoise(gl_FragCoord.xy) * (1.0 / 255.0) - (0.5 / 255.0);
+            gl_FragColor.rgb += vec3( gradientNoise(gl_FragCoord.xy + vec2(7.0, 13.0)) * (1.0 / 255.0) - (0.5 / 255.0) );
         }
         `;
     }

package/src/engine/ecs/gui/hud/HeadsUpDisplaySystem.js

@@ -85,7 +85,7 @@ class HeadsUpDisplaySystem extends System {
 
             x *= transform_scale.x;
             y *= transform_scale.y;
-            z *= transform_scale.y;
+            z *= transform_scale.z;
 
             const q = transform.rotation;
 

package/src/engine/ecs/gui/position/ViewportPosition.d.ts

@@ -50,10 +50,11 @@ declare class ViewportPosition {
      */
     equals(other: ViewportPosition): boolean;
     hash(): number;
-    fromJSON({ position, offset, anchor, screenEdgeWidth, stickToScreenEdge, enabled, }: {
+    fromJSON({ position, offset, anchor, resolveGuiCollisions, screenEdgeWidth, stickToScreenEdge, enabled, }: {
         position?: Vector2;
         offset?: Vector2;
         anchor?: Vector2;
+        resolveGuiCollisions?: boolean;
         screenEdgeWidth?: number;
         stickToScreenEdge?: boolean;
         enabled?: boolean;
@@ -71,6 +72,7 @@ declare class ViewportPosition {
             x: number;
             y: number;
         };
+        resolveGuiCollisions: boolean;
         screenEdgeWidth: number;
         stickToScreenEdge: boolean;
         enabled: boolean;

package/src/engine/ecs/gui/position/ViewportPosition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewportPosition.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/position/ViewportPosition.js"],"names":[],"mappings":"oCAOU,MAAM;;;;;;AAOhB;IAuGI,4CAMC;IA5GD;;;OAGG;IACH,UAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,QAFU,OAAO,CAEM;IACvB;;;OAGG;IACH,QAFU,OAAO,CAEU;IAG3B;;;;OAIG;IACH,sBAFU,OAAO,CAEY;IAE7B;;;;OAIG;IACH,iBAFU,MAAM,CAEK;IAGrB;;;OAGG;IACH,mBAFU,OAAO,CAES;IAE1B;;;OAGG;IACH,SAFU,eAAe,CAEW;IAEpC;;;;OAIG;IACH,cAHW,gBAAgB,GACd,OAAO,CAWnB;IAED,eAUC;IAED;;;;;;;aAgBC;IAED;;;;;;;;;;;;;;;;MASC;CASJ;;;;;oBA3HmB,kCAAkC;4BAC1B,2CAA2C"}
+{"version":3,"file":"ViewportPosition.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/position/ViewportPosition.js"],"names":[],"mappings":"oCAOU,MAAM;;;;;;AAOhB;IA0GI,4CAMC;IA/GD;;;OAGG;IACH,UAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,QAFU,OAAO,CAEM;IACvB;;;OAGG;IACH,QAFU,OAAO,CAEU;IAG3B;;;;OAIG;IACH,sBAFU,OAAO,CAEY;IAE7B;;;;OAIG;IACH,iBAFU,MAAM,CAEK;IAGrB;;;OAGG;IACH,mBAFU,OAAO,CAES;IAE1B;;;OAGG;IACH,SAFU,eAAe,CAEW;IAEpC;;;;OAIG;IACH,cAHW,gBAAgB,GACd,OAAO,CAWnB;IAED,eAUC;IAED;;;;;;;;aAkBC;IAED;;;;;;;;;;;;;;;;;MAUC;CASJ;;;;;oBA9HmB,kCAAkC;4BAC1B,2CAA2C"}

package/src/engine/ecs/gui/position/ViewportPosition.js

@@ -91,7 +91,8 @@ class ViewportPosition {
             position = Vector2.zero,
             offset = Vector2.zero,
             anchor = Vector2.zero,
-            screenEdgeWidth = 0,
+            resolveGuiCollisions = false,
+            screenEdgeWidth = 10,
             stickToScreenEdge = false,
             enabled = true,
         }
@@ -99,6 +100,7 @@ class ViewportPosition {
         this.position.fromJSON(position);
         this.offset.fromJSON(offset);
         this.anchor.fromJSON(anchor);
+        this.resolveGuiCollisions = resolveGuiCollisions;
         this.screenEdgeWidth = screenEdgeWidth;
         this.stickToScreenEdge = stickToScreenEdge;
         this.enabled.fromJSON(enabled);
@@ -109,6 +111,7 @@ class ViewportPosition {
             position: this.position.toJSON(),
             offset: this.offset.toJSON(),
             anchor: this.anchor.toJSON(),
+            resolveGuiCollisions: this.resolveGuiCollisions,
             screenEdgeWidth: this.screenEdgeWidth,
             stickToScreenEdge: this.stickToScreenEdge,
             enabled: this.enabled.toJSON()

package/src/engine/ecs/storage/binary/BinarySerializationRegistry.d.ts

@@ -36,6 +36,15 @@ export class BinarySerializationRegistry {
      * @returns {BinaryClassSerializationAdapter|undefined}
      */
     removeAdapter(className: string): BinaryClassSerializationAdapter | undefined;
+    /**
+     * Reverse of {@link registerAdapter}: resolve the registered class name for a given class (constructor).
+     * Useful when serializing a value whose class name is not known up-front — obtain the constructor via
+     * `Object.getPrototypeOf(value).constructor` and look it up here. Does not read or mutate any instance.
+     *
+     * @param {Function} klass class/constructor to look up
+     * @returns {string|undefined} the class name under which an adapter is registered, or `undefined` if none
+     */
+    getClassName(klass: Function): string | undefined;
     /**
      *
      * @param {string} className
@@ -62,5 +71,6 @@ export class BinarySerializationRegistry {
      * @type {boolean}
      */
     readonly isBinarySerializationRegistry: boolean;
+    #private;
 }
 //# sourceMappingURL=BinarySerializationRegistry.d.ts.map

package/src/engine/ecs/storage/binary/BinarySerializationRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinarySerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/storage/binary/BinarySerializationRegistry.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH;IAEI;;;;OAIG;IACH,2BAAsB;IACtB;;;;OAIG;IACH,6BAAwB;IAExB;;;OAGG;IACH,2BAFW,iCAAiC,QAM3C;IAED;;;;;;OAMG;IACH,sEAJW,MAAM,GACJ,OAAO,CAkCnB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,kCAAgC,SAAS,CAYrD;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,kCAAgC,SAAS,CAMrD;IAED;;;;;OAKG;IACH,4BAJW,MAAM,kCAEJ,OAAO,CA6CnB;IAED;;;;;;OAMG;IACH,6BALW,MAAM,gBACN,MAAM,eACN,MAAM,GACJ,qBAAqB,GAAC,IAAI,CA0DtC;IAIL;;;OAGG;IACH,wCAFU,OAAO,CAEkD;CANlE"}
+{"version":3,"file":"BinarySerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/storage/binary/BinarySerializationRegistry.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH;IAEI;;;;OAIG;IACH,2BAAsB;IACtB;;;;OAIG;IACH,6BAAwB;IAWxB;;;OAGG;IACH,2BAFW,iCAAiC,QAM3C;IAED;;;;;;OAMG;IACH,sEAJW,MAAM,GACJ,OAAO,CAyCnB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,kCAAgC,SAAS,CA2BrD;IAED;;;;;;;OAOG;IACH,+BAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,kCAAgC,SAAS,CAMrD;IAED;;;;;OAKG;IACH,4BAJW,MAAM,kCAEJ,OAAO,CA6CnB;IAED;;;;;;OAMG;IACH,6BALW,MAAM,gBACN,MAAM,eACN,MAAM,GACJ,qBAAqB,GAAC,IAAI,CA0DtC;IAIL;;;OAGG;IACH,wCAFU,OAAO,CAEkD;;CANlE"}

package/src/engine/ecs/storage/binary/BinarySerializationRegistry.js

@@ -22,6 +22,15 @@ export class BinarySerializationRegistry {
      */
     serializers = new Map();
 
+    /**
+     * Reverse index of the {@link serializers} map, keyed by the adapter's {@link BinaryClassSerializationAdapter.klass}.
+     * Lets callers resolve the registered class name of a value from its constructor without touching the value itself.
+     * When one class is registered under several names, the first registered name wins (mirrors {@link serializers}).
+     * @readonly
+     * @type {Map<Function, string>}
+     */
+    #klass_to_name = new Map();
+
     /**
      *
      * @param {BinaryClassSerializationAdapter[]} adapters
@@ -69,6 +78,13 @@ export class BinarySerializationRegistry {
 
         this.serializers.set(_className, adapter);
 
+        const klass = adapter.klass;
+
+        if (klass !== null && klass !== undefined && !this.#klass_to_name.has(klass)) {
+            // record reverse mapping, first registered name wins
+            this.#klass_to_name.set(klass, _className);
+        }
+
         return true;
     }
 
@@ -84,11 +100,38 @@ export class BinarySerializationRegistry {
 
         if (adapter !== undefined) {
             this.serializers.delete(className);
+
+            const klass = adapter.klass;
+
+            if (klass !== null && klass !== undefined && this.#klass_to_name.get(klass) === className) {
+                // this name owned the reverse mapping; hand it to another surviving name for the same class if
+                // one exists, so getClassName stays consistent when a class is registered under several names
+                this.#klass_to_name.delete(klass);
+
+                for (const [otherName, otherAdapter] of this.serializers) {
+                    if (otherAdapter.klass === klass) {
+                        this.#klass_to_name.set(klass, otherName);
+                        break;
+                    }
+                }
+            }
         }
 
         return adapter;
     }
 
+    /**
+     * Reverse of {@link registerAdapter}: resolve the registered class name for a given class (constructor).
+     * Useful when serializing a value whose class name is not known up-front — obtain the constructor via
+     * `Object.getPrototypeOf(value).constructor` and look it up here. Does not read or mutate any instance.
+     *
+     * @param {Function} klass class/constructor to look up
+     * @returns {string|undefined} the class name under which an adapter is registered, or `undefined` if none
+     */
+    getClassName(klass) {
+        return this.#klass_to_name.get(klass);
+    }
+
     /**
      *
      * @param {string} className

package/src/engine/ecs/storage/binary/object-v2/BinaryObjectDeSerializer.d.ts

@@ -0,0 +1,93 @@
+/**
+ * A resolved class-table entry. Migration is resolved lazily, on the first adapter-encoded object of the class,
+ * because whether a class was written via an adapter (and therefore whether the stored version needs migrating) is
+ * a property of the object tag in the body, not of the reader's registry.
+ *
+ * @typedef {Object} ResolvedClass
+ * @property {string} typeName
+ * @property {number} version version the data was written with
+ * @property {BinaryClassSerializationAdapter|undefined} adapter registered adapter, or undefined
+ * @property {Function|undefined} Klass constructor to instantiate, or undefined if unresolvable
+ * @property {BinaryClassUpgrader[]|null} migrators cached migrator chain (null = none needed)
+ * @property {boolean} migratorsResolved whether the migrator chain has been computed yet
+ */
+/**
+ * Reader half of the general object-graph binary serializer. Consumes documents produced by
+ * {@link BinaryObjectSerializer}.
+ *
+ * Needs:
+ *  - a {@link BinarySerializationRegistry} for hand-written adapters and version migrators;
+ *  - a {@link ModuleRegistry} mapping `typeName -> class` so reflective (adapter-less) class instances can be
+ *    reconstructed. It may be omitted if the data contains no reflective class instances (plain objects, arrays and
+ *    adapter-backed classes need no module registry).
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BinaryObjectDeSerializer {
+    /**
+     * @param {BinarySerializationRegistry} registry
+     * @param {ModuleRegistry} [modules] required only if the data contains reflective (adapter-less) class instances
+     */
+    constructor(registry: BinarySerializationRegistry, modules?: ModuleRegistry);
+    /**
+     * @param {BinarySerializationRegistry} registry
+     */
+    setRegistry(registry: BinarySerializationRegistry): void;
+    /**
+     * @param {ModuleRegistry} [modules]
+     */
+    setModuleRegistry(modules?: ModuleRegistry): void;
+    /**
+     * Deserialize a complete document written by {@link BinaryObjectSerializer.serialize}.
+     *
+     * @template T
+     * @param {BinaryBuffer} buffer source, read at the current {@link BinaryBuffer.position}
+     * @returns {T}
+     */
+    deserialize<T>(buffer: BinaryBuffer): T;
+    /**
+     * Read a single value. Nesting adapters call this to deserialize a child of any type.
+     *
+     * @template T
+     * @param {BinaryBuffer} buffer
+     * @returns {T}
+     */
+    readValue<T_1>(buffer: BinaryBuffer): T_1;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isBinaryObjectDeSerializer: boolean;
+    #private;
+}
+/**
+ * A resolved class-table entry. Migration is resolved lazily, on the first adapter-encoded object of the class,
+ * because whether a class was written via an adapter (and therefore whether the stored version needs migrating) is
+ * a property of the object tag in the body, not of the reader's registry.
+ */
+export type ResolvedClass = {
+    typeName: string;
+    /**
+     * version the data was written with
+     */
+    version: number;
+    /**
+     * registered adapter, or undefined
+     */
+    adapter: BinaryClassSerializationAdapter | undefined;
+    /**
+     * constructor to instantiate, or undefined if unresolvable
+     */
+    Klass: Function | undefined;
+    /**
+     * cached migrator chain (null = none needed)
+     */
+    migrators: BinaryClassUpgrader[] | null;
+    /**
+     * whether the migrator chain has been computed yet
+     */
+    migratorsResolved: boolean;
+};
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+//# sourceMappingURL=BinaryObjectDeSerializer.d.ts.map

package/src/engine/ecs/storage/binary/object-v2/BinaryObjectDeSerializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryObjectDeSerializer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/storage/binary/object-v2/BinaryObjectDeSerializer.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;GAYG;AACH;IA4BI;;;OAGG;IACH,6EAGC;IAED;;OAEG;IACH,yDAKC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;OAMG;IACH,uBAHW,YAAY,KAwCtB;IA0BD;;;;;;OAMG;IACH,uBAHW,YAAY,OAgDtB;IAoFL;;;OAGG;IACH,qCAFU,OAAO,CAE4C;;CAN5D;;;;;;;cAvRa,MAAM;;;;aACN,MAAM;;;;aACN,kCAAgC,SAAS;;;;WACzC,WAAS,SAAS;;;;eAClB,qBAAqB,GAAC,IAAI;;;;uBAC1B,OAAO;;6BAjCQ,4CAA4C"}