@woosh/meep-engine 3.60.5 → 3.60.6

package/src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GTAO's own spatial filter: one 3x3 edge-stopped pass over visibility and the bend.
+ *
+ * Its input and output are `rgba16float`: visibility in `x`, and in `yzw` the world-space bend, the bent normal
+ * minus the shading normal. The bend is what is filtered, never the bent normal, so an unoccluded texel, whose
+ * bend is zero, keeps the normal map's detail exactly however much its neighbours are averaged in.
+ *
+ * Visibility is filtered as `fragment_shader_denoise_ao` filters it — the A-trous step, its edge-stopping
+ * weights and phi values — with the variance taken from visibility alone, since the input carries no second
+ * moment. That shader stays as it is: it is shared with denoisers that do keep moments.
+ *
+ * @type {ImageShader}
+ */
+export const shader_gtao_spatial_denoise: ImageShader;
+import { ImageShader } from "../../shader/ImageShader.js";
+//# sourceMappingURL=shader_gtao_spatial_denoise.d.ts.map

package/src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_gtao_spatial_denoise.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.js"],"names":[],"mappings":"AA+HA;;;;;;;;;;;;GAYG;AACH,0CAFU,WAAW,CAiBlB;4BAvJyB,6BAA6B"}

package/src/shade/renderer/postprocess/gtao/shader_gtao_spatial_denoise.js

