@woosh/meep-engine 3.58.0 → 3.60.0

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

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,17 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,145 @@
+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

@@ -0,0 +1,12 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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"}

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

@@ -0,0 +1,105 @@
+import { WebGPUExtensionType } from "../../../../descriptor/WebGPUExtensionType.js";
+import { COLLECTION_U32_STRUCT_READ } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+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 { atomic_u32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { chunk_vgeo_cut_access } from "../runtime/cut/chunk_vgeo_cut_access.js";
+import { chunk_vgeo_cut_descent } from "../runtime/cut/chunk_vgeo_cut_descent.js";
+import { VGEO_CUT_PARAMS_STRUCT } from "../runtime/cut/VGEO_CUT_PARAMS_STRUCT.js";
+import { VGEO_CUT_STAT } from "../runtime/layout/VGEO_CUT_STAT.js";
+import { VGEO_INSTANCE_OFFSET } from "../runtime/layout/VGEO_INSTANCE_OFFSET.js";
+import { VGEO_PAGE_ROW_OFFSET } from "../runtime/layout/VGEO_PAGE_ROW_OFFSET.js";
+import { VGEO_SDF_CLUSTER_WORDS, VGEO_SDF_COUNTER, VGEO_SDF_COUNTER_WORDS, VGEO_SDF_SETTINGS } from "./VGEO_SDF.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", VGEO_SDF_SETTINGS);
+
+resources.createGroup()
+    .addUniform("params", VGEO_CUT_PARAMS_STRUCT)
+    .addStorageBuffer("vg_lookup", WebGPUArray.from(u32), false)
+    .addStorageBuffer("vg_arena", WebGPUArray.from(u32), false)
+;
+
+resources.createGroup()
+    .addStorageBuffer("instances", WebGPUArray.from(u32), false)
+    .addStorageBuffer("queue_in", COLLECTION_U32_STRUCT_READ, false)
+    .addStorageBuffer("queue_out", COLLECTION_U32_STRUCT_WRITE, true)
+;
+
+resources.createGroup()
+    .addStorageBuffer("claim", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("feedback", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("vg_want_stamps", WebGPUArray.from(atomic_u32), true)
+    // a job's counters, `VGEO_SDF_COUNTER_WORDS` each
+    .addStorageBuffer("vgeo_sdf_counters", WebGPUArray.from(atomic_u32), true)
+    // the cut's clusters, a job and a meshlet row each; the count runs past what the list holds
+    .addStorageBuffer("vgeo_sdf_clusters", COLLECTION_U32_STRUCT_WRITE, true)
+;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+/** A geometry is cut whole: nothing is outside. */
+fn vg_cut_sphere_outside(instance_base: u32, sphere: vec4<f32>) -> bool {
+    return false;
+}
+
+fn vg_cut_box_outside(instance_base: u32, lower: vec3<f32>, upper: vec3<f32>) -> bool {
+    return false;
+}
+
+/**
+ * A cluster in the cut, a stand-in's too, onto the list as its job and its meshlet row. A stand-in, for a page not
+ * resident or a group not selectable, is counted against its job, whose cut is then not the one it asked for; past
+ * the list a cluster is dropped and counted, and its job's cut is incomplete too.
+ */
+fn vg_cut_take(instance_base: u32, page_row: u32, verdict: VGVerdict) {
+    let job = instances[instance_base + ${VGEO_INSTANCE_OFFSET.MESH_INDEX}u];
+    let counters = job * ${VGEO_SDF_COUNTER_WORDS}u;
+
+    atomicAdd(&vgeo_sdf_counters[counters + ${VGEO_SDF_COUNTER.TAKEN}u], 1u);
+
+    if (verdict.kind != VG_VERDICT_TAKE) {
+        atomicAdd(&vgeo_sdf_counters[counters + ${VGEO_SDF_COUNTER.STAND_INS}u], 1u);
+    }
+
+    let slot = atomicAdd(&vgeo_sdf_clusters.count, 1u);
+
+    if (slot >= settings.cluster_capacity) {
+        atomicAdd(&vgeo_sdf_counters[counters + ${VGEO_SDF_COUNTER.DROPPED}u], 1u);
+        vg_stat(${VGEO_CUT_STAT.MESHLETS_DROPPED}u, 1u);
+        return;
+    }
+
+    let entry = ${VGEO_SDF_CLUSTER_WORDS}u * slot;
+
+    vgeo_sdf_clusters.elements[entry] = job;
+    vgeo_sdf_clusters.elements[entry + 1u] = vg_page_field(page_row, ${VGEO_PAGE_ROW_OFFSET.MESHLET_BASE}u) + verdict.cluster;
+
+    vg_stat(${VGEO_CUT_STAT.DRAWN}u, 1u);
+}
+`, [
+    chunk_vgeo_cut_descent,
+    chunk_vgeo_cut_access,
+]);
+
+body.addExtension(WebGPUExtensionType.Subgroups);
+
+/**
+ * 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.from({
+    label: "VGeo SDF Cut",
+    resources,
+    body,
+});

package/src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_probe_meta_pick2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick4_probe_meta_pick2.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_probe_meta_pick2.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;GAUG;AACH,4CAFU,SAAS,CAkDlB;0BAtEyB,0CAA0C"}
+{"version":3,"file":"chunk_brick4_probe_meta_pick2.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_probe_meta_pick2.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AACH,4CAFU,SAAS,CAoClB;0BAxDyB,0CAA0C"}

package/src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_probe_meta_pick2.js

@@ -1,8 +1,6 @@
 import { f32, vec2u } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
-import {
-    chunk_sample_discrete_wrs_mat2x4
-} from "../../../../shader/chunk/random/reservoir/chunk_sample_discrete_wrs_mat2x4.js";
+import { chunk_pick2_wrs_mat2x4 } from "../../../../shader/chunk/random/reservoir/chunk_pick2_wrs_mat2x4.js";
 import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
 import { BRICK4_PROBE_SAMPLE_META_STRUCT } from "./BRICK4_PROBE_SAMPLE_META_STRUCT.js";
 import { BRICK4_RESOURCE } from "../BRICK4_RESOURCE.js";
@@ -34,32 +32,18 @@ fn brick4_probe_meta_pick2(
     noise: vec2<f32>,
 ) -> ${BRICK4_PROBE_SAMPLE2_META_STRUCT.wgsl_ref} {
 
-    var _u = noise.x;
-    var ws = metadata.weights;
+    let pick = pick2_wrs_mat2x4(metadata.weights, noise);
 
-    // pick samples
-    let sample0 = sample_discrete_wrs_mat2x4(ws, &_u);
-    var weight0 = metadata.weights[sample0 >> 2][sample0 & 3];
+    let sample0 = pick.indices.x;
+    let sample1 = pick.indices.y;
 
-    // clear out selected sample
-    ws[sample0 >> 2][sample0 & 3] = 0.0;
-
-    // use a fresh entropy sample
-    _u = noise.y;
-
-    let sample1 = sample_discrete_wrs_mat2x4(ws, &_u);
-    var weight1 = ws[sample1 >> 2][sample1 & 3];
-
-    let local_index_0 = metadata.indices[sample0 >> 2][sample0 & 3];
-    let local_index_1 = metadata.indices[sample1 >> 2][sample1 & 3];
+    let local_index_0 = metadata.indices[sample0 >> 2u][sample0 & 3u];
+    let local_index_1 = metadata.indices[sample1 >> 2u][sample1 & 3u];
 
     let global_index_0 = brick4.data[node_address + local_index_0];
     let global_index_1 = brick4.data[node_address + local_index_1];
 
-    // re-normalize weights
-    let weight_sum = max(1e-6, weight0 + weight1);
-
-    weight1 /= weight_sum;
+    let weight1 = pick.blend;
 
     let result = ${BRICK4_PROBE_SAMPLE2_META_STRUCT.make({
         global_indices: 'vec2u(global_index_0, global_index_1)',
@@ -71,7 +55,7 @@ fn brick4_probe_meta_pick2(
 }
     `, [
         BRICK4_PROBE_SAMPLE2_META_STRUCT.declaration_chunk,
-        chunk_sample_discrete_wrs_mat2x4,
+        chunk_pick2_wrs_mat2x4,
     ]
 )
 

package/src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick4_sample_forward_indirect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js"],"names":[],"mappings":"AAsCA,6DAqEC;0BAnGyB,0CAA0C"}
+{"version":3,"file":"chunk_brick4_sample_forward_indirect.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js"],"names":[],"mappings":"AAcA,6DAqEC;0BA3EyB,0CAA0C"}

