@woosh/meep-engine 3.47.0 → 3.50.0

package/src/shade/renderer/texture/atlas/chunk_tile_atlas_slot_origin.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Texel origin of a slot's tile in a {@link GPUTileAtlas3D} — the corner of its skirt, not of its
+ * content — on the device: the WGSL twin of `GPUTileAtlas3D.slot_origin`, and the one place a
+ * shader finds a slot.
+ *
+ * Slot `s` sits at grid cell `index_to_grid3d(s, slots)`, x fastest and z slowest, and a cell is one
+ * tile along each axis, so the origin is the cell times `tile_size`, per axis.
+ *
+ * The footprint is the caller's to supply, as tiles along x and y: a shader that knows the tile
+ * size takes it from the texture itself, `textureDimensions(atlas).xy / tile_size.xy`, which is
+ * always the footprint the bound texture was built with; one that does not takes the atlas's
+ * `slots_x` and `slots_y` from a uniform the host refreshes after its last `allocate`. z is not an
+ * argument: the layer is whatever the slot index reaches.
+ *
+ * @see GPUTileAtlas3D
+ * @type {CodeChunk}
+ */
+export const chunk_tile_atlas_slot_origin: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_tile_atlas_slot_origin.d.ts.map

package/src/shade/renderer/texture/atlas/chunk_tile_atlas_slot_origin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_tile_atlas_slot_origin.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/atlas/chunk_tile_atlas_slot_origin.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,SAAS,CAWjB;0BA5BwB,oCAAoC"}

package/src/shade/renderer/texture/atlas/chunk_tile_atlas_slot_origin.js

@@ -0,0 +1,30 @@
+import { chunk_index_to_grid3d } from "../../shader/chunk/grid/chunk_index_to_grid3d.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Texel origin of a slot's tile in a {@link GPUTileAtlas3D} — the corner of its skirt, not of its
+ * content — on the device: the WGSL twin of `GPUTileAtlas3D.slot_origin`, and the one place a
+ * shader finds a slot.
+ *
+ * Slot `s` sits at grid cell `index_to_grid3d(s, slots)`, x fastest and z slowest, and a cell is one
+ * tile along each axis, so the origin is the cell times `tile_size`, per axis.
+ *
+ * The footprint is the caller's to supply, as tiles along x and y: a shader that knows the tile
+ * size takes it from the texture itself, `textureDimensions(atlas).xy / tile_size.xy`, which is
+ * always the footprint the bound texture was built with; one that does not takes the atlas's
+ * `slots_x` and `slots_y` from a uniform the host refreshes after its last `allocate`. z is not an
+ * argument: the layer is whatever the slot index reaches.
+ *
+ * @see GPUTileAtlas3D
+ * @type {CodeChunk}
+ */
+export const chunk_tile_atlas_slot_origin = CodeChunk.from(
+    //language=WGSL
+    `
+fn tile_atlas_slot_origin(slot: u32, slots: vec2<u32>, tile_size: vec3<u32>) -> vec3<u32> {
+    return index_to_grid3d(slot, slots) * tile_size;
+}
+`, [
+        chunk_index_to_grid3d,
+    ]
+);

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

@@ -1,4 +1,6 @@
 /**
+ * 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/draw_texture_as_rgba.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"draw_texture_as_rgba.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/draw_texture_as_rgba.js"],"names":[],"mappings":"AAkFA;;;;;;;;;GASG;AACH;IAP+B,KAAK;IACS,MAAM,EAAxC,MAAM,oBAAkB;IACN,UAAU,EAA5B,MAAM,EAAE;IACS,cAAc,GAA/B,MAAM;IACoB,YAAY;IACpC,MAAM,CA4DlB;AAGD;;;;;;;;GAQG;AACH;IANsC,OAAO;IACd,MAAM;IACT,cAAc,GAA/B,MAAM;IACc,MAAM;IACD,QAAQ;SAyJ3C"}
+{"version":3,"file":"draw_texture_as_rgba.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/draw_texture_as_rgba.js"],"names":[],"mappings":"AAkFA;;;;;;;;;;;GAWG;AACH;IAP+B,KAAK;IACS,MAAM,EAAxC,MAAM,oBAAkB;IACN,UAAU,EAA5B,MAAM,EAAE;IACS,cAAc,GAA/B,MAAM;IACoB,YAAY;IACpC,MAAM,CA4DlB;AAGD;;;;;;;;GAQG;AACH;IANsC,OAAO;IACd,MAAM;IACT,cAAc,GAA/B,MAAM;IACc,MAAM;IACD,QAAQ;SAyJ3C"}

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

@@ -1,4 +1,5 @@
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  * @typedef {import("./SceneVolumetrics.js").SceneVolumetrics} SceneVolumetrics
  * @typedef {import("../buffer/table/GPUTypedTable.js").GPUTypedTable} GPUTypedTable
@@ -10,24 +11,48 @@
  * 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,
+ * baked on the device the first time this updates, and the rest are whoever asked
+ * {@link noise_atlas} for them. Per scene rather than per device because a volume names its tile
+ * by slot, and the volumes are the scene's.
  */
 export class GPUSceneVolumetrics {
+    /**
+     * Offer the pipeline every scene's first {@link update} bakes its default noise tile with — see
+     * {@link PipelineEnquiry}. Fog itself is drawn by passes of the view, for a scene that has volumes.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      *
+     * @param {GPUDevice} device
      * @param {GPUTypedTable} table the scene database's `participating_media_volumes` table
      * @param {SceneVolumetrics} volumetrics
      */
-    constructor(table: import("../buffer/table/GPUTypedTable.js").GPUTypedTable<any>, volumetrics: SceneVolumetrics);
+    constructor(device: GPUDevice, table: import("../buffer/table/GPUTypedTable.js").GPUTypedTable<any>, volumetrics: SceneVolumetrics);
     /**
      * @type {SceneVolumetrics}
      */
     source: SceneVolumetrics;
     /**
-     * Nothing to release: the rows belong to the scene database.
+     * The tiles a volume's `noise_slot` names. Slot {@link PARTICIPATING_MEDIA_NOISE_DEFAULT_SLOT}
+     * is the engine's; `allocate` one and `write` it for a tile of your own.
+     *
+     * @returns {GPUTileAtlas3D}
+     */
+    get noise_atlas(): GPUTileAtlas3D;
+    /**
+     * The rows belong to the scene database; the atlas is ours.
      */
     destroy(): void;
     /**
@@ -38,7 +63,9 @@ export class GPUSceneVolumetrics {
     update(gfx: GraphicsContext, time_delta_s: number): void;
     #private;
 }
+export type PipelineEnquiry = import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
 export type SceneVolumetrics = import("./SceneVolumetrics.js").SceneVolumetrics;
 export type GPUTypedTable = import("../buffer/table/GPUTypedTable.js").GPUTypedTable<any>;
+import { GPUTileAtlas3D } from "../texture/atlas/GPUTileAtlas3D.js";
 //# sourceMappingURL=GPUSceneVolumetrics.d.ts.map

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":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;GAWG;AACH;IAeI;;;;OAIG;IACH,+FAFW,gBAAgB,EAM1B;IAtBD;;OAEG;IACH,QAFU,gBAAgB,CAEpB;IAqBN;;OAEG;IACH,gBACC;IAED;;;;OAIG;IACH,YAHW,eAAe,gBACf,MAAM,QA4ChB;;CAEJ;8BAlGY,OAAO,uBAAuB,EAAE,eAAe;+BAC/C,OAAO,uBAAuB,EAAE,gBAAgB"}
+{"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"}