@woosh/meep-engine 3.53.0 → 3.54.0

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

@@ -92,12 +92,15 @@ export function tile_atlas_bordered_block(content: Uint8Array, content_size: Arr
  */
 export class GPUTileAtlas3D {
     /**
-     * Every argument is required: an atlas is declared, not configured.
+     * Every argument is required: an atlas is declared, not configured. Either `format` (one texture)
+     * or `formats` (one or more synchronized textures sharing the same slot grid) must be given.
      *
      * @param {object} options
      * @param {GPUDevice} options.device
-     * @param {GPUTextureFormat} options.format an uncompressed, copyable format — what a 3-D texture
-     * allows, and what {@link write} sizes its block by
+     * @param {GPUTextureFormat} [options.format] an uncompressed, copyable format — what a 3-D texture
+     * allows, and what {@link write} sizes its block by (mutually exclusive with `formats`)
+     * @param {GPUTextureFormat[]} [options.formats] one or more uncompressed, copyable formats for a
+     * multi-texture atlas (mutually exclusive with `format`)
      * @param {number[]} options.content_size texels of content along x, y and z of a tile, three
      * positive integers; a cubic tile is `[n, n, n]`. Copied: the array stays the caller's
      * @param {number} options.border texels of skirt on each side of the content, at least 1 for a
@@ -114,9 +117,10 @@ export class GPUTileAtlas3D {
      * are copies
      * @param {string} options.label the texture's label
      */
-    constructor({ device, format, content_size, border, slots_x, slots_y, capacity, usage, label }: {
+    constructor({ device, formats, content_size, border, slots_x, slots_y, capacity, usage, label }: {
         device: GPUDevice;
-        format: GPUTextureFormat;
+        format?: GPUTextureFormat;
+        formats?: GPUTextureFormat[];
         content_size: number[];
         border: number;
         slots_x: number;
@@ -129,14 +133,42 @@ export class GPUTileAtlas3D {
      * @returns {GPUTextureContext}
      */
     get texture(): GPUTextureContext;
+    /**
+     * All synchronized textures of the atlas.
+     * @returns {readonly GPUTextureContext[]}
+     */
+    get textures(): readonly GPUTextureContext[];
+    /**
+     * @returns {number}
+     */
+    get texture_count(): number;
+    /**
+     * @param {number} index
+     * @returns {GPUTextureContext}
+     */
+    texture_at(index: number): GPUTextureContext;
     /**
      * @returns {GPUTextureFormat}
      */
     get format(): GPUTextureFormat;
+    /**
+     * @returns {readonly GPUTextureFormat[]}
+     */
+    get formats(): readonly GPUTextureFormat[];
+    /**
+     * @param {number} index
+     * @returns {GPUTextureFormat}
+     */
+    format_at(index: number): GPUTextureFormat;
     /**
      * @returns {number}
      */
     get bytes_per_texel(): number;
+    /**
+     * @param {number} index
+     * @returns {number}
+     */
+    bytes_per_texel_at(index: number): number;
     /**
      * Texels of content along x, y and z of a tile. Frozen: the atlas's own, not a copy.
      * @returns {readonly number[]}
@@ -216,8 +248,9 @@ export class GPUTileAtlas3D {
      * @param {number} slot a live slot
      * @param {Uint8Array} content `content_size[0] · content_size[1] · content_size[2] ·
      * bytes_per_texel` bytes, x fastest, then y, then z
+     * @param {number} [texture_index=0] which texture of the atlas to write into
      */
-    write(slot: number, content: Uint8Array): void;
+    write(slot: number, content: Uint8Array, texture_index?: number): void;
     /**
      * Put a whole tile, skirt included, into a slot from a buffer on the device — the way a compute
      * bake lands: it writes the `tile_size` block into a storage buffer, rows padded to the copy
@@ -229,8 +262,9 @@ export class GPUTileAtlas3D {
      * @param {number} byte_offset where the block starts in the buffer
      * @param {number} bytes_per_row stride of a row of `tile_size[0]` texels, a multiple of
      * `COPY_BYTES_PER_ROW_ALIGNMENT`; rows per image is `tile_size[1]`
+     * @param {number} [texture_index=0] which texture of the atlas to copy into
      */
-    copy_from_buffer(encoder: GPUCommandEncoder, slot: number, buffer: GPUBuffer, byte_offset: number, bytes_per_row: number): void;
+    copy_from_buffer(encoder: GPUCommandEncoder, slot: number, buffer: GPUBuffer, byte_offset: number, bytes_per_row: number, texture_index?: number): void;
     destroy(): void;
     #private;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"GPUTileAtlas3D.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/atlas/GPUTileAtlas3D.js"],"names":[],"mappings":"AA8lBA;;;;;;;;GAQG;AACH,2CANW,MAAM,WACN,MAAM,WACN,MAAM,OACN,MAAM,EAAE,GAAC,WAAW,GAClB,MAAM,EAAE,GAAC,WAAW,CAchC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,sDARW,MAAM,WACN,MAAM,eACN,MAAM,eACN,MAAM,iBACN,MAAM,OACN,MAAM,EAAE,GACN,OAAO,CAoCnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,mDATW,UAAU,gBAEV,UAAU,MAAM,CAAC,UACjB,MAAM,mBACN,MAAM,OACN,UAAU,GAER,UAAU,CAkDtB;AAtuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;IA4FI;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH;QAnB8B,MAAM;QACC,MAAM;QAEd,YAAY,EAA9B,MAAM,EAAE;QAEQ,MAAM,EAAtB,MAAM;QAEU,OAAO,EAAvB,MAAM;QAEU,OAAO,EAAvB,MAAM;QAEU,QAAQ,EAAxB,MAAM;QAEwB,KAAK;QAInB,KAAK,EAArB,MAAM;OA0EhB;IAED;;OAEG;IACH,iCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;;OAGG;IACH,sCAEC;IAED;;OAEG;IACH,qBAEC;IAED;;;;OAIG;IACH,mCAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;;OAKG;IACH,YAFa,MAAM,CAkBlB;IAED;;OAEG;IACH,WAFW,MAAM,QAOhB;IAED;;;;;;;;OAQG;IACH,kBAJW,MAAM,OACN,MAAM,EAAE,GAAC,WAAW,GAClB,MAAM,EAAE,GAAC,WAAW,CAehC;IAED;;;;;;;OAOG;IACH,YAJW,MAAM,WACN,UAAU,QAiCpB;IAED;;;;;;;;;;;OAWG;IACH,mDANW,MAAM,kCAEN,MAAM,iBACN,MAAM,QA+BhB;IAED,gBAEC;;CAsHJ;kCA1lBiC,yBAAyB"}
+{"version":3,"file":"GPUTileAtlas3D.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/atlas/GPUTileAtlas3D.js"],"names":[],"mappings":"AAssBA;;;;;;;;GAQG;AACH,2CANW,MAAM,WACN,MAAM,WACN,MAAM,OACN,MAAM,EAAE,GAAC,WAAW,GAClB,MAAM,EAAE,GAAC,WAAW,CAchC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,sDARW,MAAM,WACN,MAAM,eACN,MAAM,eACN,MAAM,iBACN,MAAM,OACN,MAAM,EAAE,GACN,OAAO,CAoCnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,mDATW,UAAU,gBAEV,UAAU,MAAM,CAAC,UACjB,MAAM,mBACN,MAAM,OACN,UAAU,GAER,UAAU,CAkDtB;AA90BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;IA4FI;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QArB8B,MAAM;QACE,MAAM;QAEJ,OAAO,GAApC,kBAAkB;QAEA,YAAY,EAA9B,MAAM,EAAE;QAEQ,MAAM,EAAtB,MAAM;QAEU,OAAO,EAAvB,MAAM;QAEU,OAAO,EAAvB,MAAM;QAEU,QAAQ,EAAxB,MAAM;QAEwB,KAAK;QAInB,KAAK,EAArB,MAAM;OAiGhB;IAED;;OAEG;IACH,iCAEC;IAED;;;OAGG;IACH,6CAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,kBAHW,MAAM,GACJ,iBAAiB,CAO7B;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,2CAEC;IAED;;;OAGG;IACH,iBAHW,MAAM,oBAQhB;IAED;;OAEG;IACH,8BAEC;IAED;;;OAGG;IACH,0BAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;OAGG;IACH,sCAEC;IAED;;OAEG;IACH,qBAEC;IAED;;;;OAIG;IACH,mCAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;;OAKG;IACH,YAFa,MAAM,CAkBlB;IAED;;OAEG;IACH,WAFW,MAAM,QAOhB;IAED;;;;;;;;OAQG;IACH,kBAJW,MAAM,OACN,MAAM,EAAE,GAAC,WAAW,GAClB,MAAM,EAAE,GAAC,WAAW,CAehC;IAED;;;;;;;;OAQG;IACH,YALW,MAAM,WACN,UAAU,kBAEV,MAAM,QAkChB;IAED;;;;;;;;;;;;OAYG;IACH,mDAPW,MAAM,kCAEN,MAAM,iBACN,MAAM,kBAEN,MAAM,QAgChB;IAED,gBAIC;;CAqIJ;kCAlsBiC,yBAAyB"}

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

@@ -56,19 +56,19 @@ export class GPUTileAtlas3D {
     #device;
 
     /**
-     * @type {GPUTextureContext}
+     * @type {readonly GPUTextureContext[]}
      */
-    #texture;
+    #textures;
 
     /**
-     * @type {GPUTextureFormat}
+     * @type {readonly GPUTextureFormat[]}
      */
-    #format;
+    #formats;
 
     /**
-     * @type {number}
+     * @type {readonly number[]}
      */
-    #bytes_per_texel;
+    #bytes_per_texel_list;
 
     /**
      * Texels of content along x, y and z.
@@ -142,12 +142,15 @@ export class GPUTileAtlas3D {
     #label;
 
     /**
-     * Every argument is required: an atlas is declared, not configured.
+     * Every argument is required: an atlas is declared, not configured. Either `format` (one texture)
+     * or `formats` (one or more synchronized textures sharing the same slot grid) must be given.
      *
      * @param {object} options
      * @param {GPUDevice} options.device
-     * @param {GPUTextureFormat} options.format an uncompressed, copyable format — what a 3-D texture
-     * allows, and what {@link write} sizes its block by
+     * @param {GPUTextureFormat} [options.format] an uncompressed, copyable format — what a 3-D texture
+     * allows, and what {@link write} sizes its block by (mutually exclusive with `formats`)
+     * @param {GPUTextureFormat[]} [options.formats] one or more uncompressed, copyable formats for a
+     * multi-texture atlas (mutually exclusive with `format`)
      * @param {number[]} options.content_size texels of content along x, y and z of a tile, three
      * positive integers; a cubic tile is `[n, n, n]`. Copied: the array stays the caller's
      * @param {number} options.border texels of skirt on each side of the content, at least 1 for a
@@ -164,9 +167,19 @@ export class GPUTileAtlas3D {
      * are copies
      * @param {string} options.label the texture's label
      */
-    constructor({ device, format, content_size, border, slots_x, slots_y, capacity, usage, label }) {
+    constructor({ device, formats, content_size, border, slots_x, slots_y, capacity, usage, label }) {
         assert.defined(device, 'device');
-        assert.isString(format, 'format');
+        const format_list = formats;
+
+
+
+        assert.isArrayLike(format_list, 'formats');
+        assert.greaterThan(format_list.length, 0, 'formats must not be empty');
+
+        for (let i = 0; i < format_list.length; i++) {
+            assert.isString(format_list[i], `formats[${i}]`);
+        }
+
         assert.isArrayLike(content_size, 'content_size');
         assert.equal(content_size.length, 3, 'content_size is texels along x, y and z');
         assert.isPositiveInteger(content_size[0], 'content_size[0]');
@@ -184,14 +197,21 @@ export class GPUTileAtlas3D {
         assert.greaterThan(usage, 0, 'usage: a texture no shader binds is not an atlas anyone reads');
         assert.isString(label, 'label');
 
-        const info = gpu_texture_format_info(format);
+        const bytes_per_texel_list = [];
+
+        for (let i = 0; i < format_list.length; i++) {
+            const fmt = format_list[i];
+            const info = gpu_texture_format_info(fmt);
+
+            assert.equal(info.block_width, 1, `${fmt} is block-compressed; a 3-D texture cannot be`);
+            assert.equal(info.copyable, true, `${fmt} cannot be copied into, and a tile is written by copy`);
 
-        assert.equal(info.block_width, 1, `${format} is block-compressed; a 3-D texture cannot be`);
-        assert.equal(info.copyable, true, `${format} cannot be copied into, and a tile is written by copy`);
+            bytes_per_texel_list.push(info.bytes_per_block);
+        }
 
         this.#device = device;
-        this.#format = format;
-        this.#bytes_per_texel = info.bytes_per_block;
+        this.#formats = Object.freeze([...format_list]);
+        this.#bytes_per_texel_list = Object.freeze(bytes_per_texel_list);
         this.#content_size = Object.freeze([content_size[0], content_size[1], content_size[2]]);
         this.#border = border;
 
@@ -212,20 +232,26 @@ export class GPUTileAtlas3D {
         this.#slots_y = slots_y;
         this.#label = label;
 
-        const texture = new GPUTextureContext(device);
-        const td = texture.descriptor;
+        const textures = [];
+
+        for (let i = 0; i < format_list.length; i++) {
+            const texture = new GPUTextureContext(device);
+            const td = texture.descriptor;
+
+            td.label = format_list.length === 1 ? label : `${label}[${i}]`;
+            td.format = format_list[i];
+            td.dimension = "3d";
+            td.mipLevelCount = 1;
+            // bound however the clients said, written by host writes and device copies, and copied out
+            // of itself when it grows
+            td.usage = usage
+                | GPUTextureUsage.COPY_DST
+                | GPUTextureUsage.COPY_SRC;
 
-        td.label = label;
-        td.format = format;
-        td.dimension = "3d";
-        td.mipLevelCount = 1;
-        // bound however the clients said, written by host writes and device copies, and copied out
-        // of itself when it grows
-        td.usage = usage
-            | GPUTextureUsage.COPY_DST
-            | GPUTextureUsage.COPY_SRC;
+            textures.push(texture);
+        }
 
-        this.#texture = texture;
+        this.#textures = Object.freeze(textures);
 
         assert.lessThanOrEqual(slots_x, this.#limit_x, `slots_x ${slots_x} of ${tile_x} texels exceed maxTextureDimension3D ${max_dimension}`);
         assert.lessThanOrEqual(slots_y, this.#limit_y, `slots_y ${slots_y} of ${tile_y} texels exceed maxTextureDimension3D ${max_dimension}`);
@@ -242,21 +268,76 @@ export class GPUTileAtlas3D {
      * @returns {GPUTextureContext}
      */
     get texture() {
-        return this.#texture;
+        return this.#textures[0];
+    }
+
+    /**
+     * All synchronized textures of the atlas.
+     * @returns {readonly GPUTextureContext[]}
+     */
+    get textures() {
+        return this.#textures;
+    }
+
+    /**
+     * @returns {number}
+     */
+    get texture_count() {
+        return this.#textures.length;
+    }
+
+    /**
+     * @param {number} index
+     * @returns {GPUTextureContext}
+     */
+    texture_at(index) {
+        assert.isNonNegativeInteger(index, 'index');
+        assert.lessThan(index, this.#textures.length, 'index');
+
+        return this.#textures[index];
     }
 
     /**
      * @returns {GPUTextureFormat}
      */
     get format() {
-        return this.#format;
+        return this.#formats[0];
+    }
+
+    /**
+     * @returns {readonly GPUTextureFormat[]}
+     */
+    get formats() {
+        return this.#formats;
+    }
+
+    /**
+     * @param {number} index
+     * @returns {GPUTextureFormat}
+     */
+    format_at(index) {
+        assert.isNonNegativeInteger(index, 'index');
+        assert.lessThan(index, this.#formats.length, 'index');
+
+        return this.#formats[index];
     }
 
     /**
      * @returns {number}
      */
     get bytes_per_texel() {
-        return this.#bytes_per_texel;
+        return this.#bytes_per_texel_list[0];
+    }
+
+    /**
+     * @param {number} index
+     * @returns {number}
+     */
+    bytes_per_texel_at(index) {
+        assert.isNonNegativeInteger(index, 'index');
+        assert.lessThan(index, this.#bytes_per_texel_list.length, 'index');
+
+        return this.#bytes_per_texel_list[index];
     }
 
     /**
@@ -407,13 +488,16 @@ export class GPUTileAtlas3D {
      * @param {number} slot a live slot
      * @param {Uint8Array} content `content_size[0] · content_size[1] · content_size[2] ·
      * bytes_per_texel` bytes, x fastest, then y, then z
+     * @param {number} [texture_index=0] which texture of the atlas to write into
      */
-    write(slot, content) {
+    write(slot, content, texture_index = 0) {
         assert.ok(this.is_live(slot), `slot ${slot} is not allocated`);
         assert.isInstanceOf(content, Uint8Array, 'content');
+        assert.isNonNegativeInteger(texture_index, 'texture_index');
+        assert.lessThan(texture_index, this.#textures.length, 'texture_index');
 
         const n = this.#content_size;
-        const bpt = this.#bytes_per_texel;
+        const bpt = this.#bytes_per_texel_list[texture_index];
 
         assert.equal(content.length, n[0] * n[1] * n[2] * bpt, `content holds ${content.length} bytes; a tile's content is ${n[0]}×${n[1]}×${n[2]} texels of ${bpt} bytes`);
 
@@ -426,7 +510,7 @@ export class GPUTileAtlas3D {
 
         this.#device.queue.writeTexture(
             {
-                texture: this.#texture.gpu_texture,
+                texture: this.#textures[texture_index].gpu_texture,
                 mipLevel: 0,
                 origin: this.slot_origin(slot, [0, 0, 0]),
             },
@@ -451,20 +535,23 @@ export class GPUTileAtlas3D {
      * @param {number} byte_offset where the block starts in the buffer
      * @param {number} bytes_per_row stride of a row of `tile_size[0]` texels, a multiple of
      * `COPY_BYTES_PER_ROW_ALIGNMENT`; rows per image is `tile_size[1]`
+     * @param {number} [texture_index=0] which texture of the atlas to copy into
      */
-    copy_from_buffer(encoder, slot, buffer, byte_offset, bytes_per_row) {
+    copy_from_buffer(encoder, slot, buffer, byte_offset, bytes_per_row, texture_index = 0) {
         assert.defined(encoder, 'encoder');
         assert.ok(this.is_live(slot), `slot ${slot} is not allocated`);
         assert.defined(buffer, 'buffer');
         assert.isNonNegativeInteger(byte_offset, 'byte_offset');
         assert.isNonNegativeInteger(bytes_per_row, 'bytes_per_row');
+        assert.isNonNegativeInteger(texture_index, 'texture_index');
+        assert.lessThan(texture_index, this.#textures.length, 'texture_index');
 
         const tile = this.#tile_size;
         const tx = tile[0];
         const ty = tile[1];
         const tz = tile[2];
 
-        assert.greaterThanOrEqual(bytes_per_row, tx * this.#bytes_per_texel, 'bytes_per_row is shorter than a row of the tile');
+        assert.greaterThanOrEqual(bytes_per_row, tx * this.#bytes_per_texel_list[texture_index], 'bytes_per_row is shorter than a row of the tile');
 
         encoder.copyBufferToTexture(
             {
@@ -474,7 +561,7 @@ export class GPUTileAtlas3D {
                 rowsPerImage: ty,
             },
             {
-                texture: this.#texture.gpu_texture,
+                texture: this.#textures[texture_index].gpu_texture,
                 mipLevel: 0,
                 origin: this.slot_origin(slot, [0, 0, 0]),
             },
@@ -483,7 +570,9 @@ export class GPUTileAtlas3D {
     }
 
     destroy() {
-        this.#texture.destroy();
+        for (let i = 0; i < this.#textures.length; i++) {
+            this.#textures[i].destroy();
+        }
     }
 
     /**
@@ -508,8 +597,14 @@ export class GPUTileAtlas3D {
         this.#slots_z = layers;
         this.#resize_live();
 
+        const width = this.#slots_x * tile[0];
+        const height = this.#slots_y * tile[1];
+        const depth = layers * tile[2];
+
         // preserve: a new layer keeps every tile where it was, because x and y do not change
-        this.#texture.resize(this.#slots_x * tile[0], this.#slots_y * tile[1], layers * tile[2], true);
+        for (let i = 0; i < this.#textures.length; i++) {
+            this.#textures[i].resize(width, height, depth, true);
+        }
     }
 
     /**
@@ -538,13 +633,18 @@ export class GPUTileAtlas3D {
         const layers = Math.ceil((this.capacity + 1) / (nx * ny));
 
         const device = this.#device;
-        const texture = this.#texture;
-
-        const source = texture.gpu_texture;
+        const textures = this.#textures;
+        const texture_count = textures.length;
 
-        texture.descriptor.size = [nx * tx, ny * ty, layers * tz];
+        const sources = new Array(texture_count);
+        const destinations = new Array(texture_count);
 
-        const destination = device.createTexture(texture.descriptor);
+        for (let i = 0; i < texture_count; i++) {
+            const texture = textures[i];
+            sources[i] = texture.gpu_texture;
+            texture.descriptor.size = [nx * tx, ny * ty, layers * tz];
+            destinations[i] = device.createTexture(texture.descriptor);
+        }
 
         const encoder = device.createCommandEncoder({
             label: `${this.#label} / widen`
@@ -562,19 +662,21 @@ export class GPUTileAtlas3D {
 
             const run = Math.min(sx - from[0], nx - to[0], count - slot);
 
-            encoder.copyTextureToTexture(
-                {
-                    texture: source,
-                    mipLevel: 0,
-                    origin: [from[0] * tx, from[1] * ty, from[2] * tz],
-                },
-                {
-                    texture: destination,
-                    mipLevel: 0,
-                    origin: [to[0] * tx, to[1] * ty, to[2] * tz],
-                },
-                [run * tx, ty, tz]
-            );
+            for (let i = 0; i < texture_count; i++) {
+                encoder.copyTextureToTexture(
+                    {
+                        texture: sources[i],
+                        mipLevel: 0,
+                        origin: [from[0] * tx, from[1] * ty, from[2] * tz],
+                    },
+                    {
+                        texture: destinations[i],
+                        mipLevel: 0,
+                        origin: [to[0] * tx, to[1] * ty, to[2] * tz],
+                    },
+                    [run * tx, ty, tz]
+                );
+            }
 
             slot += run;
         }
@@ -582,7 +684,9 @@ export class GPUTileAtlas3D {
         device.queue.submit([encoder.finish()]);
 
         // destroys the old texture; the copies out of it were submitted first
-        texture.replace(destination);
+        for (let i = 0; i < texture_count; i++) {
+            textures[i].replace(destinations[i]);
+        }
 
         this.#slots_x = nx;
         this.#slots_y = ny;

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

@@ -137,7 +137,7 @@ export class GPUSceneVolumetrics {
 
         this.#noise_atlas = new GPUTileAtlas3D({
             device,
-            format: PARTICIPATING_MEDIA_NOISE_TILE_FORMAT,
+            formats: [PARTICIPATING_MEDIA_NOISE_TILE_FORMAT],
             // 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,

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

@@ -21,6 +21,10 @@ export class GPUViewVolumetrics {
      * @returns {number}
      */
     get froxel_far(): number;
+    /**
+     * @returns {GPUIrradianceClipmap}
+     */
+    get irradiance_clipmap(): GPUIrradianceClipmap;
     destroy(): void;
     /**
      *
@@ -30,18 +34,10 @@ export class GPUViewVolumetrics {
      * @param {number} options.light_cluster_lookup
      * @param {number} options.light_cluster_parameters
      * @param {number} options.shadowmap_atlas
-     * @param {ShaderSwitchSet} [options.shader_switches] the renderer's; the passes that light froxels are built
-     *   for them, the froxel GI that starts the froxel irradiance volume among them
-     * @param {import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4] the scene's,
-     *   while Brick4 runs
-     * @param {import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
-     *   scene's, while LPV runs
-     * @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) 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.
+     * @param {ShaderSwitchSet} [options.shader_switches]
+     * @param {import("../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap} [options.brick4]
+     * @param {import("../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv]
+     * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number, uniform: number}}}
      */
     graph_update({ graph, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, shader_switches, brick4, lpv, }: {
         graph: FrameGraph;
@@ -58,11 +54,13 @@ export class GPUViewVolumetrics {
         irradiance: {
             Y: number;
             CoCg: number;
+            uniform: number;
         };
     };
     #private;
 }
 export type FrameGraph = import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
 export type GPUViewContext = import("../view/GPUViewContext.js").GPUViewContext;
+import { GPUIrradianceClipmap } from "./irradiance_clipmap/GPUIrradianceClipmap.js";
 import { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
 //# sourceMappingURL=GPUViewVolumetrics.d.ts.map

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":"AAmCA;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;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAlB+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QAEoE,MAAM,GAAzF,OAAO,iDAAiD,EAAE,cAAc;QAEkB,GAAG,GAA7F,OAAO,mDAAmD,EAAE,mBAAmB;QAE7E;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,CAwIvF;;CAEJ;yBAnkBY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc;gCAf/B,uCAAuC"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAiCA;IAiJI;;;;OAIG;IACH,kBAHW,cAAc,qBA2CxB;IA1JD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IA0HD;;OAEG;IACH,+CAEC;IAED,gBAcC;IA6ND;;;;;;;;;;;;OAYG;IACH;QAV+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QACoE,MAAM,GAAzF,OAAO,iDAAiD,EAAE,cAAc;QACkB,GAAG,GAA7F,OAAO,mDAAmD,EAAE,mBAAmB;QAC7E;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAsGxG;;CAEJ;yBA9iBY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc;qCAZ1B,8CAA8C;gCAXnD,uCAAuC"}