@woosh/meep-engine 3.58.0 → 3.60.0

package/src/shade/renderer/Renderer.js

@@ -46,6 +46,10 @@ import {
 } from "./global_illumination/brick4/gpu/draw/shader_brick4_indirect_lighting.js";
 import { shader_brick4_specular } from "./global_illumination/brick4/gpu/draw/shader_brick4_specular.js";
 import { shader_diffuse_IBL } from "./global_illumination/ibl/shader_diffuse_IBL.js";
+import { shader_probe_clipmap_diffuse } from "./global_illumination/probe_clipmap/probe/shader_probe_clipmap_diffuse.js";
+import {
+    shader_probe_clipmap_indirect_lighting
+} from "./global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.js";
 import { shader_specular_IBL } from "./global_illumination/ibl/shader_specular_IBL.js";
 import { GPULightProbeVolumeRenderer } from "./global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js";
 import { shader_diffuse_LPV } from "./global_illumination/lpv/shader_diffuse_LPV.js";
@@ -526,7 +530,9 @@ export class Renderer {
     /**
      * While TAA is off nothing writes the history textures, but the frame counter that
      * indexes them keeps advancing — re-enabling would blend with arbitrarily stale
-     * history of arbitrary parity. Reset temporal history on the transition.
+     * history of arbitrary parity. Reset temporal history on the transition — but not the path
+     * tracer's accumulation, which TAA does not feed: a page flipping between the traced reference
+     * and the rasterized image turns TAA off and back on each time, and would lose the reference.
      * @param {boolean} v
      */
     set feature_taa_enabled(v) {
@@ -535,7 +541,7 @@ export class Renderer {
         }
 
         this.#feature_taa_enabled = v;
-        this.indicate_view_change();
+        this.#reset_temporal_filters();
     }
 
     /**
@@ -1098,12 +1104,19 @@ export class Renderer {
      * Primarily instructs resetting history on temporal accumulation
      */
     indicate_view_change() {
-        this.#postprocess.reset_history();
-
         if (this.#path_tracer !== undefined) {
             this.#path_tracer.clear_history = true;
         }
 
+        this.#reset_temporal_filters();
+    }
+
+    /**
+     * Discard the history every temporal filter blends with.
+     */
+    #reset_temporal_filters() {
+        this.#postprocess.reset_history();
+
         this.#taa.reset_history = true;
 
         if (this.#nss !== undefined) {
@@ -1221,7 +1234,6 @@ export class Renderer {
         // SSR overrides specular below using the same explicitly selected mode.
         switch (mode) {
             case ShadeIndirectLightingMode.IBL:
-            // lit as IBL until its probes are traced (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §13, S4)
             case ShadeIndirectLightingMode.ProbeClipmap:
                 diffuse_pass = {
                     shader: shader_diffuse_IBL,
@@ -1231,6 +1243,7 @@ export class Renderer {
                         tEnvironment: gr_texture_environment,
                     },
                 };
+                // the probe clipmap's too until it has probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.6)
                 specular_pass = {
                     shader: shader_specular_IBL,
                     inputs: {
@@ -1242,6 +1255,48 @@ export class Renderer {
                         camera: gr_buffer_camera_current,
                     },
                 };
+
+                // its light is the probes' once the mode has run this frame (§9.6); a pixel no probe
+                // weighs anything for takes IBL's inside the passes
+                if (mode === ShadeIndirectLightingMode.ProbeClipmap && this.#probe_clipmap_gi.has_probes) {
+                    // SSR off: both lobes in one pass, from one pick
+                    if (prefer_fused && !this.feature_ssr_enabled) {
+                        [current_color_out] = graph_image_pass({
+                            graph,
+                            shader: shader_probe_clipmap_indirect_lighting,
+                            output: [current_color_out],
+                            input_depth: gr_texture_depth_current,
+                            load_op: "load",
+                            inputs: this.#probe_clipmap_gi.write_sampling_bindings({
+                                tDepth: gr_texture_depth_current,
+                                tNormals: gr_texture_normal,
+                                tBentNormals: bent_normals,
+                                tGBufferAlbedo: gr_texture_material_albedo_ao,
+                                tGBufferPBR: gr_texture_pbr,
+                                tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                                view: view_ctx.uniform_buffer.buffer,
+                                camera: gr_buffer_camera_current,
+                                tEnvironment: gr_texture_environment,
+                                tSplitSum: STATIC_GRAPHICS_ENGINE_ASSETS.split_sum,
+                            }),
+                        });
+                        return current_color_out;
+                    }
+
+                    diffuse_pass = {
+                        shader: shader_probe_clipmap_diffuse,
+                        inputs: this.#probe_clipmap_gi.write_sampling_bindings({
+                            tDepth: gr_texture_depth_current,
+                            tNormals: gr_texture_normal,
+                            tBentNormals: bent_normals,
+                            tGBufferAlbedo: gr_texture_material_albedo_ao,
+                            tSTBN_vec2: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                            view: view_ctx.uniform_buffer.buffer,
+                            camera: gr_buffer_camera_current,
+                            tEnvironment: gr_texture_environment,
+                        }),
+                    };
+                }
                 break;
 
             case ShadeIndirectLightingMode.Brick4:
@@ -1331,6 +1386,14 @@ export class Renderer {
                 throw new Error(`Unsupported indirect lighting mode: ${mode}`);
         }
 
+        // before SSR, whose resolve under the probe clipmap reflects the diffuse at the hit's texel
+        const [indirect_diffuse] = graph_image_pass({
+            graph,
+            ...diffuse_pass,
+            input_depth: gr_texture_depth_current,
+            output_resolution: view_ctx.resolution,
+        });
+
         let indirect_specular;
         if (this.feature_ssr_enabled) {
             const ssr = this.#postprocess.ssr.graph_pass({
@@ -1351,6 +1414,9 @@ export class Renderer {
                 input_environment: gr_texture_environment,
                 brick4: ssr_brick4,
                 lpv: ssr_lpv,
+                input_indirect_diffuse: mode === ShadeIndirectLightingMode.ProbeClipmap ? indirect_diffuse : undefined,
+                // in every mode: a clipmap of no cascade while it has no probes
+                probes: this.#probe_clipmap_gi,
                 shader_switches: this.#shader_switches,
                 resolution,
             });
@@ -1365,13 +1431,6 @@ export class Renderer {
             });
         }
 
