@woosh/meep-engine 3.53.0 → 3.55.0

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#201@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#203@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/postprocess/ssr/prefilter/NOTES.md

@@ -37,10 +37,3 @@ It has drifted against the live pipeline in one way that a reader will not notic
 directory: the à-trous path grew `chunk_ssr_metadata`, and the variance/metadata contract the
 prefilter expects predates it. Reconcile those before wiring the pass in, rather than after.
 
-## Sibling trap, same territory
-
-`graph_build_depth_max_pyramid.js` (also one directory up, also unreferenced) builds a
-**single-channel `r32float`** max-depth chain, while the live `HierarchicalZBuffer` the SSR trace
-actually reads is **two-channel** — `chunk_ffx_sssr_load_depth` reads its `.y`. The two are not
-interchangeable, and swapping one in for the other gives a silently zero `.y` rather than an error.
-That file's own header says the same thing.

package/src/shade/renderer/shader/chunk/depth/chunk_query_depth_from_screen_space_bb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_query_depth_from_screen_space_bb.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/depth/chunk_query_depth_from_screen_space_bb.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,qDAFU,SAAS,CAqDZ;0BA7DmB,6BAA6B"}
+{"version":3,"file":"chunk_query_depth_from_screen_space_bb.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/depth/chunk_query_depth_from_screen_space_bb.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,qDAFU,SAAS,CAsDZ;0BA7DmB,6BAA6B"}

package/src/shade/renderer/shader/chunk/depth/chunk_query_depth_from_screen_space_bb.js

