@woosh/meep-engine 3.28.0 → 3.29.0

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_partial_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;GAeG;AACH,gMAFa;IAAC,eAAe,EAAC,MAAM,CAAC;IAAC,cAAc,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAmMjG"}
+{"version":3,"file":"graph_rasterize_partial_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;GAeG;AACH,gMAFa;IAAC,eAAe,EAAC,MAAM,CAAC;IAAC,cAAc,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAgMjG"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js

@@ -3,7 +3,6 @@ import { noop } from "../../../../core/function/noop.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { shader_hzb_mesh_filter_2way } from "../cull/hzb/shader_hzb_mesh_filter_2way.js";
-import { U32_CONTAINER_STRUCT } from "../../shader/type/U32_CONTAINER_STRUCT.js";
 import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
 import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
 import { TransparencyMode } from "../../material/TransparencyMode.js";
@@ -96,16 +95,11 @@ export function graph_rasterize_partial_opaque({
             0
         );
 
-        // TODO(chrome-153): transient uniform, not an immediate value — see the shader.
-        const u_bucket_index = encoder.allocateTransientValueBuffer(U32_CONTAINER_STRUCT, {
-            value: bucket_index,
-        });
-
         // split 2 ways
         shader_hzb_mesh_filter_2way.dispatchIndirect({
             encoder,
             bindings: {
-                bucket_index: u_bucket_index,
+                bucket_index: { value: bucket_index },
                 camera_previous,
                 bucket_data: buckets,
                 scene_database: scene_ctx.scene_database_buffer,
@@ -187,7 +181,9 @@ export function graph_rasterize_partial_opaque({
 
         // ----------
 
-        const gr_command_iterate_meshlets_0 = graph_build_indirect_dispatch_command(graph, meshlet_expansion_0, COMPUTE_SHADER_DEFAULT_GROUP_SIZE);
+        // folded: a meshlet collection is past what one dispatch dimension reaches — see
+        // IndirectComputeCommandBuildPass
+        const gr_command_iterate_meshlets_0 = graph_build_indirect_dispatch_command(graph, meshlet_expansion_0, COMPUTE_SHADER_DEFAULT_GROUP_SIZE, true);
 
         const pass_data_meshlets_1 = new MeshletFilter2WayPassData();
 

package/src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_remaining_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js"],"names":[],"mappings":"AAgGA;;;;;;;;;;;;;;;;;GAiBG;AACH,kOAFa;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAkGlD"}
+{"version":3,"file":"graph_rasterize_remaining_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;;;GAiBG;AACH,kOAFa;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAkGlD"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_remaining_opaque.js

@@ -9,7 +9,6 @@ import { graph_record_stat } from "../../util/graph_record_stat.js";
 import { build_indirect_compute_dispatch_command } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
 import { graph_sort_meshlets_by_bucket_id } from "../expand/bucket/meshlet/graph_sort_meshlets_by_bucket_id.js";
 import { shader_meshlets_extract_bucket } from "../expand/bucket/meshlet/shader_meshlets_extract_bucket.js";
-import { U32_CONTAINER_STRUCT } from "../../shader/type/U32_CONTAINER_STRUCT.js";
 import { graph_mesh_filter_one_way } from "../expand/graph_mesh_filter_one_way.js";
 import { graph_meshlets_filter_one_way } from "../expand/graph_meshlets_filter_one_way.js";
 import { graph_meshlets_rasterize } from "../expand/graph_meshlets_rasterize.js";
@@ -49,6 +48,8 @@ function graph_extract_meshlets_from_bucket({
 
         const bucket_id = data.bucket_id;
 
+        // folded: a meshlet collection is past what one dispatch dimension reaches — see
+        // IndirectComputeCommandBuildPass
         build_indirect_compute_dispatch_command(
             COMPUTE_SHADER_DEFAULT_GROUP_SIZE,
             encoder,
@@ -56,19 +57,15 @@ function graph_extract_meshlets_from_bucket({
             // the bucketed buffer header consists of pairs of u32 values (count,offset)
             bucket_id * (u32.size * 2),
             command,
-            0
+            0,
+            true,
         );
 
-        // TODO(chrome-153): transient uniform, not an immediate value — see the shader.
-        const u_bucket_index = encoder.allocateTransientValueBuffer(U32_CONTAINER_STRUCT, {
-            value: bucket_id,
-        });
-
         shader_meshlets_extract_bucket.dispatchIndirect({
             encoder,
             command,
             bindings: {
-                bucket_index: u_bucket_index,
+                bucket_index: { value: bucket_id },
                 bucket_data: buckets,
                 output: output,
             }

package/src/shade/renderer/shadow/map/DEFAULT_SHADOWMAP_UPDATE_BUDGET.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Default per-frame shadow refresh budget, measured in **views** (one cube face counts as one
+ * view, one CSM cascade counts as one view, etc.). A point light costs 6 views, a spot light 1, a
+ * directional SHADOWMAP_CSM_CASCADE_COUNT. A bigger light consumes more of the budget, which
+ * keeps the cost of the refresh step roughly proportional to how much work we're asking the
+ * GPU to do — a single point light running the meshlet rasterization pipeline 6 times is
+ * equivalent work to 6 spot lights.
+ *
+ * Directional lights are always refreshed unconditionally (they drive the whole scene) and
+ * their view cost is charged against the budget, so they effectively reduce the pool available
+ * for local lights that frame.
+ *
+ * Unused budget is carried over between frames when demand exceeds supply. This lets a light
+ * that's too expensive to fit in a single frame (e.g. a point needing 6 views when only 2 are
+ * free) eventually get its turn without permanently starving other lights.
+ *
+ * Only the starting value: what a scene actually spends is
+ * {@link GPUSceneShadowmapContext.update_budget}, which the renderer pushes from
+ * {@link Renderer.shadow_update_budget} every frame. Raise it to keep more lights current for more
+ * raster work per frame, lower it to spend less.
+ *
+ * @type {number}
+ */
+export const DEFAULT_SHADOWMAP_UPDATE_BUDGET: number;
+//# sourceMappingURL=DEFAULT_SHADOWMAP_UPDATE_BUDGET.d.ts.map

package/src/shade/renderer/shadow/map/DEFAULT_SHADOWMAP_UPDATE_BUDGET.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DEFAULT_SHADOWMAP_UPDATE_BUDGET.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/DEFAULT_SHADOWMAP_UPDATE_BUDGET.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8CAFU,MAAM,CAEiC"}

package/src/shade/renderer/shadow/map/DEFAULT_SHADOWMAP_UPDATE_BUDGET.js

@@ -0,0 +1,24 @@
+/**
+ * Default per-frame shadow refresh budget, measured in **views** (one cube face counts as one
+ * view, one CSM cascade counts as one view, etc.). A point light costs 6 views, a spot light 1, a
+ * directional SHADOWMAP_CSM_CASCADE_COUNT. A bigger light consumes more of the budget, which
+ * keeps the cost of the refresh step roughly proportional to how much work we're asking the
+ * GPU to do — a single point light running the meshlet rasterization pipeline 6 times is
+ * equivalent work to 6 spot lights.
+ *
+ * Directional lights are always refreshed unconditionally (they drive the whole scene) and
+ * their view cost is charged against the budget, so they effectively reduce the pool available
+ * for local lights that frame.
+ *
+ * Unused budget is carried over between frames when demand exceeds supply. This lets a light
+ * that's too expensive to fit in a single frame (e.g. a point needing 6 views when only 2 are
+ * free) eventually get its turn without permanently starving other lights.
+ *
+ * Only the starting value: what a scene actually spends is
+ * {@link GPUSceneShadowmapContext.update_budget}, which the renderer pushes from
+ * {@link Renderer.shadow_update_budget} every frame. Raise it to keep more lights current for more
+ * raster work per frame, lower it to spend less.
+ *
+ * @type {number}
+ */
+export const DEFAULT_SHADOWMAP_UPDATE_BUDGET = 8;

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts

@@ -50,6 +50,16 @@ export class GPUSceneShadowmapContext {
      * @type {boolean}
      */
     use_tetrahedron_point_shadows: boolean;
+    /**
+     * @param {number} v views per frame, at least one. A higher budget keeps more lights current
+     *        and rasterizes more per frame; a lower one refreshes fewer of them per frame and
+     *        leaves the rest sampling older depth until their turn comes around.
+     */
+    set update_budget(v: number);
+    /**
+     * @returns {number} views this scene may spend refreshing shadowmaps each frame
+     */
+    get update_budget(): number;
     /**
      * @returns {number} number of shadowmaps rasterized in the most recent draw pass
      */

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAyGA;;GAEG;AACH;IAoNI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EA+D5B;IAxRD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IA2EtC;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAkGD;;;;;OAKG;IACH,iCAMC;IAgHD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAgE3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QAsFhC;IAsbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAwOnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAiBC;;CACJ;qCA38CY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;oCA7DX,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAsFA;;GAEG;AACH;IAgPI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EA+D5B;IApTD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IA2BtC;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA8ED;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAkGD;;;;;OAKG;IACH,iCAMC;IAgHD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAgE3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QAsFhC;IAsbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAwOnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAiBC;;CACJ;qCAn9CY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;oCA9DX,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js

@@ -30,6 +30,7 @@ import {
     shader_csm_caster_range_accumulate,
     shader_csm_caster_range_publish,
 } from "./csm/shader/shader_csm_caster_range.js";
+import { DEFAULT_SHADOWMAP_UPDATE_BUDGET } from "./DEFAULT_SHADOWMAP_UPDATE_BUDGET.js";
 import { DirectionalLightShadowmap } from "./DirectionalLightShadowmap.js";
 import { POINT_SHADOW_CUBE_COLS, POINT_SHADOW_CUBE_ROWS } from "./POINT_SHADOW_CUBE_LAYOUT.js";
 import {
@@ -83,26 +84,6 @@ const DEFAULT_SHADOWMAP_DIRECTIONAL_RESOLUTION = [
  */
 const DEFAULT_SHADOWMAP_LOCAL_RESOLUTION = 128;
 
-/**
- * Per-frame shadow refresh budget, measured in **views** (one cube face counts as one view,
- * one CSM cascade counts as one view, etc.). A point light costs 6 views, a spot light 1, a
- * directional SHADOWMAP_CSM_CASCADE_COUNT. A bigger light consumes more of the budget, which
- * keeps the cost of the refresh step roughly proportional to how much work we're asking the
- * GPU to do — a single point light running the meshlet rasterization pipeline 6 times is
- * equivalent work to 6 spot lights.
- *
- * Directional lights are always refreshed unconditionally (they drive the whole scene) and
- * their view cost is charged against the budget, so they effectively reduce the pool available
- * for local lights that frame.
- *
- * Unused budget is carried over between frames when demand exceeds supply — see
- * {@link GPUSceneShadowmapContext.#budget_carry_over}. This lets a light that's too expensive
- * to fit in a single frame (e.g. a point needing 6 views when only 2 are free) eventually get
- * its turn without permanently starving other lights.
- * @type {number}
- */
-const SHADOWMAP_UPDATE_BUDGET = 8;
-
 /**
  * Shadows for a single scene
  */
@@ -200,6 +181,34 @@ export class GPUSceneShadowmapContext {
      */
     #current_frame_index = -1;
 
+    /**
+     * Per-frame refresh budget in views, spent by {@link select_for_draw} on top of
+     * {@link #budget_carry_over}. Defaults to {@link DEFAULT_SHADOWMAP_UPDATE_BUDGET}, which is
+     * also where the view accounting is written down; the renderer pushes its own
+     * {@link Renderer.shadow_update_budget} here before each frame's light update, alongside
+     * {@link enabled}.
+     * @type {number}
+     */
+    #update_budget = DEFAULT_SHADOWMAP_UPDATE_BUDGET;
+
+    /**
+     * @returns {number} views this scene may spend refreshing shadowmaps each frame
+     */
+    get update_budget() {
+        return this.#update_budget;
+    }
+
+    /**
+     * @param {number} v views per frame, at least one. A higher budget keeps more lights current
+     *        and rasterizes more per frame; a lower one refreshes fewer of them per frame and
+     *        leaves the rest sampling older depth until their turn comes around.
+     */
+    set update_budget(v) {
+        assert.isPositiveInteger(v, 'update_budget');
+
+        this.#update_budget = v;
+    }
+
     /**
      * View-budget surplus carried forward from prior frames. Accumulates whenever we had
      * non-directional candidates that couldn't fit in the per-frame budget (i.e. a point light
@@ -602,7 +611,7 @@ export class GPUSceneShadowmapContext {
         // Steps 4 and 5: score every map and greedy-fill the view budget in score order. See
         // ShadowmapDrawSelector for why this is a heap drain rather than a sort — the budget
         // consumes a handful of winners out of however many candidates the scene has.
-        const budget_total = SHADOWMAP_UPDATE_BUDGET + this.#budget_carry_over;
+        const budget_total = this.#update_budget + this.#budget_carry_over;
         const selector = this.#selector;
 
         selector.select(shadowmaps, frame_index, budget_total);

package/src/core/model/node-graph/visual/layout/LayoutBoxGraph.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LayoutBoxGraph.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/LayoutBoxGraph.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;;;;;;GAQG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAyFI;;;OAGG;IACH,wBAHW,MAAM,eACN,MAAM,EAIhB;IA7FD;;OAEG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,OAFU,YAAY,CAEhB;IAEN;;;OAGG;IACH,OAFU,YAAY,CAEhB;IAEN;;OAEG;IACH,OAFU,YAAY,CAEhB;IAEN;;OAEG;IACH,OAFU,YAAY,CAEhB;IAEN;;;OAGG;IACH,WAFU,UAAU,CAEV;IAEV;;;OAGG;IACH,UAFU,UAAU,CAEX;IAET;;OAEG;IACH,YAFU,MAAM,CAED;IAEf;;OAEG;IACH,WAFU,UAAU,CAEV;IAEV;;OAEG;IACH,SAFU,UAAU,CAEZ;IAER;;;OAGG;IACH,aAFU,YAAY,CAEV;IAEZ;;;OAGG;IACH,WAFU,YAAY,CAEZ;IAEV;;;OAGG;IACH,YAFU,UAAU,CAET;IAEX;;OAEG;IACH,UAFU,UAAU,CAEX;IAET;;OAEG;IACH,WAFU,UAAU,CAEV;IAEV;;OAEG;IACH,SAFU,UAAU,CAEZ;IAUR;;;;;;;;;OASG;IACH,kBAJW,MAAM,cACN,MAAM,GACJ,IAAI,CAwBhB;IAED;;;;;;OAMG;IACH,eANW,MAAM,SACN,MAAM,UACN,MAAM,QACN,MAAM,GACJ,IAAI,CAMhB;IAED;;;;;;;OAOG;IACH,gBAPW,MAAM,QACN,MAAM,MACN,MAAM,UACN,MAAM,QACN,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;OAQG;IACH,mBAFa,IAAI,CAsChB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;CACJ"}

package/src/core/model/node-graph/visual/layout/layout_assign_coordinates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_assign_coordinates.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_assign_coordinates.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,8EAVW,MAAM,SACN,UAAU,QACV,UAAU,eACV,UAAU,oCAER;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAgC3C"}

package/src/core/model/node-graph/visual/layout/layout_assign_layers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_assign_layers.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_assign_layers.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sEAPW,UAAU,GAER,MAAM,CAsDlB"}

package/src/core/model/node-graph/visual/layout/layout_break_cycles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_break_cycles.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_break_cycles.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,4DANa,UAAU,CAmOtB"}

package/src/core/model/node-graph/visual/layout/layout_insert_lanes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_insert_lanes.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_insert_lanes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,yEARW,UAAU,GAGR,MAAM,CA8ElB"}

package/src/core/model/node-graph/visual/layout/layout_order_layers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_order_layers.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_order_layers.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wEATW,MAAM,UACN,MAAM,GACJ;IAAC,KAAK,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,CAyJ7F"}

package/src/core/model/node-graph/visual/layout/layout_orient_links.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layout_orient_links.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/layout_orient_links.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qEANW,UAAU,GACR,MAAM,CAkClB"}

package/src/shade/playground/vgeo_viewer/cut_geometry.d.ts

@@ -1,61 +0,0 @@
-/**
- * Decode the selected clusters into one geometry.
- *
- * @param {VGeoCut} cut
- * @param {VGEO_COLOR_MODE} color_mode
- * @returns {VGeoCutGeometry}
- */
-export function vgeo_build_cut_geometry(cut: VGeoCut, color_mode: VGEO_COLOR_MODE): VGeoCutGeometry;
-/**
- * What a cluster's colour is keyed on.
- *
- * The two normal modes are not keyed on the cluster at all: they paint every vertex with its own
- * direction, and the cluster boundaries go with it. `stored normal` is the container's own
- * {@link VGEO_ATTRIBUTE.NORMAL }, decoded out of the payload — the only mode that shows an attribute
- * the file carries rather than something derived from it. `geometric normal` is the area-weighted
- * normal of the decoded triangles, which is what every other mode shades with. The pair is the
- * point: they agree where the builder's normals still describe the geometry it shipped, and a source
- * with no normals at all makes the first one flat.
- *
- * `clamp` is the streaming one: it paints the clusters a coarser page is standing in for, so the
- * regions still waiting on bytes are visible as regions rather than as a number in a panel.
- */
-export type VGEO_COLOR_MODE = string;
-export namespace VGEO_COLOR_MODE {
-    let Cluster: string;
-    let Group: string;
-    let Page: string;
-    let Level: string;
-    let Error: string;
-    let Clamp: string;
-    let StoredNormal: string;
-    let GeometricNormal: string;
-}
-/**
- * A cut, decoded into one geometry.
- *
- * Nothing about it depends on where the camera is: the mesh is drawn solid and the depth buffer
- * orders it, so the triangle list is uploaded once when the cut is taken and never touched again.
- */
-export class VGeoCutGeometry {
-    /**
-     * Position and colour, indexed by {@link triangles}.
-     * @type {Geometry}
-     */
-    geometry: Geometry;
-    /**
-     * `3 · triangle_count` — the full triangle list, in cluster order, and the geometry's index.
-     * @type {Uint32Array}
-     */
-    triangles: Uint32Array;
-    /**
-     * @type {number}
-     */
-    triangle_count: number;
-    /**
-     * @type {number}
-     */
-    vertex_count: number;
-}
-import { Geometry } from "../../renderer/geometry/Geometry.js";
-//# sourceMappingURL=cut_geometry.d.ts.map

package/src/shade/playground/vgeo_viewer/cut_geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cut_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/cut_geometry.js"],"names":[],"mappings":"AAqOA;;;;;;GAMG;AACH,kEAHW,eAAe,GACb,eAAe,CAsM3B;;;;;;;;;;;;;;;8BArXS,MAAM;;;;;;;;;;;AA4IhB;;;;;GAKG;AACH;IACI;;;OAGG;IACH,UAFU,QAAQ,CAEQ;IAE1B;;;OAGG;IACH,WAFU,WAAW,CAEU;IAE/B;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,cAFU,MAAM,CAEC;CACpB;yBA5NwB,qCAAqC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/main.js"],"names":[],"mappings":""}

package/src/shade/playground/vgeo_viewer/sample_asset.d.ts

@@ -1,18 +0,0 @@
-/**
- * Build a sample container and hand back a source over it.
- *
- * The page size is deliberately far below the 256 KB default: a sample that came out as one page
- * would be a container with nothing to stream, and the point of opening this one is to watch it
- * arrive.
- *
- * @param {number} [major]
- * @param {number} [minor]
- * @param {number} [page_size] target decoded bytes per page
- * @returns {{source: VGeoByteSource, build_ms: number}}
- */
-export function vgeo_sample_source(major?: number, minor?: number, page_size?: number): {
-    source: VGeoByteSource;
-    build_ms: number;
-};
-import { VGeoByteSource } from "../../renderer/geometry/virtual/format/read/VGeoByteSource.js";
-//# sourceMappingURL=sample_asset.d.ts.map

package/src/shade/playground/vgeo_viewer/sample_asset.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sample_asset.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/sample_asset.js"],"names":[],"mappings":"AA0GA;;;;;;;;;;;GAWG;AACH,2CALW,MAAM,UACN,MAAM,cACN,MAAM,GACJ;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAiBtD;+BA1HM,+DAA+D"}

package/src/shade/playground/vgeo_viewer/select_cut.d.ts

@@ -1,173 +0,0 @@
-/**
- * Select the cut for a view from whatever the reader currently holds.
- *
- * A traversal rather than a flat pass over every cluster, per design §4 — and it gets the cut rule's
- * first half for free. The rule is `project(parent) > τ AND project(self) ≤ τ`; a group is only ever
- * reached by descending *through* the cluster whose step consumed it, and that descent happened
- * precisely because the step projected above τ. Every cluster of a group shares that step's sphere
- * and error, so the parent test is satisfied by the act of arriving.
- *
- * The residency clamp is the live one here, and it is the reason a cut can be taken at all before
- * the file has finished arriving: a cluster that wants a page nobody has is drawn as it stands.
- *
- * @param {VGeoContainerReader} reader
- * @param {VGeoCutView} view
- * @returns {VGeoCut}
- */
-export function vgeo_select_cut(reader: VGeoContainerReader, view: VGeoCutView): VGeoCut;
-/**
- * Selecting a cut from a partially resident container.
- *
- * The traversal itself is the runtime's rule, not a debug approximation of it: descend the page
- * graph from the root's parentless groups, refine a cluster whose error projects above τ, take it
- * when it does not. What this file adds is the part a whole-file reader never has to think about —
- * what to do when the page a refinement wants is not here.
- *
- * The answer is the format's (`VGEO_FORMAT.md` §10): **draw the coarser cluster and say so**. The
- * result is a genuine surface — watertight, correct, merely coarser in that region — and the want it
- * records carries the exact byte range that would refine it. That is what makes streaming safe in
- * any arrival order, and it is why this file's most interesting number is `clamped`.
- *
- * "Not here" is `VGeoContainerReader.is_selectable`, not `is_resident`, and the difference is the
- * one thing about this traversal that is not obvious: a group is refined into only once every page
- * holding one of its *parents* is installed. Residency alone lets a group be entered through the
- * parents that arrived while a coarse cluster still covers the one that did not, and then both are
- * drawn over the same surface. §10 calls that out by name — "no holes **and no double-draw**, in any
- * arrival order" — and the second half is the one that fails silently.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-/**
- * The view a cut is selected for. `VIRTUAL_GEOMETRY_DESIGN.md` §4: a cut is selected at one camera's
- * distances and pixel budget, and is the wrong cut for any other.
- */
-export class VGeoCutView {
-    /**
-     * Camera position, object space — the viewer draws at identity, so world and object agree.
-     * @type {Float32Array}
-     */
-    eye: Float32Array;
-    /**
-     * Pixels of permitted error. The one quality dial.
-     * @type {number}
-     */
-    tau: number;
-    /**
-     * Height of the render target, in pixels — the projection's numerator.
-     * @type {number}
-     */
-    screen_height: number;
-    /**
-     * @type {number}
-     */
-    fov_y: number;
-    /**
-     * @type {boolean}
-     */
-    cull_enabled: boolean;
-    /**
-     * Six normalized world-space planes, as {@link Camera.frustum} holds them.
-     * @type {Float32Array}
-     */
-    frustum: Float32Array;
-}
-/**
- * What one traversal came to, including what it had to look at to get there and what it could not
- * reach.
- *
- * A cut holds the {@link VGeoPage} objects it selected from rather than page indices, so it stays
- * drawable across an eviction: the bytes it needs are reachable from the cut itself. Nothing here
- * goes stale because residency moved under it.
- */
-export class VGeoCut {
-    /**
-     * The page each selected cluster came from, parallel to {@link clusters}.
-     * @type {VGeoPage[]}
-     */
-    pages: VGeoPage[];
-    /**
-     * Selected clusters, as indices within the page at the same position of {@link pages}. There is
-     * no global cluster id in the format and none in the reader; a cluster is a page and an index.
-     * @type {number[]}
-     */
-    clusters: number[];
-    /**
-     * @type {number}
-     */
-    triangle_count: number;
-    /**
-     * @type {number}
-     */
-    vertex_count: number;
-    /**
-     * @type {number}
-     */
-    groups_visited: number;
-    /**
-     * @type {number}
-     */
-    clusters_tested: number;
-    /**
-     * Clusters whose subtree the frustum threw away, which is a whole region rather than one
-     * cluster — the reason culling belongs in the traversal and not after it.
-     * @type {number}
-     */
-    culled: number;
-    /**
-     * Clusters that projected above τ and were drawn anyway, because the page holding their
-     * refinement is not resident.
-     *
-     * **This is the number that says a cut is still arriving.** Zero means the cut on screen is the
-     * one the container's own metric selects for this view; anything above it means part of the
-     * surface is standing in for something finer, and {@link wants} says exactly what to fetch to
-     * fix it.
-     *
-     * @type {number}
-     */
-    clamped: number;
-    /**
-     * Of those, the ones whose child group's page is **here** and merely not selectable yet, because
-     * a page holding one of that group's other parents is not.
-     *
-     * They carry no want: there is nothing to fetch from a cluster that already has the bytes it
-     * points at. What unblocks them is elsewhere in the same cut — the cluster clamped directly
-     * against the missing page — so this number is not a second streaming frontier, it is how much
-     * of the coarseness on screen is the ancestor rule holding a group back rather than bandwidth.
-     *
-     * @type {number}
-     */
-    clamped_on_activation: number;
-    /**
-     * Which clusters those were, keyed `page · 65536 + cluster`. What the panel counts, a display
-     * can paint — so the regions still waiting on bytes are visible as regions.
-     * @type {Set<number>}
-     */
-    clamped_keys: Set<number>;
-    /**
-     * Clusters whose `child_ref` names an entry outside their page's child table.
-     *
-     * Impossible in a file the validator accepts, and reachable here precisely because validation is
-     * off by default — so it is counted and the cluster is drawn as a leaf, rather than read out of
-     * bounds or thrown out of a traversal that was two thirds of the way to a picture.
-     *
-     * @type {number}
-     */
-    broken_child_refs: number;
-    /**
-     * The pages this cut would need to stop being clamped, one entry per page, most wanted first.
-     * @type {VGeoPageWant[]}
-     */
-    wants: VGeoPageWant[];
-    /**
-     * Distinct pages the traversal read from.
-     * @type {number}
-     */
-    pages_touched: number;
-    /**
-     * @type {number}
-     */
-    duration_ms: number;
-}
-import { VGeoPageWant } from "../../renderer/geometry/virtual/format/read/VGeoPageWant.js";
-//# sourceMappingURL=select_cut.d.ts.map

package/src/shade/playground/vgeo_viewer/select_cut.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"select_cut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vgeo_viewer/select_cut.js"],"names":[],"mappings":"AAsPA;;;;;;;;;;;;;;;GAeG;AACH,mEAHW,WAAW,GACT,OAAO,CAgKnB;AA5ZD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AACH;IACI;;;OAGG;IACH,KAFU,YAAY,CAEI;IAE1B;;;OAGG;IACH,KAFU,MAAM,CAER;IAER;;;OAGG;IACH,eAFU,MAAM,CAEK;IAErB;;OAEG;IACH,OAFU,MAAM,CAEQ;IAExB;;OAEG;IACH,cAFU,OAAO,CAEI;IAErB;;;OAGG;IACH,SAFU,YAAY,CAES;CAClC;AAED;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,OAFU,UAAU,CAET;IAEX;;;;OAIG;IACH,UAFU,MAAM,EAAE,CAEJ;IAEd;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,cAFU,MAAM,CAEC;IAEjB;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;OAEG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,QAFU,MAAM,CAEL;IAEX;;;;;;;;;;OAUG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;;;;;;OAUG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,cAFU,IAAI,MAAM,CAAC,CAEI;IAEzB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,YAAY,EAAE,CAEb;IAEX;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;OAEG;IACH,aAFU,MAAM,CAEA;CACnB;6BAjLM,6DAA6D"}

package/src/shade/renderer/geometry/virtual/build/VGeoFaceGraph.d.ts

@@ -1,52 +0,0 @@
-export class VGeoFaceGraph {
-    /**
-     * @param {BinaryTopology} mesh
-     * @param {BinaryTopologyFaceGraph} face_graph
-     */
-    constructor(mesh: BinaryTopology, face_graph: BinaryTopologyFaceGraph);
-    /**
-     * @type {BinaryTopology}
-     */
-    mesh: BinaryTopology;
-    /**
-     * CSR over dense face-graph vertices; edge weights are shared-edge counts.
-     * @type {MetisGraph}
-     */
-    graph: MetisGraph;
-    /**
-     * `vertex_face_ids[dense] = face id`.
-     * @type {Uint32Array}
-     */
-    vertex_face_ids: Uint32Array;
-    /**
-     * Scratch stamp for unique-vertex counting, one entry per mesh vertex slot.
-     * @type {Int32Array}
-     */
-    vertex_stamp: Int32Array;
-    /**
-     * Monotonic stamp value, so the scratch never needs clearing.
-     * @type {number}
-     */
-    stamp: number;
-    /**
-     * Scratch `graph vertex -> its position in the member list being split right now`, one entry per
-     * graph vertex. Only the entries of that member list mean anything, which is all
-     * {@link vgeo_split_face_set}'s partition step ever reads: it consults this exclusively for
-     * neighbours the membership stamp has already confirmed are members.
-     *
-     * Dense rather than a `Map` because the keys are dense face-graph vertices to begin with, and
-     * because a `Map` cannot answer this question at all past 2^24 entries — the leaf cut runs over
-     * every face of the mesh at once, so a mesh of more than 16.7M triangles in one connected
-     * component would otherwise stop the builder dead.
-     * @type {Uint32Array}
-     */
-    member_index: Uint32Array;
-    /**
-     * How many distinct mesh vertices a set of dense face-graph vertices touches.
-     *
-     * @param {number[]|Int32Array} members dense face-graph vertices
-     * @returns {number}
-     */
-    count_unique_vertices(members: number[] | Int32Array): number;
-}
-//# sourceMappingURL=VGeoFaceGraph.d.ts.map

package/src/shade/renderer/geometry/virtual/build/VGeoFaceGraph.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VGeoFaceGraph.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/VGeoFaceGraph.js"],"names":[],"mappings":"AAcA;IA4CI;;;OAGG;IACH,uEAMC;IArDD;;OAEG;IACH,qBAAY;IAEZ;;;OAGG;IACH,kBAAa;IAEb;;;OAGG;IACH,iBAFU,WAAW,CAEE;IAEvB;;;OAGG;IACH,cAFU,UAAU,CAEA;IAEpB;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;;;;;OAWG;IACH,cAFU,WAAW,CAED;IAcpB;;;;;OAKG;IACH,+BAHW,MAAM,EAAE,GAAC,UAAU,GACjB,MAAM,CA2BlB;CACJ"}

package/src/shade/renderer/geometry/virtual/build/VGeoGatheredFaces.d.ts

@@ -1,24 +0,0 @@
-/**
- * A face set gathered into standalone, locally-indexed form.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class VGeoGatheredFaces {
-    /**
-     * `3 * vertex_count` local coordinates.
-     * @type {Float32Array}
-     */
-    positions: Float32Array;
-    /**
-     * `3 * triangle_count` local vertex indices.
-     * @type {Uint32Array}
-     */
-    indices: Uint32Array;
-    /**
-     * Vertex ids in the mesh this was pulled out of, one per local vertex, in first-use order.
-     * @type {Uint32Array}
-     */
-    vertex_ids: Uint32Array;
-}
-//# sourceMappingURL=VGeoGatheredFaces.d.ts.map

package/src/shade/renderer/geometry/virtual/build/VGeoGatheredFaces.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VGeoGatheredFaces.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/build/VGeoGatheredFaces.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACI;;;OAGG;IACH,WAFU,YAAY,CAEU;IAEhC;;;OAGG;IACH,SAFU,WAAW,CAEQ;IAE7B;;;OAGG;IACH,YAFU,WAAW,CAEW;CACnC"}