-        const [indirect_diffuse] = graph_image_pass({
-            graph,
-            ...diffuse_pass,
-            input_depth: gr_texture_depth_current,
-            output_resolution: view_ctx.resolution,
-        });
-
         // resolve indirect lighting
         [current_color_out] = graph_image_pass({
             graph,
@@ -1730,6 +1789,12 @@ export class Renderer {
 
         this.#update_output_resolution();
 
+        // The depth ping-pong and the visibility target are created at the internal resolution
+        // below, so it has to be real by then rather than the 1x1 it is declared at: a 1x1 texture
+        // cannot carry G_BUFFER_MIP_LEVELS mips. Only the texture drawn into is resized per frame,
+        // so frame 0's previous depth is used at the size it was created at.
+        this.#update_internal_resolution();
+
         this.#graphics = new GraphicsContext(device);
 
         const graphics = this.#graphics;
@@ -2104,12 +2169,6 @@ export class Renderer {
     }
 
     #apply_size() {
-        const out_w = this.#output_resolution.x;
-        const out_h = this.#output_resolution.y;
-
-        this.#textures_taa_history.forEach(t => t.resize(out_w, out_h));
-
-
         this.#context_needs_update = true;
     }
 
@@ -2155,20 +2214,10 @@ export class Renderer {
             this.#nss.jitter_sequence_size = Math.ceil(nss_base * taa_sequence_scale);
         }
 
-        const in_w = this.#internal_resolution.x;
-        const in_h = this.#internal_resolution.y;
-
-        this.#textures_depth.forEach(t => {
-            t.resize(in_w, in_h)
-        });
-
-        this.#vis_render_target.resize(in_w, in_h);
-
-        // resizing destroys BOTH ping-pong depth textures, including the one holding last
-        // frame's depth — disocclusion/SSAO would read a zeroed "previous depth" this frame
-        // and silently corrupt temporal history. The external resize() path resets history
-        // via indicate_view_change(); internal-resolution changes (DRS steps) must too.
-        this.indicate_view_change();
+        // Nothing is resized here. The visibility target and this frame's depth are sized in
+        // #begin_frame, once the depth ping-pong has cycled, so last frame's depth keeps the size it
+        // was drawn at and stays readable as previous depth. Not a view change either: each temporal
+        // history sees the size change and handles it itself.
 
         this.#internal_resolution_needs_update = false;
     }