@@ -1,62 +1,62 @@
-import { CodeChunk } from "../../compiler/CodeChunk.js";
-import { AABB3_STRUCT } from "../geometry/aabb3/AABB3_STRUCT.js";
-import { chunk_min4 } from "../math/chunk_min4.js";
-import { chunk_ndc_to_uv } from "../texture/chunk_ndc_to_uv.js";
-import { chunk_uv_to_texel_coordinate } from "../texture/chunk_uv_to_texel_coordinate.js";
-
-/**
- * TODO check out this post https://x.com/anki3d/status/1713238150418518023
- * @type {CodeChunk}
- */
-export const chunk_query_depth_from_screen_space_bb = CodeChunk.from(
-    //language=WGSL
-    `
-fn query_depth_from_screen_space_bb( 
-    pb: ${AABB3_STRUCT.wgsl_ref},
-    hzb: texture_2d<f32>,
-) -> f32 {
-    var n_min = saturate( ndc_to_uv(pb.min.xy) );
-    var n_max = saturate( ndc_to_uv(pb.max.xy) );
-
-    let bb_dim = abs(n_max - n_min);
-
-    let hzb_size_u = textureDimensions(hzb);
-    let hzb_size_f = vec2<f32>(hzb_size_u);
-
-    let bb_dim_hz = bb_dim * hzb_size_f;
-    
-    let longest_edge = max(bb_dim_hz.x, bb_dim_hz.y);
-
-    let mip_level_count = textureNumLevels(hzb);
-
-    let mip_level = min( 
-        u32( ceil(log2( max(longest_edge, 1.0) ) ) ),
-        mip_level_count - 1
-    );
-    
-    let mip_resolution = hzb_size_u >> vec2(mip_level);
-
-    // sample 4 corners, we know that they fit in a 2x2 footprint at most
-    let p0 = vec2<u32>((uv_to_texel_coordinate( n_min, mip_resolution)));
-    let p3 = vec2<u32>((uv_to_texel_coordinate( n_max, mip_resolution)));
-    let p1 = vec2(p3.x, p0.y);
-    let p2 = vec2(p0.x, p3.y);
-
-    let d0 = textureLoad(hzb, p0, mip_level).x;
-    let d1 = textureLoad(hzb, p1, mip_level).x;
-    let d2 = textureLoad(hzb, p2, mip_level).x;
-    let d3 = textureLoad(hzb, p3, mip_level).x;
-
-    // value that's most far away from us
-    let min_depth = min4(d0, d1, d2, d3);
-
-    let depth_delta = pb.max.z - min_depth;
-
-    return depth_delta;
-}
-`, [
-        AABB3_STRUCT.declaration_chunk,
-        chunk_min4,
-        chunk_uv_to_texel_coordinate,
-        chunk_ndc_to_uv
-    ]);
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { AABB3_STRUCT } from "../geometry/aabb3/AABB3_STRUCT.js";
+import { chunk_min4 } from "../math/chunk_min4.js";
+import { chunk_ndc_to_uv } from "../texture/chunk_ndc_to_uv.js";
+
+/**
+ * TODO check out this post https://x.com/anki3d/status/1713238150418518023
+ * @type {CodeChunk}
+ */
+export const chunk_query_depth_from_screen_space_bb = CodeChunk.from(
+    //language=WGSL
+    `
+fn query_depth_from_screen_space_bb( 
+    pb: ${AABB3_STRUCT.wgsl_ref},
+    hzb: texture_2d<f32>,
+) -> f32 {
+    var n_min = saturate( ndc_to_uv(pb.min.xy) );
+    var n_max = saturate( ndc_to_uv(pb.max.xy) );
+
+    let bb_dim = abs(n_max - n_min);
+
+    let hzb_size_u = textureDimensions(hzb);
+    let hzb_size_f = vec2<f32>(hzb_size_u);
+
+    let bb_dim_hz = bb_dim * hzb_size_f;
+    
+    let longest_edge = max(bb_dim_hz.x, bb_dim_hz.y);
+
+    let mip_level_count = textureNumLevels(hzb);
+
+    let mip_level = min( 
+        u32( ceil(log2( max(longest_edge, 1.0) ) ) ),
+        mip_level_count - 1
+    );
+    
+    let mip_resolution = textureDimensions(hzb, mip_level);
+    let mip_resolution_f = vec2<f32>(mip_resolution);
+    let max_coord = mip_resolution - vec2(1u);
+
+    // sample 4 corners, we know that they fit in a 2x2 footprint at most
+    let p0 = min(vec2<u32>(n_min * mip_resolution_f), max_coord);
+    let p3 = min(vec2<u32>(n_max * mip_resolution_f), max_coord);
+    let p1 = vec2(p3.x, p0.y);
+    let p2 = vec2(p0.x, p3.y);
+
+    let d0 = textureLoad(hzb, p0, mip_level).x;
+    let d1 = textureLoad(hzb, p1, mip_level).x;
+    let d2 = textureLoad(hzb, p2, mip_level).x;
+    let d3 = textureLoad(hzb, p3, mip_level).x;
+
+    // value that's most far away from us
+    let min_depth = min4(d0, d1, d2, d3);
+
+    let depth_delta = pb.max.z - min_depth;
+
+    return depth_delta;
+}
+`, [
+        AABB3_STRUCT.declaration_chunk,
+        chunk_min4,
+        chunk_ndc_to_uv
+    ]);

package/src/shade/renderer/shader/chunk/random/lowbias/chunk_hash_lowbias32_vec2u.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @type {CodeChunk}
+ */
+export const chunk_hash_lowbias32_vec2u: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_hash_lowbias32_vec2u.d.ts.map

package/src/shade/renderer/shader/chunk/random/lowbias/chunk_hash_lowbias32_vec2u.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_hash_lowbias32_vec2u.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/random/lowbias/chunk_hash_lowbias32_vec2u.js"],"names":[],"mappings":"AAGA;;GAEG;AACH,yCAFU,SAAS,CAclB;0BAlByB,gCAAgC"}

package/src/shade/renderer/shader/chunk/random/lowbias/chunk_hash_lowbias32_vec2u.js

