@woosh/meep-engine 2.165.5 → 2.165.7

package/src/engine/graphics/particles/particular/engine/utils/volume/AttributeValue.d.ts

@@ -1,16 +1,76 @@
-import Signal from "../../../../../../../core/events/signal/Signal";
-import {ParameterLookupTable} from "../../parameter/ParameterLookupTable";
-
-export class AttributeValue {
-    readonly onValueChange: Signal<void>
-
-    lookup: (ParameterLookupTable | null)
-
-    write_lookup_value(v: number): void
-
-    public lookup_value: number
-
-    write_value(v: number[]): void
-
-    read_value(destination: number[])
-}
+export class AttributeValue {
+    /**
+     * Attribute spec
+     * @type {AttributeSpec}
+     */
+    __spec: AttributeSpec;
+    /**
+     *
+     * @type {number[]}
+     */
+    __value: number[];
+    /**
+     *
+     * @type {ParameterLookupTable}
+     * @private
+     */
+    private __lut;
+    /**
+     *
+     * @type {Signal}
+     */
+    onValueChange: Signal;
+    /**
+     * @param {AttributeSpec} s
+     */
+    set spec(arg: AttributeSpec);
+    /**
+     *
+     * @returns {AttributeSpec}
+     */
+    get spec(): AttributeSpec;
+    /**
+     * Will generate actual typed value storage
+     */
+    init(): void;
+    /**
+     * @param {ParameterLookupTable} v
+     */
+    set lookup(arg: ParameterLookupTable);
+    /**
+     *
+     * @returns {ParameterLookupTable}
+     */
+    get lookup(): ParameterLookupTable;
+    set lookup_value(arg: any);
+    /**
+     *
+     * @param {number} v
+     */
+    write_lookup_value(v: number): void;
+    /**
+     *
+     * @param {number[]} v
+     */
+    write_value_silent(v: number[]): void;
+    /**
+     *
+     * @param {number[]} v
+     */
+    write_value(v: number[]): void;
+    /**
+     *
+     * @param {number[]} destination
+     */
+    read_value(destination: number[]): void;
+    /**
+     *
+     * @param {number[]} [value]
+     * @param {Object} [lookup]
+     * @param {number} [lookup_value]
+     */
+    fromJSON({ value, lookup, lookup_value }?: number[]): void;
+}
+import Signal from "../../../../../../../core/events/signal/Signal.js";
+import { ParameterLookupTable } from "../../parameter/ParameterLookupTable.js";
+//# sourceMappingURL=AttributeValue.d.ts.map

package/src/engine/graphics/particles/particular/engine/utils/volume/SamplingFunctionKind.d.ts

@@ -1,4 +1,6 @@
-export enum SamplingFunctionKind {
-    Random = 0,
-    Grid = 1
-}
+export type SamplingFunctionKind = number;
+export namespace SamplingFunctionKind {
+    let Random: number;
+    let Grid: number;
+}
+//# sourceMappingURL=SamplingFunctionKind.d.ts.map

package/src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.d.ts

@@ -1,8 +1,92 @@
-import {EnginePlugin} from "../../../../../plugin/EnginePlugin";
-
-export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
-    /**
-     * Higher value will make AO appear darker, lower values will make it lighter
-     */
-    public intensity: number
-}
+export class AmbientOcclusionPostProcessEffect extends EnginePlugin {
+    __material: ShaderMaterial;
+    /**
+     * Should normal buffer be used or not? Using normal buffer might be significantly more expensive, as this would require normal buffer to be built every frame. If there are other users of the buffer - this is not an issue
+     * @type {boolean}
+     * @private
+     */
+    private __use_normals;
+    /**
+     * Resolution scale at which AO is to be rendered. Higher scale will lead to sharper and better looking results
+     * @type {number}
+     * @private
+     */
+    private __resolution_scale;
+    /**
+     *
+     * @type {CompositLayer}
+     * @private
+     */
+    private __composit_layer;
+    /**
+     *
+     * @type {Camera|null}
+     * @private
+     */
+    private __render_camera;
+    __render_target: WebGLMultisampleRenderTarget;
+    /**
+     *
+     * @type {FrameBuffer[]}
+     * @private
+     */
+    private __used_buffers;
+    /**
+     * Edge-aware upscale + denoise: a single non-separable pass that resolves the half-res AO
+     * into the full-res composit layer using plane-distance weights.
+     * @type {ShaderMaterial}
+     * @private
+     */
+    private __upscale_material;
+    /**
+     * Hilbert-index permutation LUT, shared by the AO sampling and upscale dithers.
+     * @type {DataTexture}
+     * @private
+     */
+    private __hilbert_texture;
+    /**
+     * Higher value will make AO appear darker, lower values will make it lighter
+     * @param {number} v
+     */
+    set intensity(arg: number);
+    /**
+     *
+     * @return {number}
+     */
+    get intensity(): number;
+    /**
+     *
+     * @param {Camera} camera
+     * @private
+     */
+    private __setCamera;
+    __prepare_uniforms(): void;
+    __prepare_draw(): void;
+    /**
+     *
+     * @private
+     */
+    private __render;
+    /**
+     *
+     * @param {boolean} value
+     */
+    setNormalBufferUsage(value: boolean): void;
+    /**
+     *
+     * @param {FrameBuffer} buffer
+     * @private
+     */
+    private __add_used_frame_buffer;
+    /**
+     *
+     * @param {FrameBuffer} buffer
+     * @private
+     */
+    private __remove_used_frame_buffer;
+    __update_render_target_size(): void;
+}
+import { EnginePlugin } from "../../../../../plugin/EnginePlugin.js";
+import { ShaderMaterial } from "three";
+import { WebGLMultisampleRenderTarget } from "three";
+//# sourceMappingURL=AmbientOcclusionPostProcessEffect.d.ts.map