@@ -0,0 +1,156 @@
+import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
+import { chunk_compute_edge_stopping_weight } from "../../shader/chunk/filter/chunk_compute_edge_stopping_weight.js";
+import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addTexture("tInput")
+    .addTexture("tDepth")
+    .addTexture("tNormal", "uint");
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const phi_visibility = 4.0;
+const phi_normal = 128.0;
+const sigma_depth = 1.0;
+
+const offsets = array< vec2<i32>, 8 >(
+    vec2( -1, -1 ),
+    vec2(  0, -1 ),
+    vec2(  1, -1 ),
+    vec2( -1,  0 ),
+    vec2(  1,  0 ),
+    vec2( -1,  1 ),
+    vec2(  0,  1 ),
+    vec2(  1,  1 ),
+);
+
+// Visibility's spatial variance over a 3x3 Gaussian. The input carries visibility alone, so its second moment
+// is the square of each texel's.
+fn gtao_visibility_variance(ipos: vec2<i32>) -> f32 {
+    let kernel = array<f32, 3>(0.25, 0.125, 0.0625);
+
+    var moments = vec2<f32>(0.0);
+
+    for (var yy = -1; yy <= 1; yy++) {
+        for (var xx = -1; xx <= 1; xx++) {
+            let v = textureLoad(tInput, ipos + vec2<i32>(xx, yy), 0).x;
+
+            moments += vec2(v, v * v) * kernel[ abs(xx) + abs(yy) ];
+        }
+    }
+
+    return max(moments.y - moments.x * moments.x, 0.0);
+}
+
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> @location(0) vec4<f32> {
+    let ipos = vec2<i32>(coord.xy);
+    let screen_size = vec2<i32>(textureDimensions(tInput));
+
+    const eps_variance = 1e-10;
+    const kernel_weights = array<f32,3>( 1.0, 2.0 / 3.0, 1.0 / 6.0 );
+
+    let center = textureLoad(tInput, ipos, 0);
+
+    let std_dev = sqrt(max(0.0, eps_variance + gtao_visibility_variance(ipos)));
+
+    let phi_luma = phi_visibility * std_dev;
+
+    let current_normal = decode_g_buffer_normal(textureLoad(tNormal, ipos, 0).xy);
+    let center_depth   = textureLoad(tDepth, ipos, 0).r;
+
+    // the centre at weight 1, so the edge-stopping functions cannot leave nothing
+    var sum_w_visibility = 1.0;
+    var sum_visibility   = center.x;
+
+    // The bend is averaged weighted by visibility as well. A bent normal stands for the visible directions;
+    // the bent normal of several texels together is the sum of each one's scaled by how much it sees,
+    // normalized, and with neighbours whose normals agree that is the shading normal plus this average.
+    var sum_w_bend = center.x;
+    var sum_bend   = center.yzw * center.x;
+
+    for (var i = 0; i < 8; i++) {
+        let offset = offsets[i];
+
+        let p = ipos + offset;
+
+        if (any(p < vec2(0)) || any(p >= screen_size)) {
+            continue;
+        }
+
+        let kernel = kernel_weights[ abs(offset.x) ] * kernel_weights[ abs(offset.y) ];
+
+        let texel = textureLoad(tInput, p, 0);
+
+        let sample_normal = decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy);
+        let sample_depth  = textureLoad(tDepth, p, 0).r;
+
+        let w = compute_edge_stopping_weight(
+            center_depth,
+            sample_depth,
+            sigma_depth,
+
+            current_normal,
+            sample_normal,
+            phi_normal,
+
+            center.x,
+            texel.x,
+            phi_luma
+        ) * kernel;
+
+        sum_w_visibility += w;
+        sum_visibility   += w * texel.x;
+
+        let w_bend = w * texel.x;
+
+        sum_w_bend += w_bend;
+        sum_bend   += w_bend * texel.yzw;
+    }
+
+    return vec4(sum_visibility / sum_w_visibility, sum_bend / sum_w_bend);
+}
+    `,
+    [
+        chunk_decode_g_buffer_normal,
+        chunk_compute_edge_stopping_weight,
+    ]);
+
+/**
+ * GTAO's own spatial filter: one 3x3 edge-stopped pass over visibility and the bend.
+ *
+ * Its input and output are `rgba16float`: visibility in `x`, and in `yzw` the world-space bend, the bent normal
+ * minus the shading normal. The bend is what is filtered, never the bent normal, so an unoccluded texel, whose
+ * bend is zero, keeps the normal map's detail exactly however much its neighbours are averaged in.
+ *
+ * Visibility is filtered as `fragment_shader_denoise_ao` filters it — the A-trous step, its edge-stopping
+ * weights and phi values — with the variance taken from visibility alone, since the input carries no second
+ * moment. That shader stays as it is: it is shared with denoisers that do keep moments.
+ *
+ * @type {ImageShader}
+ */
+export const shader_gtao_spatial_denoise = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "GTAO Spatial Denoise",
+        resources,
+        body
+    }),
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+    targets: [
+        {
+            format: "rgba16float",
+            // Background is skipped, so it keeps the clear: not occluded, not bent. Downstream neighbourhoods
+            // read across silhouettes and must see background as unoccluded.
+            clearValue: [1, 0, 0, 0],
+        }
+    ]
+});

package/src/shade/renderer/scene/GPUSceneContext.d.ts

@@ -105,8 +105,8 @@ export class GPUSceneContext {
      * (REVIEW_LEDGER U1): `register` a container with {@link virtual_geometry_residency}, and every
      * page after the root arrives because a cut asked for it. The renderer opens and closes each
      * frame and schedules each reading, and {@link destroy} releases all of it; a host touches none
-     * of it. With them, the source of its geometries' caches ({@link VGeoSDFProxies}): a cache asked
-     * of a virtual geometry is baked from a proxy cut from it.
+     * of it. With them, the source of its geometries' caches and cards ({@link VGeoSDFProxies}): a virtual
+     * geometry whose cache is asked for stands in through its proxy.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and
      *     {@link GPUVirtualGeometryRuntime}, except for `residency`

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -399,8 +399,8 @@ export class GPUSceneContext {
      * (REVIEW_LEDGER U1): `register` a container with {@link virtual_geometry_residency}, and every
      * page after the root arrives because a cut asked for it. The renderer opens and closes each
      * frame and schedules each reading, and {@link destroy} releases all of it; a host touches none
-     * of it. With them, the source of its geometries' caches ({@link VGeoSDFProxies}): a cache asked
-     * of a virtual geometry is baked from a proxy cut from it.
+     * of it. With them, the source of its geometries' caches and cards ({@link VGeoSDFProxies}): a virtual
+     * geometry whose cache is asked for stands in through its proxy.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and
      *     {@link GPUVirtualGeometryRuntime}, except for `residency`
@@ -448,8 +448,8 @@ export class GPUSceneContext {
 
             feedback = new VGeoFeedbackLoop({ runtime, residency: tiers });
 
-            // last: it makes its buffers and subscribes to the caches as it is made
-            proxies = new VGeoSDFProxies({ device: this.#device, runtime, geometries: this.geometries });
+            // last: it subscribes to the caches as it is made
+            proxies = new VGeoSDFProxies({ geometries: this.geometries });
         } catch (error) {
             // the pool is the only one holding anything yet: the fetcher spawns its workers on its
             // first fetch, and the runtime makes its buffer on its first frame
@@ -874,7 +874,7 @@ export class GPUSceneContext {
             return;
         }
 
-        // its proxies out of the geometry manager, and its cut's buffers, ahead of the runtime's
+        // it hears no more of the caches; its proxies stay with the geometry manager, destroyed with it
         this.#virtual_geometry_proxies.destroy();
 
         this.#virtual_geometry_feedback.destroy();

package/src/shade/renderer/geometry/virtual/sdf/VGEO_SDF.d.ts

@@ -1,47 +0,0 @@
-/**
- * Words of the payload's header for `job_count` jobs: their counters, then the cut's own counters from its feedback
- * slot (`VGEO_CUT_STAT`), which say whether the cut left a subtree undescended.
- *
- * @param {number} job_count
- * @returns {number}
- */
-export function vgeo_sdf_header_words(job_count: number): number;
-/**
- * The extraction's settings, an immediate of each of its passes.
- * @type {WebGPUStruct}
- */
-export const VGEO_SDF_SETTINGS: WebGPUStruct;
-/**
- * A job the frame cuts, as the host writes it: the vgeo geometry row it cuts and the projection constant that puts its
- * error against a τ of 1, `1 / (½ voxel)` in the geometry's own units. A job the frame writes out (`decode` 1) has its
- * room in the payload: `vertex_count` vertices from `vertex_base` and `triangle_count` triangles from `triangle_base`,
- * what its last complete cut held.
- * @type {WebGPUStruct}
- */
-export const VGEO_SDF_JOB_STRUCT: WebGPUStruct;
-/**
- * A job's counters, atomics the frame's passes add into: the clusters its cut took, the stand-ins among them (a
- * cluster taken for a page not resident or a group held), those dropped past the cluster list, the vertices and
- * triangles of its listed clusters, and of those, what the decode wrote into its room.
- */
-export const VGEO_SDF_COUNTER: Readonly<{
-    TAKEN: 0;
-    STAND_INS: 1;
-    DROPPED: 2;
-    VERTICES: 3;
-    TRIANGLES: 4;
-    VERTICES_WRITTEN: 5;
-    TRIANGLES_WRITTEN: 6;
-}>;
-/**
- * Words of a job's counters.
- * @type {number}
- */
-export const VGEO_SDF_COUNTER_WORDS: number;
-/**
- * Words of a cluster list entry: its job, then its meshlet row.
- * @type {number}
- */
-export const VGEO_SDF_CLUSTER_WORDS: number;
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-//# sourceMappingURL=VGEO_SDF.d.ts.map

package/src/shade/renderer/geometry/virtual/sdf/VGEO_SDF.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VGEO_SDF.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/sdf/VGEO_SDF.js"],"names":[],"mappings":"AAsEA;;;;;;GAMG;AACH,iDAHW,MAAM,GACJ,MAAM,CAIlB;AArED;;;GAGG;AACH,gCAFU,YAAY,CAWA;AAEtB;;;;;;GAMG;AACH,kCAFU,YAAY,CAWL;AAEjB;;;;GAIG;AACH;;;;;;;;GAQG;AAEH;;;GAGG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,qCAFU,MAAM,CAEwB;6BAnEX,sCAAsC"}

package/src/shade/renderer/geometry/virtual/sdf/VGEO_SDF.js

@@ -1,80 +0,0 @@
-import { f32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { VGEO_CUT_STAT_COUNT } from "../runtime/layout/VGEO_CUT_STAT_COUNT.js";
-
-/*
- The layouts of a vgeo geometry's proxy extraction (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8, as S8 built it): each geometry
- whose cache is asked for is cut whole at half its cache's level-0 voxel, its cut's clusters listed, and, once a cut
- stands nothing in, its vertices and triangles written out and read back for the proxy the mesh bake bakes.
-*/
-
-/**
- * The extraction's settings, an immediate of each of its passes.
- * @type {WebGPUStruct}
- */
-export const VGEO_SDF_SETTINGS = WebGPUStruct.from({
-    /** jobs the frame cuts */
-    job_count: u32,
-    /** entries the cluster list holds */
-    cluster_capacity: u32,
-    /** the word of the payload its vertices start at, 3 floats a vertex */
-    vertex_offset: u32,
-    /** the word of the payload its triangles start at, 3 indices a triangle */
-    index_offset: u32,
-}, "VGeoSDFSettings");
-
-/**
- * A job the frame cuts, as the host writes it: the vgeo geometry row it cuts and the projection constant that puts its
- * error against a τ of 1, `1 / (½ voxel)` in the geometry's own units. A job the frame writes out (`decode` 1) has its
- * room in the payload: `vertex_count` vertices from `vertex_base` and `triangle_count` triangles from `triangle_base`,
- * what its last complete cut held.
- * @type {WebGPUStruct}
- */
-export const VGEO_SDF_JOB_STRUCT = WebGPUStruct.from({
-    vg_row: u32,
-    projection_k: f32,
-    decode: u32,
-    vertex_base: u32,
-    triangle_base: u32,
-    vertex_count: u32,
-    triangle_count: u32,
-    pad: u32,
-}, "VGeoSDFJob");
-
-/**
- * A job's counters, atomics the frame's passes add into: the clusters its cut took, the stand-ins among them (a
- * cluster taken for a page not resident or a group held), those dropped past the cluster list, the vertices and
- * triangles of its listed clusters, and of those, what the decode wrote into its room.
- */
-export const VGEO_SDF_COUNTER = Object.freeze({
-    TAKEN: 0,
-    STAND_INS: 1,
-    DROPPED: 2,
-    VERTICES: 3,
-    TRIANGLES: 4,
-    VERTICES_WRITTEN: 5,
-    TRIANGLES_WRITTEN: 6,
-});
-
-/**
- * Words of a job's counters.
- * @type {number}
- */
-export const VGEO_SDF_COUNTER_WORDS = 8;
-
-/**
- * Words of a cluster list entry: its job, then its meshlet row.
- * @type {number}
- */
-export const VGEO_SDF_CLUSTER_WORDS = 2;
-
-/**
- * Words of the payload's header for `job_count` jobs: their counters, then the cut's own counters from its feedback
- * slot (`VGEO_CUT_STAT`), which say whether the cut left a subtree undescended.
- *
- * @param {number} job_count
- * @returns {number}
- */
-export function vgeo_sdf_header_words(job_count) {
-    return job_count * VGEO_SDF_COUNTER_WORDS + VGEO_CUT_STAT_COUNT;
-}

package/src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_collect.d.ts

@@ -1,16 +0,0 @@
-/**
- * Lanes of the collect, a lane a job.
- * @type {number}
- */
-export const VGEO_SDF_COLLECT_WORKGROUP_SIZE: number;
-/**
- * The extraction's collect (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8, as S8 built it): a cut's instance record a job,
- * as every cut's collect writes one (`chunk_vgeo_cut_instance`), its geometry's root page, lookup and claim width from
- * the geometry's row. Cut in the geometry's own space, at a world error under half its cache's voxel: `k` the job's,
- * the distance weight 0.
- *
- * @type {ComputeShader}
- */
-export const shader_vgeo_sdf_collect: ComputeShader;
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_vgeo_sdf_collect.d.ts.map

package/src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_collect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_vgeo_sdf_collect.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_collect.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH,8CAFU,MAAM,CAEkC;AAwClD;;;;;;;GAOG;AACH,sCAFU,aAAa,CAMpB;8BAhE2B,kCAAkC"}

package/src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_collect.js

@@ -1,67 +0,0 @@
-import { COLLECTION_U32_STRUCT_WRITE } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { chunk_vgeo_cut_instance } from "../runtime/cut/chunk_vgeo_cut_instance.js";
-import { VGEO_INSTANCE_OFFSET } from "../runtime/layout/VGEO_INSTANCE_OFFSET.js";
-import { VGEO_SDF_JOB_STRUCT, VGEO_SDF_SETTINGS } from "./VGEO_SDF.js";
-
-/**
- * Lanes of the collect, a lane a job.
- * @type {number}
- */
-export const VGEO_SDF_COLLECT_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.setImmediate("settings", VGEO_SDF_SETTINGS);
-
-resources.createGroup()
-    .addStorageBuffer("vgeo_sdf_jobs", WebGPUArray.from(VGEO_SDF_JOB_STRUCT))
-    .addStorageBuffer("vg_geometries", WebGPUArray.from(u32))
-    // a cut's instance records, and their claim widths for the scan
-    .addStorageBuffer("instances", WebGPUArray.from(u32), true)
-    .addStorageBuffer("claim_widths", COLLECTION_U32_STRUCT_WRITE, true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${VGEO_SDF_COLLECT_WORKGROUP_SIZE})
-fn main(@builtin(global_invocation_id) id: vec3<u32>) {
-    let job = id.x;
-
-    if (job >= settings.job_count) {
-        return;
-    }
-
-    // a job's record names its job where a view's names its mesh row: what its take lists the job's clusters under
-    let base = vg_instance_record(job, vgeo_sdf_jobs[job].vg_row, settings.job_count);
-
-    if (base == VG_INSTANCE_RECORD_NONE) {
-        return;
-    }
-
-    // no eye: at a distance weight of 0 the projection is the error itself over half the voxel, wherever it is
-    vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE}u, 0.0);
-    vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE + 1}u, 0.0);
-    vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE + 2}u, 0.0);
-    vg_store(base, ${VGEO_INSTANCE_OFFSET.PROJECTION_K}u, vgeo_sdf_jobs[job].projection_k);
-    vg_store(base, ${VGEO_INSTANCE_OFFSET.DISTANCE_WEIGHT}u, 0.0);
-}
-`, [chunk_vgeo_cut_instance]);
-
-/**
- * The extraction's collect (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8, as S8 built it): a cut's instance record a job,
- * as every cut's collect writes one (`chunk_vgeo_cut_instance`), its geometry's root page, lookup and claim width from
- * the geometry's row. Cut in the geometry's own space, at a world error under half its cache's voxel: `k` the job's,
- * the distance weight 0.
- *
- * @type {ComputeShader}
- */
-export const shader_vgeo_sdf_collect = ComputeShader.from({
-    label: "VGeo SDF Collect",
-    resources,
-    body,
-});