@@ -0,0 +1,19 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_hash_lowbias32 } from "../chunk_hash_lowbias32.js";
+
+/**
+ * @type {CodeChunk}
+ */
+export const chunk_hash_lowbias32_vec2u = CodeChunk.from(
+    //language=WGSL
+    `
+fn hash_lowbias32_vec2u(v:vec2<u32>) -> u32{
+    let combined = v.x * 0x85ebca6bu + 
+                   v.y * 0xc2b2ae35u;
+                   
+    return hash_lowbias32(combined);
+}
+    `,[
+        chunk_hash_lowbias32,
+    ]
+)

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_get_mip_resolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ffx_sssr_get_mip_resolution.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_get_mip_resolution.js"],"names":[],"mappings":"AAEA,0DAOE;0BATwB,6BAA6B"}
+{"version":3,"file":"chunk_ffx_sssr_get_mip_resolution.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_get_mip_resolution.js"],"names":[],"mappings":"AAGA,0DAUE;0BAbwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_get_mip_resolution.js

@@ -1,10 +1,16 @@
-import { CodeChunk } from "../../compiler/CodeChunk.js";
-
-export const chunk_ffx_sssr_get_mip_resolution = CodeChunk.from(
-    //language=WGSL
-    `
-fn ffx_sssr_get_mip_resolution(screen_dimensions:vec2<f32>, mip_level:i32) -> vec2<f32>{
-    return screen_dimensions * pow(0.5, f32(mip_level));
-}
-    `
-);
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { SCREEN_HZB_RESOURCE } from "./SCREEN_SPACE_RESOURCES.js";
+
+export const chunk_ffx_sssr_get_mip_resolution = CodeChunk.from(
+    //language=WGSL
+    `
+fn ffx_sssr_get_mip_resolution(screen_dimensions:vec2<f32>, mip_level:i32) -> vec2<f32>{
+    if (mip_level <= 0) {
+        return screen_dimensions;
+    }
+    return vec2<f32>(textureDimensions(tHZB, mip_level - 1));
+}
+    `
+);
+
+chunk_ffx_sssr_get_mip_resolution.requireResource(SCREEN_HZB_RESOURCE);

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_hierarchical_raymarch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ffx_sssr_hierarchical_raymarch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_hierarchical_raymarch.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,mDAFU,SAAS,CAqGZ;0BAlHmB,6BAA6B"}
+{"version":3,"file":"chunk_ffx_sssr_hierarchical_raymarch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_hierarchical_raymarch.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,mDAFU,SAAS,CAuGZ;0BApHmB,6BAA6B"}

package/src/shade/renderer/shader/chunk/screen_space/chunk_ffx_sssr_hierarchical_raymarch.js

