@woosh/meep-engine 3.41.0 → 3.43.0

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.js

@@ -0,0 +1,39 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_complex_multiply } from "../complex/chunk_complex_multiply.js";
+
+/**
+ * Four unnormalized inverse discrete Fourier transforms of 128 complex values, cooperatively by a workgroup of
+ * 256 invocations: `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}` for each of the four lines of `fft128x4_lines`.
+ *
+ * The caller writes each line's input in bit-reversed order (`X[n]` at `reverseBits(n) >> 25`), calls
+ * `fft128x4_inverse(lane)` from every invocation in uniform control flow, and reads the output in natural order.
+ * Radix-2 decimation in time: seven stages, each invocation one butterfly of one line a stage, a barrier
+ * between stages. The values live in 4 KiB of workgroup memory instead of a private array per invocation, which
+ * a 128-point line spills to local memory.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128x4_inverse_workgroup = CodeChunk.from(
+    //language=WGSL
+    `
+var<workgroup> fft128x4_lines: array<vec2<f32>, 512>;
+
+fn fft128x4_inverse(lane: u32) {
+    let line = (lane >> 6u) << 7u;
+    let k = lane & 63u;
+    for (var stage = 0u; stage < 7u; stage++) {
+        workgroupBarrier();
+        let span = 1u << stage;
+        let offset = k & (span - 1u);
+        let i = line + ((k >> stage) << (stage + 1u)) + offset;
+        let j = i + span;
+        // e^{+iπ·offset/span}: the inverse transform's twiddle for a butterfly over 2·span values
+        let angle = 3.14159265358979 / f32(span) * f32(offset);
+        let t = complex_multiply(vec2<f32>(cos(angle), sin(angle)), fft128x4_lines[j]);
+        let u = fft128x4_lines[i];
+        fft128x4_lines[i] = u + t;
+        fft128x4_lines[j] = u - t;
+    }
+    workgroupBarrier();
+}
+`, [chunk_complex_multiply]);

package/src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderResourceSetDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js"],"names":[],"mappings":"AAuIA;IAoBI;;OAEG;IACH;cAFoB,MAAM;cAAQ,UAAU;MAI3C;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,SACN,UAAU,GAAC,MAAM,GAEf,IAAI,CAoDhB;IAED;;;OAGG;IACH,8CAEC;IAGD;;;OAGG;IACH,6CAEC;IAaD;;;;OAIG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED,+FAYC;IAED;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACW,KAAK,GAAtB,MAAM;QACJ,6BAA6B,CAsBzC;IAED;;;;OAIG;IACH,gBAHW,6BAA6B,GAC3B,OAAO,CAQnB;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAW/B;IAED;;OAEG;IACH,oCAFa,wBAAwB,CAiBpC;IAED;;;OAGG;IACH,yBAFY,EAAE,EAAE,CAcf;IAED;;;;OAIG;IACH,8BAHW,iBAAe,MAAM,GACnB,wBAAwB,CAMpC;IAED;;;;;OAKG;IACH,qCAHW,sBAAsB,GACpB,oBAAoB,EAAE,CAgBlC;IAED;;;OAGG;IACH,qBAFY,SAAS,CAwGpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,iCAHW,YAAY,GACV,OAAO,CAwFnB;;CACJ;;eA2BS,SAAS,2BAA2B,CAAC;;2BA1oBlC,OAAO,yCAAyC,EAAE,YAAY;qCAC9D,OAAO,2CAA2C,EAAE,sBAAsB;yBAC1E,OAAO,uBAAuB,EAAE,UAAU;8CALT,oCAAoC;yCAZzC,0DAA0D;0BAIzE,0BAA0B"}
+{"version":3,"file":"ShaderResourceSetDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js"],"names":[],"mappings":"AAyIA;IAoBI;;OAEG;IACH;cAFoB,MAAM;cAAQ,UAAU;MAI3C;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,SACN,UAAU,GAAC,MAAM,GAEf,IAAI,CAoDhB;IAED;;;OAGG;IACH,8CAEC;IAGD;;;OAGG;IACH,6CAEC;IAaD;;;;OAIG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED,+FAYC;IAED;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACW,KAAK,GAAtB,MAAM;QACJ,6BAA6B,CAsBzC;IAED;;;;OAIG;IACH,gBAHW,6BAA6B,GAC3B,OAAO,CAQnB;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAW/B;IAED;;OAEG;IACH,oCAFa,wBAAwB,CAiBpC;IAED;;;OAGG;IACH,yBAFY,EAAE,EAAE,CAcf;IAED;;;;OAIG;IACH,8BAHW,iBAAe,MAAM,GACnB,wBAAwB,CAMpC;IAED;;;;;OAKG;IACH,qCAHW,sBAAsB,GACpB,oBAAoB,EAAE,CAgBlC;IAED;;;OAGG;IACH,qBAFY,SAAS,CAwGpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,iCAHW,YAAY,GACV,OAAO,CAwFnB;;CACJ;;eA2BS,SAAS,2BAA2B,CAAC;;2BA5oBlC,OAAO,yCAAyC,EAAE,YAAY;qCAC9D,OAAO,2CAA2C,EAAE,sBAAsB;yBAC1E,OAAO,uBAAuB,EAAE,UAAU;8CALT,oCAAoC;yCAZzC,0DAA0D;0BAIzE,0BAA0B"}

package/src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js

@@ -83,6 +83,8 @@ function gen_type_storage_texture(member) {
 
     if (member.viewDimension === "2d") {
         proper_type = "texture_storage_2d"
+    } else if (member.viewDimension === "2d-array") {
+        proper_type = "texture_storage_2d_array";
     } else if (member.viewDimension === "3d") {
         proper_type = "texture_storage_3d";
     } else {

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts

@@ -34,7 +34,10 @@ export class GPUViewVolumetrics {
      *   module that starts the froxel irradiance volume
      * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number}}} the
      *   integrated aerial LUT, the metadata buffer, and the froxel irradiance volume
-     *   (chunk_volumetrics_irradiance_sh) for the transparent surfaces the lighting pass cannot see
+     *   (chunk_volumetrics_irradiance_sh) that lit particles are lit by. The two do not depend on
+     *   each other, and a pass building only one of them is culled when nothing reads it. A scene
+     *   with no participating-media volume records no fog at all, and `resolved` is then a constant:
+     *   no in-scatter, full transmittance.
      */
     graph_update({ graph, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, indirect_lighting_mode, }: {
         graph: FrameGraph;

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

@@ -1 +1 @@
-{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAiCA;IAkII;;;;OAIG;IACH,kBAHW,cAAc,qBAwBxB;IAxHD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IA6ND;;;;;;;;;;;;;OAaG;IACH;QAX+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;QAEjE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAyFvF;;CAEJ;yBApfY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAkCA;IA2II;;;;OAIG;IACH,kBAHW,cAAc,qBAyCxB;IAlJD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAkHD,gBAaC;IA6ND;;;;;;;;;;;;;;;;OAgBG;IACH;QAd+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;QAEjE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAmIvF;;CAEJ;yBA1jBY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc"}

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

@@ -10,6 +10,7 @@ import {
     build_volumetrics_sun_shadow_transform,
     volumetrics_sun_shadow_cascade_far
 } from "./build_volumetrics_sun_shadow_transform.js";
+import { graph_build_froxel_irradiance } from "./graph_build_froxel_irradiance.js";
 import { graph_build_volumetrics } from "./graph_build_volumetrics.js";
 import {
     VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT,
@@ -151,6 +152,15 @@ export class GPUViewVolumetrics {
      */
     #sun_shadow_cascade_far = new Float32Array(4);
 
+    /**
+     * What the fog integrates to through no medium: nothing in-scattered (.rgb 0), everything
+     * transmitted (.a 1). Handed out in place of the aerial LUT on a frame whose scene has no
+     * participating-media volume, so every surface that samples the fog keeps doing so and reads
+     * it as none, for one texel and no pass. Written once, at construction.
+     * @type {GPUTextureContext}
+     */
+    #no_medium;
+
     /**
      * @type {GPUTypedBuffer}
      */
@@ -181,6 +191,23 @@ export class GPUViewVolumetrics {
             this.#volumetrics_textures[i] = texture;
         }
 
+        const no_medium = new GPUTextureContext(device);
+        no_medium.descriptor.label = "volumetrics/no medium";
+        no_medium.descriptor.format = "rgba16float";
+        no_medium.descriptor.dimension = "3d";
+        no_medium.descriptor.size = [1, 1, 1];
+        no_medium.descriptor.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST;
+
+        device.queue.writeTexture(
+            { texture: no_medium.gpu_texture },
+            new Float16Array([0, 0, 0, 1]),
+            { bytesPerRow: 8, rowsPerImage: 1 },
+            [1, 1, 1]
+        );
+        no_medium.incrementVersion();
+
+        this.#no_medium = no_medium;
+
         this.#metadata = GPUTypedBuffer.create({
             type: VOLUMETRICS_METADATA_STRUCT,
             device,
@@ -200,6 +227,8 @@ export class GPUViewVolumetrics {
             textures[i] = null;
         }
 
+        this.#no_medium.destroy();
+
     }
 
     #update_resolution() {
@@ -433,7 +462,10 @@ export class GPUViewVolumetrics {
      *   module that starts the froxel irradiance volume
      * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number}}} the
      *   integrated aerial LUT, the metadata buffer, and the froxel irradiance volume
-     *   (chunk_volumetrics_irradiance_sh) for the transparent surfaces the lighting pass cannot see
+     *   (chunk_volumetrics_irradiance_sh) that lit particles are lit by. The two do not depend on
+     *   each other, and a pass building only one of them is culled when nothing reads it. A scene
+     *   with no participating-media volume records no fog at all, and `resolved` is then a constant:
+     *   no in-scatter, full transmittance.
      */
     graph_update({
                      graph,
@@ -479,6 +511,35 @@ export class GPUViewVolumetrics {
 
         const resolution = this.#volumetrics_textures[0].size;
 
+        // Particle lighting first, and on its own: it reads no medium. The frame graph culls it when
+        // nothing reads it.
+        const irradiance = graph_build_froxel_irradiance({
+            graph,
+            camera,
+            view,
+            lights,
+            light_cluster_data,
+            light_cluster_lookup,
+            light_cluster_parameters,
+            shadowmap_atlas,
+            volumetrics_metadata: gr_metadata,
+            resolution,
+            indirect_lighting_mode,
+        });
+
+        if (view.scene.volumetrics.source.volumes.length === 0) {
+            // No medium: nothing scatters and nothing absorbs, so the fog is the identity everywhere
+            // and the passes that would integrate it to that are not recorded. Nothing accumulates
+            // either, which leaves the history stale for whenever a volume arrives.
+            this.#reset_history = true;
+
+            return {
+                resolved: graph_import_texture(graph, this.#no_medium, "volumetrics no medium"),
+                metadata: gr_metadata,
+                irradiance,
+            };
+        }
+
         // Ping-pong the two persistent froxel textures: this frame writes [parity] and reads the
         // previous frame's accumulation from [parity ^ 1]. On the first frame / after a resize the
         // history is invalid, which #update_metadata signals via history_reset (the TAA then emits
@@ -493,16 +554,26 @@ export class GPUViewVolumetrics {
             taa_output = graph_import_texture(graph, this.#volumetrics_textures[parity], "volumetrics taa output");
         }
 
-        const { lut_aerial, irradiance } = graph_build_volumetrics({
+        /*
+         The sun's transmittance and the multiple scattering are the scene sky's, built once and
+         read from here on. Brought current now rather than in a pass: the sky submits commands of
+         its own, which land ahead of this frame's -- recorded into the frame graph they would be
+         paid every frame, which is what they used to be. A no-op after the first call.
+        */
+        const sky = view.scene.sky;
+
+        sky.update();
+
+        const { lut_aerial } = graph_build_volumetrics({
             graph,
             camera,
             lights,
             view,
+            sky,
             light_cluster_data,
             light_cluster_lookup,
             light_cluster_parameters,
             shadowmap_atlas,
-            indirect_lighting_mode,
 
             volumetrics_metadata: gr_metadata,
             volumetric_resolution: resolution,