package/src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AmbientOcclusionPostProcessEffect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js"],"names":[],"mappings":"AAoBA;IAIQ,WAA0C;IAI1C,2BAQE;IAyBF;;;;OAIG;IACH,sBAA0B;IAE1B;;;;OAIG;IACH,2BAA6B;IAG7B;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,wBAA2B;IAE3B,8CAUE;IAEF;;;;OAIG;IACH,uBAAwB;IAExB;;;;;OAKG;IACH,2BASE;IAKF;;;;OAIG;IACH,0BAAwD;IAK5D;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;OAIG;IACH,oBAeC;IAED,iBAEC;IAED,2BAoCC;IAED,uBASC;IAED;;;OAGG;IACH,iBAwBC;IAED;;;OAGG;IACH,4BAFW,OAAO,QAiCjB;IAED;;;;OAIG;IACH,gCASC;IAED;;;;OAIG;IACH,mCAUC;IAGD,oCAiBC;IAED,wBA2CC;IAED,yBAiBC;CAEJ;6BApZ4B,uCAAuC;+BAD7D,OAAO;6CAAP,OAAO"}
+{"version":3,"file":"AmbientOcclusionPostProcessEffect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js"],"names":[],"mappings":"AAoBA;IAQQ,2BAQE;IAyBF;;;;OAIG;IACH,sBAA0B;IAE1B;;;;OAIG;IACH,2BAA6B;IAG7B;;;;OAIG;IACH,yBAA4B;IAE5B;;;;OAIG;IACH,wBAA2B;IAE3B,8CAUE;IAEF;;;;OAIG;IACH,uBAAwB;IAExB;;;;;OAKG;IACH,2BASE;IAKF;;;;OAIG;IACH,0BAAwD;IAK5D;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;OAIG;IACH,oBAeC;IAMD,2BAoCC;IAED,uBASC;IAED;;;OAGG;IACH,iBAwBC;IAED;;;OAGG;IACH,4BAFW,OAAO,QAiCjB;IAED;;;;OAIG;IACH,gCASC;IAED;;;;OAIG;IACH,mCAUC;IAGD,oCAiBC;CAkEJ;6BApZ4B,uCAAuC;+BAD7D,OAAO;6CAAP,OAAO"}

package/src/engine/graphics/render/buffer/simple-fx/ao/SAOUpscaleShader.js

