@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/texture/draw_texture_as_rgba.js

@@ -81,6 +81,8 @@ function wgsl_decode_sample(source, sample_name) {
 }
 
 /**
+ * Draw a 2-D texture as RGBA. One slice of a 3-D texture is drawn by
+ * {@link graph_draw_texture_3d_slice_as_rgba} instead.
  *
  * @param {Object} options
  * @param {FrameGraph} options.graph

package/src/shade/renderer/texture/graph_draw_texture_3d_slice_as_rgba.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Draw one axis-aligned slice of a 3-D texture into a new texture, for debugging: the slice at
+ * `slice` along `axis`, read at `mip_level`, each texel times `scale` plus `bias`, per channel.
+ *
+ * Every option is required. Where the slice lands on the output, and which formats it reads, is
+ * {@link shader_draw_texture_3d_slice_as_rgba}'s; a 2-D texture is `graph_draw_texture_as_rgba`'s.
+ *
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {number} options.source the graph resource of a 3-D texture whose format reads as f32
+ * @param {number[]} options.resolution of the output
+ * @param {number} options.axis 0, 1 or 2: x, y or z, the axis the slice is taken across
+ * @param {number} options.slice the texel index along `axis`, at `mip_level`
+ * @param {number} options.mip_level
+ * @param {number[]} options.scale rgba, what each channel of a texel is multiplied by
+ * @param {number[]} options.bias rgba, what is added to each channel after
+ * @param {GPUTextureFormat} options.output_format
+ * @returns {number} the output texture's graph resource
+ */
+export function graph_draw_texture_3d_slice_as_rgba({ graph, source, resolution, axis, slice, mip_level, scale, bias, output_format, }: {
+    graph: FrameGraph;
+    source: number;
+    resolution: number[];
+    axis: number;
+    slice: number;
+    mip_level: number;
+    scale: number[];
+    bias: number[];
+    output_format: GPUTextureFormat;
+}): number;
+//# sourceMappingURL=graph_draw_texture_3d_slice_as_rgba.d.ts.map

package/src/shade/renderer/texture/graph_draw_texture_3d_slice_as_rgba.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph_draw_texture_3d_slice_as_rgba.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/graph_draw_texture_3d_slice_as_rgba.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAX+B,KAAK;IACT,MAAM,EAAtB,MAAM;IACY,UAAU,EAA5B,MAAM,EAAE;IACQ,IAAI,EAApB,MAAM;IACU,KAAK,EAArB,MAAM;IACU,SAAS,EAAzB,MAAM;IACY,KAAK,EAAvB,MAAM,EAAE;IACU,IAAI,EAAtB,MAAM,EAAE;IACkB,aAAa;IACrC,MAAM,CAiFlB"}

package/src/shade/renderer/texture/graph_draw_texture_3d_slice_as_rgba.js

