@woosh/meep-engine 3.61.2 → 3.61.3

package/src/shade/renderer/volumetrics/chunk_frustum_unit_box_coverage_multisample.js

@@ -1,39 +1,48 @@
 import { chunk_frustum_sample_point } from "../shader/chunk/geometry/frustum/chunk_frustum_sample_point.js";
-import { chunk_random } from "../shader/chunk/random/chunk_random.js";
+import { chunk_sobol_sample_vec2 } from "../shader/chunk/noise/chunk_sobol_sample_vec2.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 
+/**
+ * The share of a frustum's volume inside the unit box [-0.5, 0.5]³, estimated along 4 rays from its near
+ * face to its far face: the mean of the fraction of each ray inside the box.
+ *
+ * The rays cross the face at points `4 · round` to `4 · round + 3` of the shuffled, Owen-scrambled Sobol
+ * sequence of `seed` (`sample_sobol_2d`), in the face's (u, v), u from the left plane to the right and v
+ * from the bottom to the top. Each call's 4 points are one per quarter of the face along either axis, and one
+ * per quadrant. The 2^m calls of an aligned run of rounds put one point in each dyadic cell of area
+ * 2^-(m+2). The points depend only on the seed and the round, and a ray is the planes' blend at its point:
+ * the same frustum's planes carried into another space by a rigid or uniformly scaled map, each plane
+ * renormalized, cast the same rays there.
+ *
+ * ```wgsl
+ * fn frustum_unit_box_coverage(frustum: array<vec4f, 6>, round: u32, seed: u32) -> f32 // frustum planes [LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR]
+ * ```
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_frustum_unit_box_coverage_multisample = CodeChunk.from(
     //language=WGSL
     `
 fn frustum_unit_box_coverage(
     frustum: array< vec4f, 6>,
+    round: u32,
+    seed: u32,
 ) -> f32 {
-    
-    // 4 Samples is usually the "Sweet Spot" for volumetrics.
-    // 1 = Hard Edges
-    // 4 = Smooth with slight noise (cleaned up by TAA)
-    // 16 = High quality but expensive
     const SAMPLE_COUNT = 4u;
-    
+
     var total_coverage = 0.0;
 
     for(var i = 0u; i < SAMPLE_COUNT; i++){
-    
-        // 1. Generate Random UVs
-        // This distributes rays across the face of the froxel.
-        let u = random();
-        let v = random();
-        
-        // 2. Construct Ray
-        // Note: We must re-calculate direction per-sample because 
-        // perspective frustums diverge (rays are not parallel).
-        let start = frustum_sample_point(frustum, vec3f(u, v, 0.0));
-        let end   = frustum_sample_point(frustum, vec3f(u, v, 1.0));
+        let uv = sample_sobol_2d(round * SAMPLE_COUNT + i, seed);
+
+        // perspective frustums diverge, so each ray takes its own direction
+        let start = frustum_sample_point(frustum, vec3f(uv, 0.0));
+        let end   = frustum_sample_point(frustum, vec3f(uv, 1.0));
 
         let dir = end - start;
         let inv_dir = 1.0 / (dir + vec3f(1e-5));
-        
-        // 3. Slab Method (Intersection with Unit Box -0.5 to 0.5)
+
+        // slab test against the unit box
         let t0 = (vec3f(-0.5) - start) * inv_dir;
         let t1 = (vec3f( 0.5) - start) * inv_dir;
 
@@ -43,7 +52,6 @@ fn frustum_unit_box_coverage(
         let enter = max(max(tmin.x, tmin.y), tmin.z);
         let exit  = min(min(tmax.x, tmax.y), tmax.z);
 
-        // 4. Accumulate Ratio
         let t_start = max(0.0, enter);
         let t_end   = min(1.0, exit);
 
@@ -54,6 +62,6 @@ fn frustum_unit_box_coverage(
 }
     `, [
         chunk_frustum_sample_point,
-        chunk_random
+        chunk_sobol_sample_vec2,
     ]
-);
+);

package/src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AA8QA,yEAIE;8BA3P4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AA6QA,yEAIE;8BA3P4B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js

@@ -18,8 +18,7 @@ import {
 } from "../shader/chunk/geometry/frustum/chunk_frustum_transform_plane_matrix.js";
 import { chunk_mat4_extract_scale } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_scale.js";
 import { chunk_stbn_sample_vec3 } from "../shader/chunk/noise/chunk_stbn_sample_vec3.js";
-import { chunk_random } from "../shader/chunk/random/chunk_random.js";
-import { chunk_random_initialize } from "../shader/chunk/random/chunk_random_initialize.js";
+import { chunk_pcg4d } from "../shader/chunk/random/pcg/chunk_pcg4d.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
@@ -69,7 +68,8 @@ fn main(
         return;
     }
     
-    random_initialize(voxel_coord, vec3(view.frame_index, 0xCAFEBEEF, 1337));
+    // the froxel's coverage points: a sequence of its own, a round of it a frame, the same points for every volume
+    let coverage_seed = pcg4d(vec4<u32>(voxel_coord, 0x1F83D9ABu)).x;
     
     let uv = vec2f(voxel_coord.xy) / vec2f(resolution.xy);
     
@@ -187,7 +187,7 @@ fn main(
         // volumetrics_froxel_containment.spec.js keeps the geometry proven if the balance changes.
 
         // estimate volume coverage to avoid aliasing and get a better overlap test
-        var volume_coverage = frustum_unit_box_coverage(local_frustum);
+        var volume_coverage = frustum_unit_box_coverage(local_frustum, view.frame_index, coverage_seed);
 
         if(volume_coverage == 0.0){
             // skip
@@ -252,8 +252,7 @@ fn main(
         chunk_frustum_transform_plane_matrix,
         chunk_aabb3_intersects_frustum,
         chunk_compute_near_far_from_projection,
-        chunk_random_initialize,
-        chunk_random,
+        chunk_pcg4d,
         chunk_rgb_to_luminance,
         chunk_frustum_unit_box_coverage_multisample,
         chunk_compute_volume_fade_factor,

package/src/shade/renderer/water/query/GPUWaterQueries.d.ts

@@ -24,7 +24,7 @@ export class GPUWaterQueries {
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry: PipelineEnquiry): void;
-    static "__#279@#execute"(pass: any, resources: any, context: any): void;
+    static "__#281@#execute"(pass: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/wind/GPUSceneWind.d.ts

@@ -42,7 +42,7 @@ export class GPUSceneWind {
      * @param {number} capacity
      * @returns {GPUTileAtlas3D}
      */