@@ -1,17 +1,29 @@
 import { Vector2 } from 'three';
 
 /**
- * Edge-aware upscale + denoise for the half-resolution SAO buffer.
+ * Depth-aware upscale + denoise for the half-resolution SAO buffer.
  *
- * A single non-separable pass (separable bilateral filters leak across diagonal silhouettes). Each
- * tap is weighted by its distance to the *plane* of the centre pixel, modelled from the screen-space
- * depth gradient (ReBLUR-style): slanted surfaces are predicted correctly, so only genuine depth
- * discontinuities are rejected -- no normal buffer and no hand-tuned raw-depth tolerance. The
- * geometry tolerance is intentionally tight so background occlusion never bleeds into the foreground
- * or vice versa.
+ * A single non-separable pass (separable bilateral filters leak across diagonal silhouettes),
+ * reworked 2026-07-22 into a nearest-depth-style upsample. The previous version sampled tAO
+ * BILINEARLY (an unconditional weight-1 centre tap plus bilinear disk taps): at a geometry
+ * silhouette the hardware bilinear mixes AO texels from both sides of the depth step inside a
+ * single fetch, which no downstream weight can undo -- and silhouettes are exactly where the disk
+ * taps get depth-rejected, degenerating the output to that contaminated centre tap: a staircase
+ * tracing the half-res texel grid. Low-contrast AO mostly hides this; a high-contrast consumer of
+ * the same recipe (nekomancer's ground fog, bright fog behind dark props) made it plainly visible.
  *
- * Taps follow a Vogel disk rotated per pixel by an R2 blue-noise angle, which both spreads the
- * gather as a dithered (non-grid) pattern and pairs with the R2-rotated sampling kernel in SAOShader.
+ * Now every tap (centre included) SNAPS to an AO texel, texelFetches it unfiltered, and is
+ * weighted by its screen distance AND by comparing the depth THAT TEXEL'S AO PASS ACTUALLY USED
+ * (SAOShader snaps its centre to the containing full-res depth texel; reproduced here) against
+ * the *plane* of the centre pixel, modelled from the clamped screen-space depth gradient
+ * (ReBLUR-style): slanted surfaces are predicted correctly, only genuine depth discontinuities
+ * are rejected -- no normal buffer and no hand-tuned raw-depth tolerance -- and the AO edge lands
+ * on the full-res geometry edge. A nearest-in-depth fallback covers pixels whose depth no AO
+ * texel sampled (thin silhouettes).
+ *
+ * Taps follow a Vogel disk rotated per pixel by an R2 blue-noise angle, which spreads the gather
+ * as a dithered (non-grid) pattern, pairs with the R2-rotated sampling kernel in SAOShader, and
+ * dithers away the tap-to-texel snapping.
  */
 
 const SAOUpscaleShader = {
@@ -96,15 +108,21 @@ const SAOUpscaleShader = {
 
 			float zc = getViewZ( centerDepth );
 
+			// plane-distance tolerance scales with view depth (footprint and depth precision grow with
+			// distance); smaller depthSigma = tighter fg/bg separation
+			float tol = max( EPSILON, depthSigma * abs( zc ) );
+			float invSigma = 1.0 / tol;
+
 			// screen-space depth gradient defines the centre pixel's plane; predicting a tap's depth
-			// from it means slanted surfaces are not rejected, only true discontinuities are
-			vec2 dz = vec2( dFdx( zc ), dFdy( zc ) );
+			// from it means slanted surfaces are not rejected, only true discontinuities are. The slope
+			// is CLAMPED to the depth tolerance per pixel: at a silhouette the quad derivative spans
+			// the whole fg/bg depth gap, and an unclamped plane would "predict" that gap as legitimate
+			// slant, re-admitting cross-edge taps.
+			vec2 dz = clamp( vec2( dFdx( zc ), dFdy( zc ) ), - tol, tol );
 
 			vec2 texel = 1.0 / size;
-
-			// plane-distance tolerance scales with view depth (footprint and depth precision grow with
-			// distance); smaller depthSigma = tighter fg/bg separation
-			float invSigma = 1.0 / max( EPSILON, depthSigma * abs( zc ) );
+			vec2 aoSize = vec2( textureSize( tAO, 0 ) );
+			ivec2 aoMax = ivec2( aoSize ) - 1;
 
 			// per-pixel rotation of the Vogel tap set -> dithered, non-separable gather. Hilbert-curve
 			// permutation index through Marty's R2 sequence (matches the AO sampling dither).
@@ -114,36 +132,59 @@ const SAOUpscaleShader = {
 			float spatialSigma = blurRadius * 0.5;
 			float invSpatial2 = 1.0 / ( 2.0 * spatialSigma * spatialSigma );
 
-			// centre tap
-			float sum = texture2D( tAO, vUv ).x;
-			float wsum = 1.0;
-
-			for ( int i = 0; i < NUM_TAPS; i ++ ) {
-				// Vogel-disk offset in output pixels, rotated per pixel
-				float fi = float( i ) + 0.5;
-				float r = sqrt( fi / float( NUM_TAPS ) ) * blurRadius;
-				float theta = fi * 2.39996323 + rot;       // golden angle
-				vec2 o = r * vec2( cos( theta ), sin( theta ) );
-
-				vec2 tapUv = vUv + o * texel;
-
-				if ( tapUv.x < 0.0 || tapUv.x > 1.0 || tapUv.y < 0.0 || tapUv.y > 1.0 ) continue;
-
-				float zt = getViewZ( getDepth( tapUv ) );
-
-				// distance from the tap to the centre pixel's plane
-				float planeDist = abs( zt - ( zc + dot( dz, o ) ) );
+			float sum = 0.0;
+			float wsum = 0.0;
+
+			// nearest-in-depth tap: fallback when every tap rejects (a pixel whose depth no AO texel
+			// sampled, e.g. a thin silhouette)
+			float nearestAO = 1.0;
+			float nearestDist = 1e30;
+
+			for ( int i = 0; i <= NUM_TAPS; i ++ ) {
+				// tap 0 is the pixel's own containing AO texel; 1..NUM_TAPS are the Vogel disk,
+				// offset in output pixels, rotated per pixel
+				vec2 o = vec2( 0.0 );
+				if ( i != 0 ) {
+					float fi = float( i ) - 0.5;
+					float r = sqrt( fi / float( NUM_TAPS ) ) * blurRadius;
+					float theta = fi * 2.39996323 + rot;       // golden angle
+					o = r * vec2( cos( theta ), sin( theta ) );
+				}
+
+				// SNAP to an AO texel and fetch it UNFILTERED -- hardware bilinear would mix occlusion
+				// across the fg/bg step inside a single fetch, which no weight can undo. Clamping to
+				// the buffer edge extends border texels instead of dropping the tap.
+				ivec2 tc = clamp( ivec2( ( vUv + o * texel ) * aoSize ), ivec2( 0 ), aoMax );
+				vec2 tapUv = ( vec2( tc ) + 0.5 ) / aoSize;
+
+				// the depth THE AO PASS USED for this texel: SAOShader snaps its centre to the
+				// containing full-res depth texel (its centerUv), reproduced here so the weight judges
+				// the tap by the geometry its occlusion was actually computed for
+				vec2 marchUv = ( floor( tapUv * size ) + 0.5 ) * texel;
+				float zt = getViewZ( getDepth( marchUv ) );
+
+				// distance from that depth to the centre pixel's plane; the offset is re-derived from
+				// the snapped texel centre so both weights match the texel actually fetched
+				vec2 oPx = ( tapUv - vUv ) * size;
+				float planeDist = abs( zt - ( zc + dot( dz, oPx ) ) );
 
 				float wGeom = exp( - planeDist * planeDist * invSigma * invSigma );
-				float wSpatial = exp( - dot( o, o ) * invSpatial2 );
+				float wSpatial = exp( - dot( oPx, oPx ) * invSpatial2 );
 
 				float w = wGeom * wSpatial;
 
-				sum += w * texture2D( tAO, tapUv ).x;
+				float ao = texelFetch( tAO, tc, 0 ).x;
+				sum += w * ao;
 				wsum += w;
+
+				if ( planeDist < nearestDist ) {
+					nearestDist = planeDist;
+					nearestAO = ao;
+				}
 			}
 
-			out_occlusion = sum / wsum;
+			// every tap rejected -> take the closest-in-depth texel rather than a contaminated blend
+			out_occlusion = wsum > 1e-4 ? sum / wsum : nearestAO;
 		}`
 
 };

package/src/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.d.ts

@@ -17,9 +17,6 @@ export class TemporalSupersamplingRenderPlugin extends EnginePlugin {
     };
     __hook_post_render(): void;
     initialize(engine: any): void;
-    finalize(): void;
-    startup(): Promise<any>;
-    shutdown(): Promise<any>;
 }
 import { EnginePlugin } from "../../../../../plugin/EnginePlugin.js";
 //# sourceMappingURL=TemporalSupersamplingRenderPlugin.d.ts.map

package/src/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TemporalSupersamplingRenderPlugin.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.js"],"names":[],"mappings":"AAIA;IAIQ;;;;OAIG;IACH,sBAAsB;IAEtB,uBAAwB;IACxB,8BAAkE;IAGlE;QACI;;;;WAIG;2BAFQ,MAAM,EAAE,UACR,MAAM,EAAE;MAkBtB;IAGL,2BAIC;IAED,8BAEC;IAED,iBAEC;IAED,wBAWC;IAED,yBAKC;CACJ;6BA3E4B,uCAAuC"}
+{"version":3,"file":"TemporalSupersamplingRenderPlugin.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/render/buffer/simple-fx/taa/TemporalSupersamplingRenderPlugin.js"],"names":[],"mappings":"AAIA;IAIQ;;;;OAIG;IACH,sBAAsB;IAEtB,uBAAwB;IACxB,8BAAkE;IAGlE;QACI;;;;WAIG;2BAFQ,MAAM,EAAE,UACR,MAAM,EAAE;MAkBtB;IAGL,2BAIC;IAED,8BAEC;CAyBJ;6BA3E4B,uCAAuC"}

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

@@ -18,7 +18,7 @@ export class Decal extends AbstractLight {
      * @type {number}
      */
     draw_priority: number;
-    __signal_transfom_changed: Signal<any, any, any, any, any, any, any, any>;
+    __signal_transfom_changed: Signal;
     /**
      *
      * @param {number[]|Float32Array|ArrayLike<number>} m
@@ -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,kCAA6C;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