@@ -2222,9 +2271,6 @@ export class Renderer {
         }
 
         this.#apply_size();
-
-        // drop history buffers to prevent artifacts
-        this.indicate_view_change();
     }
 
     /**
@@ -2264,8 +2310,10 @@ export class Renderer {
             this.#graphics.virtual_textures.update();
         }
 
-        // cycle depth attachment
+        // cycle depth attachment, then size the target this frame draws into. Previous depth is not
+        // attached, so it keeps the size it was drawn at.
         this.#vis_render_target.depth_attachment = this.texture_depth_current;
+        this.#vis_render_target.resize(this.#internal_resolution.x, this.#internal_resolution.y);
         this.#postprocess.update(this.#frame_count);
 
         // Advance whichever upscaler we're going to ask for jitter on this
@@ -2735,6 +2783,10 @@ export class Renderer {
         const taa_history_0 = this.#get_texture_taa_history(0);
         const taa_history_1 = this.#get_texture_taa_history(-1);
 
+        // Only the texture resolved into follows the output. The history keeps the size it was
+        // resolved at across a resize and is read by uv; it is resized in turn when it is written.
+        taa_history_1.resize(this.#output_resolution.x, this.#output_resolution.y);
+
         const gr_texture_taa_history = graph_import_texture(graph, taa_history_0, "taa history");
         const gr_texture_taa_out = graph_import_texture(graph, taa_history_1, "taa out");
         let gr_texture_depth_previous = graph_import_texture(graph, this.texture_depth_previous, "depth previous");
@@ -2876,9 +2928,10 @@ export class Renderer {
         // below is skipped on the same fact.
         const has_volumetrics = view_ctx.scene.volumetrics.source.volumes.length > 0;
 
-        // The probe clipmap GI runs after the G-buffer and the shadow maps and before the volumetrics
-        // that sample it (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §5). Made for this view and these
-        // settings on the first frame in the mode, and given back on the first frame out of it.
+        // The probe clipmap GI runs after the G-buffer and before the volumetrics that sample it
+        // (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §5); its hits trace their own shadow rays, so it reads no
+        // shadow map. Made for this view and these settings on the first frame in the mode, and given back
+        // on the first frame out of it.
         if (this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap) {
             this.#probe_clipmap_gi.graph_update({
                 graph,
@@ -2887,8 +2940,6 @@ export class Renderer {
                 depth: gr_texture_depth_current,
                 normal: gr_texture_normal,
                 stbn: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
-                // a cache of the lighting, not the simulation: its response runs on the wall clock
-                time: performance.now() / 1000,
                 movers: gr_scene_movers,
             });
         } else {
@@ -2906,6 +2957,8 @@ export class Renderer {
             // the running mode's GI source, for froxel GI; it is given no other mode's
             brick4: this.indirect_lighting_mode === ShadeIndirectLightingMode.Brick4 ? view_ctx.scene.volumetric_light_map : undefined,
             lpv: this.indirect_lighting_mode === ShadeIndirectLightingMode.LPV ? view_ctx.scene.light_probe_volume : undefined,
+            // in every mode: a clipmap of no cascade while it has no probes
+            probes: this.#probe_clipmap_gi,
         });
 
         /**
@@ -2978,8 +3031,6 @@ export class Renderer {
                 graph: graph,
                 frame_index: this.#frame_count,
                 input_depth: gr_texture_depth_current,
-                input_color: current_color_out,
-                input_depth_previous: gr_texture_depth_previous,
                 input_velocity: gr_velocity,
                 input_normal: gr_texture_normal,
                 input_occlusion: gr_occlusion_clip,
@@ -3163,6 +3214,8 @@ export class Renderer {
                 volumetrics_irradiance: volumetrics.irradiance,
 
                 shader_switches: this.#shader_switches,
+                // in every mode: a clipmap of no cascade while it has no probes
+                probes: this.#probe_clipmap_gi,
                 avboit: this.avboit,
                 side_channels,
             });
@@ -3243,6 +3296,7 @@ export class Renderer {
                     texture_color_history: gr_texture_taa_history,
                     texture_velocity: gr_velocity,
                     texture_occlusion: gr_occlusion_clip,
+                    output_resolution: this.#output_resolution.asArray(),
                 });
             }
         }

package/src/shade/renderer/extension/ViewTextures.d.ts

@@ -19,7 +19,8 @@ export class ViewTextures extends FrameRecord {
     get depth(): number;
     set depth_previous(handle: number);
     /**
-     * Last frame's depth, which reprojection-shaped effects need.
+     * Last frame's depth, which reprojection-shaped effects need. At the size last frame was drawn
+     * at, which after a resolution change is not {@link depth}'s: address it in its own grid.
      *
      * @returns {number}
      */

