@woosh/meep-engine 2.165.4 → 2.165.6

package/src/engine/graphics/render/forward_plus/LightManager.d.ts

@@ -191,6 +191,11 @@ export class LightManager {
      * @private
      */
     private __handle_light_dimensions_change;
+    /**
+     *
+     * @private
+     */
+    private __handle_light_appearance_change;
     /**
      *
      * @param {LightRenderMetadata} data

package/src/engine/graphics/render/forward_plus/LightManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/forward_plus/LightManager.js"],"names":[],"mappings":"AAoIA;IAiBQ;;;;OAIG;IACH,2BAAgD;IAEhD,oCAAoC;IACpC,yCAA4C;IAE5C;;;;;;;;OAQG;IACH,0BAKC;IAaD;;;;;OAKG;IACH,+BAAoD;IAMpD;;;;;OAKG;IACH,8BAAmD;IAMnD;;;;OAIG;IACH,uCAAiF;IAWjF;;;;;OAKG;IACH,+BAEE;IAEF;;;;OAIG;IACH,iCAA8E;IAE9E;;;;OAIG;IACH,2BAAmC;IAEnC;;;;;OAKG;IACH,kCAAoE;IACpE;;;;;OAKG;IACH,kCAAoE;IAEpE;;;;OAIG;IACH,gCAAiC;IAEjC;;;;OAIG;IACH,6BAAiD;IACjD;;;;OAIG;IACH,6BAAiD;IAEjD;;;;OAIG;IACH,uBAAmC;IAEnC;;;;OAIG;IACH,8BAAiD;IAEjD;;;;OAIG;IACH,4BAA+C;IAG/C;;;;OAIG;IACH,yBAA2C;IAE3C;;;;OAIG;IACH,iCAAmD;IAUnD;;;;;OAKG;IACH,kCAAqC;IAErC;;;;OAIG;IACH,mCAAsC;IAK1C,0BAEC;IAED;;;;;;OAMG;IACH,0CAQC;IAED;;;OAGG;IACH,uCAEC;IAED,qCAQC;IAED;;;;;;OAMG;IACH,4CAgBC;IAED,iCAIC;IAED,gCA6BC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;OAGG;IACH,oBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,kBAFa,WAAW,CAIvB;IAED;;OAEG;IACH,sBAFa,aAAa,CAIzB;IAED;;OAEG;IACH,wBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,iBAFa,SAAS,OAAO,CAAC,CAI7B;IAED;;;OAGG;IACH,yCAKC;IAED;;;;OAIG;IACH,qCAyBC;IAED;;;;OAIG;IACH,uCA8BC;IAED;;;;OAIG;IACH,qCAMC;IAED;;;;OAIG;IACH,uCAKC;IAED;;;;;OAKG;IACH,4CAJW,mBAAmB,GACjB,MAAM,CAalB;IAED;;;;;;OAMG;IACH,+BAgCC;IAED;;;OAGG;IACH,6BAoBC;IAED,6BAYC;IAGD;;;;OAIG;IACH,6BAMC;IAED,mCA0EC;IAED,mCAgFC;IAED;;;OAGG;IACH,oCA+IC;IAED;;;OAGG;IACH,uCAUC;IAED;;;OAGG;IACH,oCAOC;IAED;;;OAGG;IACH,uCAWC;IAED;;;OAGG;IACH,mBAFW,SAAO,MAAM,iBAAiB,QAmDxC;IAED,gBAKC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,KACN,MAAM,QA2ChB;IAED;;;;OAIG;IACH,gCAFa,OAAO,CAInB;IAED;;;OAGG;IACH,qCAMC;IAED;;;;OAIG;IACH,mCAFa,OAAO,CAiBnB;;CACJ;4BAvrCM,OAAO;8BAAP,OAAO;oBAkBM,kCAAkC;oCAiBlB,0BAA0B"}
+{"version":3,"file":"LightManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/forward_plus/LightManager.js"],"names":[],"mappings":"AAoIA;IAiBQ;;;;OAIG;IACH,2BAAgD;IAEhD,oCAAoC;IACpC,yCAA4C;IAE5C;;;;;;;;OAQG;IACH,0BAKC;IAaD;;;;;OAKG;IACH,+BAAoD;IAMpD;;;;;OAKG;IACH,8BAAmD;IAMnD;;;;OAIG;IACH,uCAAiF;IAWjF;;;;;OAKG;IACH,+BAEE;IAEF;;;;OAIG;IACH,iCAA8E;IAE9E;;;;OAIG;IACH,2BAAmC;IAEnC;;;;;OAKG;IACH,kCAAoE;IACpE;;;;;OAKG;IACH,kCAAoE;IAEpE;;;;OAIG;IACH,gCAAiC;IAEjC;;;;OAIG;IACH,6BAAiD;IACjD;;;;OAIG;IACH,6BAAiD;IAEjD;;;;OAIG;IACH,uBAAmC;IAEnC;;;;OAIG;IACH,8BAAiD;IAEjD;;;;OAIG;IACH,4BAA+C;IAG/C;;;;OAIG;IACH,yBAA2C;IAE3C;;;;OAIG;IACH,iCAAmD;IAUnD;;;;;OAKG;IACH,kCAAqC;IAErC;;;;OAIG;IACH,mCAAsC;IAK1C,0BAEC;IAED;;;;;;OAMG;IACH,0CAQC;IAED;;;OAGG;IACH,uCAEC;IAED,qCAQC;IAED;;;;;;OAMG;IACH,4CAgBC;IAED,iCAIC;IAED,gCA6BC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;OAGG;IACH,oBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,kBAFa,WAAW,CAIvB;IAED;;OAEG;IACH,sBAFa,aAAa,CAIzB;IAED;;OAEG;IACH,wBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,iBAFa,SAAS,OAAO,CAAC,CAI7B;IAED;;;OAGG;IACH,yCAKC;IAED;;;OAGG;IACH,yCAGC;IAED;;;;OAIG;IACH,qCAyBC;IAED;;;;OAIG;IACH,uCA8BC;IAED;;;;OAIG;IACH,qCAOC;IAED;;;;OAIG;IACH,uCAMC;IAED;;;;;OAKG;IACH,4CAJW,mBAAmB,GACjB,MAAM,CAalB;IAED;;;;;;OAMG;IACH,+BAgCC;IAED;;;OAGG;IACH,6BAoBC;IAED,6BAYC;IAGD;;;;OAIG;IACH,6BAMC;IAED,mCA0EC;IAED,mCAgFC;IAED;;;OAGG;IACH,oCA+IC;IAED;;;OAGG;IACH,uCAUC;IAED;;;OAGG;IACH,oCAOC;IAED;;;OAGG;IACH,uCAWC;IAED;;;OAGG;IACH,mBAFW,SAAO,MAAM,iBAAiB,QAmDxC;IAED,gBAKC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,KACN,MAAM,QA2ChB;IAED;;;;OAIG;IACH,gCAFa,OAAO,CAInB;IAED;;;OAGG;IACH,qCAMC;IAED;;;;OAIG;IACH,mCAFa,OAAO,CAiBnB;;CACJ;4BAlsCM,OAAO;8BAAP,OAAO;oBAkBM,kCAAkC;oCAiBlB,0BAA0B"}

package/src/engine/graphics/render/forward_plus/LightManager.js

@@ -505,6 +505,15 @@ export class LightManager {
         this.__light_data_needs_update = true;
     }
 
+    /**
+     *
+     * @private
+     */
+    __handle_light_appearance_change() {
+        // appearance changes (such as color or intensity) don't affect bounds, only the encoded data
+        this.__light_data_needs_update = true;
+    }
+
     /**
      *
      * @param {LightRenderMetadata} data
@@ -585,6 +594,7 @@ export class LightManager {
         const light = data.light;
 
         light.onDimensionChanged(this.__handle_light_dimensions_change, this);
+        light.onAppearanceChanged(this.__handle_light_appearance_change, this);
     }
 
     /**
@@ -597,6 +607,7 @@ export class LightManager {
 
         const light = data.light;
         light.offDimensionChanged(this.__handle_light_dimensions_change, this);
+        light.offAppearanceChanged(this.__handle_light_appearance_change, this);
     }
 
     /**

package/src/engine/graphics/render/forward_plus/model/AbstractLight.d.ts

@@ -2,7 +2,7 @@ export class AbstractLight {
     id: number;
     toString(): string;
     /**
-     *
+     * Dimension changes affect the light's bounds ({@link AbstractLight#getAABB}) as well as its encoded record
      * @param {function} f
      * @param {*} [thisArg]
      * @returns {void}
@@ -15,6 +15,21 @@ export class AbstractLight {
      * @returns {void}
      */
     offDimensionChanged(f: Function, thisArg?: any): void;
+    /**
+     * Appearance changes affect the light's encoded record ({@link AbstractLight#toArray}) but not its bounds,
+     * such as color or intensity
+     * @param {function} f
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    onAppearanceChanged(f: Function, thisArg?: any): void;
+    /**
+     *
+     * @param {function} f
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    offAppearanceChanged(f: Function, thisArg?: any): void;
     /**
      *
      * @param {number[]} result

package/src/engine/graphics/render/forward_plus/model/AbstractLight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractLight.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/model/AbstractLight.js"],"names":[],"mappings":"AAEA;IAEI,WAAkB;IAGlB,mBAEC;IAED;;;;;OAKG;IACH,gDAFa,IAAI,CAIhB;IAED;;;;;OAKG;IACH,iDAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,EAAE,GACN,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACrC,IAAI,CAIhB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,WAClC,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,eAHW,aAAa,GACX,MAAM,CAIlB;IAGL,aAA4B;CAF3B"}
+{"version":3,"file":"AbstractLight.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/model/AbstractLight.js"],"names":[],"mappings":"AAEA;IAEI,WAAkB;IAGlB,mBAEC;IAED;;;;;OAKG;IACH,gDAFa,IAAI,CAIhB;IAED;;;;;OAKG;IACH,iDAFa,IAAI,CAIhB;IAED;;;;;;OAMG;IACH,iDAFa,IAAI,CAIhB;IAED;;;;;OAKG;IACH,kDAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,EAAE,GACN,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACrC,IAAI,CAIhB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,WAClC,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,eAHW,aAAa,GACX,MAAM,CAIlB;IAGL,aAA4B;CAF3B"}

package/src/engine/graphics/render/forward_plus/model/AbstractLight.js

@@ -10,7 +10,7 @@ export class AbstractLight {
     }
 
     /**
-     *
+     * Dimension changes affect the light's bounds ({@link AbstractLight#getAABB}) as well as its encoded record
      * @param {function} f
      * @param {*} [thisArg]
      * @returns {void}
@@ -29,6 +29,27 @@ export class AbstractLight {
         throw new Error('Not Implemented');
     }
 
+    /**
+     * Appearance changes affect the light's encoded record ({@link AbstractLight#toArray}) but not its bounds,
+     * such as color or intensity
+     * @param {function} f
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    onAppearanceChanged(f, thisArg) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {function} f
+     * @param {*} [thisArg]
+     * @returns {void}
+     */
+    offAppearanceChanged(f, thisArg) {
+        throw new Error('Not Implemented');
+    }
+
     /**
      *
      * @param {number[]} result

package/src/engine/graphics/render/forward_plus/model/Decal.d.ts

@@ -29,6 +29,13 @@ export class Decal extends AbstractLight {
     compare(other: any): number;
     onDimensionChanged(f: any, thisArg: any): void;
     offDimensionChanged(f: any, thisArg: any): void;
+    /**
+     * Appearance data (color, uv) is stored in raw arrays without change signals; uv only shifts when the
+     * texture atlas re-packs, which happens alongside decal addition/removal where the encoded data is
+     * invalidated anyway
+     */
+    onAppearanceChanged(f: any, thisArg: any): void;
+    offAppearanceChanged(f: any, thisArg: any): void;
     getCenter(result: any): void;
     getAABB(result: any): void;
     toArray(destination: any, address: any): number;

package/src/engine/graphics/render/forward_plus/model/Decal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Decal.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/model/Decal.js"],"names":[],"mappings":"AASA;IAIQ;;;OAGG;IACH,WAFU,MAAM,EAAE,GAAC,YAAY,GAAC,MAAM,CAED;IACrC,gCAA6C;IAC7C,iBAA6B;IAE7B,oBAAgC;IAKhC;;;OAGG;IACH,2BAA2B;IAE3B;;;;OAIG;IACH,eAFU,MAAM,CAEM;IAEtB,0EAA6C;IAGjD;;;OAGG;IACH,gBAFW,MAAM,EAAE,GAAC,YAAY,GAAC,UAAU,MAAM,CAAC,QAOjD;IAED,6CAGC;IAED,yCAGC;IAED,4BAUC;IAED,+CAGC;IAED,gDAGC;IAED,6BAKC;IAED,2BAIC;IAED,gDAcC;IAGL;;;OAGG;IACH,kBAFU,OAAO,CAEM;IAEvB,2BAAkC;CARjC;8BAjH6B,oBAAoB;mBAK/B,6CAA6C"}
+{"version":3,"file":"Decal.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/model/Decal.js"],"names":[],"mappings":"AASA;IAIQ;;;OAGG;IACH,WAFU,MAAM,EAAE,GAAC,YAAY,GAAC,MAAM,CAED;IACrC,gCAA6C;IAC7C,iBAA6B;IAE7B,oBAAgC;IAKhC;;;OAGG;IACH,2BAA2B;IAE3B;;;;OAIG;IACH,eAFU,MAAM,CAEM;IAEtB,0EAA6C;IAGjD;;;OAGG;IACH,gBAFW,MAAM,EAAE,GAAC,YAAY,GAAC,UAAU,MAAM,CAAC,QAOjD;IAED,6CAGC;IAED,yCAGC;IAED,4BAUC;IAED,+CAGC;IAED,gDAGC;IAED;;;;OAIG;IACH,gDACC;IAED,iDACC;IAED,6BAKC;IAED,2BAIC;IAED,gDAcC;IAGL;;;OAGG;IACH,kBAFU,OAAO,CAEM;IAEvB,2BAAkC;CARjC;8BA5H6B,oBAAoB;mBAK/B,6CAA6C"}

