@woosh/meep-engine 3.59.0 → 3.60.1

package/package.json

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

package/src/shade/playground/probe_clipmap/index.html

@@ -143,6 +143,18 @@
         frame-time knob; this page starts higher so Sponza is whole in seconds, not minutes.
     </p>
 
+    <label>
+        <span>Card capture</span>
+        <select id="card_capture_mode">
+            <option value="Raster" selected>Raster — the material's own pass</option>
+            <option value="Trace">Trace — a ray a texel</option>
+        </select>
+    </label>
+    <p class="note">
+        How the cards take their albedo. A change captures every card set again; the Mesh cards view
+        shows what they hold.
+    </p>
+
     <hr>
 
     <div id="status"></div>

package/src/shade/playground/probe_clipmap/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AAyFA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA0QzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AA0FA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA8QzB"}

package/src/shade/playground/probe_clipmap/main.js

@@ -11,6 +11,7 @@ import { camera_frame_sphere } from "../../renderer/camera/camera_frame_sphere.j
 import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { MeshCardCaptureMode } from "../../renderer/geometry/sdf/cards/MeshCardCaptureMode.js";
 import { ProbeClipmapDebugView } from "../../renderer/global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js";
 import { make_sunlight } from "../../renderer/light/make_sunlight.js";
 import { PointLight } from "../../renderer/light/model/PointLight.js";
@@ -237,6 +238,10 @@ export async function start() {
         renderer.probe_clipmap.debug_view = ProbeClipmapDebugView[event.target.value];
     });
 
