@woosh/meep-engine 3.61.0 → 3.61.1

package/package.json

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

package/src/engine/ecs/storage/populateEngineSerializationRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AA0MA;;;;;;;;GAQG;AACH,iGA0HC"}
+{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AA6MA;;;;;;;;GAQG;AACH,iGA2HC"}

package/src/engine/ecs/storage/populateEngineSerializationRegistry.js

@@ -85,6 +85,9 @@ import { DecalSerializationAdapter } from "../../graphics/ecs/decal/v2/DecalSeri
 import {
     DecalSerializationUpgrader_0_1
 } from "../../graphics/ecs/decal/v2/DecalSerializationUpgrader_0_1.js";
+import {
+    DecalSerializationUpgrader_1_2
+} from "../../graphics/ecs/decal/v2/DecalSerializationUpgrader_1_2.js";
 import Highlight from "../../graphics/ecs/highlight/Highlight.js";
 import { HighlightSerializationAdapter } from "../../graphics/ecs/highlight/HighlightSerializationAdapter.js";
 import {
@@ -291,6 +294,7 @@ export function populateEngineSerializationRegistry(registry) {
     registry.registerUpgrader(Tag.typeName, new TagSerializationUpgrader_0_1());
     registry.registerUpgrader(ParticipatingMedia.typeName, new ParticipatingMediaSerializationUpgrader_0_1());
     registry.registerUpgrader(Decal.typeName, new DecalSerializationUpgrader_0_1());
+    registry.registerUpgrader(Decal.typeName, new DecalSerializationUpgrader_1_2());
 
     registry.registerUpgrader(FogOfWar.typeName, new FogOfWarSerializationUpdater_0_1());
 

package/src/engine/graphics/ecs/decal/v2/Decal.d.ts

@@ -36,7 +36,12 @@ export class Decal {
      */
     uri: string;
     /**
-     * Base colour and coverage. Its alpha is what the decal's coverage means.
+     * Base colour and the decal's mask. Its alpha is the coverage every channel blends by, scaled
+     * per channel by the `*_weight` fields — so a decal that writes only normals still takes its
+     * shape from this alpha, with {@link albedo_weight} at zero.
+     *
+     * Optional: with none, the mask is one across the whole projection volume and the colour is
+     * {@link color}.
      * @type {string}
      */
     uri_albedo: string;
@@ -87,6 +92,35 @@ export class Decal {
      * @type {number}
      */
     emissive_intensity: number;
+    /**
+     * How much of this decal's albedo is written, in [0, 1]. It scales the coverage this one channel
+     * blends by: zero leaves the surface's albedo exactly as it was, one writes it at the full
+     * coverage of the mask. Carried to the GPU as a 16-bit unorm.
+     * @type {number}
+     */
+    albedo_weight: number;
+    /**
+     * How much of this decal's normal is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    normal_weight: number;
+    /**
+     * How much of this decal's roughness is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    roughness_weight: number;
+    /**
+     * How much of this decal's metalness is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    metalness_weight: number;
+    /**
+     * How much of this decal's emission is written, in [0, 1]. As {@link albedo_weight} — and since a
+     * decal's emission replaces what is beneath it rather than adding to it, zero is also what keeps
+     * an emitting surface emitting under a decal.
+     * @type {number}
+     */
+    emissive_weight: number;
     /**
      * Internal transient reference to loaded asset
      * @type {Sampler2D|null}
@@ -119,8 +153,13 @@ export class Decal {
         metalness: number;
         emissive_color: string;
         emissive_intensity: number;
+        albedo_weight: number;
+        normal_weight: number;
+        roughness_weight: number;
+        metalness_weight: number;
+        emissive_weight: number;
     };
-    fromJSON({ uri, uri_albedo, uri_normal, uri_orm, uri_emissive, priority, color, roughness, metalness, emissive_color, emissive_intensity }: {
+    fromJSON({ uri, uri_albedo, uri_normal, uri_orm, uri_emissive, priority, color, roughness, metalness, emissive_color, emissive_intensity, albedo_weight, normal_weight, roughness_weight, metalness_weight, emissive_weight }: {
         uri?: string;
         uri_albedo?: string;
         uri_normal?: string;
@@ -132,6 +171,11 @@ export class Decal {
         metalness?: number;
         emissive_color?: string;
         emissive_intensity?: number;
+        albedo_weight?: number;
+        normal_weight?: number;
+        roughness_weight?: number;
+        metalness_weight?: number;
+        emissive_weight?: number;
     }): void;
     hash(): number;
     /**

package/src/engine/graphics/ecs/decal/v2/Decal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Decal.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/decal/v2/Decal.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAmGI,+BAMC;IAvGD;;;;;;;OAOG;IACH,KAFU,MAAM,CAEP;IAET;;;OAGG;IACH,YAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,YAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,SAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,cAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,OAFU,KAAK,CAEe;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;OAEG;IACH,WAFU,MAAM,CAEF;IAEd;;OAEG;IACH,gBAFU,KAAK,CAEwB;IAEvC;;;;OAIG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,yBAAwB;IAExB;;;;OAIG;IACH,qBAAoB;IAEpB;;;;;;OAMG;IACH,yBAEC;IAUD;;;;;;;;;;;;MAcC;IAED;;;;;;;;;;;;aA+CC;IAED,eAkBC;IAED;;;;OAIG;IACH,cAHW,KAAK,GACH,OAAO,CAenB;CACJ;;;;sBApPqB,oCAAoC"}
+{"version":3,"file":"Decal.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/decal/v2/Decal.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA0II,+BAMC;IA9ID;;;;;;;OAOG;IACH,KAFU,MAAM,CAEP;IAET;;;;;;;;OAQG;IACH,YAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,YAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,SAFU,MAAM,CAEH;IAEb;;;;OAIG;IACH,cAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,OAFU,KAAK,CAEe;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;OAEG;IACH,WAFU,MAAM,CAEF;IAEd;;OAEG;IACH,gBAFU,KAAK,CAEwB;IAEvC;;;;OAIG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;OAKG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;;;OAKG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,yBAAwB;IAExB;;;;OAIG;IACH,qBAAoB;IAEpB;;;;;;OAMG;IACH,yBAEC;IAUD;;;;;;;;;;;;;;;;;MAmBC;IAED;;;;;;;;;;;;;;;;;aA+DC;IAED,eAsBC;IAED;;;;OAIG;IACH,cAHW,KAAK,GACH,OAAO,CAoBnB;CACJ;;;;sBAzTqB,oCAAoC"}

package/src/engine/graphics/ecs/decal/v2/Decal.js

@@ -44,7 +44,12 @@ export class Decal {
     uri = "";
 
     /**
-     * Base colour and coverage. Its alpha is what the decal's coverage means.
+     * Base colour and the decal's mask. Its alpha is the coverage every channel blends by, scaled
+     * per channel by the `*_weight` fields — so a decal that writes only normals still takes its
+     * shape from this alpha, with {@link albedo_weight} at zero.
+     *
+     * Optional: with none, the mask is one across the whole projection volume and the colour is
+     * {@link color}.
      * @type {string}
      */
     uri_albedo = "";
@@ -105,6 +110,40 @@ export class Decal {
      */
     emissive_intensity = 0;
 
+    /**
+     * How much of this decal's albedo is written, in [0, 1]. It scales the coverage this one channel
+     * blends by: zero leaves the surface's albedo exactly as it was, one writes it at the full
+     * coverage of the mask. Carried to the GPU as a 16-bit unorm.
+     * @type {number}
+     */
+    albedo_weight = 1;
+
+    /**
+     * How much of this decal's normal is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    normal_weight = 1;
+
+    /**
+     * How much of this decal's roughness is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    roughness_weight = 1;
+
+    /**
+     * How much of this decal's metalness is written, in [0, 1]. As {@link albedo_weight}.
+     * @type {number}
+     */
+    metalness_weight = 1;
+
+    /**
+     * How much of this decal's emission is written, in [0, 1]. As {@link albedo_weight} — and since a
+     * decal's emission replaces what is beneath it rather than adding to it, zero is also what keeps
+     * an emitting surface emitting under a decal.
+     * @type {number}
+     */
+    emissive_weight = 1;
+
     /**
      * Internal transient reference to loaded asset
      * @type {Sampler2D|null}
@@ -150,7 +189,12 @@ export class Decal {
             roughness: this.roughness,
             metalness: this.metalness,
             emissive_color: this.emissive_color.toCssRGBAString(),
-            emissive_intensity: this.emissive_intensity
+            emissive_intensity: this.emissive_intensity,
+            albedo_weight: this.albedo_weight,
+            normal_weight: this.normal_weight,
+            roughness_weight: this.roughness_weight,
+            metalness_weight: this.metalness_weight,
+            emissive_weight: this.emissive_weight
         };
     }
 
@@ -165,7 +209,12 @@ export class Decal {
                  roughness = 1,
                  metalness = 0,
                  emissive_color = '#FFFFFF',
-                 emissive_intensity = 0
+                 emissive_intensity = 0,
+                 albedo_weight = 1,
+                 normal_weight = 1,
+                 roughness_weight = 1,
+                 metalness_weight = 1,
+                 emissive_weight = 1
              }) {
 
         assert.isString(uri, 'uri');
@@ -178,6 +227,11 @@ export class Decal {
         assert.isNumber(roughness, 'roughness');
         assert.isNumber(metalness, 'metalness');
         assert.isNumber(emissive_intensity, 'emissive_intensity');
+        assert.isNumber(albedo_weight, 'albedo_weight');
+        assert.isNumber(normal_weight, 'normal_weight');
+        assert.isNumber(roughness_weight, 'roughness_weight');
+        assert.isNumber(metalness_weight, 'metalness_weight');
+        assert.isNumber(emissive_weight, 'emissive_weight');
 
         const albedo_before = this.albedo_uri;
 
@@ -199,12 +253,18 @@ export class Decal {
         this.metalness = metalness;
         this.emissive_intensity = emissive_intensity;
 
+        this.albedo_weight = albedo_weight;
+        this.normal_weight = normal_weight;
+        this.roughness_weight = roughness_weight;
+        this.metalness_weight = metalness_weight;
+        this.emissive_weight = emissive_weight;
+
         this.color.parse(color);
         this.emissive_color.parse(emissive_color);
     }
 
     hash() {
-        return hash_mix3(
+        return hash_mix2(hash_mix3(
             computeStringHash(this.uri) ^ this.color.hash(),
             hash_mix2(
                 hash_mix2(
@@ -220,7 +280,11 @@ export class Decal {
                 hash_mix2(computeHashFloat(this.roughness), computeHashFloat(this.metalness)),
                 hash_mix2(this.emissive_color.hash(), computeHashFloat(this.emissive_intensity))
             )
-        );
+        ), hash_mix3(
+            hash_mix2(computeHashFloat(this.albedo_weight), computeHashFloat(this.normal_weight)),
+            hash_mix2(computeHashFloat(this.roughness_weight), computeHashFloat(this.metalness_weight)),
+            computeHashFloat(this.emissive_weight)
+        ));
     }
 
     /**
@@ -240,6 +304,11 @@ export class Decal {
             && this.metalness === other.metalness
             && this.emissive_color.equals(other.emissive_color)
             && this.emissive_intensity === other.emissive_intensity
+            && this.albedo_weight === other.albedo_weight
+            && this.normal_weight === other.normal_weight
+            && this.roughness_weight === other.roughness_weight
+            && this.metalness_weight === other.metalness_weight
+            && this.emissive_weight === other.emissive_weight
             ;
     }
 }

package/src/engine/graphics/ecs/decal/v2/DecalSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DecalSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/decal/v2/DecalSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,oBAAc;IAGd;;;;OAIG;IACH,uCAFW,KAAK,QAmBf;IAED;;;;OAIG;IACH,yCAFW,KAAK,QAmBf;CACJ;gDAvD+C,mEAAmE;sBAC7F,YAAY"}
+{"version":3,"file":"DecalSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/decal/v2/DecalSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,oBAAc;IAGd;;;;OAIG;IACH,uCAFW,KAAK,QAyBf;IAED;;;;OAIG;IACH,yCAFW,KAAK,QAyBf;CACJ;gDAnE+C,mEAAmE;sBAC7F,YAAY"}

package/src/engine/graphics/ecs/decal/v2/DecalSerializationAdapter.js

@@ -4,7 +4,7 @@ import { Decal } from "./Decal.js";
 export class DecalSerializationAdapter extends BinaryClassSerializationAdapter {
 
     klass = Decal;
-    version = 1;
+    version = 2;
 
     /**
      *
@@ -28,6 +28,12 @@ export class DecalSerializationAdapter extends BinaryClassSerializationAdapter {
         buffer.writeFloat32Array(value.emissive_color, 0, 4);
         buffer.writeFloat32(value.emissive_intensity);
 
+        buffer.writeFloat32(value.albedo_weight);
+        buffer.writeFloat32(value.normal_weight);
+        buffer.writeFloat32(value.roughness_weight);
+        buffer.writeFloat32(value.metalness_weight);
+        buffer.writeFloat32(value.emissive_weight);
+
     }
 
     /**
@@ -52,5 +58,11 @@ export class DecalSerializationAdapter extends BinaryClassSerializationAdapter {
         buffer.readFloat32Array(value.emissive_color, 0, 4);
         value.emissive_intensity = buffer.readFloat32();
 
+        value.albedo_weight = buffer.readFloat32();
+        value.normal_weight = buffer.readFloat32();
+        value.roughness_weight = buffer.readFloat32();
+        value.metalness_weight = buffer.readFloat32();
+        value.emissive_weight = buffer.readFloat32();
+
     }
 }

package/src/engine/graphics/ecs/decal/v2/DecalSerializationUpgrader_1_2.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A v1 decal wrote every channel it carries. v2 adds a weight per channel, and a v1 decal comes
+ * back with all five at one — which is what writing every channel means.
+ */
+export class DecalSerializationUpgrader_1_2 extends BinaryClassUpgrader {
+    upgrade(source: any, target: any): void;
+}
+import { BinaryClassUpgrader } from "../../../../ecs/storage/binary/BinaryClassUpgrader.js";
+//# sourceMappingURL=DecalSerializationUpgrader_1_2.d.ts.map

package/src/engine/graphics/ecs/decal/v2/DecalSerializationUpgrader_1_2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecalSerializationUpgrader_1_2.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/decal/v2/DecalSerializationUpgrader_1_2.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAII,wCAyBC;CACJ;oCApCmC,uDAAuD"}

package/src/engine/graphics/ecs/decal/v2/DecalSerializationUpgrader_1_2.js

@@ -0,0 +1,37 @@
+import { BinaryClassUpgrader } from "../../../../ecs/storage/binary/BinaryClassUpgrader.js";
+
+/**
+ * A v1 decal wrote every channel it carries. v2 adds a weight per channel, and a v1 decal comes
+ * back with all five at one — which is what writing every channel means.
+ */
+export class DecalSerializationUpgrader_1_2 extends BinaryClassUpgrader {
+    __startVersion = 1;
+    __targetVersion = 2;
+
+    upgrade(source, target) {
+        // uri, uri_albedo, uri_normal, uri_orm, uri_emissive
+        for (let i = 0; i < 5; i++) {
+            target.writeUTF8String(source.readUTF8String());
+        }
+
+        const scratch = [0, 0, 0, 0];
+
+        target.writeFloat32(source.readFloat32()); // priority
+
+        source.readFloat32Array(scratch, 0, 4);
+        target.writeFloat32Array(scratch, 0, 4); // color
+
+        target.writeFloat32(source.readFloat32()); // roughness
+        target.writeFloat32(source.readFloat32()); // metalness
+
+        source.readFloat32Array(scratch, 0, 4);
+        target.writeFloat32Array(scratch, 0, 4); // emissive_color
+
+        target.writeFloat32(source.readFloat32()); // emissive_intensity
+
+        // albedo, normal, roughness, metalness, emissive weights
+        for (let i = 0; i < 5; i++) {
+            target.writeFloat32(1);
+        }
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"DecalSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DecalSystem.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;GAgBG;AACH;IAmHI;;;OAGG;IACH,4DAkCC;IAxJD,oDAAoC;IAyFpC;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,4BAEC;IAoDD,2CAUC;IAED,4CAgBC;IAED;;;;;;;;;;;;OAYG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAmBhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAkBhB;IAqDD,6BAiDC;IAED;;OAEG;IACH,kCAkBC;;CACJ;AAED;;;;;;GAMG;AACH;IAYI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBAzbsB,kBAAkB;4BACb,iCAAiC;sBACvC,mCAAmC;gCALzB,mDAAmD"}
+{"version":3,"file":"DecalSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/DecalSystem.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;GAgBG;AACH;IA+HI;;;OAGG;IACH,4DAkCC;IApKD,oDAAoC;IAqGpC;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,4BAEC;IAoDD,2CAUC;IAED,4CAgBC;IAED;;;;;;;;;;;;OAYG;IACH,YAJW,KAAK,aACL,WAAW,UACX,MAAM,QAoBhB;IAED;;;;OAIG;IACH,cAJW,KAAK,aACL,WAAW,UACX,MAAM,QAkBhB;IAoDD,6BAmDC;IAED;;OAEG;IACH,kCAkBC;;CACJ;AAED;;;;;;GAMG;AACH;IAYI;;OAEG;IACH,oBAFW,WAAW,EAMrB;IAED,yBAEC;;CACJ;uBAxcsB,kBAAkB;4BACb,iCAAiC;sBACvC,mCAAmC;gCALzB,mDAAmD"}