@@ -0,0 +1,116 @@
+import { assert } from "../../../core/assert.js";
+import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
+import { gpu_texture_format_numeric_type } from "./format/gpu_texture_format_numeric_type.js";
+import { TextureNumericType } from "./format/TextureNumericType.js";
+import { shader_draw_texture_3d_slice_as_rgba } from "./shader_draw_texture_3d_slice_as_rgba.js";
+
+/**
+ * Number formats a `texture_3d<f32>` binding reads.
+ *
+ * @type {TextureNumericType[]}
+ */
+const READABLE_AS_F32 = [
+    TextureNumericType.Float,
+    TextureNumericType.NormalizedUnsignedInteger,
+    TextureNumericType.NormalizedSignedInteger,
+];
+
+/**
+ * Draw one axis-aligned slice of a 3-D texture into a new texture, for debugging: the slice at
+ * `slice` along `axis`, read at `mip_level`, each texel times `scale` plus `bias`, per channel.
+ *
+ * Every option is required. Where the slice lands on the output, and which formats it reads, is
+ * {@link shader_draw_texture_3d_slice_as_rgba}'s; a 2-D texture is `graph_draw_texture_as_rgba`'s.
+ *
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {number} options.source the graph resource of a 3-D texture whose format reads as f32
+ * @param {number[]} options.resolution of the output
+ * @param {number} options.axis 0, 1 or 2: x, y or z, the axis the slice is taken across
+ * @param {number} options.slice the texel index along `axis`, at `mip_level`
+ * @param {number} options.mip_level
+ * @param {number[]} options.scale rgba, what each channel of a texel is multiplied by
+ * @param {number[]} options.bias rgba, what is added to each channel after
+ * @param {GPUTextureFormat} options.output_format
+ * @returns {number} the output texture's graph resource
+ */
+export function graph_draw_texture_3d_slice_as_rgba({
+                                                        graph,
+                                                        source,
+                                                        resolution,
+                                                        axis,
+                                                        slice,
+                                                        mip_level,
+                                                        scale,
+                                                        bias,
+                                                        output_format,
+                                                    }) {
+    assert.defined(graph, 'graph');
+    assert.isNonNegativeInteger(source, 'source');
+    assert.isArrayLike(resolution, 'resolution');
+    assert.isOneOf(axis, [0, 1, 2], 'axis');
+    assert.isNonNegativeInteger(slice, 'slice');
+    assert.isNonNegativeInteger(mip_level, 'mip_level');
+    assert.isArrayLike(scale, 'scale');
+    assert.equal(scale.length, 4, 'scale.length');
+    assert.isArrayLike(bias, 'bias');
+    assert.equal(bias.length, 4, 'bias.length');
+    assert.isString(output_format, 'output_format');
+
+    const settings = { scale, bias, axis, slice, mip_level };
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+        /**
+         * @type {GPUTextureContext}
+         */
+        const input = resources.get(data.input);
+        /**
+         * @type {GPUTextureContext}
+         */
+        const output = resources.get(data.output);
+
+        const texture = input.gpu_texture;
+
+        assert.equal(texture.dimension, "3d", 'source dimension');
+        assert.isOneOf(gpu_texture_format_numeric_type[texture.format], READABLE_AS_F32, 'source number format');
+        assert.lessThan(mip_level, texture.mipLevelCount, 'mip_level');
+        assert.lessThan(
+            slice,
+            Math.max(1, (axis === 0 ? texture.width : axis === 1 ? texture.height : texture.depthOrArrayLayers) >> mip_level),
+            'slice'
+        );
+
+        shader_draw_texture_3d_slice_as_rgba.draw({
+            encoder: context.encoder,
+            bindings: {
+                source: input,
+                settings,
+            },
+            colorAttachments: [{
+                view: output.obtainView(),
+                clearValue: [0, 0, 0, 0],
+                loadOp: "clear",
+                storeOp: "store",
+            }],
+            color_formats: [output_format],
+        });
+    }
+
+    const data = {};
+    const pass = graph.add("debug texture 3d slice draw", data, execute);
+
+    data.input = pass.read(source);
+    data.output = pass.create("out", TextureResourceDescriptor.from({
+        resolution,
+        format: output_format,
+        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+    }));
+
+    return data.output;
+}

