@woosh/meep-engine 2.165.6 → 2.165.7

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/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

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;;;;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"}
+{"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/plugin/ForwardPlusRenderingPlugin.d.ts

@@ -1,5 +1,27 @@
-import {EnginePlugin} from "../../../../plugin/EnginePlugin";
-
-export class ForwardPlusRenderingPlugin extends EnginePlugin {
-    setClusterResolution(x: number, y: number, z: number): void
-}
+export class ForwardPlusRenderingPlugin extends EnginePlugin {
+    __light_manager: LightManager;
+    __resolution: ThreeVector2;
+    __material_transformer: MaterialTransformer;
+    /**
+     * Set resolution of the cluster texture, higher resolution will result in less load on the GPU, but will take up more RAM to represent and more time to build the clusters each frame
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setClusterResolution(x: number, y: number, z: number): void;
+    /**
+     *
+     * @param {CameraView} view
+     * @private
+     */
+    private __prepare_for_render;
+    updateResolution(): void;
+    startup(): Promise<void>;
+    shutdown(): Promise<void>;
+    getLightManager(): LightManager;
+}
+import { EnginePlugin } from "../../../../plugin/EnginePlugin.js";
+import { LightManager } from "../LightManager.js";
+import { Vector2 as ThreeVector2 } from "three";
+import { MaterialTransformer } from "./MaterialTransformer.js";
+//# sourceMappingURL=ForwardPlusRenderingPlugin.d.ts.map

package/src/engine/graphics/render/forward_plus/plugin/MaterialTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MaterialTransformer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/plugin/MaterialTransformer.js"],"names":[],"mappings":"AAcA;IAEI;;;;OAIG;IACH,yDAuDC;IApDG,8BAAoC;IACpC,2BAA8B;IAEb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiChB;IAED,2CAaC;IAGL;;;OAGG;IACH,kCAWC;IAED,4BAiCC;CACJ;4CAjI2C,0DAA0D;wBAEvE,OAAO"}
+{"version":3,"file":"MaterialTransformer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/plugin/MaterialTransformer.js"],"names":[],"mappings":"AASA;IAEI;;;;OAIG;IACH,yDAuDC;IApDG,8BAAoC;IACpC,2BAA8B;IAEb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiChB;IAED,2CAaC;IAGL;;;OAGG;IACH,kCAWC;IAED,4BAiCC;CACJ;4CA5H2C,0DAA0D;wBAEvE,OAAO"}

package/src/engine/graphics/render/forward_plus/plugin/MaterialTransformer.js

@@ -5,12 +5,7 @@ import { isLitMaterial } from "./isLitMaterial.js";
 import { fp_build_fragment_shader } from "../materials/fp_build_fragment_shader.js";
 import { fp_build_vertex_shader } from "../materials/fp_build_vertex_shader.js";
 import { fp_build_vertex_lighting_shared } from "../materials/fp_build_vertex_lighting_shared.js";
