@woosh/meep-engine 3.59.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/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

@@ -54,23 +54,17 @@ 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
-     * @param {number} options.shadowmap_atlas graph handle of the frame's shadow map atlas, which shadows
-     *   the local lights at the probes' hits
      */
-    graph_update({ graph, view, settings, depth, normal, stbn, time, movers, shadowmap_atlas }: {
+    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;
-        shadowmap_atlas: number;
     }): void;
     /**
      * Whether the probes are there to read: the mode has run a frame and not been left since.
@@ -106,8 +100,8 @@ export class GPUProbeClipmapGI {
         resolution: number[];
     }): number;
     /**
-     * Have a plugin write the world's bricks too, after the engine's own providers and every
-     * provider added before it, over the same taken cells (§7.6).
+     * Have a plugin write the world's bricks too, after the mesh provider and every provider added
+     * before it, over the same taken cells (§7.6).
      *
      * @param {BrickProvider} provider
      */

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":"AAgBA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAiEI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAb+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;QAEU,eAAe,EAA/B,MAAM;aAoGhB;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;IA0CD;;;OAGG;IACH,gBAsBC;IAED,gBAcC;;CACJ;yBArdY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAlB/B,4BAA4B;gCAS5B,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"}

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js

@@ -3,7 +3,6 @@ import { BufferDescriptor } from "../../../descriptor/buffer/BufferDescriptor.js
 import { CLIPMAP_LEVEL_ARRAY } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { GPUBrickClipmap } from "./brick/GPUBrickClipmap.js";
 import { MeshSDFBrickProvider } from "./brick/mesh/MeshSDFBrickProvider.js";
-import { VGeoBrickProvider } from "./brick/vgeo/VGeoBrickProvider.js";
 import { graph_probe_clipmap_debug_brick_clipmap } from "./debug/graph_probe_clipmap_debug_brick_clipmap.js";
 import { graph_probe_clipmap_debug_mesh_cards } from "./debug/graph_probe_clipmap_debug_mesh_cards.js";
 import { graph_probe_clipmap_debug_mesh_sdf } from "./debug/graph_probe_clipmap_debug_mesh_sdf.js";
@@ -11,7 +10,7 @@ import { ProbeClipmapDebugView } from "./debug/ProbeClipmapDebugView.js";
 import { PROBE_RECORD_STRUCT } from "./probe/chunk_probe_clipmap.js";
 import { PROBE_SAMPLING_STRUCT } from "./probe/chunk_probe_clipmap_pick.js";
 import { GPUProbeClipmap } from "./probe/GPUProbeClipmap.js";
-import { PROBE_DEPTH_TEXEL_RAYS } from "./probe/PROBE_CLIPMAP.js";
+import { PROBE_DEPTH_TEXEL_RAYS, PROBE_RAYS_PER_TEXEL_MAX, PROBE_RAYS_PER_TEXEL_MIN } from "./probe/PROBE_CLIPMAP.js";
 import { ProbeClipmapSceneHolds } from "./ProbeClipmapSceneHolds.js";
 
 /**
@@ -75,8 +74,8 @@ export class GPUProbeClipmapGI {
     #destroyed = false;
 
     /**
-     * The plugins that write the world's bricks after the engine's own providers, in the order they
-     * were added (§7.6).
+     * The plugins that write the world's bricks after the mesh provider, in the order they were
+     * added (§7.6).
      * @type {BrickProvider[]}
      */
     #plugins = [];