package/src/shade/renderer/extension/ViewTextures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH;IAMI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAeD,mCAEC;IAXD;;;;OAIG;IACH,6BAEC;IAeD,oCAEC;IAXD;;;;OAIG;IACH,8BAEC;IAeD,wCAEC;IAXD;;;;OAIG;IACH,kCAEC;;CAKJ;4BA5E2B,kBAAkB"}
+{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH;IAMI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAgBD,mCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAeD,oCAEC;IAXD;;;;OAIG;IACH,8BAEC;IAeD,wCAEC;IAXD;;;;OAIG;IACH,kCAEC;;CAKJ;4BA7E2B,kBAAkB"}

package/src/shade/renderer/extension/ViewTextures.js

@@ -38,7 +38,8 @@ export class ViewTextures extends FrameRecord {
     }
 
     /**
-     * Last frame's depth, which reprojection-shaped effects need.
+     * Last frame's depth, which reprojection-shaped effects need. At the size last frame was drawn
+     * at, which after a resolution change is not {@link depth}'s: address it in its own grid.
      *
      * @returns {number}
      */

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#275@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#277@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#275@#execute_fill"(record: object, _resources: any, context: {
+    static "__#277@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#275@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#277@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#277@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#279@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#278@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#280@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#278@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#280@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#278@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#278@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#278@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#278@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#280@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#280@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#280@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#280@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#274@#execute"(data: {
+    static "__#276@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#279@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#281@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.d.ts

@@ -36,6 +36,12 @@ export const MESH_SDF_BAKE_BUDGET_MAX: number;
  * {@link cards}, whose card sets — one per (geometry, material) pair — are captured after the bake,
  * `capture_budget` pages a frame.
  *
+ * **Sources** ({@link add_source}) make the caches of geometries with no tree of their own to bake from,
+ * a virtual geometry's: such a geometry waits queued, as one whose tree is not resident yet does. A
+ * source hears of each geometry queued ({@link onRequested}), records its own work each frame ahead of
+ * the bake, and bakes a proxy of it here as any geometry, whose resident cache it then gives the
+ * geometry ({@link adopt}).
+ *
  * **Readers** bind {@link headers}, {@link indirection}, {@link texture} and {@link MESH_SDF_SAMPLER}
  * (see {@link write_bindings}) and sample through `mesh_sdf_sample`, which only a resident header
  * should be given to.
@@ -53,6 +59,11 @@ export class GPUGeometrySDFManager {
      * @type {Signal<number>}
      */
     onBaked: any;
+    /**
+     * Sent with a geometry's record each time its cache is queued for a bake: what a source listens to.
+     * @type {Signal<GPUGeometryMetadata>}
+     */
+    onRequested: any;
     /**
      * The card sets: one capture of a geometry's layout per (geometry, material) pair, which their
      * user acquires and releases. Layouts reach it as they are placed.
@@ -115,6 +126,42 @@ export class GPUGeometrySDFManager {
      * @returns {MeshSDFState}
      */
     state_of(record: GPUGeometryMetadata): MeshSDFState;
+    /**
+     * Whether a geometry's cache waits for its bake: queued, and not admitted. A cache whose last holder went is
+     * baked all the same until a {@link trim} drops it, as one admitted is.
+     *
+     * @param {GPUGeometryMetadata} record
+     * @returns {boolean}
+     */
+    is_requested(record: GPUGeometryMetadata): boolean;
+    /**
+     * Whether a holder of a geometry's cache draws both sides of it: the side a bake of it takes.
+     *
+     * @param {GPUGeometryMetadata} record
+     * @returns {boolean}
+     */
+    holds_two_sided(record: GPUGeometryMetadata): boolean;
+    /**
+     * @param {MeshSDFSource} source run first in each {@link graph_bake} from here on
+     */
+    add_source(source: MeshSDFSource): void;
+    /**
+     * @param {MeshSDFSource} source
+     */
+    remove_source(source: MeshSDFSource): void;
+    /**
+     * Give `target` the resident cache baked for `proxy`: a source's hand-in, for a geometry with no tree of its own,
+     * of a proxy in the same local space baked as any geometry is. Nothing is copied. The target's header takes the
+     * proxy's layout, entries and side, and the proxy's reads None, as dropped; {@link onBaked} is sent with the
+     * target. The cache has no cards, the target having no tree to capture them with. Held for another side than the
+     * proxy was baked for, it is queued again at the next bake, as any cache is.
+     *
+     * @param {GPUGeometryMetadata} target waiting for its bake ({@link is_requested})
+     * @param {GPUGeometryMetadata} proxy whose cache is resident
+     * @returns {boolean} whether it was adopted: false, changing nothing, when `target` no longer waits or `proxy`'s
+     *   cache is not resident
+     */
+    adopt(target: GPUGeometryMetadata, proxy: GPUGeometryMetadata): boolean;
     /**
      * Geometries whose layout was coarsened by the cap, of those baked: coarser than asked.
      * @returns {number}
@@ -200,12 +247,15 @@ export class GPUGeometrySDFManager {
      *        captures nothing
      * @param {GPUResidentMaterialContext|null} [options.materials] what the capture shades with, as it
      *        stands this frame; needed with a `capture_budget`
+     * @param {GPUMaterialManager|null} [options.material_contexts] what a raster capture draws with
+     *        ({@link GPUMeshCardSets#capture_mode}); needed with a `capture_budget` in that mode
      */
-    graph_bake({ graph, budget, capture_budget, materials }: {
+    graph_bake({ graph, budget, capture_budget, materials, material_contexts }: {
         graph: FrameGraph;
         budget: number;
         capture_budget?: number;
         materials?: GPUResidentMaterialContext | null;
+        material_contexts?: GPUMaterialManager | null;
     }): void;
     destroy(): void;
     #private;
@@ -214,6 +264,18 @@ export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/
 export type GPUGeometryManager = import("../GPUGeometryManager.js").GPUGeometryManager;
 export type GPUGeometryMetadata = import("../GPUGeometryMetadata.js").GPUGeometryMetadata;
 export type GPUResidentMaterialContext = import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
+export type GPUMaterialManager = import("../../material/GPUMaterialManager.js").GPUMaterialManager;
+/**
+ * What makes caches for geometries the bake cannot bake from a tree of their own
+ * ({@link GPUGeometrySDFManageradd_source }): it learns what is asked for from `onRequested`, records its own work in
+ * each frame's graph ahead of the bake, and hands each cache in through `adopt`.
+ */
+export type MeshSDFSource = {
+    /**
+     * records the source's work for the frame, ahead of the bake
+     */
+    graph_update: (arg0: FrameGraph) => void;
+};
 import { GPUMeshCardSets } from "./cards/GPUMeshCardSets.js";
 import { MeshSDFState } from "./MESH_SDF.js";
 //# sourceMappingURL=GPUGeometrySDFManager.d.ts.map

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometrySDFManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js"],"names":[],"mappings":"AAqIA;;;;GAIG;AACH,uCAFU,MAAM,CAEuH;AAgDvI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;IAwPI;;;OAGG;IACH,2CAFW,kBAAkB,EAS5B;IAvPD;;;OAGG;IACH,aAAuB;IAqPvB;;;;OAIG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,sBAHW,MAAM,cACN,MAAM,QAmChB;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;;;OAKG;IACH,gBAHW,mBAAmB,aACnB,OAAO,QAsBjB;IAED;;;;;OAKG;IACH,gBAHW,mBAAmB,aACnB,OAAO,QAqBjB;IAED;;OAEG;IACH,aAYC;IAED;;;;;OAKG;IACH,eAFW,mBAAmB,QAe7B;IAED;;;;;;OAMG;IACH,aAHW,mBAAmB,UACnB,mBAAmB,QA0B7B;IAQD;;;;;OAKG;IACH,iBAHW,mBAAmB,GACjB,YAAY,CAaxB;IAED;;;OAGG;IACH,8BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAUC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAIC;IAED;;;OAGG;IACH,6BAIC;IAED;;;OAGG;IACH,8EAIC;IAED;;;;;;OAMG;IACH,mCAOC;IAED;;OAEG;IACH,+BAcC;IAED;;;;;;;;;;;;;;OAcG;IACH;QAP+B,KAAK,EAAzB,UAAU;QACM,MAAM,EAAtB,MAAM;QACW,cAAc,GAA/B,MAAM;QAEoC,SAAS,GAAnD,0BAA0B,GAAC,IAAI;aA+DzC;IAk+BD,gBAsBC;;CACJ;yBA91DY,OAAO,8DAA8D,EAAE,UAAU;iCACjF,OAAO,0BAA0B,EAAE,kBAAkB;kCACrD,OAAO,2BAA2B,EAAE,mBAAmB;yCACvD,OAAO,uDAAuD,EAAE,0BAA0B;gCAjBzC,4BAA4B;6BAQtC,eAAe"}
+{"version":3,"file":"GPUGeometrySDFManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js"],"names":[],"mappings":"AA+IA;;;;GAIG;AACH,uCAFU,MAAM,CAEuH;AAgDvI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IAsQI;;;OAGG;IACH,2CAFW,kBAAkB,EAS5B;IArQD;;;OAGG;IACH,aAAuB;IAEvB;;;OAGG;IACH,iBAA2B;IA6P3B;;;;OAIG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,sBAHW,MAAM,cACN,MAAM,QAkChB;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;;;OAKG;IACH,gBAHW,mBAAmB,aACnB,OAAO,QAqBjB;IAED;;;;;OAKG;IACH,gBAHW,mBAAmB,aACnB,OAAO,QAqBjB;IAED;;OAEG;IACH,aAYC;IAED;;;;;OAKG;IACH,eAFW,mBAAmB,QAe7B;IAED;;;;;;OAMG;IACH,aAHW,mBAAmB,UACnB,mBAAmB,QA0B7B;IAQD;;;;;OAKG;IACH,iBAHW,mBAAmB,GACjB,YAAY,CAaxB;IAED;;;;;;OAMG;IACH,qBAHW,mBAAmB,GACjB,OAAO,CAInB;IAED;;;;;OAKG;IACH,wBAHW,mBAAmB,GACjB,OAAO,CAInB;IAED;;OAEG;IACH,mBAFW,aAAa,QAOvB;IAED;;OAEG;IACH,sBAFW,aAAa,QAQvB;IAED;;;;;;;;;;;OAWG;IACH,cALW,mBAAmB,SACnB,mBAAmB,GACjB,OAAO,CA4CnB;IAED;;;OAGG;IACH,8BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAUC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAIC;IAED;;;OAGG;IACH,6BAIC;IAED;;;OAGG;IACH,8EAIC;IAED;;;;;;OAMG;IACH,mCAOC;IAED;;OAEG;IACH,+BAcC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACM,MAAM,EAAtB,MAAM;QACW,cAAc,GAA/B,MAAM;QAEoC,SAAS,GAAnD,0BAA0B,GAAC,IAAI;QAEG,iBAAiB,GAAnD,kBAAkB,GAAC,IAAI;aA8EjC;IAwiCD,gBAsBC;;CACJ;yBAljEY,OAAO,8DAA8D,EAAE,UAAU;iCACjF,OAAO,0BAA0B,EAAE,kBAAkB;kCACrD,OAAO,2BAA2B,EAAE,mBAAmB;yCACvD,OAAO,uDAAuD,EAAE,0BAA0B;iCAC1F,OAAO,sCAAsC,EAAE,kBAAkB;;;;;;;;;;yBASvD,UAAU,KAAG,IAAI;;gCA3BsB,4BAA4B;6BAQf,eAAe"}