package/src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_decode.d.ts

@@ -1,17 +0,0 @@
-/**
- * Lanes of the decode, a workgroup a listed cluster: a lane a vertex, and a lane a triangle.
- * @type {number}
- */
-export const VGEO_SDF_DECODE_WORKGROUP_SIZE: number;
-/**
- * The extraction's decode (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8, as S8 built it): a workgroup a cluster the cut
- * listed, dispatched by the list's count. Each adds its cluster's vertices and triangles to its job's counts, which
- * size the job's room in a later frame. A job the host gives room this frame (`decode`) takes each cluster's share of
- * it by atomic: the cluster's positions as they are stored, in the geometry's own space, and its triangles as indices
- * into its job's vertices, which the host reads back as the proxy's mesh.
- *
- * @type {ComputeShader}
- */
-export const shader_vgeo_sdf_decode: ComputeShader;
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_vgeo_sdf_decode.d.ts.map

package/src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_decode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_vgeo_sdf_decode.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_decode.js"],"names":[],"mappings":"AAuBA;;;GAGG;AACH,6CAFU,MAAM,CAEuG;AAwGvH;;;;;;;;GAQG;AACH,qCAFU,aAAa,CAMpB;8BAzI2B,kCAAkC"}

package/src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_decode.js

@@ -1,145 +0,0 @@
-import { assert } from "../../../../../core/assert.js";
-import { COLLECTION_U32_STRUCT_READ } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
-import { chunk_meshlet_compute_attribute_section_offset } from "../../../shader/chunk/geometry/meshlet/chunk_meshlet_compute_attribute_section_offset.js";
-import { chunk_read_meshlet_attribute_vec3f } from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_attribute_vec3f.js";
-import { chunk_read_meshlet_resolved_index } from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_resolved_index.js";
-import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { atomic_u32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
-import { MESHLET_METADATA_STRUCT } from "../../meshlet/encoding/MESHLET_METADATA_STRUCT.js";
-import { VGEO_MAX_CLUSTER_TRIANGLE_COUNT } from "../format/cluster/VGEO_MAX_CLUSTER_TRIANGLE_COUNT.js";
-import { VGEO_MAX_CLUSTER_VERTEX_COUNT } from "../format/cluster/VGEO_MAX_CLUSTER_VERTEX_COUNT.js";
-import {
-    VGEO_SDF_CLUSTER_WORDS,
-    VGEO_SDF_COUNTER,
-    VGEO_SDF_COUNTER_WORDS,
-    VGEO_SDF_JOB_STRUCT,
-    VGEO_SDF_SETTINGS
-} from "./VGEO_SDF.js";
-
-/**
- * Lanes of the decode, a workgroup a listed cluster: a lane a vertex, and a lane a triangle.
- * @type {number}
- */
-export const VGEO_SDF_DECODE_WORKGROUP_SIZE = Math.max(VGEO_MAX_CLUSTER_VERTEX_COUNT, VGEO_MAX_CLUSTER_TRIANGLE_COUNT);
-
-assert.lessThanOrEqual(VGEO_SDF_DECODE_WORKGROUP_SIZE, 256, 'the decode\'s workgroup is within WebGPU\'s default invocation limit');
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.setImmediate("settings", VGEO_SDF_SETTINGS);
-
-resources.createGroup()
-    .addStorageBuffer("vgeo_sdf_jobs", WebGPUArray.from(VGEO_SDF_JOB_STRUCT))
-    .addStorageBuffer("vgeo_sdf_counters", WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer("vgeo_sdf_clusters", COLLECTION_U32_STRUCT_READ)
-    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
-    .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE)
-    // the readback's: its header, then the jobs' vertices, then their triangles
-    .addStorageBuffer("vgeo_sdf_payload", WebGPUArray.from(u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-var<workgroup> listed: u32;
-var<workgroup> writes: u32;
-var<workgroup> first_vertex: u32;
-var<workgroup> first_triangle: u32;
-
-@compute @workgroup_size(${VGEO_SDF_DECODE_WORKGROUP_SIZE})
-fn main(
-    @builtin(workgroup_id) workgroup_id: vec3<u32>,
-    @builtin(local_invocation_index) lane: u32,
-) {
-    let index = folded_workgroup_index(workgroup_id);
-
-    if (lane == 0u) {
-        listed = min(vgeo_sdf_clusters.count, settings.cluster_capacity);
-    }
-
-    // a folded dispatch's tail, and a count that ran past the list, leave whole
-    if (index >= workgroupUniformLoad(&listed)) {
-        return;
-    }
-
-    let entry = ${VGEO_SDF_CLUSTER_WORDS}u * index;
-    let job = vgeo_sdf_clusters.elements[entry];
-    let meshlet = vgeo_sdf_clusters.elements[entry + 1u];
-    let header = meshlet_metadata[meshlet];
-    let counters = job * ${VGEO_SDF_COUNTER_WORDS}u;
-
-    // every job's size, what the host makes room by; a job written out this frame takes its cluster's room in it
-    if (lane == 0u) {
-        atomicAdd(&vgeo_sdf_counters[counters + ${VGEO_SDF_COUNTER.VERTICES}u], header.vertex_count);
-        atomicAdd(&vgeo_sdf_counters[counters + ${VGEO_SDF_COUNTER.TRIANGLES}u], header.primitive_count);
-
-        var write = 0u;
-
-        if (vgeo_sdf_jobs[job].decode != 0u) {
-            let vertex = atomicAdd(&vgeo_sdf_counters[counters + ${VGEO_SDF_COUNTER.VERTICES_WRITTEN}u], header.vertex_count);
-            let triangle = atomicAdd(&vgeo_sdf_counters[counters + ${VGEO_SDF_COUNTER.TRIANGLES_WRITTEN}u], header.primitive_count);
-
-            // a cut grown since the room was made writes nothing past it; the host sees the sizes disagree
-            if (vertex + header.vertex_count <= vgeo_sdf_jobs[job].vertex_count
-                && triangle + header.primitive_count <= vgeo_sdf_jobs[job].triangle_count) {
-                first_vertex = vertex;
-                first_triangle = triangle;
-                write = 1u;
-            }
-        }
-
-        writes = write;
-    }
-
-    if (workgroupUniformLoad(&writes) == 0u) {
-        return;
-    }
-
-    let vertex_base = first_vertex;
-
-    if (lane < header.vertex_count) {
-        let position = read_meshlet_attribute_vec3f(meshlet_compute_attribute_section_offset(header) + 3u * lane);
-        let word = settings.vertex_offset + 3u * (vgeo_sdf_jobs[job].vertex_base + vertex_base + lane);
-
-        vgeo_sdf_payload[word] = bitcast<u32>(position.x);
-        vgeo_sdf_payload[word + 1u] = bitcast<u32>(position.y);
-        vgeo_sdf_payload[word + 2u] = bitcast<u32>(position.z);
-    }
-
-    // the cluster's corners as indices into its job's vertices, clamped to its own as every reader of it clamps
-    if (lane < header.primitive_count) {
-        let word = settings.index_offset + 3u * (vgeo_sdf_jobs[job].triangle_base + first_triangle + lane);
-
-        for (var corner = 0u; corner < 3u; corner++) {
-            let local = min(read_meshlet_resolved_index(header, 3u * lane + corner), header.vertex_count - 1u);
-
-            vgeo_sdf_payload[word + corner] = vertex_base + local;
-        }
-    }
-}
-`, [
-    MESHLET_METADATA_STRUCT.declaration_chunk,
-    chunk_folded_workgroup_index,
-    chunk_meshlet_compute_attribute_section_offset,
-    chunk_read_meshlet_attribute_vec3f,
-    chunk_read_meshlet_resolved_index,
-]);
-
-/**
- * The extraction's decode (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8, as S8 built it): a workgroup a cluster the cut
- * listed, dispatched by the list's count. Each adds its cluster's vertices and triangles to its job's counts, which
- * size the job's room in a later frame. A job the host gives room this frame (`decode`) takes each cluster's share of
- * it by atomic: the cluster's positions as they are stored, in the geometry's own space, and its triangles as indices
- * into its job's vertices, which the host reads back as the proxy's mesh.
- *
- * @type {ComputeShader}
- */
-export const shader_vgeo_sdf_decode = ComputeShader.from({
-    label: "VGeo SDF Decode",
-    resources,
-    body,
-});

package/src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_traverse.d.ts

@@ -1,12 +0,0 @@
-/**
- * The extraction's cut (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8, as S8 built it): the camera cut's descent
- * (`chunk_vgeo_cut_descent`) over the jobs' records, each geometry whole, at the error its record's projection constant
- * sets against a τ of 1. Every cluster in the cut, a stand-in too, goes onto the cluster list under its job; a clamp
- * wants its page through the extraction's own feedback slot, as the camera's do, so a job cut again each frame keeps
- * its pages wanted until they arrive.
- *
- * @type {ComputeShader}
- */
-export const shader_vgeo_sdf_traverse: ComputeShader;
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_vgeo_sdf_traverse.d.ts.map

package/src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_traverse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_vgeo_sdf_traverse.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/sdf/shader_vgeo_sdf_traverse.js"],"names":[],"mappings":"AA2FA;;;;;;;;GAQG;AACH,uCAFU,aAAa,CAMpB;8BApG2B,kCAAkC"}