@woosh/meep-engine 3.60.8 → 3.60.9

package/src/shade/renderer/shader/chunk/geometry/normal/chunk_anti_alias_roughness_kaplanyan.js

@@ -1,45 +1,80 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 
 /**
+ * Kaplanyan's roughness filtering, given the screen-space footprint of the plane-plane half vector
+ * rather than taking it — so a stage without implicit derivatives can hand in its own.
+ *
+ * ```wgsl
+ * fn kaplanyan_plane_half_vector(normal: vec3<f32>, tangent: vec3<f32>, bitangent: vec3<f32>) -> vec2<f32>
+ * fn anti_alias_roughness_kaplanyan_footprint(roughness: f32, footprint_bounding_box: vec2<f32>) -> f32
+ * ```
+ *
+ * `footprint_bounding_box` is `fwidth` of the half vector, as {@link chunk_anti_alias_roughness_kaplanyan}
+ * takes it.
+ *
  * @param sigma  screen space variance
  * @param Kappa  clamping treshold
  * @see "Filtering Distributions of Normals for Shading Antialiasing" by A.S. Kaplanyan et al (NVIDIA) 2016, Eurographics Proceedings
  * @see https://github.com/tksuoran/erhe/blob/57734a5ae170aa2a50c3068fe19ffc3a667c52d0/src/editor/res/shaders/circular_brushed_metal.frag#L53
  * @type {CodeChunk}
  */