-    static "__#169@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
+    static "__#174@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
     /**
      * @param {GPUDevice} device
      */

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

@@ -1,213 +0,0 @@
-/**
- * s_e: the largest component of a material's emissive factor, which the capture stores emissive
- * over. 0 for a material that emits nothing, or that has no emissive factor.
- *
- * @param {ShadeMaterial} material
- * @returns {number}
- */
-export function mesh_card_emissive_scale_of(material: ShadeMaterial): number;
-/**
- * Most pages a frame's capture may take: a workgroup a page, in one dispatch row.
- * @type {number}
- */
-export const MESH_CARD_CAPTURE_BUDGET_MAX: number;
-/**
- * Card sets (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.5): one (geometry, material) pair's capture of
- * its geometry's card layout, by card set id, the storage of which {@link GPUGeometrySDFManager}
- * keeps beside its fields and layouts.
- *
- * - A card set's pages are a run of tiles of the card atlas, one a page of the layout, in the
- *   layout's order, from page_base. The layout's column tables are the geometry's, shared by every
- *   card set of it, so a card set needs no page table of its own.
- * - The atlas is two `rgba8unorm` planes of 8×8 tiles ({@link GPUTileAtlas2D}): √(diffuse albedo)
- *   and depth; emissive / s_e and 0.
- * - Its record (`MESH_CARD_SET_STRUCT`) is written when a capture starts.
- *
- * **Lifetime.** {@link acquire} makes a card set for a pair and {@link release} gives it back; the
- * caller keeps one per pair. A card set of an aliased geometry ({@link alias}) is its source's: it
- * captures the source's layout through the source's meshlets. A card set waits until its geometry's layout is placed
- * ({@link set_layout}), is then captured, and turns resident ({@link onResident}) on the frame its
- * last page is recorded: the capture's writes come before any later pass reads it. A layout that
- * goes ({@link drop_layout}) withdraws its card sets ({@link onWithdrawn}) back to waiting.
- *
- * **Capture** ({@link graph_capture}, once a frame) takes at most `budget` pages, first captures in
- * the order they were asked for, then recaptures in the order queued. A card set's pages may span
- * frames. {@link recapture} queues a resident card set again, which reads its last capture until the
- * new one is done; a card set whose capture is under way starts it again.
- *
- * **Modes** ({@link capture_mode}). A traced card set is a run of pages, a thread a texel. A
- * rastered one is taken whole: its cards are drawn into a region of a scratch, a cell a card, and its
- * pages scattered from there into the atlas; the frame's last one may take the budget past its end.
- */
-export class GPUMeshCardSets {
-    /**
-     * @param {GPUDevice} device
-     */
-    constructor(device: GPUDevice);
-    /**
-     * Sent with a card set id when its first capture is recorded in full.
-     * @type {Signal<number>}
-     */
-    onResident: any;
-    /**
-     * Sent with a resident card set's id when its layout goes; it waits for the next.
-     * @type {Signal<number>}
-     */
-    onWithdrawn: any;
-    /**
-     * Card sets given out.
-     * @returns {number}
-     */
-    get count(): number;
-    /**
-     * @returns {number}
-     */
-    get resident_count(): number;
-    /**
-     * Recaptures asked of resident card sets, and of captures under way restarted.
-     * @returns {number}
-     */
-    get recaptures_requested(): number;
-    /**
-     * Pages the captures have recorded.
-     * @returns {number}
-     */
-    get pages_captured(): number;
-    /**
-     * Whether a frame's capture has anything to do: pages queued, or card sets turned resident with
-     * nothing to capture, still to be announced.
-     * @returns {boolean}
-     */
-    get has_pending_capture(): boolean;
-    /**
-     * Pages waiting for capture over every queue.
-     * @returns {number}
-     */
-    get pages_queued(): number;
-    /**
-     * A change captures every card set again in the new mode: resident ones read their last capture
-     * until it is done, and captures under way start again.
-     *
-     * @param {MeshCardCaptureMode} mode
-     */
-    set capture_mode(mode: number);
-    /**
-     * @returns {MeshCardCaptureMode}
-     */
-    get capture_mode(): number;
-    /**
-     * Whether readers may use the card set: captured at least once, and its layout still there.
-     *
-     * @param {number} id
-     * @returns {boolean}
-     */
-    is_resident(id: number): boolean;
-    /**
-     * The card set's geometry id.
-     *
-     * @param {number} id
-     * @returns {number}
-     */
-    geometry_of(id: number): number;
-    /**
-     * Every card set's record, by id. Replaced when it grows; take it each frame.
-     * @returns {GPUBuffer}
-     */
-    get records(): GPUBuffer;
-    /**
-     * The card atlas: plane 0 holds √(diffuse albedo) and depth, plane 1 emissive / s_e.
-     * @returns {GPUTileAtlas2D}
-     */
-    get atlas(): GPUTileAtlas2D;
-    /**
-     * A card set for a pair. The caller keeps one per pair.
-     *
-     * @param {number} geometry the geometry id the pair draws; an aliased one's card set captures its source's
-     *     layout ({@link alias})
-     * @param {ShadeMaterial} material
-     * @returns {number} card set id
-     */
-    acquire(geometry: number, material: ShadeMaterial): number;
-    /**
-     * @param {number} id
-     */
-    release(id: number): void;
-    /**
-     * The card set's material has changed (its version moved): capture it again. A resident card set
-     * reads its last capture until the new one is done.
-     *
-     * @param {number} id
-     */
-    recapture(id: number): void;
-    /**
-     * A geometry's layout is placed, with `pages` pages: its card sets can be captured.
-     *
-     * @param {number} geometry
-     * @param {number} pages
-     * @param {number} side texels a side of the layout's largest card: its grid's longest axis in
-     *        voxels, plus one, the lattice having a point at either end
-     */
-    set_layout(geometry: number, pages: number, side: number): void;
-    /**
-     * A geometry's layout is gone: its card sets wait for the next.
-     *
-     * @param {number} geometry
-     */
-    drop_layout(geometry: number): void;
-    /**
-     * The geometry `clone` is drawn as `source` from here on: its card sets, and those acquired for it after, capture
-     * `source`'s layout through `source`'s meshlets, the two being in one local space. A card set of `clone` waits
-     * for `source`'s layout, as one acquired for `source` does.
-     *
-     * @param {number} clone
-     * @param {number} source
-     */
-    alias(clone: number, source: number): void;
-    /**
-     * `clone` is no longer aliased: card sets acquired for it from here on capture its own layout. Those it has keep
-     * capturing its source's until they are given back.
-     *
-     * @param {number} clone
-     */
-    unalias(clone: number): void;
-    /**
-     * Record the frame's capture: at most `budget` pages. Records nothing when nothing waits. Card
-     * sets whose first capture this completes are resident from here, and {@link onResident} is sent
-     * for each.
-     *
-     * @param {Object} options
-     * @param {FrameGraph} options.graph
-     * @param {number} options.budget pages captured at most, `card_capture_budget`
-     * @param {number} options.arena graph handle of the arena, as the frame's bake left it
-     * @param {GPUBuffer} options.headers
-     * @param {GPUResidentMaterialContext} options.materials what the trace shades with: each traced
-     *        material is made resident, and the rows committed, before the trace is recorded
-     * @param {GPUMaterialManager} options.material_contexts what the raster draws with: each
-     *        material's template and bind group
-     * @param {Object} options.blas the geometry bindings `ray_query_blas_nearest` reads, whose
-     *        geometry and meshlet buffers the raster pulls vertices from
-     */
-    graph_capture({ graph, budget, arena, headers, materials, material_contexts, blas }: {
-        graph: FrameGraph;
-        budget: number;
-        arena: number;
-        headers: GPUBuffer;
-        materials: GPUResidentMaterialContext;
-        material_contexts: GPUMaterialManager;
-        blas: any;
-    }): void;
-    /**
-     * @returns {number} bytes
-     */
-    get gpu_memory_usage(): number;
-    destroy(): void;
-    #private;
-}
-export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-export type ShadeMaterial = import("../../../material/ShadeMaterial.js").ShadeMaterial;
-export type GPUResidentMaterialContext = import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
-export type GPUMaterialManager = import("../../../material/GPUMaterialManager.js").GPUMaterialManager;
-export type GPUMaterialContext = import("../../../material/GPUMaterialContext.js").GPUMaterialContext;
-export type Allocation = import("../../../../../core/binary/allocator/OffsetAllocator.js").Allocation;
-import { GPUTileAtlas2D } from "../../../texture/atlas/GPUTileAtlas2D.js";
-//# sourceMappingURL=GPUMeshCardSets.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"GPUMeshCardSets.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/GPUMeshCardSets.js"],"names":[],"mappings":"AAyEA;;;;;;GAMG;AACH,sDAHW,aAAa,GACX,MAAM,CAUlB;AApCD;;;GAGG;AACH,2CAFU,MAAM,CAEmF;AA0DnG;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAiMI;;OAEG;IACH,+BAIC;IAjMD;;;OAGG;IACH,gBAA0B;IAE1B;;;OAGG;IACH,iBAA2B;IAyL3B;;;OAGG;IACH,oBAUC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;OAIG;IACH,mCAIC;IAED;;;OAGG;IACH,2BAcC;IASD;;;;;OAKG;IACH,+BAgBC;IA7BD;;OAEG;IACH,2BAEC;IA0BD;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,yBAIC;IAED;;;OAGG;IACH,4BAIC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,YAEN,aAAa,GACX,MAAM,CAiClB;IAED;;OAEG;IACH,YAFW,MAAM,QA2BhB;IAED;;;;;OAKG;IACH,cAFW,MAAM,QAqBhB;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,SACN,MAAM,QACN,MAAM,QAqBhB;IAED;;;;OAIG;IACH,sBAFW,MAAM,QA+BhB;IAED;;;;;;;OAOG;IACH,aAHW,MAAM,UACN,MAAM,QAoChB;IAED;;;;;OAKG;IACH,eAFW,MAAM,QAIhB;IA0SD;;;;;;;;;;;;;;;;OAgBG;IACH;QAX+B,KAAK,EAAzB,UAAU;QACM,MAAM,EAAtB,MAAM;QACU,KAAK,EAArB,MAAM;QACa,OAAO;QACU,SAAS,EAA7C,0BAA0B;QAEE,iBAAiB,EAA7C,kBAAkB;QAEF,IAAI;aAsG9B;IAiTD;;OAEG;IACH,+BAuBC;IAED,gBAoBC;;CACJ;yBA95CY,OAAO,iEAAiE,EAAE,UAAU;4BACpF,OAAO,oCAAoC,EAAE,aAAa;yCAC1D,OAAO,0DAA0D,EAAE,0BAA0B;iCAC7F,OAAO,yCAAyC,EAAE,kBAAkB;iCACpE,OAAO,yCAAyC,EAAE,kBAAkB;yBACpE,OAAO,yDAAyD,EAAE,UAAU;+BAxB1D,0CAA0C"}