package/src/shade/renderer/texture/shader_draw_texture_3d_slice_as_rgba.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Which slice of the volume {@link shader_draw_texture_3d_slice_as_rgba} draws, and how its texels
+ * become colour.
+ *
+ * - `scale`, `bias`: per channel, rgba — the texel times `scale`, plus `bias`. A signed field in
+ *   [-m, m] lands on [0, 1] with a scale of `0.5 / m` and a bias of 0.5. A texture with fewer than
+ *   four channels reads 0 in the missing colour channels and 1 in alpha, before either is applied.
+ * - `axis`: 0, 1 or 2 — x, y or z, the axis the slice is taken across.
+ * - `slice`: the texel index along `axis`, at `mip_level`.
+ * - `mip_level`: the level the slice is read from.
+ *
+ * @type {WebGPUStruct}
+ */
+export const DRAW_TEXTURE_3D_SLICE_SETTINGS_STRUCT: WebGPUStruct;
+/**
+ * Draw one axis-aligned slice of a 3-D texture as colour: a full-target pass over the slice, nearest
+ * texel, each texel scaled and biased per channel so a signed field, a velocity component say, can be
+ * seen. The output's u runs along the first of the two axes the slice spans and v, down the target,
+ * along the second: x then y across z, x then z across y, y then z across x.
+ *
+ * Binds a `texture_3d<f32>` as `unfilterable-float`, so it reads any float, unorm or snorm format,
+ * `r32float` among them; integer and depth formats are not drawn. The settings are immediate data,
+ * {@link DRAW_TEXTURE_3D_SLICE_SETTINGS_STRUCT}.
+ *
+ * The 3-D sibling of `draw_texture_as_rgba`, which draws a 2-D texture and decodes its format;
+ * driven through `graph_draw_texture_3d_slice_as_rgba`.
+ *
+ * @type {ImageShader}
+ */
+export const shader_draw_texture_3d_slice_as_rgba: ImageShader;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ImageShader } from "../shader/ImageShader.js";
+//# sourceMappingURL=shader_draw_texture_3d_slice_as_rgba.d.ts.map

package/src/shade/renderer/texture/shader_draw_texture_3d_slice_as_rgba.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_draw_texture_3d_slice_as_rgba.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/shader_draw_texture_3d_slice_as_rgba.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;GAYG;AACH,oDAFU,YAAY,CAQW;AAqCjC;;;;;;;;;;;;;;GAcG;AACH,mDAFU,WAAW,CAalB;6BApF0B,gCAAgC;4BAJjC,0BAA0B"}

package/src/shade/renderer/texture/shader_draw_texture_3d_slice_as_rgba.js