package/src/shade/renderer/global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js

@@ -1,4 +1,4 @@
-import { chunk_murmur3_vec3u } from "../../../../shader/chunk/random/murmur/chunk_murmur3_vec3u.js";
+import { chunk_jitter_from_vectors } from "../../../../shader/chunk/random/chunk_jitter_from_vectors.js";
 import {
     chunk_sh3_color_get_irradiance_at
 } from "../../../../shader/chunk/spherical_harmonics/chunk_sh3_color_get_irradiance_at.js";
@@ -11,30 +11,6 @@ import { chunk_brick4_load_probe } from "./chunk_brick4_load_probe.js";
 import { chunk_brick4_node_by_position } from "./chunk_brick4_node_by_position.js";
 import { chunk_brick4_node_sample_probes_meta } from "./chunk_brick4_node_sample_probes_meta.js";
 import { chunk_brick4_probe_meta_pick2 } from "./chunk_brick4_probe_meta_pick2.js";
-import { VIEW_RESOURCE } from "../../../../view/VIEW_RESOURCE.js";
-
-const chunk_jitter_from_vectors = CodeChunk.from(
-    //language=WGSL
-    `
-fn jitter_from_vectors(v0:vec3<f32>, v1: vec3<f32>) -> vec2<f32>{
-    let u0 = bitcast<vec3<u32>>(v0);
-    let u1 = bitcast<vec3<u32>>(v1);
-    
-    var h0 = u0 ^ u1;
-    
-    // add temporal component
-    h0.x ^= view.frame_index;
-    
-    let h1 = murmur3_vec3u(h0);
-        
-    return unpack2x16unorm(h1);
-}
-    `, [
-        chunk_murmur3_vec3u,
-    ]
-)
-
-chunk_jitter_from_vectors.requireResource(VIEW_RESOURCE);
 
 export const chunk_brick4_sample_forward_indirect = CodeChunk.from(
     //language=WGSL

package/src/shade/renderer/global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_get_visibility_mask.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js"],"names":[],"mappings":"AASA,sDAqDE;0BAxDwB,uCAAuC"}
+{"version":3,"file":"chunk_lpv_get_visibility_mask.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js"],"names":[],"mappings":"AAUA,sDAkCE;0BArCwB,uCAAuC"}