@@ -1,117 +1,118 @@
-import { chunk_is_background } from "../depth/chunk_is_background.js";
-import { CodeChunk } from "../../compiler/CodeChunk.js";
-import { chunk_rcp_v2 } from "../geometry/vec2/chunk_rcp_v2.js";
-import { F32_MAX_DEFINITION } from "../math/F32_MAX_DEFINITION.js";
-import { chunk_ffx_sssr_advance_ray } from "./chunk_ffx_sssr_advance_ray.js";
-import { chunk_ffx_sssr_get_mip_resolution } from "./chunk_ffx_sssr_get_mip_resolution.js";
-import { chunk_ffx_sssr_initial_advance_ray } from "./chunk_ffx_sssr_initial_advance_ray.js";
-import { chunk_ffx_sssr_load_depth } from "./chunk_ffx_sssr_load_depth.js";
-
-/**
- *
- * Requires origin and direction of the ray to be in screen space [0, 1] x [0, 1]
- * NOTE: "low occupancy" exit was removed, as WebGPU doesn't have pre-requisite API for it
- * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/samples/hybridreflections/shaders/ffx_sssr_intersect.h#L110
- * @type {CodeChunk}
- */
-export const chunk_ffx_sssr_hierarchical_raymarch = CodeChunk.from(
-    //language=WGSL
-    `
-fn ffx_sssr_hierarchical_raymarch(
-    origin: vec3<f32>,
-    direction: vec3<f32>,
-    screen_size: vec2<f32>,
-    most_detailed_mip: i32,
-    max_traversal_intersections:u32,
-    valid_hit: ptr<function, bool>,
-    _num_iters: ptr<function, u32>,
-) -> vec3<f32> {
-
-    let inv_direction = select( vec3(F32_MAX), 1.0 / direction, abs(direction) > vec3(1.0e-12));
-
-    // Start on mip with highest detail.
-    var current_mip = most_detailed_mip;
-
-    // Could recompute these every iteration, but it's faster to hoist them out and update them.
-    var current_mip_resolution     = ffx_sssr_get_mip_resolution(screen_size, current_mip);
-    var current_mip_resolution_inv = 1.0 / (current_mip_resolution);
-
-    // Offset to the bounding boxes uv space to intersect the ray with the center of the next pixel.
-    // This means we ever so slightly over shoot into the next region.
-    var uv_offset = 0.005 * exp2(f32(most_detailed_mip)) / screen_size;
-    uv_offset        = select( uv_offset, -uv_offset, direction.xy < vec2(0.0) );
-
-    // Offset applied depending on current mip resolution to move the boundary to the left/right upper/lower border depending on ray direction.
-    let floor_offset = select(vec2(1.0), vec2(0.0), direction.xy < vec2(0.0)); // TODO can replace with 'step'
-
-    // Initially advance ray to avoid immediate self intersections.
-    var current_t:f32;
-    var position:vec3<f32>;
-    
-    ffx_sssr_initial_advance_ray(
-        origin, 
-        direction,
-        inv_direction,
-        current_mip_resolution,
-        current_mip_resolution_inv,
-        floor_offset,
-        uv_offset,
-        &position,
-        &current_t
-    );
-    
-    var i = 0u;
-    for (
-        ;
-        i < max_traversal_intersections && current_mip >= most_detailed_mip;
-        i++
-    ) {
-        
-        if (any(position.xy > vec2(1.0, 1.0)) || any(position.xy < vec2(0.0, 0.0))){
-            // outside of the viewport
-            break;
-        }
-
-        if (is_background(position.z)){
-            // hit sky/background, out of Z bounds basically
-            break;
-        }
-
-        let current_mip_position = current_mip_resolution * position.xy;
-        let surface_z            = ffx_sssr_load_depth(vec2<i32>(current_mip_position), current_mip);
-        
-        let skipped_tile = ffx_sssr_advance_ray(
-                origin,
-                direction,
-                inv_direction,
-                current_mip_position,
-                current_mip_resolution_inv,
-                floor_offset,
-                uv_offset,
-                surface_z,
-                &position,
-                &current_t
-        );
-        
-        current_mip += select(-1, 1, skipped_tile );
-        current_mip_resolution *= select(2.0, 0.5, skipped_tile);
-        current_mip_resolution_inv *=  select(0.5, 2.0, skipped_tile);
-        
-    }
-    
-    *_num_iters = i;
-    
-    *valid_hit = (current_mip <= most_detailed_mip && i > 0);
-
-    return position;
-}
-`, [
-        F32_MAX_DEFINITION,
-        chunk_rcp_v2,
-        chunk_ffx_sssr_get_mip_resolution,
-        chunk_ffx_sssr_initial_advance_ray,
-        chunk_ffx_sssr_advance_ray,
-        chunk_ffx_sssr_load_depth,
-        chunk_is_background
-    ]);
-
+import { chunk_is_background } from "../depth/chunk_is_background.js";
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_rcp_v2 } from "../geometry/vec2/chunk_rcp_v2.js";
+import { F32_MAX_DEFINITION } from "../math/F32_MAX_DEFINITION.js";
+import { chunk_ffx_sssr_advance_ray } from "./chunk_ffx_sssr_advance_ray.js";
+import { chunk_ffx_sssr_get_mip_resolution } from "./chunk_ffx_sssr_get_mip_resolution.js";
+import { chunk_ffx_sssr_initial_advance_ray } from "./chunk_ffx_sssr_initial_advance_ray.js";
+import { chunk_ffx_sssr_load_depth } from "./chunk_ffx_sssr_load_depth.js";
+
+/**
+ *
+ * Requires origin and direction of the ray to be in screen space [0, 1] x [0, 1]
+ * NOTE: "low occupancy" exit was removed, as WebGPU doesn't have pre-requisite API for it
+ * @see https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/1bbe66e7ea0d358e84af4471a90aa9c35b583de0/samples/hybridreflections/shaders/ffx_sssr_intersect.h#L110
+ * @type {CodeChunk}
+ */
+export const chunk_ffx_sssr_hierarchical_raymarch = CodeChunk.from(
+    //language=WGSL
+    `
+fn ffx_sssr_hierarchical_raymarch(
+    origin: vec3<f32>,
+    direction: vec3<f32>,
+    screen_size: vec2<f32>,
+    most_detailed_mip: i32,
+    max_traversal_intersections:u32,
+    valid_hit: ptr<function, bool>,
+    _num_iters: ptr<function, u32>,
+) -> vec3<f32> {
+
+    let inv_direction = select( vec3(F32_MAX), 1.0 / direction, abs(direction) > vec3(1.0e-12));
+    let max_mip = i32(textureNumLevels(tHZB));
+
+    // Start on mip with highest detail.
+    var current_mip = min(most_detailed_mip, max_mip);
+
+    var current_mip_resolution     = ffx_sssr_get_mip_resolution(screen_size, current_mip);
+    var current_mip_resolution_inv = 1.0 / (current_mip_resolution);
+
+    // Offset to the bounding boxes uv space to intersect the ray with the center of the next pixel.
+    // This means we ever so slightly over shoot into the next region.
+    var uv_offset = 0.005 * exp2(f32(most_detailed_mip)) / screen_size;
+    uv_offset        = select( uv_offset, -uv_offset, direction.xy < vec2(0.0) );
+
+    // Offset applied depending on current mip resolution to move the boundary to the left/right upper/lower border depending on ray direction.
+    let floor_offset = select(vec2(1.0), vec2(0.0), direction.xy < vec2(0.0)); // TODO can replace with 'step'
+
+    // Initially advance ray to avoid immediate self intersections.
+    var current_t:f32;
+    var position:vec3<f32>;
+    
+    ffx_sssr_initial_advance_ray(
+        origin, 
+        direction,
+        inv_direction,
+        current_mip_resolution,
+        current_mip_resolution_inv,
+        floor_offset,
+        uv_offset,
+        &position,
+        &current_t
+    );
+    
+    var i = 0u;
+    for (
+        ;
+        i < max_traversal_intersections && current_mip >= most_detailed_mip;
+        i++
+    ) {
+        
+        if (any(position.xy > vec2(1.0, 1.0)) || any(position.xy < vec2(0.0, 0.0))){
+            // outside of the viewport
+            break;
+        }
+
+        if (is_background(position.z)){
+            // hit sky/background, out of Z bounds basically
+            break;
+        }
+
+        let current_mip_position = current_mip_resolution * position.xy;
+        let surface_z            = ffx_sssr_load_depth(vec2<i32>(current_mip_position), current_mip);
+        
+        let skipped_tile = ffx_sssr_advance_ray(
+                origin,
+                direction,
+                inv_direction,
+                current_mip_position,
+                current_mip_resolution_inv,
+                floor_offset,
+                uv_offset,
+                surface_z,
+                &position,
+                &current_t
+        );
+        
+        current_mip = min(current_mip + select(-1, 1, skipped_tile), max_mip);
+        if (current_mip >= most_detailed_mip) {
+            current_mip_resolution = ffx_sssr_get_mip_resolution(screen_size, current_mip);
+            current_mip_resolution_inv = 1.0 / current_mip_resolution;
+        }
+        
+    }
+    
+    *_num_iters = i;
+    
+    *valid_hit = (current_mip <= most_detailed_mip && i > 0);
+
+    return position;
+}
+`, [
+        F32_MAX_DEFINITION,
+        chunk_rcp_v2,
+        chunk_ffx_sssr_get_mip_resolution,
+        chunk_ffx_sssr_initial_advance_ray,
+        chunk_ffx_sssr_advance_ray,
+        chunk_ffx_sssr_load_depth,
+        chunk_is_background
+    ]);

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"}