@woosh/meep-engine 3.52.0 → 3.54.0

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

@@ -1,20 +1,28 @@
-import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
-
-export const SAMPLER_LINEAR_UPSCALE = Object.freeze(SamplerDescriptor.from({
-    magFilter: "linear",
-    addressModeU: "clamp-to-edge",
-    addressModeV: "clamp-to-edge",
-    addressModeW: "clamp-to-edge",
-}));
-
-export const SAMPLER_LINEAR_DOWNSCALE = Object.freeze(SamplerDescriptor.from({
-    minFilter: "linear",
-    addressModeU: "clamp-to-edge",
-    addressModeV: "clamp-to-edge"
-}))
-
-export const SAMPLER_NEAREST = Object.freeze(SamplerDescriptor.from({
-    magFilter: "nearest",
-    addressModeU: "clamp-to-edge",
-    addressModeV: "clamp-to-edge"
-}));
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+
+/**
+ * Magnification-only linear clamp sampler (`magFilter: "linear"`, `minFilter: "nearest"`,
+ * `mipmapFilter: "nearest"`, `maxAnisotropy: 1`).
+ *
+ * Intended ONLY for upscaling single-mip 2D render targets (e.g. post-processing upsampling).
+ * Do NOT use for 3D scene textures, atlases, or mipmapped targets that undergo minification —
+ * use `SAMPLER_TRILINEAR_CLAMP` or `SAMPLER_ANISOTROPIC_CLAMP` instead.
+ */
+export const SAMPLER_LINEAR_UPSCALE = Object.freeze(SamplerDescriptor.from({
+    magFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge",
+}));
+
+export const SAMPLER_LINEAR_DOWNSCALE = Object.freeze(SamplerDescriptor.from({
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+}))
+
+export const SAMPLER_NEAREST = Object.freeze(SamplerDescriptor.from({
+    magFilter: "nearest",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+}));

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

@@ -0,0 +1,8 @@
+/**
+ * Trilinear clamp-to-edge sampler (`magFilter: "linear"`, `minFilter: "linear"`, `mipmapFilter: "linear"`).
+ * Use for mipmapped 2D render targets and LUTs where linear filtering is required across both
+ * magnification/minification and mip levels without anisotropic footprint expansion.
+ */
+export const SAMPLER_TRILINEAR_CLAMP: Readonly<SamplerDescriptor>;
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+//# sourceMappingURL=SAMPLER_TRILINEAR_CLAMP.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SAMPLER_TRILINEAR_CLAMP.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/texture/SAMPLER_TRILINEAR_CLAMP.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,kEAOI;kCAd8B,+CAA+C"}

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

@@ -0,0 +1,15 @@
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+
+/**
+ * Trilinear clamp-to-edge sampler (`magFilter: "linear"`, `minFilter: "linear"`, `mipmapFilter: "linear"`).
+ * Use for mipmapped 2D render targets and LUTs where linear filtering is required across both
+ * magnification/minification and mip levels without anisotropic footprint expansion.
+ */
+export const SAMPLER_TRILINEAR_CLAMP = Object.freeze(SamplerDescriptor.from({
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge",
+    magFilter: "linear",
+    minFilter: "linear",
+    mipmapFilter: "linear",
+}));

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/view/chunk_view_mip_bias.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Multiplier applied to screen-space UV derivatives before dividing by `view.upscale_ratio`
+ * to bias texture mip selection for temporal super-sampling (TAAU / NSS).
+ *
+ * @type {number}
+ */
+export const RENDER_MIP_DERIVATIVE_BIAS: number;
+/**
+ * Shared WGSL helpers for biasing screen-space UV derivatives and mip levels according to
+ * the active internal resolution scale (`view.upscale_ratio = output_resolution / internal_resolution`)
+ * and global TAA mip bias ({@link RENDER_GLOBAL_MIP_BIAS}).
+ *
+ * When rendering at reduced internal resolution (`upscale_ratio > 1.0`), raw screen-space
+ * derivatives (`dpdx` / `dpdy` or finite differences across internal pixels) measure the
+ * coarser internal pixel footprint rather than the final output pixel footprint reconstructed
+ * by temporal upscaling. Scaling derivatives by `view_uv_derivative_bias(view.upscale_ratio)`
+ * ensures mip selection and anisotropic filtering match the target output resolution.
+ */
+export const chunk_view_mip_bias: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_view_mip_bias.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_view_mip_bias.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/view/chunk_view_mip_bias.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,yCAFU,MAAM,CAE2D;AAE3E;;;;;;;;;;GAUG;AACH,4CAqBE;0BA1CwB,iCAAiC"}

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

@@ -0,0 +1,44 @@
+import { RENDER_GLOBAL_MIP_BIAS } from "../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+
+/**
+ * Multiplier applied to screen-space UV derivatives before dividing by `view.upscale_ratio`
+ * to bias texture mip selection for temporal super-sampling (TAAU / NSS).
+ *
+ * @type {number}
+ */
+export const RENDER_MIP_DERIVATIVE_BIAS = 1 / (1 - RENDER_GLOBAL_MIP_BIAS);
+
+/**
+ * Shared WGSL helpers for biasing screen-space UV derivatives and mip levels according to
+ * the active internal resolution scale (`view.upscale_ratio = output_resolution / internal_resolution`)
+ * and global TAA mip bias ({@link RENDER_GLOBAL_MIP_BIAS}).
+ *
+ * When rendering at reduced internal resolution (`upscale_ratio > 1.0`), raw screen-space
+ * derivatives (`dpdx` / `dpdy` or finite differences across internal pixels) measure the
+ * coarser internal pixel footprint rather than the final output pixel footprint reconstructed
+ * by temporal upscaling. Scaling derivatives by `view_uv_derivative_bias(view.upscale_ratio)`
+ * ensures mip selection and anisotropic filtering match the target output resolution.
+ */
+export const chunk_view_mip_bias = CodeChunk.from(
+    //language=WGSL
+    `
+const RENDER_MIP_DERIVATIVE_BIAS: f32 = ${RENDER_MIP_DERIVATIVE_BIAS.toFixed(8)};
+const RENDER_GLOBAL_MIP_BIAS: f32 = ${RENDER_GLOBAL_MIP_BIAS.toFixed(8)};
+
+/**
+ * Per-axis multiplier for screen-space UV gradients (\`ddx\` by \`.x\`, \`ddy\` by \`.y\`)
+ * that accounts for both temporal upscaling (\`upscale_ratio\`) and global TAA mip bias.
+ */
+fn view_uv_derivative_bias(upscale_ratio: vec2<f32>) -> vec2<f32> {
+    return vec2<f32>(RENDER_MIP_DERIVATIVE_BIAS) / upscale_ratio;
+}
+
+/**
+ * Scalar LOD bias (in mip levels) corresponding to \`upscale_ratio\` and global TAA mip bias.
+ */
+fn view_mip_bias(upscale_ratio: vec2<f32>) -> f32 {
+    return -log2(max(upscale_ratio.x, upscale_ratio.y)) + RENDER_GLOBAL_MIP_BIAS;
+}
+`
+);

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,