-
-/**
- * @readonly
- * @type {string}
- */
-const PROPERTY_TRANSFORMER_MARKER = '@forward-plus-material-transformer';
+import { FORWARD_PLUS_MATERIAL_MARKER } from "./forwardPlusMaterialMarker.js";
 
 export class MaterialTransformer extends AbstractMaterialTransformer {
 
@@ -94,10 +89,10 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
     }
 
     transform(source) {
-        if (source.hasOwnProperty(PROPERTY_TRANSFORMER_MARKER)) {
+        if (source.hasOwnProperty(FORWARD_PLUS_MATERIAL_MARKER)) {
             // already transformed
 
-            if (source[PROPERTY_TRANSFORMER_MARKER] !== this) {
+            if (source[FORWARD_PLUS_MATERIAL_MARKER] !== this) {
                 throw new Error('The material is already transformed, but is associated with a different transformer instance');
             } else {
                 return source;
@@ -121,7 +116,7 @@ export class MaterialTransformer extends AbstractMaterialTransformer {
             result.onBeforeCompile = composeCompile(source.onBeforeCompile, this.__on_before_compile);
 
 
-            result[PROPERTY_TRANSFORMER_MARKER] = this;
+            result[FORWARD_PLUS_MATERIAL_MARKER] = this;
 
         }
 

package/src/engine/graphics/render/forward_plus/plugin/forwardPlusMaterialMarker.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Whether `material` carries the Forward+ transformation marker, i.e. it has already
+ * been run through a {@link MaterialTransformer}.
+ * @param {Material} material
+ * @returns {boolean}
+ */
+export function isForwardPlusTransformed(material: Material): boolean;
+/**
+ * Property key stamped onto a material once a Forward+ {@link MaterialTransformer} has
+ * injected clustered-lighting / decal shader code into it. The value stored under the
+ * key is the transformer instance that performed the transformation.
+ * @readonly
+ * @type {string}
+ */
+export const FORWARD_PLUS_MATERIAL_MARKER: string;
+//# sourceMappingURL=forwardPlusMaterialMarker.d.ts.map

package/src/engine/graphics/render/forward_plus/plugin/forwardPlusMaterialMarker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwardPlusMaterialMarker.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/plugin/forwardPlusMaterialMarker.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,8DAFa,OAAO,CAInB;AAjBD;;;;;;GAMG;AACH,2CAFU,MAAM,CAEiE"}

package/src/engine/graphics/render/forward_plus/plugin/forwardPlusMaterialMarker.js

@@ -0,0 +1,18 @@
+/**
+ * Property key stamped onto a material once a Forward+ {@link MaterialTransformer} has
+ * injected clustered-lighting / decal shader code into it. The value stored under the
+ * key is the transformer instance that performed the transformation.
+ * @readonly
+ * @type {string}
+ */
+export const FORWARD_PLUS_MATERIAL_MARKER = '@forward-plus-material-transformer';
+
+/**
+ * Whether `material` carries the Forward+ transformation marker, i.e. it has already
+ * been run through a {@link MaterialTransformer}.
+ * @param {Material} material
+ * @returns {boolean}
+ */
+export function isForwardPlusTransformed(material) {
+    return material.hasOwnProperty(FORWARD_PLUS_MATERIAL_MARKER);
+}

package/src/engine/graphics/render/forward_plus/plugin/isForwardPlusLightingSkipped.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Development diagnostic. Returns `true` when `material` will silently miss Forward+
+ * clustered lighting: Forward+ is active (a {@link MaterialTransformer} compile step is
+ * registered on the manager), the material is lit, yet it never went through
+ * transformation.
+ *
+ * Returns `false` when Forward+ is not installed, because lit materials are then
+ * legitimately untransformed — this keeps the check correct for engine configurations
+ * that do not use Forward+ rendering.
+ *
+ * @param {MaterialManager} material_manager
+ * @param {Material} material
+ * @returns {boolean}
+ */
+export function isForwardPlusLightingSkipped(material_manager: MaterialManager, material: Material): boolean;
+//# sourceMappingURL=isForwardPlusLightingSkipped.d.ts.map

package/src/engine/graphics/render/forward_plus/plugin/isForwardPlusLightingSkipped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isForwardPlusLightingSkipped.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/render/forward_plus/plugin/isForwardPlusLightingSkipped.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,qGAFa,OAAO,CAcnB"}

package/src/engine/graphics/render/forward_plus/plugin/isForwardPlusLightingSkipped.js

@@ -0,0 +1,31 @@
+import { isLitMaterial } from "./isLitMaterial.js";
+import { MaterialTransformer } from "./MaterialTransformer.js";
+import { isForwardPlusTransformed } from "./forwardPlusMaterialMarker.js";
+
+/**
+ * Development diagnostic. Returns `true` when `material` will silently miss Forward+
+ * clustered lighting: Forward+ is active (a {@link MaterialTransformer} compile step is
+ * registered on the manager), the material is lit, yet it never went through
+ * transformation.
+ *
+ * Returns `false` when Forward+ is not installed, because lit materials are then
+ * legitimately untransformed — this keeps the check correct for engine configurations
+ * that do not use Forward+ rendering.
+ *
+ * @param {MaterialManager} material_manager
+ * @param {Material} material
+ * @returns {boolean}
+ */
+export function isForwardPlusLightingSkipped(material_manager, material) {
+    if (!isLitMaterial(material)) {
+        // unlit materials are never transformed for clustered lighting
+        return false;
+    }
+
+    if (material_manager.getCompilationSteps(MaterialTransformer).length === 0) {
+        // Forward+ is not active, nothing is expected to transform lit materials
+        return false;
+    }
+
+    return !isForwardPlusTransformed(material);
+}

package/src/engine/graphics/render/frame_graph/FrameGraph.d.ts

@@ -54,7 +54,7 @@ export class FrameGraph {
      *
      * @type {Signal<IFrameGraphContext,this>}
      */
-    onExecuted: Signal<IFrameGraphContext, this>;
+    onExecuted: any;
     /**
      *
      * @type {FramePassNode[]}

package/src/engine/graphics/render/frame_graph/FrameGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FrameGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/frame_graph/FrameGraph.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAmCI;;;OAGG;IACH,mBAFW,MAAM,EAOhB;IA3CD;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,6CAA0B;IAE1B;;;;OAIG;IACH,qBAAkB;IAElB;;;;OAIG;IACH,yBAAsB;IAEtB;;;;OAIG;IACH,4BAAyB;IAazB;;;;OAIG;IACH,qBAHW,MAAM,sBAehB;IAED;;;;OAIG;IACH,oBAHW,MAAM,qBAehB;IAED;;;;OAIG;IACH,qBAHW,MAAM,KAKhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,oBAEJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,6BAYC;IAED;;;;;;OAMG;IACH,4BAeC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,MAAM,CAkBlB;IAED;;;;;;OAMG;IACH,2BALW,MAAM,wDAGJ,MAAM,CAUlB;IAED;;;OAGG;IACH,4BAHa,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,eALW,MAAM,4BAGJ,gBAAgB,CA2B5B;IAED;;;;;;OAMG;IACH,iEAFa,OAAO,CAQnB;IAED,gBA6FC;IAED;;;OAGG;IACH,2CAuDC;IAED;;;;;;;OAOG;IACH;gBAFqB,EAAE;mBAAa,EAAE;MA2DrC;IAED;;;;;OAKG;IACH,eAFY,MAAM,CA0GjB;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC;8BAxnB6B,oBAAoB;6BACrB,mBAAmB;iCAJf,uBAAuB"}
+{"version":3,"file":"FrameGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/frame_graph/FrameGraph.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAmCI;;;OAGG;IACH,mBAFW,MAAM,EAOhB;IA3CD;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,gBAA0B;IAE1B;;;;OAIG;IACH,qBAAkB;IAElB;;;;OAIG;IACH,yBAAsB;IAEtB;;;;OAIG;IACH,4BAAyB;IAazB;;;;OAIG;IACH,qBAHW,MAAM,sBAehB;IAED;;;;OAIG;IACH,oBAHW,MAAM,qBAehB;IAED;;;;OAIG;IACH,qBAHW,MAAM,KAKhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,oBAEJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,6BAYC;IAED;;;;;;OAMG;IACH,4BAeC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,MAAM,CAkBlB;IAED;;;;;;OAMG;IACH,2BALW,MAAM,wDAGJ,MAAM,CAUlB;IAED;;;OAGG;IACH,4BAHa,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,eALW,MAAM,4BAGJ,gBAAgB,CA2B5B;IAED;;;;;;OAMG;IACH,iEAFa,OAAO,CAQnB;IAED,gBA6FC;IAED;;;OAGG;IACH,2CAuDC;IAED;;;;;;;OAOG;IACH;gBAFqB,EAAE;mBAAa,EAAE;MA2DrC;IAED;;;;;OAKG;IACH,eAFY,MAAM,CA0GjB;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC;8BAxnB6B,oBAAoB;6BACrB,mBAAmB;iCAJf,uBAAuB"}

package/src/engine/graphics/render/frame_graph/resource/TextureResourceDescriptor.d.ts

@@ -2,7 +2,7 @@ export class TextureResourceDescriptor extends ResourceDescriptor {
     static from({ height, width, format, channel_count, initial_state }: {
         height?: number;
         width?: number;
-        format?: BinaryDataType;
+        format?: string;
         channel_count?: number;
         initial_state?: number;
     }): TextureResourceDescriptor;

package/src/engine/graphics/render/gizmo/Gizmo.d.ts

@@ -1,3 +1,7 @@
-import {GizmoShapeRenderingInterface} from "./GizmoShapeRenderingInterface";
-
-export const Gizmo: GizmoShapeRenderingInterface;
+/**
+ *
+ * @type {GizmoShapeRenderingInterface}
+ */
+export const Gizmo: GizmoShapeRenderingInterface;
+import { GizmoShapeRenderingInterface } from "./GizmoShapeRenderingInterface.js";
+//# sourceMappingURL=Gizmo.d.ts.map

package/src/engine/graphics/render/gizmo/GizmoRenderingPlugin.d.ts

@@ -1,5 +1,5 @@
-import {EnginePlugin} from "../../../plugin/EnginePlugin";
-
-export class GizmoRenderingPlugin extends EnginePlugin{
-    
-}
+export class GizmoRenderingPlugin extends EnginePlugin {
+    __layer: any;
+}
+import { EnginePlugin } from "../../../plugin/EnginePlugin.js";
+//# sourceMappingURL=GizmoRenderingPlugin.d.ts.map

package/src/engine/graphics/render/gizmo/GizmoRenderingPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GizmoRenderingPlugin.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/gizmo/GizmoRenderingPlugin.js"],"names":[],"mappings":"AAGA;IACI,wBAUC;IATG,aAA0D;IAW9D,yBAMC;CAEJ;6BAxB4B,iCAAiC"}
+{"version":3,"file":"GizmoRenderingPlugin.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/gizmo/GizmoRenderingPlugin.js"],"names":[],"mappings":"AAGA;IAEQ,aAA0D;CAmBjE;6BAxB4B,iCAAiC"}

package/src/engine/graphics/render/gizmo/GizmoShapeRenderingInterface.d.ts

@@ -1,13 +1,72 @@
-export class GizmoShapeRenderingInterface {
-    color: number[]
-
-    draw_solid_cube(center: number[], size: number[]): void
-
-    draw_wire_cube(center: number[], size: number[]): void
-
-    draw_solid_sphere(center: number[], radius: number): void
-
-    draw_wire_sphere(center: number[], radius: number): void
-
-    static INSTANCE: GizmoShapeRenderingInterface
-}
+/**
+ * Inspired by IMGUI and Unity's debug renderer
+ */
+export class GizmoShapeRenderingInterface {
+    /**
+     *
+     * @type {number[]|Float32Array}
+     * @private
+     */
+    private __color;
+    __boxes_solid: InstancedMeshGroup;
+    __boxes_wire: InstancedMeshGroup;
+    __sphere_solid: InstancedMeshGroup;
+    __sphere_wire: InstancedMeshGroup;
+    __lines: Lines;
+    __get_groups(): (InstancedMeshGroup | Lines)[];
+    /**
+     *
+     * @param {THREE.Object3D[]} destination
+     * @param {number} destination_offset
+     * @param {number[]} frustum
+     */
+    collect(destination: THREE.Object3D[], destination_offset: number, frustum: number[]): number;
+    clear(): void;
+    /**
+     * Color used for drawing shapes, draw_x will take on the currently set color when called
+     * RGBA
+     * @param {number[]} color
+     */
+    set color(arg: number[]);
+    /**
+     * RGBA
+     * @return {number[]}
+     */
+    get color(): number[];
+    /**
+     *
+     * @param {number[]} center
+     * @param {number[]} size
+     */
+    draw_solid_cube(center: number[], size: number[]): void;
+    /**
+     *
+     * @param {number[]} center
+     * @param {number[]} size
+     */
+    draw_wire_cube(center: number[], size: number[]): void;
+    /**
+     *
+     * @param {number[]} from
+     * @param {number[]} to
+     */
+    draw_line(from: number[], to: number[]): void;
+    /**
+     *
+     * @param {number[]} center
+     * @param {number} radius
+     */
+    draw_solid_sphere(center: number[], radius: number): void;
+    /**
+     *
+     * @param {number[]} center
+     * @param {number} radius
+     */
+    draw_wire_sphere(center: number[], radius: number): void;
+}
+export namespace GizmoShapeRenderingInterface {
+    let INSTANCE: GizmoShapeRenderingInterface;
+}
+import { InstancedMeshGroup } from "../../geometry/instancing/InstancedMeshGroup.js";
+import { Lines } from "../Lines.js";
+//# sourceMappingURL=GizmoShapeRenderingInterface.d.ts.map

package/src/engine/graphics/render/layers/RenderLayer.d.ts

@@ -1,22 +1,78 @@
-import {Object3D} from "three";
-import {IncrementalDeltaSet} from "../visibility/IncrementalDeltaSet";
-import {RenderLayerState} from "./RenderLayerState";
-
-export class RenderLayer {
-    name: string
-    state: RenderLayerState
-
-    managed: boolean
-
-    /**
-     * @deprecated
-     */
-    extractRenderable(leafData: any): Object3D
-
-    /**
-     * @deprecated
-     */
-    visibleSet: IncrementalDeltaSet<Object3D>
-
-    compute_depth_range: ((result: { near: number; far: number }, frustum: ArrayLike<number>, plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number) => void) | null
-}
+export class RenderLayer {
+    /**
+     *
+     * @type {RenderLayerState}
+     */
+    state: RenderLayerState;
+    /**
+     *
+     * @type {String|null}
+     */
+    name: string | null;
+    /**
+     * Layer is managed externally, visibility will not be updated in the rendering engine
+     * @deprecated
+     * @type {boolean}
+     */
+    managed: boolean;
+    /**
+     *
+     * @type {function(*): Object3D}
+     */
+    extractRenderable: (arg0: any) => Object3D;
+    /**
+     * @deprecated use CameraView's visible set instead
+     * Contains visible elements across all views, if element is in at least one view - it will be here
+     * @deprecated
+     * @type {IncrementalDeltaSet<THREE.Object3D>}
+     */
+    visibleSet: IncrementalDeltaSet<THREE.Object3D>;
+    /**
+     * @deprecated
+     * @param {boolean} v
+     */
+    set visible(arg: boolean);
+    /**
+     * @deprecated
+     * @returns {boolean}
+     */
+    get visible(): boolean;
+    /**
+     * Compute near and far clipping planes for a camera given a frustum.
+     * Note: near plane is frustum.planes[4], far plane is frustum.planes[5]
+     * @deprecated
+     * @param {Frustum} frustum
+     * @param {number} near
+     * @param {number} far
+     * @param {function(near:number, far:number)} callback
+     * @param [thisArg]
+     */
+    computeNearFarClippingPlanes(frustum: Frustum, near: number, far: number, callback: any, thisArg?: any): void;
+    /**
+     * @deprecated
+     * @param {THREE.Object3D[]} destination
+     * @param {number} destination_offset
+     * @param {CameraView} view
+     * @returns {number} Number of records added to destination
+     */
+    buildVisibleSet(destination: THREE.Object3D[], destination_offset: number, view: CameraView): number;
+    /**
+     * Expand a (near, far) depth range to cover this layer's content that
+     * intersects a frustum. Driven by the camera's autoClip path; defaults to
+     * a no-op for layers that don't own a BVH or don't participate in depth
+     * fitting (e.g. screen-space overlays).
+     *
+     * Systems with a BVH wire this from their `startup` alongside
+     * `buildVisibleSet` — typically using
+     * {@link bvh_query_depth_range_in_frustum} against their own BVH.
+     *
+     * @type {((result:{near:number,far:number}, frustum:ArrayLike<number>, plane_normal_x:number, plane_normal_y:number, plane_normal_z:number, plane_constant:number) => void) | null}
+     */
+    compute_depth_range: (result: {
+        near: number;
+        far: number;
+    }, frustum: ArrayLike<number>, plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number) => void;
+}
+import { RenderLayerState } from "./RenderLayerState.js";
+import { IncrementalDeltaSet } from "../visibility/IncrementalDeltaSet.js";
+//# sourceMappingURL=RenderLayer.d.ts.map