@@ -0,0 +1,90 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+import { u32, vec4f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+
+/**
+ * Which slice of the volume {@link shader_draw_texture_3d_slice_as_rgba} draws, and how its texels
+ * become colour.
+ *
+ * - `scale`, `bias`: per channel, rgba — the texel times `scale`, plus `bias`. A signed field in
+ *   [-m, m] lands on [0, 1] with a scale of `0.5 / m` and a bias of 0.5. A texture with fewer than
+ *   four channels reads 0 in the missing colour channels and 1 in alpha, before either is applied.
+ * - `axis`: 0, 1 or 2 — x, y or z, the axis the slice is taken across.
+ * - `slice`: the texel index along `axis`, at `mip_level`.
+ * - `mip_level`: the level the slice is read from.
+ *
+ * @type {WebGPUStruct}
+ */
+export const DRAW_TEXTURE_3D_SLICE_SETTINGS_STRUCT = WebGPUStruct.from({
+    scale: vec4f,
+    bias: vec4f,
+    axis: u32,
+    slice: u32,
+    mip_level: u32,
+}, "DrawTexture3DSliceSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-draw, 48 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", DRAW_TEXTURE_3D_SLICE_SETTINGS_STRUCT);
+
+resources.createGroup()
+    .addTexture("source", "unfilterable-float", "3d");
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @location(0) uv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+
+    let size = textureDimensions(source, settings.mip_level);
+
+    let across_x = settings.axis == 0u;
+    let across_y = settings.axis == 1u;
+
+    // the two axes the slice spans, in order: y and z across x, x and z across y, x and y across z
+    let plane = select(select(size.xy, size.xz, across_y), size.yz, across_x);
+
+    // nearest texel: a debug view shows cells as they are
+    let p = min(vec2<u32>(uv * vec2<f32>(plane)), plane - 1u);
+
+    let s = settings.slice;
+
+    let texel = select(select(vec3<u32>(p, s), vec3<u32>(p.x, s, p.y), across_y), vec3<u32>(s, p), across_x);
+
+    return textureLoad(source, texel, settings.mip_level) * settings.scale + settings.bias;
+}
+`);
+
+/**
+ * Draw one axis-aligned slice of a 3-D texture as colour: a full-target pass over the slice, nearest
+ * texel, each texel scaled and biased per channel so a signed field, a velocity component say, can be
+ * seen. The output's u runs along the first of the two axes the slice spans and v, down the target,
+ * along the second: x then y across z, x then z across y, y then z across x.
+ *
+ * Binds a `texture_3d<f32>` as `unfilterable-float`, so it reads any float, unorm or snorm format,
+ * `r32float` among them; integer and depth formats are not drawn. The settings are immediate data,
+ * {@link DRAW_TEXTURE_3D_SLICE_SETTINGS_STRUCT}.
+ *
+ * The 3-D sibling of `draw_texture_as_rgba`, which draws a 2-D texture and decodes its format;
+ * driven through `graph_draw_texture_3d_slice_as_rgba`.
+ *
+ * @type {ImageShader}
+ */
+export const shader_draw_texture_3d_slice_as_rgba = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Draw Texture 3D Slice as RGBA",
+        body,
+        resources,
+    }),
+    targets: [
+        {
+            format: "rgba8unorm"
+        }
+    ]
+});

package/src/shade/renderer/texture/util/ZERO_UINT_PIXEL_TEXTURE.d.ts

@@ -0,0 +1,10 @@
+/**
+ * One `r32uint` texel of 0: the default of a `uint` texture binding, for a pass that has nothing to
+ * bind there, as `BLACK_PIXEL_TEXTURE` is for a float one. A `uint` binding cannot take a float
+ * texture. Packed formats read 0 as black: rgb9e5 does.
+ *
+ * @type {ShadeTexture}
+ */
+export const ZERO_UINT_PIXEL_TEXTURE: ShadeTexture;
+import { ShadeTexture } from "../ShadeTexture.js";
+//# sourceMappingURL=ZERO_UINT_PIXEL_TEXTURE.d.ts.map

package/src/shade/renderer/texture/util/ZERO_UINT_PIXEL_TEXTURE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZERO_UINT_PIXEL_TEXTURE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/util/ZERO_UINT_PIXEL_TEXTURE.js"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH,sCAFU,YAAY,CAE0C;6BAnBnC,oBAAoB"}

package/src/shade/renderer/texture/util/ZERO_UINT_PIXEL_TEXTURE.js

@@ -0,0 +1,33 @@
+import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
+import { ColorSpace } from "../ColorSpace.js";
+import { ShadeTexture } from "../ShadeTexture.js";
+import { ShadeTextureFlags } from "../ShadeTextureFlags.js";
+import { ShadeImage } from "../source/ShadeImage.js";
+import { TextureFilterType } from "../TextureFilterType.js";
+import { TextureWrapType } from "../TextureWrapType.js";
+
+const image = ShadeImage.fromSampler2D(Sampler2D.uint32(1, 1, 1));
+
+// non-colour data, read as integers
+image.color_space = ColorSpace.None;
+image.normalized = false;
+
+/**
+ * One `r32uint` texel of 0: the default of a `uint` texture binding, for a pass that has nothing to
+ * bind there, as `BLACK_PIXEL_TEXTURE` is for a float one. A `uint` binding cannot take a float
+ * texture. Packed formats read 0 as black: rgb9e5 does.
+ *
+ * @type {ShadeTexture}
+ */
+export const ZERO_UINT_PIXEL_TEXTURE = ShadeTexture.from(image);
+
+ZERO_UINT_PIXEL_TEXTURE.label = "zero uint";
+
+ZERO_UINT_PIXEL_TEXTURE.wrapS = TextureWrapType.ClampToEdge;
+ZERO_UINT_PIXEL_TEXTURE.wrapT = TextureWrapType.ClampToEdge;
+
+ZERO_UINT_PIXEL_TEXTURE.minFilter = TextureFilterType.Nearest;
+ZERO_UINT_PIXEL_TEXTURE.magFilter = TextureFilterType.Nearest;
+ZERO_UINT_PIXEL_TEXTURE.mipmapFilter = TextureFilterType.Nearest;
+
+ZERO_UINT_PIXEL_TEXTURE.clearFlag(ShadeTextureFlags.GenerateMipMaps);

package/src/shade/renderer/view/VIEW_RESOURCE.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The view's uniforms (`VIEW_UNIFORM_STRUCT`), as the chunks that read them declare them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const VIEW_RESOURCE: ShaderResourceDescriptor;
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
+//# sourceMappingURL=VIEW_RESOURCE.d.ts.map

package/src/shade/renderer/view/VIEW_RESOURCE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VIEW_RESOURCE.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/view/VIEW_RESOURCE.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,4BAFU,wBAAwB,CAEyD;yCAPlD,gDAAgD"}

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

@@ -0,0 +1,8 @@
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
+import { VIEW_UNIFORM_STRUCT } from "./VIEW_UNIFORM_STRUCT.js";
+
+/**
+ * The view's uniforms (`VIEW_UNIFORM_STRUCT`), as the chunks that read them declare them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const VIEW_RESOURCE = ShaderResourceDescriptor.uniform("view", VIEW_UNIFORM_STRUCT);

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

@@ -11,10 +11,13 @@
  * of their own.
  *
  * The table is written whole whenever {@link SceneVolumetrics#version} moves — cleared and refilled
- * in the scene's volume order — and not at all otherwise; the scene database's own update, later in
- * the same frame, takes the rows to the GPU. The rows are dense from 0, which the passes' walk over
- * `[0, participating_media_volumes_count)` relies on. A volume whose transform has no inverse —
- * scaled to nothing on an axis — gets no row.
+ * in the scene's volume order. While only {@link SceneVolumetrics#noise_version} moves, each row whose
+ * noise phases differ from what was last written gets those seven words and nothing else, through the
+ * table's partial stream (`set_fields`): a scrolling field costs a few words a volume a frame, not a
+ * table rebuild with an inversion a volume. Otherwise nothing is written. The scene database's own
+ * update, later in the same frame, takes the rows to the GPU. The rows are dense from 0, which the
+ * passes' walk over `[0, participating_media_volumes_count)` relies on. A volume whose transform has
+ * no inverse — scaled to nothing on an axis — gets no row.
  *
  * **The noise atlas lives here too.** Every volume's noise is a tile of one 3-D atlas the passes
  * bind beside the scene database, and the atlas is this scene's: slot 0 is the engine's own tile,

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

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUSceneVolumetrics.js"],"names":[],"mappings":"AAoBA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IAEI;;;;;OAKG;IACH,iCAFW,eAAe,QAIzB;IA2BD;;;;;OAKG;IACH,kHAFW,gBAAgB,EA2B1B;IAxDD;;OAEG;IACH,QAFU,gBAAgB,CAEpB;IAuDN;;;;;OAKG;IACH,kCAEC;IAED;;OAEG;IACH,gBAEC;IAED;;;;OAIG;IACH,YAHW,eAAe,gBACf,MAAM,QAqEhB;;CACJ;8BAxLY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;+BAC/C,OAAO,uBAAuB,EAAE,gBAAgB;;+BApB9B,oCAAoC"}
+{"version":3,"file":"GPUSceneVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUSceneVolumetrics.js"],"names":[],"mappings":"AA+BA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAEI;;;;;OAKG;IACH,iCAFW,eAAe,QAIzB;IAsDD;;;;;OAKG;IACH,kHAFW,gBAAgB,EA4B1B;IApFD;;OAEG;IACH,QAFU,gBAAgB,CAEpB;IAmFN;;;;;OAKG;IACH,kCAEC;IAED;;OAEG;IACH,gBAEC;IAED;;;;OAIG;IACH,YAHW,eAAe,gBACf,MAAM,QAuChB;;CAwKJ;8BAhWY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;+BAC/C,OAAO,uBAAuB,EAAE,gBAAgB;;+BA9B9B,oCAAoC"}

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

@@ -1,6 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import { m4_invert } from "../../../core/geom/3d/mat4/m4_invert.js";
 import { ShadeGPUCommandContext } from "../../device/ShadeGPUCommandContext.js";
+import { generate_record_writer } from "../buffer/table/serde/generate_record_writer.js";
 import { GPUTileAtlas3D } from "../texture/atlas/GPUTileAtlas3D.js";
 import {
     bake_volumetrics_noise_tile,
@@ -17,6 +18,16 @@ import {
     PARTICIPATING_MEDIA_NOISE_TILE_CONTENT_SIZE,
     PARTICIPATING_MEDIA_NOISE_TILE_FORMAT
 } from "./noise/PARTICIPATING_MEDIA_NOISE.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "./PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+
+/**
+ * A row's noise phases, the only words of it a scrolling field changes from frame to frame.
+ * @type {import("../buffer/table/serde/generate_record_writer.js").GPURecordWriter}
+ */
+const NOISE_PHASE_WRITER = generate_record_writer(PARTICIPATING_MEDIA_VOLUME_STRUCT, ['noise_flow_phase', 'noise_offset', 'noise_warp_offset']);
+
+/** `noise_offset` and `noise_warp_offset`, three floats each, and `noise_flow_phase`. */
+const NOISE_PHASE_WORDS = 7;
 
 /**
  * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
@@ -32,10 +43,13 @@ import {
  * of their own.
  *
  * The table is written whole whenever {@link SceneVolumetrics#version} moves — cleared and refilled
- * in the scene's volume order — and not at all otherwise; the scene database's own update, later in
- * the same frame, takes the rows to the GPU. The rows are dense from 0, which the passes' walk over
- * `[0, participating_media_volumes_count)` relies on. A volume whose transform has no inverse —
- * scaled to nothing on an axis — gets no row.
+ * in the scene's volume order. While only {@link SceneVolumetrics#noise_version} moves, each row whose
+ * noise phases differ from what was last written gets those seven words and nothing else, through the
+ * table's partial stream (`set_fields`): a scrolling field costs a few words a volume a frame, not a
+ * table rebuild with an inversion a volume. Otherwise nothing is written. The scene database's own
+ * update, later in the same frame, takes the rows to the GPU. The rows are dense from 0, which the
+ * passes' walk over `[0, participating_media_volumes_count)` relies on. A volume whose transform has
+ * no inverse — scaled to nothing on an axis — gets no row.
  *
  * **The noise atlas lives here too.** Every volume's noise is a tile of one 3-D atlas the passes
  * bind beside the scene database, and the atlas is this scene's: slot 0 is the engine's own tile,
@@ -62,6 +76,33 @@ export class GPUSceneVolumetrics {
 
     #version = -1;
 
+    /** The {@link SceneVolumetrics#noise_version} the rows' phases were last brought up to. */
+    #noise_version = -1;
+
+    /**
+     * Each volume's row as {@link #repack} placed it, by the volume's index, -1 for one with no row.
+     * Grown by the repack, never shrunk.
+     * @type {Int32Array}
+     */
+    #rows = new Int32Array(16);
+
+    /**
+     * The phases each volume's row holds, as f32, {@link NOISE_PHASE_WORDS} a volume by its index:
+     * `noise_offset`, `noise_warp_offset`, then `noise_flow_phase`.
+     * @type {Float32Array}
+     */
+    #written_phases = new Float32Array(16 * NOISE_PHASE_WORDS);
+
+    /** What {@link NOISE_PHASE_WRITER} is handed, reused for every row. */
+    #phase_record = {
+        noise_flow_phase: 0,
+        noise_offset: new Float32Array(3),
+        noise_warp_offset: new Float32Array(3),
+    };
+
+    /** The repack's scratch for each volume's inverse transform. */
+    #transform_inverse = new Float32Array(16);
+
     /**
      * The scene database's `participating_media_volumes` table; owned by the database.
      * @type {GPUTypedTable}
@@ -97,7 +138,8 @@ export class GPUSceneVolumetrics {
         this.#noise_atlas = new GPUTileAtlas3D({
             device,
             format: PARTICIPATING_MEDIA_NOISE_TILE_FORMAT,
-            content_size: PARTICIPATING_MEDIA_NOISE_TILE_CONTENT_SIZE,
+            // a cube: the bake makes the same number of features along every edge
+            content_size: [PARTICIPATING_MEDIA_NOISE_TILE_CONTENT_SIZE, PARTICIPATING_MEDIA_NOISE_TILE_CONTENT_SIZE, PARTICIPATING_MEDIA_NOISE_TILE_CONTENT_SIZE],
             border: PARTICIPATING_MEDIA_NOISE_TILE_BORDER,
             slots_x: PARTICIPATING_MEDIA_NOISE_ATLAS_SLOTS_X,
             slots_y: PARTICIPATING_MEDIA_NOISE_ATLAS_SLOTS_Y,
@@ -155,23 +197,150 @@ export class GPUSceneVolumetrics {
             this.#default_baked = true;
         }
 
-        if (this.#version === this.source.version) {
-            // no change
+        const source = this.source;
+
+        if (this.#version !== source.version) {
+            this.#repack();
+
+            this.#version = source.version;
+            // the repack wrote the phases as they stand
+            this.#noise_version = source.noise_version;
+
             return;
         }
 
+        if (this.#noise_version !== source.noise_version) {
+            this.#write_phases();
+
+            this.#noise_version = source.noise_version;
+        }
+    }
+
+    /**
+     * Every row's noise phases that differ from what this last wrote for it, and nothing else:
+     * {@link NOISE_PHASE_WRITER}'s words per changed row, through the table's partial stream.
+     *
+     * Compared while assigned, as f32 — the precision the row holds — against
+     * {@link #written_phases}, so a noisy volume that is not scrolling writes nothing. The volumes
+     * are the ones {@link #repack} packed, in the same order: adding or removing one moves the
+     * version, which repacks instead.
+     */
+    #write_phases() {
+        const table = this.#table;
+        const volumes = this.source.volumes;
+        const rows = this.#rows;
+        const written = this.#written_phases;
+        const record = this.#phase_record;
+        const offset_out = record.noise_offset;
+        const warp_out = record.noise_warp_offset;
+
+        const count = volumes.length;
+
+        for (let i = 0; i < count; i++) {
+            const row = rows[i];
+
+            if (row < 0) {
+                // no row: scaled to nothing on an axis
+                continue;
+            }
+
+            const v = volumes[i];
+            const offset = v.noise_offset;
+            const warp = v.noise_warp_offset;
+            const base = i * NOISE_PHASE_WORDS;
+
+            let changed = false;
+
+            const o0 = Math.fround(offset[0]);
+            const o1 = Math.fround(offset[1]);
+            const o2 = Math.fround(offset[2]);
+            const w0 = Math.fround(warp[0]);
+            const w1 = Math.fround(warp[1]);
+            const w2 = Math.fround(warp[2]);
+            const flow = Math.fround(v.noise_flow_phase);
+
+            if (written[base] !== o0) {
+                written[base] = o0;
+                changed = true;
+            }
+
+            if (written[base + 1] !== o1) {
+                written[base + 1] = o1;
+                changed = true;
+            }
+
+            if (written[base + 2] !== o2) {
+                written[base + 2] = o2;
+                changed = true;
+            }
+
+            if (written[base + 3] !== w0) {
+                written[base + 3] = w0;
+                changed = true;
+            }
+
+            if (written[base + 4] !== w1) {
+                written[base + 4] = w1;
+                changed = true;
+            }
+
+            if (written[base + 5] !== w2) {
+                written[base + 5] = w2;
+                changed = true;
+            }
+
+            if (written[base + 6] !== flow) {
+                written[base + 6] = flow;
+                changed = true;
+            }
+
+            if (!changed) {
+                continue;
+            }
+
+            offset_out[0] = o0;
+            offset_out[1] = o1;
+            offset_out[2] = o2;
+            warp_out[0] = w0;
+            warp_out[1] = w1;
+            warp_out[2] = w2;
+            record.noise_flow_phase = flow;
+
+            table.set_fields(row, record, NOISE_PHASE_WRITER);
+        }
+    }
+
+    /**
+     * The whole table, cleared and refilled in the scene's volume order, dense from row 0; each
+     * volume's row and phases remembered for {@link #write_phases}.
+     */
+    #repack() {
         const table = this.#table;
 
         table.clear();
 
-        const m4_transform_inverse = new Float32Array(16);
+        const m4_transform_inverse = this.#transform_inverse;
 
         const volumes = this.source.volumes;
+        const count = volumes.length;
 
-        for (let i = 0; i < volumes.length; i++) {
+        if (this.#rows.length < count) {
+            const capacity = Math.max(count, 2 * this.#rows.length);
+
+            this.#rows = new Int32Array(capacity);
+            this.#written_phases = new Float32Array(capacity * NOISE_PHASE_WORDS);
+        }
+
+        const rows = this.#rows;
+        const written = this.#written_phases;
+
+        for (let i = 0; i < count; i++) {
             const v = volumes[i];
 
-            if (!m4_invert(m4_transform_inverse, v.transform.matrix)) {
+            rows[i] = -1;
+
+            // the transform itself: its matrix is its first sixteen elements
+            if (!m4_invert(m4_transform_inverse, v.transform)) {
                 // scaled to nothing on an axis: it encloses nothing, and without an inverse every
                 // pass would place it wrong — an all-zero matrix puts the whole world inside it
                 continue;
@@ -180,7 +349,17 @@ export class GPUSceneVolumetrics {
             assert.greaterThan(v.noise_scale, 0, 'noise_scale must be positive');
             assert.ok(this.#noise_atlas.is_live(v.noise_slot), `noise_slot ${v.noise_slot} is not an allocated tile of this scene's noise atlas`);
 