package/src/engine/graphics/render/forward_plus/model/Decal.js

@@ -83,6 +83,17 @@ export class Decal extends AbstractLight {
         this.__signal_transfom_changed.remove(f, thisArg);
     }
 
+    /**
+     * Appearance data (color, uv) is stored in raw arrays without change signals; uv only shifts when the
+     * texture atlas re-packs, which happens alongside decal addition/removal where the encoded data is
+     * invalidated anyway
+     */
+    onAppearanceChanged(f, thisArg) {
+    }
+
+    offAppearanceChanged(f, thisArg) {
+    }
+
     getCenter(result) {
         // extract translation portion of the matrix
         result[0] = this.transform[12];

package/src/engine/graphics/render/forward_plus/model/PointLight.d.ts

@@ -23,6 +23,8 @@ export class PointLight extends AbstractLight {
     getAABB(result: any): void;
     onDimensionChanged(listener: any, context: any): void;
     offDimensionChanged(listener: any, context: any): void;
+    onAppearanceChanged(listener: any, context: any): void;
+    offAppearanceChanged(listener: any, context: any): void;
     /**
      * @readonly
      * @type {boolean}

package/src/engine/graphics/render/forward_plus/model/PointLight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PointLight.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/model/PointLight.js"],"names":[],"mappings":"AAKA;IAEI;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,iBAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,gBAFU,KAAK,CAEY;IAE3B;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAG3B,6BAEC;IAED,2BAeC;IAED,sDAGC;IAED,uDAGC;IA6BL;;;OAGG;IACH,uBAFU,OAAO,CAEgB;IAEjC,2BAAuC;CARtC;8BArF6B,oBAAoB;oBAD9B,qCAAqC;oBADrC,qCAAqC;sBADnC,oCAAoC"}
+{"version":3,"file":"PointLight.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/model/PointLight.js"],"names":[],"mappings":"AAKA;IAEI;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,iBAFU,OAAO,CAEO;IAExB;;;OAGG;IACH,gBAFU,KAAK,CAEY;IAE3B;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAG3B,6BAEC;IAED,2BAeC;IAED,sDAGC;IAED,uDAGC;IAED,uDAGC;IAED,wDAGC;IA6BL;;;OAGG;IACH,uBAFU,OAAO,CAEgB;IAEjC,2BAAuC;CARtC;8BA/F6B,oBAAoB;oBAD9B,qCAAqC;oBADrC,qCAAqC;sBADnC,oCAAoC"}

package/src/engine/graphics/render/forward_plus/model/PointLight.js

@@ -61,6 +61,16 @@ export class PointLight extends AbstractLight {
         this.radius.onChanged.remove(listener, context);
     }
 
+    onAppearanceChanged(listener, context) {
+        this.color.onChanged.add(listener, context);
+        this.intensity.onChanged.add(listener, context);
+    }
+
+    offAppearanceChanged(listener, context) {
+        this.color.onChanged.remove(listener, context);
+        this.intensity.onChanged.remove(listener, context);
+    }
+
     /**
      *
      * @param {number[]|Float32Array|Float64Array} destination

package/src/engine/graphics/render/forward_plus/model/SpotLight.d.ts

@@ -38,6 +38,8 @@ export class SpotLight extends AbstractLight {
     getAABB(result: any): void;
     onDimensionChanged(listener: any, context: any): void;
     offDimensionChanged(listener: any, context: any): void;
+    onAppearanceChanged(listener: any, context: any): void;
+    offAppearanceChanged(listener: any, context: any): void;
     /**
      * @readonly
      * @type {boolean}

package/src/engine/graphics/render/forward_plus/model/SpotLight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpotLight.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/model/SpotLight.js"],"names":[],"mappings":"AAMA;IAGI;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,oBAFU,OAAO,CAES;IAE1B;;;OAGG;IACH,gBAFU,OAAO,CAEgB;IAEjC;;;OAGG;IACH,mBAFU,OAAO,CAES;IAE1B;;;OAGG;IACH,gBAFU,KAAK,CAEY;IAE3B;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B;;;OAGG;IACH,mBAFU,OAAO,CAEW;IAG5B,6BAYC;IAED,2BAcC;IAED,sDAKC;IAED,uDAKC;IAuCL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;8BA/H6B,oBAAoB;oBAD9B,qCAAqC;oBADrC,qCAAqC;sBAFnC,oCAAoC"}
+{"version":3,"file":"SpotLight.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/model/SpotLight.js"],"names":[],"mappings":"AAMA;IAGI;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,oBAFU,OAAO,CAES;IAE1B;;;OAGG;IACH,gBAFU,OAAO,CAEgB;IAEjC;;;OAGG;IACH,mBAFU,OAAO,CAES;IAE1B;;;OAGG;IACH,gBAFU,KAAK,CAEY;IAE3B;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B;;;OAGG;IACH,mBAFU,OAAO,CAEW;IAG5B,6BAYC;IAED,2BAcC;IAED,sDAKC;IAED,uDAKC;IAED,uDAIC;IAED,wDAIC;IAuCL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;8BA3I6B,oBAAoB;oBAD9B,qCAAqC;oBADrC,qCAAqC;sBAFnC,oCAAoC"}

package/src/engine/graphics/render/forward_plus/model/SpotLight.js

@@ -94,6 +94,18 @@ export class SpotLight extends AbstractLight {
         this.direction.onChanged.remove(listener, context);
     }
 
+    onAppearanceChanged(listener, context) {
+        this.color.onChanged.add(listener, context);
+        this.intensity.onChanged.add(listener, context);
+        this.penumbra.onChanged.add(listener, context);
+    }
+
+    offAppearanceChanged(listener, context) {
+        this.color.onChanged.remove(listener, context);
+        this.intensity.onChanged.remove(listener, context);
+        this.penumbra.onChanged.remove(listener, context);
+    }
+
     /**
      *
      * @param {number[]|Float32Array|Float64Array} destination

package/src/engine/graphics/shadows/ShadowMapRenderer.d.ts

@@ -18,6 +18,16 @@ export class ShadowMapRenderer {
      * @param {Light} light
      */
     update(renderer: THREE.WebGLRenderer, shadow: LightShadow, scene: Scene, light: Light): void;
+    /**
+     * Render each cube face of a point light shadow into its own viewport of
+     * the shadow map atlas (4x2 face grid, matching three.js cubeToUV layout)
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {PointLightShadow} shadow
+     * @param {Scene} scene
+     * @param {THREE.PointLight} light
+     * @private
+     */
+    private __render_cube_faces;
     /**
      *
      * @param {LightShadow} shadow

package/src/engine/graphics/shadows/ShadowMapRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadowMapRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shadows/ShadowMapRenderer.js"],"names":[],"mappings":"AAuCA;IAGQ;;;;OAIG;IACH,mBAAsB;IAEtB;;;OAGG;IACH,gBAFU,MAAM,CAEkB;IAItC;;;;;;OAMG;IACH,iBALW,MAAM,aAAa,8BAEnB,KAAK,sBAuEf;IAED;;;;OAIG;IACH,sBAyCC;IAED;;;;;OAKG;IACH,qBA8BC;CACJ;mBAhNkB,uCAAuC;sBADnD,OAAO"}
+{"version":3,"file":"ShadowMapRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shadows/ShadowMapRenderer.js"],"names":[],"mappings":"AAuCA;IAGQ;;;;OAIG;IACH,mBAAsB;IAEtB;;;OAGG;IACH,gBAFU,MAAM,CAEkB;IAItC;;;;;;OAMG;IACH,iBALW,MAAM,aAAa,8BAEnB,KAAK,sBAoFf;IAED;;;;;;;;OAQG;IACH,4BA8BC;IAED;;;;OAIG;IACH,sBAyCC;IAED;;;;;OAKG;IACH,qBAiDC;CACJ;mBAzRkB,uCAAuC;sBADnD,OAAO"}

package/src/engine/graphics/shadows/ShadowMapRenderer.js

@@ -102,18 +102,31 @@ export class ShadowMapRenderer {
 
         renderer.clear(true, true, false);
 
-        shadow.updateMatrices(light, 0);
+        if (shadow.isPointLightShadow === true) {
 
-        this.onBeforeRender.send3(renderer, shadow_camera, scene);
+            if (target.width > 0 && target.height > 0) {
+
+                this.__render_cube_faces(renderer, shadow, scene, light);
+
+                // no VSM pass: three.js point shadow sampling (getPointShadow)
+                // reads plain RGBA-packed distance regardless of shadow map type
+            }
 
-        if (target.width <= 0 || target.height <= 0) {
-            // no point in rendering
         } else {
-            // do the draw
-            renderer.render(scene, shadow_camera);
 
-            if (renderer.shadowMap.type === VSMShadowMap) {
-                this.__do_vsm_pass(shadow);
+            shadow.updateMatrices(light, 0);
+
+            this.onBeforeRender.send3(renderer, shadow_camera, scene);
+
+            if (target.width <= 0 || target.height <= 0) {
+                // no point in rendering
+            } else {
+                // do the draw
+                renderer.render(scene, shadow_camera);
+
+                if (renderer.shadowMap.type === VSMShadowMap) {
+                    this.__do_vsm_pass(shadow);
+                }
             }
         }
 
@@ -132,6 +145,47 @@ export class ShadowMapRenderer {
         renderer.info.render.frame++;
     }
 
+    /**
+     * Render each cube face of a point light shadow into its own viewport of
+     * the shadow map atlas (4x2 face grid, matching three.js cubeToUV layout)
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {PointLightShadow} shadow
+     * @param {Scene} scene
+     * @param {THREE.PointLight} light
+     * @private
+     */
+    __render_cube_faces(renderer, shadow, scene, light) {
+        const target = shadow.map;
+        const shadow_camera = shadow.camera;
+        const map_size = shadow.mapSize;
+
+        const viewport_count = shadow.getViewportCount();
+
+        for (let i = 0; i < viewport_count; i++) {
+            // orient the shadow camera along the face direction
+            shadow.updateMatrices(light, i);
+
+            const viewport = shadow.getViewport(i);
+
+            target.viewport.set(
+                map_size.x * viewport.x,
+                map_size.y * viewport.y,
+                map_size.x * viewport.z,
+                map_size.y * viewport.w
+            );
+
+            // re-bind to apply the updated viewport
+            renderer.setRenderTarget(target);
+
+            this.onBeforeRender.send3(renderer, shadow_camera, scene);
+
+            renderer.render(scene, shadow_camera);
+        }
+
+        // leave the target with a full-size viewport to keep other consumers unaffected
+        target.viewport.set(0, 0, target.width, target.height);
+    }
+
     /**
      *
      * @param {LightShadow} shadow
@@ -191,6 +245,25 @@ export class ShadowMapRenderer {
 
         if (shadow.map === null) {
 
+            // point light shadows pack six cube faces into a 4x2 viewport
+            // atlas, other shadow types occupy the full target (extents 1x1)
+            const frame_extents = shadow.getFrameExtents();
+
+            // clamp so the atlas fits into a single texture, shrinking the
+            // per-face resolution if necessary (mirrors THREE.WebGLShadowMap)
+            const max_texture_size = renderer.capabilities.maxTextureSize;
+
+            if (_shadowMapSize.x * frame_extents.x > max_texture_size) {
+                _shadowMapSize.x = Math.floor(max_texture_size / frame_extents.x);
+            }
+
+            if (_shadowMapSize.y * frame_extents.y > max_texture_size) {
+                _shadowMapSize.y = Math.floor(max_texture_size / frame_extents.y);
+            }
+
+            const target_width = _shadowMapSize.x * frame_extents.x;
+            const target_height = _shadowMapSize.y * frame_extents.y;
+
             const pars = {
                 format: RGBAFormat,
                 scissorTest: false,
@@ -201,7 +274,7 @@ export class ShadowMapRenderer {
                 pars.minFilter = LinearFilter;
                 pars.magFilter = LinearFilter;
 
-                shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, Object.assign({
+                shadow.mapPass = new WebGLRenderTarget(target_width, target_height, Object.assign({
                     depthBuffer: false
                 }, pars));
 
@@ -211,7 +284,7 @@ export class ShadowMapRenderer {
 
             }
 
-            shadow.map = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars);
+            shadow.map = new WebGLRenderTarget(target_width, target_height, pars);
             shadow.map.texture.name = '.shadowMap';
 
             shadow.camera.updateProjectionMatrix();

package/src/engine/graphics/shadows/testPointShadowMapRendering.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=testPointShadowMapRendering.d.ts.map

package/src/engine/graphics/shadows/testPointShadowMapRendering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testPointShadowMapRendering.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shadows/testPointShadowMapRendering.js"],"names":[],"mappings":""}

package/src/engine/graphics/shadows/testPointShadowMapRendering.js

@@ -0,0 +1,242 @@
+import {
+    initializeGameBinarySerializationRegistry
+} from "../../../../../model/game/GameBinarySerializationRegistry.js";
+import { enableEditor } from "../../../../editor/enableEditor.js";
+import Vector2 from "../../../core/geom/Vector2.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { ArrayBufferLoader } from "../../asset/loaders/ArrayBufferLoader.js";
+import { AttachmentSystem } from "../../ecs/attachment/AttachmentSystem.js";
+import { SerializationMetadata } from "../../ecs/components/SerializationMetadata.js";
+import Entity from "../../ecs/Entity.js";
+import GUIElement from "../../ecs/gui/GUIElement.js";
+import GUIElementSystem from "../../ecs/gui/GUIElementSystem.js";
+import HeadsUpDisplaySystem from "../../ecs/gui/hud/HeadsUpDisplaySystem.js";
+import ViewportPosition from "../../ecs/gui/position/ViewportPosition.js";
+import ViewportPositionSystem from "../../ecs/gui/position/ViewportPositionSystem.js";
+import AnimationSystem from "../../ecs/systems/AnimationSystem.js";
+import ClingToTerrainSystem from "../../ecs/terrain/ecs/cling/ClingToTerrainSystem.js";
+import TerrainSystem from "../../ecs/terrain/ecs/TerrainSystem.js";
+import { Transform } from "../../ecs/transform/Transform.js";
+import { EngineConfiguration } from "../../EngineConfiguration.js";
+import { EngineHarness } from "../../EngineHarness.js";
+import InputControllerSystem from "../../input/ecs/systems/InputControllerSystem.js";
+import { InputSystem } from "../../input/ecs/systems/InputSystem.js";
+import { BehaviorSystem } from "../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { loadSerializedScene } from "../../scene/SerializedScene.js";
+import { SoundEmitterSystem } from "../../sound/ecs/emitter/SoundEmitterSystem.js";
+import SoundControllerSystem from "../../sound/ecs/SoundControllerSystem.js";
+import SoundListenerSystem from "../../sound/ecs/SoundListenerSystem.js";
+import { CameraSystem } from "../ecs/camera/CameraSystem.js";
+import TopDownCameraControllerSystem from "../ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import MeshHighlightSystem from "../ecs/highlight/system/MeshHighlightSystem.js";
+import { Light } from "../ecs/light/Light.js";
+import LightSystem from "../ecs/light/LightSystem.js";
+import { LightType } from "../ecs/light/LightType.js";
+import { ShadedGeometrySystem } from "../ecs/mesh-v2/ShadedGeometrySystem.js";
+import Mesh from "../ecs/mesh/Mesh.js";
+import { MeshSystem } from "../ecs/mesh/MeshSystem.js";
+import { PathDisplaySystem } from "../ecs/path/PathDisplaySystem.js";
+import Trail2DSystem from "../ecs/trail2d/Trail2DSystem.js";
+import WaterSystem from "../ecs/water/WaterSystem.js";
+import { ParticleEmitterSystem } from "../particles/ecs/ParticleEmitterSystem.js";
+import { buildCanvasViewFromTexture } from "../render/visibility/hiz/buildCanvasViewFromTexture.js";
+
+const eh = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {EngineConfiguration}
+ */
+function makeConfig(engine) {
+
+    const config = new EngineConfiguration();
+
+    /**
+     *
+     * @type {SoundEngine}
+     */
+    const sound = engine.sound;
+    const graphics = engine.graphics;
+    const assetManager = engine.assetManager;
+    const devices = engine.devices;
+
+    const guiSystem = new GUIElementSystem(engine.gui.view, engine);
+    const headsUpDisplaySystem = new HeadsUpDisplaySystem(graphics);
+
+    config.addLoader('arraybuffer', new ArrayBufferLoader());
+
+    initializeGameBinarySerializationRegistry(engine.binarySerializationRegistry);
+
+    config.addManySystems(
+        new AttachmentSystem(),
+        new SoundEmitterSystem(assetManager, sound),
+        new SoundControllerSystem(),
+        new SoundListenerSystem(sound.context),
+        guiSystem,
+        new AnimationSystem(graphics.viewport.size),
+        new TopDownCameraControllerSystem(graphics),
+        new CameraSystem(engine.graphics),
+        new MeshSystem(engine),
+        new ClingToTerrainSystem(),
+        new TerrainSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
+        new ViewportPositionSystem(graphics.viewport.size),
+        new InputControllerSystem(devices),
+        new InputSystem(devices),
+        new MeshHighlightSystem(engine),
+        new LightSystem(engine, {
+            shadowResolution: 2048
+        }),
+        headsUpDisplaySystem,
+        new BehaviorSystem(engine),
+        new PathDisplaySystem(engine),
+        new ParticleEmitterSystem(engine),
+        new ShadedGeometrySystem(engine),
+        new WaterSystem(graphics)
+    );
+
+    return config;
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function get_three_light(engine) {
+
+    return engine.graphics.scene.children.find(l => l.isPointLight && l.castShadow);
+}
+
+/**
+ * Preview the 4x2 cube face atlas of the point light's shadow map
+ * @param {Engine} engine
+ */
+function init_shadowmap_preview(engine) {
+    const ecd = engine.entityManager.dataset;
+
+    const graphics = engine.graphics;
+    const preview = buildCanvasViewFromTexture({
+        width: 1024,
+        height: 512,
+        renderer: graphics.renderer,
+        texture: null
+    });
+
+    graphics.on.postOpaquePass.add(() => {
+
+        const light = get_three_light(engine);
+
+        if (light !== undefined && light.shadow.map !== null) {
+            preview.texture = light.shadow.map.texture;
+
+            preview.render();
+        }
+    });
+
+
+    new Entity()
+        .add(ViewportPosition.fromJSON({
+            offset: new Vector2(10, 10)
+        }))
+        .add(GUIElement.fromView(preview.view))
+        .add(SerializationMetadata.Transient)
+        .build(ecd);
+}
+
+/**
+ * Point light above the character, casters placed on every axis so all six
+ * cube faces receive geometry
+ * @param {Engine} engine
+ * @param {Vector3} center
+ */
+function build_point_light_scene(engine, center) {
+    const ecd = engine.entityManager.dataset;
+
+    const CASTER_URL = "data/models/Conqueror Mech/Conqueror Mech.gltf";
+    const LIGHT_HEIGHT = 3;
+    const RING_RADIUS = 4;
+
+    // light itself
+    const light = new Light();
+    light.type.set(LightType.POINT);
+    light.color.setRGB(1.0, 0.85, 0.6);
+    light.intensity.set(2);
+    light.distance.set(20);
+    light.castShadow.set(true);
+
+    const light_transform = new Transform();
+    light_transform.position.set(center.x, center.y + LIGHT_HEIGHT, center.z);
+
+    new Entity()
+        .add(light)
+        .add(light_transform)
+        .add(SerializationMetadata.Transient)
+        .build(ecd);
+
+    // casters on +X/-X/+Z/-Z of the light; the ground receives -Y, the caster
+    // hovering above the light exercises the +Y face
+    const positions = [
+        [RING_RADIUS, 0, 0],
+        [-RING_RADIUS, 0, 0],
+        [0, 0, RING_RADIUS],
+        [0, 0, -RING_RADIUS],
+        [0, LIGHT_HEIGHT + 2, 0]
+    ];
+
+    for (const [x, y, z] of positions) {
+        const transform = new Transform();
+        transform.position.set(center.x + x, center.y + y, center.z + z);
+
+        new Entity()
+            .add(Mesh.fromURL(CASTER_URL))
+            .add(transform)
+            .add(SerializationMetadata.Transient)
+            .build(ecd);
+    }
+}
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {Promise<void>}
+ */
+async function main(engine) {
+
+    const ecd = engine.entityManager.dataset;
+    await loadSerializedScene('data/levels/character_creation/level.bin', ecd, engine);
+
+
+    // center the test scene on any placed mesh, fall back to the origin
+    let center = new Vector3(0, 0, 0);
+
+    ecd.traverseComponents(Mesh, (mesh, entity) => {
+        const transform = ecd.getComponent(entity, Transform);
+
+        if (transform !== undefined) {
+            center = transform.position;
+            return false;
+        }
+    });
+
+    build_point_light_scene(engine, center);
+
+    init_shadowmap_preview(engine);
+
+    window.light = get_three_light(engine);
+}
+
+async function init(engineHarness) {
+
+    const engine = await engineHarness.initialize();
+
+    const config = makeConfig(engine);
+
+    await config.apply(engine);
+
+    enableEditor(engine);
+
+    main(engine).catch(e => console.error('testPointShadowMapRendering failed:', e));
+}
+
+init(eh);

package/src/engine/graphics/trail/tube/TubeMaterialX.d.ts

@@ -1,5 +1,12 @@
 export class TubeMaterialX extends ShaderMaterial {
-    constructor(params: any);
+    /**
+     * @param {Object} params three.js material parameters, plus:
+     * @param {boolean} [params.lit=false] compile the lit variant — standard light
+     *     chain, receive-only shadows — instead of the unlit one
+     */
+    constructor({ lit, ...params }?: {
+        lit?: boolean;
+    });
 }
 import { ShaderMaterial } from "three";
 //# sourceMappingURL=TubeMaterialX.d.ts.map

package/src/engine/graphics/trail/tube/TubeMaterialX.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TubeMaterialX.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/trail/tube/TubeMaterialX.js"],"names":[],"mappings":"AAsDA;IACI,yBAuBC;CACJ;+BA/E0D,OAAO"}
+{"version":3,"file":"TubeMaterialX.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/trail/tube/TubeMaterialX.js"],"names":[],"mappings":"AAuIA;IACI;;;;OAIG;IACH;QAH4B,GAAG,GAApB,OAAO;OAoCjB;CACJ;+BA/KsF,OAAO"}