+    element('card_capture_mode').addEventListener('change', event => {
+        renderer.probe_clipmap.card_capture_mode = MeshCardCaptureMode[event.target.value];
+    });
+
     const taa_toggle = element('taa');
     const path_tracing_toggle = element('path_tracing');
 

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AAwJA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,wCAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD;;;;OAIG;IACH,eAFU,oBAAoB,CAEa;IAY3C;;;;;;;OAOG;IACH,mBAFU,qBAAqB,CAEkB;IAEjD;;;;;OAKG;IACH,mBAFU,oBAAoB,CAEgB;IAE9C;;;OAGG;IACH,QAFU,cAAc,CAEM;IAE9B;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEiB;IAElC,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAW1C,oCAIC;IAED,mCAEC;IAYD,oCAIC;IAED,mCAEC;IAED;;;;;;OAMG;IACH,6BAFU,OAAO,CAEmB;IAcpC;;OAEG;IACH,uCAEC;IAyBD,0CAIC;IAED,yCAEC;IAED;;;;;OAKG;IACH,yBAFU,MAAM,CAEY;IAW5B,8CAMC;IAED,6CAEC;IAUD,8CAMC;IAED,6CAEC;IAWD,mDAKC;IAED,kDAEC;IASD,+CAKC;IAED,8CAEC;IAED,+BAA6B;IAC7B,4CAA0C;IAkB1C,qCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;;;OAOG;IACH,oCAOC;IAnBD,mCAEC;IAmBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAYD;;OAEG;IACH,sCAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B;;;;;;;;;;OAUG;IACH,qBAA+B;IAgB/B;;;OAGG;IACH,yCAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,+BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,iBAAiB,GAAC,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,yBAHW,eAAe,GACb,eAAe,CA8B3B;IAED;;;;;OAKG;IACH,4BAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAUD;;;;;;;;;;;;;;;;;OAiBG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAsB7B;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAYnB;IAED;;OAEG;IACH,8BAFa,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,yBAHW,KAAK,GACJ,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAMC;IAiBD;;;;OAIG;IACH,gCAHW,KAAK,GACH,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,kBAFW,KAAK,QAyBf;IAiSD,oGAAoG;IACpG,kDAA2C;IAO3C;;;;OAIG;IACH,0BAEC;IAiBD;;;;;;OAMG;IACH,qBAHW,eAAe,GACb,iBAAiB,CAW7B;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAwFD;;;;;;;;OAQG;IACH;QAJsC,OAAO;QACd,MAAM;QACT,UAAU,GAA3B,MAAM;sBA8MhB;IAED;;;;;;;;;;;;;;OAcG;IACH,0BAFW,eAAe,QA8DzB;IAyDD;;;;;;;;;;;;;;;;;OAiBG;IACH,WAFa,IAAI,CA0ChB;IAgCD,4BAwBC;IAkID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAmFD,0CAMC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,eAZW,iBAAiB,SACjB,KAAK,uBACL,MAAM,GAIJ,OAAO,CAuCnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBARW,iBAAiB,SACjB,KAAK,sBACL,MAAM,UACN,iBAAiB,GACf,OAAO,CAiBnB;;CA2lCJ;+BA51GY,OAAO,8CAA8C,EAAE,gBAAgB;gCACvE,OAAO,+CAA+C,EAAE,iBAAiB;gCACzE,OAAO,+BAA+B,EAAE,iBAAiB;8BACzD,OAAO,gCAAgC,EAAE,eAAe;gCACxD,OAAO,gDAAgD,EAAE,iBAAiB;8BAC1E,OAAO,4BAA4B,EAAE,eAAe;oBACpD,OAAO,kBAAkB,EAAE,KAAK;6BAnChB,yBAAyB;0CACZ,gCAAgC;qCA7CrC,6DAA6D;sCA+C5D,4BAA4B;qCAD7B,2BAA2B;+BAEjC,6CAA6C;gCAC5C,sCAAsC;2BAhC3C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAuD7C,uBAAuB;mCAChB,qCAAqC;gCAnExC,sBAAsB;oBAxDlC,4BAA4B;kCAuHd,gCAAgC;2BAvFvC,2BAA2B;iCAqFrB,0CAA0C;4CAnE/B,+DAA+D;yBA6ClF,yBAAyB;kCAChB,kCAAkC;kCAUlC,wBAAwB;oBAnCtC,0BAA0B;gCA1Dd,uCAAuC;uCAgDhC,sDAAsD"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -2928,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,
@@ -2939,10 +2940,7 @@ 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,
-                shadowmap_atlas: gr_shadowmap_atlas,
             });
         } else {
             this.#probe_clipmap_gi.release();

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"}

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js

@@ -43,7 +43,7 @@ import { shader_mesh_cards_log } from "./cards/shader_mesh_cards_log.js";
 import { shader_mesh_cards_merge } from "./cards/shader_mesh_cards_merge.js";
 import { shader_mesh_cards_pages } from "./cards/shader_mesh_cards_pages.js";
 import { shader_mesh_cards_split } from "./cards/shader_mesh_cards_split.js";
-import { MESH_SDF_BRICK_TEXELS, MeshSDFState } from "./MESH_SDF.js";
+import { MESH_SDF_BRICK_TEXELS, MESH_SDF_BRICK_VOXELS, MeshSDFState } from "./MESH_SDF.js";
 import { MESH_SDF_SAMPLER } from "./MESH_SDF_RESOURCES.js";
 import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
 import { MeshSDFLayout } from "./MeshSDFLayout.js";
@@ -53,6 +53,16 @@ import { MeshSDFLayout } from "./MeshSDFLayout.js";
  * @typedef {import("../GPUGeometryManager.js").GPUGeometryManager} GPUGeometryManager
  * @typedef {import("../GPUGeometryMetadata.js").GPUGeometryMetadata} GPUGeometryMetadata
  * @typedef {import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} GPUResidentMaterialContext
+ * @typedef {import("../../material/GPUMaterialManager.js").GPUMaterialManager} GPUMaterialManager
+ */
+
+/**
+ * What makes caches for geometries the bake cannot bake from a tree of their own
+ * ({@link GPUGeometrySDFManager#add_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`.
+ *
+ * @typedef {Object} MeshSDFSource
+ * @property {function(FrameGraph): void} graph_update records the source's work for the frame, ahead of the bake
  */
 
 /*
@@ -216,6 +226,12 @@ function grow_typed(array, length) {
  * {@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.
@@ -240,6 +256,18 @@ export class GPUGeometrySDFManager {
      */
     onBaked = new Signal();
 
+    /**
+     * Sent with a geometry's record each time its cache is queued for a bake: what a source listens to.
+     * @type {Signal<GPUGeometryMetadata>}
+     */
+    onRequested = new Signal();
+
+    /**
+     * Run first in each {@link graph_bake}.
+     * @type {MeshSDFSource[]}
+     */
+    #sources = [];
+
     #voxel_size = 0.125;
     #max_bricks = 18;
 
@@ -265,6 +293,8 @@ export class GPUGeometrySDFManager {
     #card_pages = new Uint32Array(64);
     /** Words the placed layout keeps. */
     #card_words = new Uint32Array(64);
+    /** Texels a side of the layout's largest card: the grid's longest axis in voxels, plus one. */
+    #card_side = new Uint32Array(64);
 
     /**
      * The range each geometry's cards are being placed in.
@@ -522,8 +552,7 @@ export class GPUGeometrySDFManager {
             }
 
             if (this.#references[id] > 0 && state[id] === HOST_NONE) {
-                state[id] = HOST_QUEUED;
-                this.#queue.push(id);
+                this.#request(id);
             }
         }
 
@@ -569,8 +598,7 @@ export class GPUGeometrySDFManager {
         }
 
         if (++this.#references[id] === 1 && this.#state[id] === HOST_NONE) {
-            this.#state[id] = HOST_QUEUED;
-            this.#queue.push(id);
+            this.#request(id);
         }
 
         this.#holders_changed.push(id);
@@ -699,6 +727,103 @@ export class GPUGeometrySDFManager {
         }
     }
 
+    /**
+     * 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) {
+        return this.#state[record.index] === HOST_QUEUED;
+    }
+
+    /**
+     * 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) {
+        return (this.#two_sided_references[record.index] ?? 0) > 0;
+    }
+
+    /**
+     * @param {MeshSDFSource} source run first in each {@link graph_bake} from here on
+     */
+    add_source(source) {
+        assert.defined(source, 'source');
+        assert.equal(this.#sources.includes(source), false, 'source added already');
+
+        this.#sources.push(source);
+    }
+
+    /**
+     * @param {MeshSDFSource} source
+     */
+    remove_source(source) {
+        const index = this.#sources.indexOf(source);
+
+        if (index !== -1) {
+            this.#sources.splice(index, 1);
+        }
+    }
+
+    /**
+     * 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, proxy) {
+        assert.defined(target, 'target');
+        assert.defined(proxy, 'proxy');
+        assert.notEqual(target.index, proxy.index, 'a geometry cannot adopt its own cache');
+
+        const id = target.index;
+        const from = proxy.index;
+
+        if (!this.is_requested(target) || this.#state[from] !== HOST_RESIDENT) {
+            return false;
+        }
+
+        this.#drop_cards(from);
+
+        const range = this.#ranges[from];
+
+        this.#ranges[id] = range;
+        this.#ranges[from] = null;
+        this.#brick_count[id] = this.#brick_count[from];
+        this.#two_sided[id] = this.#two_sided[from];
+        this.#generation[id]++;
+
+        this.#state[from] = HOST_NONE;
+        this.#state[id] = HOST_RESIDENT;
+
+        // the layout the proxy was admitted with: a configure since would have dropped its cache
+        const layout = this.#layout;
+
+        layout.compute(proxy.geometry.bounding_box, this.#voxel_size, this.#max_bricks);
+
+        this.#write_header(id, layout, range.offset + 1, MeshSDFState.Resident);
+
+        this.#word_scratch[0] = MeshSDFState.None;
+        this.#device.queue.writeBuffer(this.#headers, from * HEADER_BYTES + HEADER_STATE, this.#word_scratch, 0, 1);
+
+        // the side its holders draw is checked at the next bake
+        this.#holders_changed.push(id);
+
+        this.onBaked.send1(id);
+
+        return true;
+    }
+
     /**
      * Geometries whose layout was coarsened by the cap, of those baked: coarser than asked.
      * @returns {number}
@@ -857,8 +982,10 @@ 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 = 0, materials = null }) {
+    graph_bake({ graph, budget, capture_budget = 0, materials = null, material_contexts = null }) {
         assert.defined(graph, 'graph');
         assert.isPositiveInteger(budget, 'budget');
         assert.lessThanOrEqual(budget, MESH_SDF_BAKE_BUDGET_MAX, 'budget');
@@ -867,6 +994,13 @@ export class GPUGeometrySDFManager {
 
         this.#frame++;
 
+        // the sources first: a cache adopted here is not admitted to a bake of its own below
+        const sources = this.#sources;
+
+        for (let i = 0; i < sources.length; i++) {
+            sources[i].graph_update(graph);
+        }
+
         this.#follow_sides();
 
         // the last bake's commands were submitted before this call: what they read may be handed out
@@ -880,12 +1014,12 @@ export class GPUGeometrySDFManager {
 
         const queued_bound = this.#read_queued + (this.#admitted_total - this.#read_admitted);
 
-        const has_work = this.#queue.length > 0
+        const has_work = this.#admittable()
             || queued_bound > 0
             || this.#freed.length > 0
             || this.#pushes.length > 0
             || this.#fill_pending
-            || this.#place_queue.length > 0
+            || this.#placeable()
             || this.#compact_queue.length > 0;
 
         let arena = -1;
@@ -916,7 +1050,15 @@ export class GPUGeometrySDFManager {
             blas.meshlet_metadata = geometries.meshlets.buffer_metadata;
             blas.meshlet_data = geometries.meshlets.buffer_data;
 
-            this.#cards.graph_capture({ graph, budget: capture_budget, arena, headers: this.#headers, materials, blas });
+            this.#cards.graph_capture({
+                graph,
+                budget: capture_budget,
+                arena,
+                headers: this.#headers,
+                materials,
+                material_contexts,
+                blas,
+            });
         }
     }
 
@@ -1008,9 +1150,7 @@ export class GPUGeometrySDFManager {
             }
 
             this.#drop(id);
-
-            this.#state[id] = HOST_QUEUED;
-            this.#queue.push(id);
+            this.#request(id);
         }
 
         changed.length = 0;
@@ -1084,12 +1224,69 @@ export class GPUGeometrySDFManager {
             this.#card_state[id] = CARDS_PLACED;
             this.#write_header_cards(id, target.offset);
 
-            this.#cards.set_layout(id, this.#card_pages[id]);
+            this.#cards.set_layout(id, this.#card_pages[id], this.#card_side[id]);
         }
 
         queue.length = 0;
     }
 
+    /**
+     * Whether a queued geometry's tree is traceable, so that a bake could admit it. A geometry that
+     * waits for its tree, or for a source's cache, records no bake while it waits. Drops from the queue
+     * what was dropped, or adopted, since it was queued.
+     *
+     * @returns {boolean}
+     */
+    #admittable() {
+        const queue = this.#queue;
+        const blas = this.#geometries.blas;
+
+        let kept = 0;
+        let admittable = false;
+
+        for (let i = 0; i < queue.length; i++) {
+            const id = queue[i];
+
+            if (this.#state[id] !== HOST_QUEUED) {
+                continue;
+            }
+
+            queue[kept++] = id;
+
+            if (!admittable && blas.get_address(this.#records[id]) !== undefined) {
+                admittable = true;
+            }
+        }
+
+        queue.length = kept;
+
+        return admittable;
+    }
+
+    /**
+     * Whether a resident geometry's cards wait for placement. Drops from the queue what was dropped, or
+     * adopted away, since it was queued.
+     *
+     * @returns {boolean}
+     */
+    #placeable() {
+        const queue = this.#place_queue;
+
+        let kept = 0;
+
+        for (let i = 0; i < queue.length; i++) {
+            const id = queue[i];
+
+            if (this.#state[id] === HOST_RESIDENT && this.#card_state[id] === CARDS_QUEUED) {
+                queue[kept++] = id;
+            }
+        }
+
+        queue.length = kept;
+
+        return kept > 0;
+    }
+
     /**
      * Admit queued geometries in request order: those whose tree is resident, while every brick they
      * could queue fits on the ring beside what may be on it already.
@@ -1153,7 +1350,7 @@ export class GPUGeometrySDFManager {
                 this.#coarsened_count++;
             }
 
-            this.#write_header_baking(id, layout, range.offset + 1);
+            this.#write_header(id, layout, range.offset + 1, MeshSDFState.Baking);
 
             // level 0's grid, which the cards are placed over
             const grid = layout.bricks;
@@ -1162,6 +1359,7 @@ export class GPUGeometrySDFManager {
             this.#placement_words[id] = placement.words;
             this.#placement_scratch[id] = placement.histograms;
             this.#placement_columns[id] = 2 * (grid[0] * grid[1] + grid[1] * grid[2] + grid[0] * grid[2]);
+            this.#card_side[id] = Math.max(grid[0], grid[1], grid[2]) * MESH_SDF_BRICK_VOXELS + 1;
 
             this.#word_scratch[0] = count;
             this.#device.queue.writeBuffer(this.#indirection, range.offset * 4, this.#word_scratch, 0, 1);
@@ -1605,12 +1803,25 @@ export class GPUGeometrySDFManager {
         }
     }
 
+    /**
+     * Queue a held geometry's bake, and say so.
+     *
+     * @param {number} id
+     */
+    #request(id) {
+        this.#state[id] = HOST_QUEUED;
+        this.#queue.push(id);
+
+        this.onRequested.send1(this.#records[id]);
+    }
+
     /**
      * @param {number} id
      * @param {MeshSDFLayout} layout
      * @param {number} indirection
+     * @param {MeshSDFState} state
      */
-    #write_header_baking(id, layout, indirection) {
+    #write_header(id, layout, indirection, state) {
         const view = this.#header_scratch;
 
         for (let axis = 0; axis < 3; axis++) {
@@ -1622,7 +1833,7 @@ export class GPUGeometrySDFManager {
         view.setUint32(HEADER_LEVEL_COUNT, layout.level_count, true);
         view.setUint32(HEADER_INDIRECTION, indirection, true);
         view.setUint32(HEADER_CARDS, GPU_DATABASE_NULL, true);
-        view.setUint32(HEADER_STATE, MeshSDFState.Baking, true);
+        view.setUint32(HEADER_STATE, state, true);
         view.setUint32(HEADER_SOURCE, GPU_DATABASE_NULL, true);
         view.setUint32(HEADER_GENERATION, this.#generation[id], true);
         view.setUint32(HEADER_TWO_SIDED, this.#two_sided[id], true);
@@ -1665,6 +1876,7 @@ export class GPUGeometrySDFManager {
         this.#placement_columns = grow_typed(this.#placement_columns, length);
         this.#card_pages = grow_typed(this.#card_pages, length);
         this.#card_words = grow_typed(this.#card_words, length);
+        this.#card_side = grow_typed(this.#card_side, length);
     }
 
     #ensure_device() {

package/src/shade/renderer/geometry/sdf/cards/GPUMeshCardSets.d.ts

@@ -33,6 +33,10 @@ export const MESH_CARD_CAPTURE_BUDGET_MAX: number;
  * the order they were asked for, then recaptures in the order queued. A card set's pages may span
  * frames. {@link recapture} queues a resident card set again, which reads its last capture until the
  * new one is done; a card set whose capture is under way starts it again.
+ *
+ * **Modes** ({@link capture_mode}). A traced card set is a run of pages, a thread a texel. A
+ * rastered one is taken whole: its cards are drawn into a region of a scratch, a cell a card, and its
+ * pages scattered from there into the atlas; the frame's last one may take the budget past its end.
  */
 export class GPUMeshCardSets {
     /**
@@ -79,6 +83,17 @@ export class GPUMeshCardSets {
      * @returns {number}
      */
     get pages_queued(): number;
+    /**
+     * A change captures every card set again in the new mode: resident ones read their last capture
+     * until it is done, and captures under way start again.
+     *
+     * @param {MeshCardCaptureMode} mode
+     */
+    set capture_mode(mode: number);
+    /**
+     * @returns {MeshCardCaptureMode}
+     */
+    get capture_mode(): number;
     /**
      * Whether readers may use the card set: captured at least once, and its layout still there.
      *
@@ -127,8 +142,10 @@ export class GPUMeshCardSets {
      *
      * @param {number} geometry
      * @param {number} pages
+     * @param {number} side texels a side of the layout's largest card: its grid's longest axis in
+     *        voxels, plus one, the lattice having a point at either end
      */
-    set_layout(geometry: number, pages: number): void;
+    set_layout(geometry: number, pages: number, side: number): void;
     /**
      * A geometry's layout is gone: its card sets wait for the next.
      *
@@ -145,15 +162,19 @@ export class GPUMeshCardSets {
      * @param {number} options.budget pages captured at most, `card_capture_budget`
      * @param {number} options.arena graph handle of the arena, as the frame's bake left it
      * @param {GPUBuffer} options.headers
-     * @param {GPUResidentMaterialContext} options.materials
-     * @param {Object} options.blas the geometry bindings `ray_query_blas_nearest` reads
+     * @param {GPUResidentMaterialContext} options.materials what the trace shades with
+     * @param {GPUMaterialManager} options.material_contexts what the raster draws with: each
+     *        material's template and bind group
+     * @param {Object} options.blas the geometry bindings `ray_query_blas_nearest` reads, whose
+     *        geometry and meshlet buffers the raster pulls vertices from
      */
-    graph_capture({ graph, budget, arena, headers, materials, blas }: {
+    graph_capture({ graph, budget, arena, headers, materials, material_contexts, blas }: {
         graph: FrameGraph;
         budget: number;
         arena: number;
         headers: GPUBuffer;
         materials: GPUResidentMaterialContext;
+        material_contexts: GPUMaterialManager;
         blas: any;
     }): void;
     /**
@@ -166,6 +187,8 @@ export class GPUMeshCardSets {
 export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
 export type ShadeMaterial = import("../../../material/ShadeMaterial.js").ShadeMaterial;
 export type GPUResidentMaterialContext = import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
+export type GPUMaterialManager = import("../../../material/GPUMaterialManager.js").GPUMaterialManager;
+export type GPUMaterialContext = import("../../../material/GPUMaterialContext.js").GPUMaterialContext;
 export type Allocation = import("../../../../../core/binary/allocator/OffsetAllocator.js").Allocation;
 import { GPUTileAtlas2D } from "../../../texture/atlas/GPUTileAtlas2D.js";
 //# sourceMappingURL=GPUMeshCardSets.d.ts.map