-export const chunk_anti_alias_roughness_kaplanyan = CodeChunk.from(
+export const chunk_anti_alias_roughness_kaplanyan_footprint = CodeChunk.from(
     //language=WGSL
     `
-fn anti_alias_roughness_kaplanyan (
-        roughness:f32, 
-        normal:vec3<f32>, 
+fn kaplanyan_plane_half_vector(
+        normal:vec3<f32>,
         tangent: vec3<f32>,
         bitangent: vec3<f32>
+) -> vec2<f32> {
+    // Compute plane-plane half vector (hpp)
+    let hpp_ws = normal; // assume normal
+
+    return vec2(dot(hpp_ws, tangent), dot(hpp_ws, bitangent));
+}
+
+fn anti_alias_roughness_kaplanyan_footprint (
+        roughness:f32,
+        footprint_bounding_box: vec2<f32>
 ) -> f32{
-    
+
     const sigma = 0.50;
     const Kappa = 0.18;
-    
+
     const sigma2 = sigma * sigma;
-    
-    // Compute plane-plane half vector (hpp)
-    let hpp_ws = normal; // assume normal
-    
-    let hpp = vec2(dot(hpp_ws, tangent), dot(hpp_ws, bitangent));
-    
-    // compute filtering region
-    // Use ddx/ddy, thanks to quad shading!
-    let footprint_bounding_box = fwidth(hpp);
-    
+
     let max_footprint = clamp( max(footprint_bounding_box.x , footprint_bounding_box.y), 1e-3, 0.3);
-    
+
     let variance =  sigma2 * max_footprint * max_footprint;
-    
+
     let kernel_roughness = min( Kappa, variance * 2.0 );
-    
+
     // Beckmann proxy convolution (for GGX)
-    let filtered_roughness = sqrt(roughness * roughness + kernel_roughness);          
+    let filtered_roughness = sqrt(roughness * roughness + kernel_roughness);
 
     return filtered_roughness;
 }`);
 
+/**
+ * Kaplanyan's roughness filtering with the footprint from the fragment's own `fwidth` — fragment
+ * stage only.
+ *
+ * @see chunk_anti_alias_roughness_kaplanyan_footprint
+ * @type {CodeChunk}
+ */
+export const chunk_anti_alias_roughness_kaplanyan = CodeChunk.from(
+    //language=WGSL
+    `
+fn anti_alias_roughness_kaplanyan (
+        roughness:f32,
+        normal:vec3<f32>,
+        tangent: vec3<f32>,
+        bitangent: vec3<f32>
+) -> f32{
+    let hpp = kaplanyan_plane_half_vector(normal, tangent, bitangent);
+
+    // compute filtering region
+    // Use ddx/ddy, thanks to quad shading!
+    return anti_alias_roughness_kaplanyan_footprint(roughness, fwidth(hpp));
+}`, [
+    chunk_anti_alias_roughness_kaplanyan_footprint,
+]);

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_keyed_append.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The key {@link chunk_subgroup_keyed_append} skips, and the place it hands a lane that holds no key.
+ *
+ * @type {number}
+ */
+export const SUBGROUP_KEYED_APPEND_NONE: number;
+/**
+ * Count each lane into `counters[key]`, one atomic per distinct key the subgroup holds: the
+ * subgroup takes its smallest outstanding key, the lanes holding it count themselves in, the first
+ * of them adds that many with one `atomicAdd`, and the round repeats until no key is left. Each
+ * lane comes away with its place among everything counted into its key — the counter's value
+ * before the round, plus its rank among the round's lanes.
+ *
+ * `fn subgroup_keyed_append(counters: ptr<storage, array<atomic<u32>>, read_write>, key: u32) -> u32`
+ *
+ * A lane with key {@link SUBGROUP_KEYED_APPEND_NONE} counts into nothing and gets that word back.
+ * Every lane of the subgroup calls it, from subgroup-uniform control flow.
+ *
+ * A subgroup runs one round per distinct key it holds, so the loop is bounded by its lane count.
+ * Keys that follow the screen — a material per pixel, read a block of pixels per subgroup — come in
+ * runs, and a subgroup ordinarily holds one or two.
+ *
+ * The order of places across subgroups is whatever order their atomics land in.
+ * Nothing here assumes how subgroups map onto `local_invocation_index`.
+ *
+ * @see chunk_subgroup_append_slot for one counter
+ * @type {CodeChunk}
+ */
+export const chunk_subgroup_keyed_append: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_subgroup_keyed_append.d.ts.map

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_keyed_append.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_subgroup_keyed_append.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_keyed_append.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,yCAFU,MAAM,CAEqC;AAErD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,0CAFU,SAAS,CA2ChB;0BAxEuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_keyed_append.js

@@ -0,0 +1,77 @@
+import { UINT32_MAX } from "../../../../../core/binary/UINT32_MAX.js";
+import { WebGPUExtensionType } from "../../../../descriptor/WebGPUExtensionType.js";
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * The key {@link chunk_subgroup_keyed_append} skips, and the place it hands a lane that holds no key.
+ *
+ * @type {number}
+ */
+export const SUBGROUP_KEYED_APPEND_NONE = UINT32_MAX;
+
+/**
+ * Count each lane into `counters[key]`, one atomic per distinct key the subgroup holds: the
+ * subgroup takes its smallest outstanding key, the lanes holding it count themselves in, the first
+ * of them adds that many with one `atomicAdd`, and the round repeats until no key is left. Each
+ * lane comes away with its place among everything counted into its key — the counter's value
+ * before the round, plus its rank among the round's lanes.
+ *
+ * `fn subgroup_keyed_append(counters: ptr<storage, array<atomic<u32>>, read_write>, key: u32) -> u32`
+ *
+ * A lane with key {@link SUBGROUP_KEYED_APPEND_NONE} counts into nothing and gets that word back.
+ * Every lane of the subgroup calls it, from subgroup-uniform control flow.
+ *
+ * A subgroup runs one round per distinct key it holds, so the loop is bounded by its lane count.
+ * Keys that follow the screen — a material per pixel, read a block of pixels per subgroup — come in
+ * runs, and a subgroup ordinarily holds one or two.
+ *
+ * The order of places across subgroups is whatever order their atomics land in.
+ * Nothing here assumes how subgroups map onto `local_invocation_index`.
+ *
+ * @see chunk_subgroup_append_slot for one counter
+ * @type {CodeChunk}
+ */
+export const chunk_subgroup_keyed_append = CodeChunk.from(
+    //language=WGSL
+    `
+// the trip count is uniform across the subgroup by construction: every lane sees the same minimum
+@diagnostic(off, subgroup_uniformity)
+fn subgroup_keyed_append(counters: ptr<storage, array<atomic<u32>>, read_write>, key: u32) -> u32 {
+    const NONE = ${SUBGROUP_KEYED_APPEND_NONE}u;
+
+    var outstanding = key;
+    var place = NONE;
+
+    loop {
+        let round_key = subgroupMin(outstanding);
+
+        if (round_key == NONE) {
+            break;
+        }
+
+        let in_round = outstanding == round_key;
+        let one = select(0u, 1u, in_round);
+
+        let rank = subgroupExclusiveAdd(one);
+        let total = subgroupAdd(one);
+
+        var base = 0u;
+
+        if (in_round && rank == 0u) {
+            base = atomicAdd(&counters[round_key], total);
+        }
+
+        // only the adding lane holds anything but 0
+        base = subgroupAdd(base);
+
+        if (in_round) {
+            place = base + rank;
+            outstanding = NONE;
+        }
+    }
+
+    return place;
+}
+`);
+
+chunk_subgroup_keyed_append.addExtension(WebGPUExtensionType.Subgroups);

package/src/shade/renderer/texture/virtual/VirtualTextureManager.d.ts

@@ -83,6 +83,12 @@ export class VirtualTextureManager {
      * @returns {RenderPipelineDescriptor}
      */
     get material_pipeline_descriptor(): import("../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+    /**
+     * The surface function of the virtual-texture material variant for this manager's cache
+     * geometry — the one {@link material_pipeline_descriptor} is built around.
+     * @returns {CodeChunk}
+     */
+    get material_surface(): import("../../shader/compiler/CodeChunk.js").CodeChunk;
     /**
      * Register a stack (idempotent per stack — shared stacks ref-count).
      * Allocates the page-table region, publishes the info row, and pins the

package/src/shade/renderer/texture/virtual/VirtualTextureManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualTextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/VirtualTextureManager.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA4KI;;;OAGG;IACH,+BAIC;IAvBD;;OAEG;IACH;;;;;;;;;;MAUE;IAYF;;;OAGG;IACH,8BAIC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,2EAIC;IAED;;OAEG;IACH,qCAIC;IAED;;OAEG;IACH,mCAIC;IAED;;OAEG;IACH,6BAIC;IAED;;OAEG;IACH,sCAIC;IAED;;OAEG;IACH,gCAIC;IAED;;;;OAIG;IACH,uIAQC;IA8DD;;;;;;;OAOG;IACH,sBAHW,mBAAmB,GACjB,MAAM,CA6FlB;IAED;;;;;OAKG;IACH,wBAFW,mBAAmB,QAgF7B;IA8ED;;;;;;;;;OASG;IACH,wBAFW,WAAW,QAoFrB;IA8KD;;;;;;OAMG;IACH,wBAqBC;IAED;;;OAGG;IACH,eAkHC;IAID;;;;;;;;;;;;OAYG;IACH;QAN4B,KAAK,EAAtB,UAAU;QACW,IAAI,EAAzB,cAAc;QACD,gBAAgB,EAA7B,MAAM;QACO,oBAAoB,EAAjC,MAAM;QACU,wBAAwB;aA6FlD;IAED,gBA8BC;;CACJ;yBA5uCY,OAAO,8DAA8D,EAAE,UAAU;uCACjF,OAAO,iEAAiE,EAAE,wBAAwB;wBAClG,OAAO,oCAAoC,EAAE,SAAS;6BACtD,OAAO,8BAA8B,EAAE,cAAc;kCACrD,OAAO,0BAA0B,EAAE,mBAAmB;gCAPnC,sBAAsB"}
+{"version":3,"file":"VirtualTextureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/virtual/VirtualTextureManager.js"],"names":[],"mappings":"AAmHA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA4KI;;;OAGG;IACH,+BAIC;IAvBD;;OAEG;IACH;;;;;;;;;;MAUE;IAYF;;;OAGG;IACH,8BAIC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,2EAIC;IAED;;OAEG;IACH,qCAIC;IAED;;OAEG;IACH,mCAIC;IAED;;OAEG;IACH,6BAIC;IAED;;OAEG;IACH,sCAIC;IAED;;OAEG;IACH,gCAIC;IAED;;;;OAIG;IACH,uIAQC;IAED;;;;OAIG;IACH,+EAIC;IA8DD;;;;;;;OAOG;IACH,sBAHW,mBAAmB,GACjB,MAAM,CA6FlB;IAED;;;;;OAKG;IACH,wBAFW,mBAAmB,QAgF7B;IA8ED;;;;;;;;;OASG;IACH,wBAFW,WAAW,QAoFrB;IA8KD;;;;;;OAMG;IACH,wBAqBC;IAED;;;OAGG;IACH,eAkHC;IAID;;;;;;;;;;;;OAYG;IACH;QAN4B,KAAK,EAAtB,UAAU;QACW,IAAI,EAAzB,cAAc;QACD,gBAAgB,EAA7B,MAAM;QACO,oBAAoB,EAAjC,MAAM;QACU,wBAAwB;aA6FlD;IAED,gBA8BC;;CACJ;yBAvvCY,OAAO,8DAA8D,EAAE,UAAU;uCACjF,OAAO,iEAAiE,EAAE,wBAAwB;wBAClG,OAAO,oCAAoC,EAAE,SAAS;6BACtD,OAAO,8BAA8B,EAAE,cAAc;kCACrD,OAAO,0BAA0B,EAAE,mBAAmB;gCAPnC,sBAAsB"}

package/src/shade/renderer/texture/virtual/VirtualTextureManager.js

@@ -3,7 +3,10 @@ import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
 import { write_gpu_typed_buffer } from "../../shader/type/serde/write_gpu_typed_buffer.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { graph_read_buffer } from "../../buffer/graph_read_buffer.js";
-import { build_vt_material_pipeline_descriptor } from "../../material/standard/fragment_gbuffer_vt.js";
+import {
+    build_chunk_vt_material_surface,
+    build_vt_material_pipeline_descriptor
+} from "../../material/standard/fragment_gbuffer_vt.js";
 import { build_chunk_vt_lookup } from "./build_chunk_vt_lookup.js";
 import { build_shader_vt_feedback, VT_FEEDBACK_WORKGROUP_SIZE } from "./build_shader_vt_feedback.js";
 import {
@@ -407,6 +410,17 @@ export class VirtualTextureManager {
         return this.#material_pipeline_descriptor;
     }
 
+    /**
+     * The surface function of the virtual-texture material variant for this manager's cache
+     * geometry — the one {@link material_pipeline_descriptor} is built around.
+     * @returns {CodeChunk}
+     */
+    get material_surface() {
+        this.#ensure_initialized();
+
+        return build_chunk_vt_material_surface(this.#chunk_lookup);
+    }
+
     #ensure_initialized() {
         if (this.#initialized) {
             return;

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 "__#277@#execute"(pass: any, resources: any, context: any): void;
+    static "__#279@#execute"(pass: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device