@woosh/meep-engine 3.26.0 → 3.27.0

package/src/shade/renderer/view/GPUViewContext.js

@@ -7,6 +7,7 @@ import Vector3 from "../../../core/geom/Vector3.js";
 import { queue_typed_buffer_update } from "../shader/type/queue_typed_buffer_update.js";
 import { GPUTypedBuffer } from "../buffer/GPUTypedBuffer.js";
 import { GPUCameraContext } from "../camera/GPUCameraContext.js";
+import { VGeoViewCut } from "../geometry/virtual/runtime/VGeoViewCut.js";
 import { HierarchicalZBuffer } from "../hiz/HierarchicalZBuffer.js";
 import { GPUViewVolumetrics } from "../volumetrics/GPUViewVolumetrics.js";
 import { VIEW_UNIFORM_STRUCT } from "./VIEW_UNIFORM_STRUCT.js";
@@ -241,6 +242,22 @@ export class GPUViewContext {
     #device;
 
 
+    /**
+     * What cutting virtual geometry is per view: this view's params, and the state a cut
+     * kept between frames would live in. Held here for the same reason the HZB is —
+     * two views must not share it.
+     *
+     * @type {VGeoViewCut}
+     */
+    #virtual_geometry_cut;
+
+    /**
+     * @return {VGeoViewCut}
+     */
+    get virtual_geometry_cut() {
+        return this.#virtual_geometry_cut;
+    }
+
     /**
      *
      * @return {GPUCameraContext}
@@ -284,6 +301,8 @@ export class GPUViewContext {
 
         this.#volumetrics = new GPUViewVolumetrics(this, device);
 
+        this.#virtual_geometry_cut = new VGeoViewCut({ device, label: this.label });
+
     }
 
     /**
@@ -385,6 +404,8 @@ export class GPUViewContext {
         this.#hierarchical_z_buffer.destroy();
 
         this.#volumetrics.destroy();
+
+        this.#virtual_geometry_cut.destroy();
     }
 }
 

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AA0PA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAkgCd"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AA0PA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAykCd"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -1166,6 +1166,28 @@ export const WGSLLanguageCore = {
         return { old_value: old, exchanged: false };
     },
 
+    // ---------------------------------------------------------------------
+    // Runtime-sized arrays
+    // ---------------------------------------------------------------------
+
+    /**
+     * WGSL's `arrayLength(&a)` — how many elements of a runtime-sized array the *binding* covers.
+     *
+     * The compiler has already reduced `&a` to `a` itself, so what arrives is the bound value: a
+     * typed array, or a plain array for a binding of structs. Its length is the answer, and the
+     * binding a spec supplies is therefore what decides it — which is the point. Every collection
+     * in this engine is a `count` in front of a runtime-sized `elements`, and the count is produced
+     * by an unconditional `atomicAdd` whose element write alone is bounded, so the count can run
+     * past what the collection holds. `min(count, arrayLength(&elements))` is how a consumer reads
+     * such a collection, and without this a kernel that does so could not be emulated at all.
+     *
+     * @param {ArrayLike<*>} a
+     * @returns {number}
+     */
+    arrayLength(a) {
+        return a.length;
+    },
+
     // ---------------------------------------------------------------------
     // Barriers — no-ops when running pointwise (one thread).
     // ---------------------------------------------------------------------
@@ -1187,12 +1209,61 @@ export const WGSLLanguageCore = {
     // pointwise there is exactly one, so the answer is the caller's own value — which is also the
     // only value a shader can soundly rely on it for: one that broadcasts something its lanes
     // disagree on has made its result depend on which lane the hardware counts as first, and no
-    // CPU model reproduces that. The rest of the family — ballots, reductions, shuffles — stays
-    // unsupported on purpose: a reduction over one lane would pass tests a real wave fails, which
-    // is worse than throwing.
+    // CPU model reproduces that.
+    //
+    // The reductions and the shuffle below are the same identity, and they were left out on the
+    // argument that "a reduction over one lane would pass tests a real wave fails". That argument
+    // is right about what they cover and wrong about the alternative, because there is no
+    // alternative: a subgroup kernel has to be correct at **every** width, WGSL promising nothing
+    // about which one a device hands it, and one is a width a device may hand it. Refusing to model
+    // it does not test the wide case — it leaves the kernel with no CPU-tier coverage at all,
+    // including of the part that has nothing to do with width.
+    //
+    // So: width one is a configuration, not a stand-in for a wave. What these cover is a kernel's
+    // *semantics* at that width. What they cannot cover is the redistribution itself — whether
+    // lanes pack their neighbours' work correctly — and that needs a real device and a test that
+    // varies the counts across lanes. Anything relying on more than one lane being live must say so
+    // and be tested there.
+    //
+    // A shader that would diverge between width one and width thirty-two is a shader that has read
+    // something other than its own lane's value out of these, and that is exactly what the wide
+    // test is for.
 
     subgroupBroadcastFirst(value) { return value; },
 
+    // The reduction over a subgroup of one is that one's value.
+    subgroupAdd(value) { return value; },
+    subgroupMul(value) { return value; },
+    subgroupMin(value) { return value; },
+    subgroupMax(value) { return value; },
+    subgroupAnd(value) { return value; },
+    subgroupOr(value) { return value; },
+    subgroupXor(value) { return value; },
+
+    // Scans: exclusive of the only lane is the identity, inclusive of it is its value.
+    subgroupExclusiveAdd() { return 0; },
+    subgroupExclusiveMul() { return 1; },
+    subgroupInclusiveAdd(value) { return value; },
+    subgroupInclusiveMul(value) { return value; },
+
+    // Lane 0 is the only lane, so it is elected and it is the only one a shuffle can name. An `id`
+    // of anything else is reading a lane that does not exist, which on a device is an undefined
+    // value rather than an error — here it is an error, because a CPU model that invents one is how
+    // a kernel indexing lanes by arithmetic passes.
+    subgroupElect() { return true; },
+
+    subgroupShuffle(value, id) {
+        if (id !== 0) {
+            throw new Error(
+                `subgroupShuffle(e, ${id}): the emulated subgroup is one lane wide, so 0 is the only`
+                + ` lane there is to read. A kernel that needs a wider one has to be tested on a`
+                + ` device.`
+            );
+        }
+
+        return value;
+    },
+
     // ---------------------------------------------------------------------
     // Fragment-stage derivatives — unsupported because we run a single pixel.
     // ---------------------------------------------------------------------