@@ -88,14 +87,7 @@ export class GPUProbeClipmapGI {
     #mesh_provider = undefined;
 
     /**
-     * The virtual geometry provider (§7.8), made with the clipmaps and given back with them.
-     * @type {VGeoBrickProvider|undefined}
-     */
-    #vgeo_provider = undefined;
-
-    /**
-     * Every provider in its order, the mesh provider first and the virtual geometry provider next:
-     * what a frame's build runs.
+     * Every provider in its order, the mesh provider first: what a frame's build runs.
      * @type {BrickProvider[]}
      */
     #providers = [];
@@ -149,26 +141,20 @@ 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
-     * @param {number} options.shadowmap_atlas graph handle of the frame's shadow map atlas, which shadows
-     *   the local lights at the probes' hits
      */
-    graph_update({ graph, view, settings, depth, normal, stbn, time, movers = -1, shadowmap_atlas }) {
+    graph_update({ graph, view, settings, depth, normal, stbn, movers = -1 }) {
         assert.defined(graph, 'graph');
         assert.defined(view, 'view');
         assert.defined(settings, 'settings');
         assert.isNonNegativeInteger(depth, 'depth');
         assert.isNonNegativeInteger(normal, 'normal');
-        assert.isNonNegativeInteger(shadowmap_atlas, 'shadowmap_atlas');
-        assert.isFinite(time, 'time');
         assert.notOk(this.#destroyed, 'destroyed');
 
         // the relations between fields, checked here because each setter sees only its own field
-        assert.greaterThanOrEqual(settings.rays_per_probe, settings.radiance_resolution * settings.radiance_resolution / 4, 'rays_per_probe must be at least radiance_resolution² / 4');
-        assert.lessThanOrEqual(settings.rays_per_probe, 4 * settings.radiance_resolution * settings.radiance_resolution, 'rays_per_probe must be at most 4·radiance_resolution²');
+        assert.greaterThanOrEqual(settings.rays_per_probe, PROBE_RAYS_PER_TEXEL_MIN * settings.radiance_resolution * settings.radiance_resolution, 'rays_per_probe must be at least radiance_resolution² / 4');
+        assert.lessThanOrEqual(settings.rays_per_probe, PROBE_RAYS_PER_TEXEL_MAX * settings.radiance_resolution * settings.radiance_resolution, 'rays_per_probe must be at most 4·radiance_resolution²');
         assert.greaterThanOrEqual(settings.ray_budget, settings.rays_per_probe, 'ray_budget must be at least rays_per_probe');
         assert.lessThanOrEqual(settings.rays_per_probe, PROBE_DEPTH_TEXEL_RAYS * settings.depth_resolution * settings.depth_resolution, 'rays_per_probe must be at most 64·depth_resolution², the rays a depth texel gathers');
 
@@ -202,11 +188,13 @@ export class GPUProbeClipmapGI {
 
         sdf.configure(settings.mesh_sdf_voxel_size, settings.mesh_sdf_max_bricks);
         sdf.trim();
+        sdf.cards.capture_mode = settings.card_capture_mode;
         sdf.graph_bake({
             graph,
             budget: settings.mesh_sdf_bake_budget,
             capture_budget: settings.card_capture_budget,
             materials,
+            material_contexts: this.#graphics.materials,
         });
 
         // the card sets the capture made resident, for this frame's readers
@@ -241,9 +229,7 @@ export class GPUProbeClipmapGI {
             camera: view.camera.buffer,
             stbn,
             resolution: view.resolution,
-            time,
-            retention_time: settings.retention_time,
-            response_time: settings.response_time,
+            response_frames: settings.response_frames,
             ray_budget: settings.ray_budget,
             rays_per_probe: settings.rays_per_probe,
             brick_clipmap: this.#brick_clipmap,
@@ -251,7 +237,6 @@ export class GPUProbeClipmapGI {
             scene,
             materials,
             card_rows: this.#holds.rows_buffer,
-            shadowmap_atlas,
         });
     }
 
@@ -370,8 +355,8 @@ export class GPUProbeClipmapGI {
     }
 
     /**
-     * Have a plugin write the world's bricks too, after the engine's own providers and every
-     * provider added before it, over the same taken cells (§7.6).
+     * Have a plugin write the world's bricks too, after the mesh provider and every provider added
+     * before it, over the same taken cells (§7.6).
      *
      * @param {BrickProvider} provider
      */
@@ -407,7 +392,7 @@ export class GPUProbeClipmapGI {
         providers.length = 0;
 
         if (this.#mesh_provider !== undefined) {
-            providers.push(this.#mesh_provider, this.#vgeo_provider);
+            providers.push(this.#mesh_provider);
         }
 
         providers.push(...this.#plugins);
@@ -421,7 +406,6 @@ export class GPUProbeClipmapGI {
         const device = this.#graphics.device;
 
         this.#mesh_provider = new MeshSDFBrickProvider(device);
-        this.#vgeo_provider = new VGeoBrickProvider(device);
         this.#order_providers();
 
         this.#brick_clipmap = new GPUBrickClipmap(device, {
@@ -458,10 +442,8 @@ export class GPUProbeClipmapGI {
         this.#brick_clipmap.destroy();
         this.#probe_clipmap.destroy();
         this.#mesh_provider.destroy();
-        this.#vgeo_provider.destroy();
 
         this.#mesh_provider = undefined;
-        this.#vgeo_provider = undefined;
         this.#order_providers();
 
         this.#brick_clipmap = undefined;