package/src/shade/renderer/global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js

@@ -4,6 +4,7 @@ import {
     chunk_lpv_sample_depth_atlas,
     chunk_lpv_sample_depth_atlas_native
 } from "../../../shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.js";
+import { chunk_probe_visibility_weight } from "../../../shader/chunk/light/probe/chunk_probe_visibility_weight.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { LPV_PROBES_RESOURCE } from "../../probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
@@ -24,34 +25,14 @@ fn lpv_get_visibility_mask(
 
     let direction = local_probe_offset / distance_to_probe;
 
-    let temp = lpv_sample_depth_atlas( direction, probe_index );
-
-    let mean = temp.x;
-    let mean2 = temp.y; // mean of squared distances
-
-    // prevent variance from going to 0, which would produce NaN
-    // NOTE: not sure if this is strictly necessary
-    const MIN_VARIANCE = 1e-6;
-    let variance = max(MIN_VARIANCE, abs(mean2 - mean * mean));
+    // the mean of distances and of their squares
+    let moments = lpv_sample_depth_atlas( direction, probe_index );
 
     // normalize distance. Depth is stored relative to probe.distance_max
     let distance_normalized = distance_to_probe / probe.distance_max;
 
-    // http://www.punkuser.net/vsm/vsm_paper.pdf; equation 5
-    // Need the max in the denominator because biasing can cause a negative displacement
-    let d = distance_normalized - mean;
-    
-    if(d <= 0.0){
-        // no occlusion
-        return 1.0;
-    }
-    
-    let chebyshev_weight = variance / (variance + d * d);
-    
-    
     // note that we don't clip visibility here for light-bleeding reduction, this is done outside in the weighting function
-    
-    return chebyshev_weight;
+    return probe_visibility_chebyshev(moments.xy, distance_normalized);
     
 }
     `,
@@ -59,6 +40,7 @@ fn lpv_get_visibility_mask(
         chunk_lpv_probe_get_position,
         chunk_lpv_sample_depth_atlas_native,
         chunk_inverse_lerp,
+        chunk_probe_visibility_weight,
     ]
 );
 

package/src/shade/renderer/global_illumination/probe/octahedral/shader_lpv_build_gbuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_lpv_build_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/shader_lpv_build_gbuffer.js"],"names":[],"mappings":"AAqMA,mDA4BG;4BAzLyB,gCAAgC"}
+{"version":3,"file":"shader_lpv_build_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/shader_lpv_build_gbuffer.js"],"names":[],"mappings":"AAsMA,mDA4BG;4BA1LyB,gCAAgC"}

package/src/shade/renderer/global_illumination/probe/octahedral/shader_lpv_build_gbuffer.js

@@ -157,7 +157,8 @@ fn main(
             material_info,
             triangle,
             lambda,
-            node.global
+            node.global,
+            0.0
         );
         
         let hit_position_local = hit.t * ray.direction;

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts

@@ -14,7 +14,9 @@
  * and the settings on every frame the mode runs ({@link graph_update}). The clipmaps are made on the
  * first such frame, and made again when a frame is for another view or a structural setting has
  * changed; {@link release} gives them back on the first frame out of the mode, and {@link destroy}
- * with the renderer. Nothing is allocated before the mode first runs.
+ * with the renderer. Nothing is allocated before the mode first runs but the placeholders the probes'
+ * readers bind while there are no probes ({@link write_sampling_bindings}): seven objects of a few bytes,
+ * made on the first ask and kept until {@link destroy}.
  *
  * Each frame it holds the geometry caches and card sets its scene's SDF world draws
  * ({@link ProbeClipmapSceneHolds}), trims the caches nothing holds, and records their bake and the
@@ -52,21 +54,34 @@ export class GPUProbeClipmapGI {
      * @param {number} options.depth graph handle of the view's depth, which the probes are wanted from
      * @param {number} options.normal graph handle of the G-buffer's normals
      * @param {*} options.stbn the 2-channel spatio-temporal blue noise, `STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2`
-     * @param {number} options.time the caller's clock, seconds: what the probes' retention and response
-     *   times run on
      * @param {number} [options.movers] the graph handle of the scene's mover list for the frame,
      *   which the world's bricks are built again over
      */
-    graph_update({ graph, view, settings, depth, normal, stbn, time, movers }: {
+    graph_update({ graph, view, settings, depth, normal, stbn, movers }: {
         graph: FrameGraph;
         view: GPUViewContext;
         settings: ProbeClipmapSettings;
         depth: number;
         normal: number;
         stbn: any;
-        time: number;
         movers?: number;
     }): void;
+    /**
+     * Whether the probes are there to read: the mode has run a frame and not been left since.
+     * @returns {boolean}
+     */
+    get has_probes(): boolean;
+    /**
+     * Put what the probes' readers bind into `bindings`, `PROBE_CLIPMAP_SAMPLING_GROUP` but its sampler:
+     * once {@link has_probes}, the probes as this frame's {@link graph_update} left them
+     * (`GPUProbeClipmap.write_sampling_bindings`); before that, or out of the mode, a clipmap of no
+     * cascade, whose pick finds nothing. A shader that can take this mode's alternative binds the group in
+     * every mode, as its variants share their resources.
+     *
+     * @param {Object} bindings
+     * @returns {Object} bindings
+     */
+    write_sampling_bindings(bindings: any): any;
     /**
      * The debug view the settings ask for, in place of the frame's colour. Record it after
      * {@link graph_update} in the same frame.

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAWA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IAmDI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAX+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACC,IAAI,EAApB,MAAM;QAEW,MAAM,GAAvB,MAAM;aAkGhB;IAED;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAyCD;;;OAGG;IACH,gBAoBC;IAED,gBAQC;;CACJ;yBApWY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAf/B,4BAA4B;gCAM5B,4BAA4B;uCAErB,6BAA6B"}
+{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA0DI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACE,MAAM,GAAvB,MAAM;aAiGhB;IAED;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAyCD;;;OAGG;IACH,gBAoBC;IAED,gBAcC;;CACJ;yBApcY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAjB/B,4BAA4B;gCAQ5B,4BAA4B;uCAErB,6BAA6B"}