-            table.add({
+            const base = i * NOISE_PHASE_WORDS;
+
+            written[base] = Math.fround(v.noise_offset[0]);
+            written[base + 1] = Math.fround(v.noise_offset[1]);
+            written[base + 2] = Math.fround(v.noise_offset[2]);
+            written[base + 3] = Math.fround(v.noise_warp_offset[0]);
+            written[base + 4] = Math.fround(v.noise_warp_offset[1]);
+            written[base + 5] = Math.fround(v.noise_warp_offset[2]);
+            written[base + 6] = Math.fround(v.noise_flow_phase);
+
+            rows[i] = table.add({
                 particle_spec: {
                     scattering: v.particle_spec.scattering,
                     extinction: v.particle_spec.extinction,
@@ -192,6 +371,8 @@ export class GPUSceneVolumetrics {
                 transform_inverse: m4_transform_inverse,
                 fade_distance: v.fade_distance,
                 density: v.density,
+                noise_wind_factor: v.noise_wind_factor,
+                noise_flow_phase: v.noise_flow_phase,
                 noise_offset: v.noise_offset,
                 noise_warp_offset: v.noise_warp_offset,
                 noise_slot: v.noise_slot,
@@ -200,7 +381,5 @@ export class GPUSceneVolumetrics {
                 noise_warp: v.noise_warp,
             });
         }
-
-        this.#version = this.source.version;
     }
 }