@woosh/meep-engine 3.58.0 → 3.60.0

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.d.ts

@@ -5,22 +5,27 @@
  */
 export function enquire_build_world_light_clusters_pipelines(enquiry: PipelineEnquiry): void;
 /**
- * Builds the world-space light cluster clipmap over the cascades of the irradiance clipmap.
+ * Builds the world-space light cluster clipmap over the cascades of a clipmap: the irradiance
+ * clipmap's, or the probe clipmap's bricks.
  *
  * @param {object} options
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
  * @param {import("../GPULightCollection.js").GPULightCollection} options.lights
- * @param {number} options.irradiance_clipmap_uniform graph handle of the `IRRADIANCE_CLIPMAP_STRUCT` uniform
+ * @param {number} options.levels graph handle of a uniform that starts with the clipmap's cascade windows,
+ *   a `CLIPMAP_LEVEL_ARRAY`
  * @param {number} options.cascade_count active cascade count
- * @param {ArrayLike<number>} options.coarsest_min `[x, y, z]` world min of coarsest cascade (including skirt)
- * @param {ArrayLike<number>} options.coarsest_max `[x, y, z]` world max of coarsest cascade (including skirt)
+ * @param {number} options.border cells of its own past each face of a cascade's window that its cluster
+ *   cells cover too
+ * @param {ArrayLike<number>} options.coarsest_min `[x, y, z]` world min of coarsest cascade (including the border)
+ * @param {ArrayLike<number>} options.coarsest_max `[x, y, z]` world max of coarsest cascade (including the border)
  * @returns {{lookup: number, data: number}}
  */
-export function graph_build_world_light_clusters({ graph, lights, irradiance_clipmap_uniform, cascade_count, coarsest_min, coarsest_max, }: {
+export function graph_build_world_light_clusters({ graph, lights, levels, cascade_count, border, coarsest_min, coarsest_max, }: {
     graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     lights: import("../GPULightCollection.js").GPULightCollection;
-    irradiance_clipmap_uniform: number;
+    levels: number;
     cascade_count: number;
+    border: number;
     coarsest_min: ArrayLike<number>;
     coarsest_max: ArrayLike<number>;
 }): {

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_build_world_light_clusters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js"],"names":[],"mappings":"AAoDA;;;;GAIG;AACH,sEAFW,eAAe,QAMzB;AAED;;;;;;;;;;;GAWG;AACH;IARsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IAClB,MAAM,EAArE,OAAO,0BAA0B,EAAE,kBAAkB;IACrC,0BAA0B,EAA1C,MAAM;IACU,aAAa,EAA7B,MAAM;IACqB,YAAY,EAAvC,UAAU,MAAM,CAAC;IACU,YAAY,EAAvC,UAAU,MAAM,CAAC;IACf;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CA0H1C;8BA3KY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_build_world_light_clusters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js"],"names":[],"mappings":"AAoDA;;;;GAIG;AACH,sEAFW,eAAe,QAMzB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAXsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IAClB,MAAM,EAArE,OAAO,0BAA0B,EAAE,kBAAkB;IACrC,MAAM,EAAtB,MAAM;IAEU,aAAa,EAA7B,MAAM;IACU,MAAM,EAAtB,MAAM;IAEqB,YAAY,EAAvC,UAAU,MAAM,CAAC;IACU,YAAY,EAAvC,UAAU,MAAM,CAAC;IACf;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CA6H1C;8BAlLY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js

@@ -62,22 +62,27 @@ export function enquire_build_world_light_clusters_pipelines(enquiry) {
 }
 
 /**
- * Builds the world-space light cluster clipmap over the cascades of the irradiance clipmap.
+ * Builds the world-space light cluster clipmap over the cascades of a clipmap: the irradiance
+ * clipmap's, or the probe clipmap's bricks.
  *
  * @param {object} options
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
  * @param {import("../GPULightCollection.js").GPULightCollection} options.lights
- * @param {number} options.irradiance_clipmap_uniform graph handle of the `IRRADIANCE_CLIPMAP_STRUCT` uniform
+ * @param {number} options.levels graph handle of a uniform that starts with the clipmap's cascade windows,
+ *   a `CLIPMAP_LEVEL_ARRAY`
  * @param {number} options.cascade_count active cascade count
- * @param {ArrayLike<number>} options.coarsest_min `[x, y, z]` world min of coarsest cascade (including skirt)
- * @param {ArrayLike<number>} options.coarsest_max `[x, y, z]` world max of coarsest cascade (including skirt)
+ * @param {number} options.border cells of its own past each face of a cascade's window that its cluster
+ *   cells cover too
+ * @param {ArrayLike<number>} options.coarsest_min `[x, y, z]` world min of coarsest cascade (including the border)
+ * @param {ArrayLike<number>} options.coarsest_max `[x, y, z]` world max of coarsest cascade (including the border)
  * @returns {{lookup: number, data: number}}
  */
 export function graph_build_world_light_clusters({
     graph,
     lights,
-    irradiance_clipmap_uniform,
+    levels,
     cascade_count,
+    border,
     coarsest_min,
     coarsest_max,
 }) {
@@ -151,7 +156,8 @@ export function graph_build_world_light_clusters({
 
     const assign_data = {
         cascade_count,
-        irradiance_clipmap: -1,
+        settings: { cascade_count, border },
+        levels: -1,
         culled_lights: -1,
         proxies: -1,
         lookup: -1,
@@ -174,7 +180,8 @@ export function graph_build_world_light_clusters({
             group_count_y: groups_xy,
             group_count_z: groups_z,
             bindings: {
-                irradiance_clipmap: resources.get(data.irradiance_clipmap),
+                settings: data.settings,
+                levels: resources.get(data.levels),
                 culled_lights: resources.get(data.culled_lights),
                 proxies: resources.get(data.proxies),
                 world_cluster_lookup: resources.get(data.lookup),
@@ -183,7 +190,7 @@ export function graph_build_world_light_clusters({
         });
     });
 
-    assign_data.irradiance_clipmap = assign_pass.read(irradiance_clipmap_uniform);
+    assign_data.levels = assign_pass.read(levels);
     assign_data.culled_lights = assign_pass.read(cull_data.culled_lights);
     assign_data.proxies = assign_pass.read(cull_data.proxies);
     assign_data.lookup = assign_pass.create("World cluster / lookup", LOOKUP_DESCRIPTOR);

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.d.ts

@@ -1,10 +1,17 @@
 export const WORLD_CLUSTER_ASSIGN_WORKGROUP_SIZE: readonly number[];
 /**
- * Assigns world-space culled point and spot lights to the `8 × 8 × 8` cluster cells of each
- * cascade of the world-space irradiance clipmap.
+ * @type {WebGPUStruct}
+ */
+export const WORLD_CLUSTER_ASSIGN_SETTINGS: WebGPUStruct;
+/**
+ * Assigns world-space culled point and spot lights to the `8 × 8 × 8` cluster cells of each cascade of
+ * a clipmap: `levels[c]`'s window, grown by `settings.border` of its cells past each face, then by half
+ * a cell more. The irradiance clipmap's cascades take its tile skirt as the border; the probe clipmap's
+ * bricks none.
  *
  * @type {ComputeShader}
  */
 export const shader_world_cluster_assign_lights: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_world_cluster_assign_lights.d.ts.map

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_world_cluster_assign_lights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js"],"names":[],"mappings":"AAoBA,oEAA4E;AAoI5E;;;;;GAKG;AACH,iDAFU,aAAa,CAMpB;8BA9J2B,+BAA+B"}
+{"version":3,"file":"shader_world_cluster_assign_lights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js"],"names":[],"mappings":"AAqBA,oEAA4E;AAI5E;;GAEG;AACH,4CAFU,YAAY,CAOW;AAmIjC;;;;;;;GAOG;AACH,iDAFU,aAAa,CAMpB;6BAvK0B,mCAAmC;8BAJlC,+BAA+B"}

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js

@@ -1,12 +1,13 @@
 import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
 import { COLLECTION_U32_STRUCT_WRITE } from "../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
+import { CLIPMAP_LEVEL_ARRAY, CLIPMAP_LEVEL_STRUCT } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { IRRADIANCE_CLIPMAP_TILE_BORDER } from "../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js";
-import { IRRADIANCE_CLIPMAP_STRUCT } from "../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP_STRUCT.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { chunk_light_cluster_counts } from "../cluster/chunk_light_cluster_counts.js";
 import { CLUSTER_LIGHT_PROXY } from "../cluster/CLUSTER_LIGHT_PROXY.js";
 import { chunk_cluster_light_tuple } from "../cluster/CLUSTER_LIGHT_TYPE.js";
@@ -22,10 +23,22 @@ export const WORLD_CLUSTER_ASSIGN_WORKGROUP_SIZE = Object.freeze([4, 4, 4]);
 const BATCH_SIZE = 64;
 const MAX_PER_TYPE = WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL >>> 1;
 
+/**
+ * @type {WebGPUStruct}
+ */
+export const WORLD_CLUSTER_ASSIGN_SETTINGS = WebGPUStruct.from({
+    /** the clipmap's cascades, each `levels[c]` */
+    cascade_count: u32,
+    /** cells of its own past each face of a cascade's window that its cluster cells cover too: a reader's skirt */
+    border: f32,
+}, "WorldClusterAssignSettings");
+
 const resources = new ShaderResourceSetDescriptor();
 
+resources.setImmediate("settings", WORLD_CLUSTER_ASSIGN_SETTINGS);
+
 resources.createGroup()
-    .addUniform("irradiance_clipmap", IRRADIANCE_CLIPMAP_STRUCT)
+    .addUniform("levels", CLIPMAP_LEVEL_ARRAY)
     .addStorageBuffer("culled_lights", COLLECTION_U32_STRUCT_READ, false)
     .addStorageBuffer("proxies", WebGPUArray.from(CLUSTER_LIGHT_PROXY), false)
     .addStorageBuffer("world_cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT, true)
@@ -37,7 +50,6 @@ const body = CodeChunk.from(
 const GRID_SIZE: u32 = ${WORLD_LIGHT_CLUSTER_GRID_SIZE}u;
 const BATCH_SIZE: u32 = ${BATCH_SIZE}u;
 const MAX_PER_TYPE: u32 = ${MAX_PER_TYPE}u;
-const BORDER: f32 = ${IRRADIANCE_CLIPMAP_TILE_BORDER}.0;
 
 var<workgroup> shared_tuples: array<u32, ${BATCH_SIZE}>;
 var<workgroup> shared_proxies: array<${CLUSTER_LIGHT_PROXY.wgsl_ref}, ${BATCH_SIZE}>;
@@ -49,15 +61,15 @@ fn main(
 ) {
     let cascade = global_id.z / GRID_SIZE;
     let cell = vec3<u32>(global_id.x, global_id.y, global_id.z % GRID_SIZE);
-    let valid_cell = cascade < irradiance_clipmap.cascade_count && all(cell < vec3<u32>(GRID_SIZE));
+    let valid_cell = cascade < settings.cascade_count && all(cell < vec3<u32>(GRID_SIZE));
 
     var cell_lo = vec3<f32>(0.0);
     var cell_hi = vec3<f32>(0.0);
 
     if (valid_cell) {
-        let level = irradiance_clipmap.levels[cascade];
-        let box_min = (vec3<f32>(level.corner) - vec3<f32>(BORDER)) * level.cell_size;
-        let cluster_cell_size = (vec3<f32>(level.size) + vec3<f32>(2.0 * BORDER)) * (level.cell_size / f32(GRID_SIZE));
+        let level = levels[cascade];
+        let box_min = (vec3<f32>(level.corner) - vec3<f32>(settings.border)) * level.cell_size;
+        let cluster_cell_size = (vec3<f32>(level.size) + vec3<f32>(2.0 * settings.border)) * (level.cell_size / f32(GRID_SIZE));
         let base_lo = box_min + vec3<f32>(cell) * cluster_cell_size;
         let half_voxel = vec3<f32>(0.5 * level.cell_size);
         cell_lo = base_lo - half_voxel;
@@ -140,7 +152,7 @@ fn main(
     })};
 }
 `, [
-        IRRADIANCE_CLIPMAP_STRUCT.declaration_chunk,
+        CLIPMAP_LEVEL_STRUCT.declaration_chunk,
         CLUSTER_LIGHT_PROXY.declaration_chunk,
         LIGHT_CLUSTER_METADATA.declaration_chunk,
         chunk_grid3d_to_index,
@@ -151,8 +163,10 @@ fn main(
 );
 
 /**
- * Assigns world-space culled point and spot lights to the `8 × 8 × 8` cluster cells of each
- * cascade of the world-space irradiance clipmap.
+ * Assigns world-space culled point and spot lights to the `8 × 8 × 8` cluster cells of each cascade of
+ * a clipmap: `levels[c]`'s window, grown by `settings.border` of its cells past each face, then by half
+ * a cell more. The irradiance clipmap's cascades take its tile skirt as the border; the probe clipmap's
+ * bricks none.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/lightmap/bake/shader_lightmap_viz_to_irradiance_flat.js

@@ -169,7 +169,7 @@ fn main(
         );
         
         let material = materials[mesh.material];
-        var texture_sample_orm = indirect_sample_texture(material.texture_orm, material.sampler_orm, geometry_uv).rgba;
+        var texture_sample_orm = indirect_sample_texture(material.texture_orm, material.sampler_orm, geometry_uv, 0.0).rgba;
         
         
         let roughness = saturate(texture_sample_orm.g * material.roughness_factor);

package/src/shade/renderer/lightmap/bake/shader_lightmap_viz_to_sh.js

@@ -171,7 +171,7 @@ fn main(
         );
         
         let material = materials[mesh.material];
-        var texture_sample_orm = indirect_sample_texture(material.texture_orm, material.sampler_orm, geometry_uv).rgba;
+        var texture_sample_orm = indirect_sample_texture(material.texture_orm, material.sampler_orm, geometry_uv, 0.0).rgba;
         
         
         let roughness = texture_sample_orm.g * material.roughness_factor;

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#298@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#300@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAkIA;IAqMI;;;;OAIG;IACH,yCAFW,eAAe,EAwDzB;IA9PD;;;;OAIG;IACH,wBAAkC;IA4BlC;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAoBD;;OAEG;IACH,sCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IA4JD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAqBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBAiIC;IA6DD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD,eAWC;IAGD,gBAMC;;CACJ;8BA/0BY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAlB5C,oCAAoC;AAYtE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}
+{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAmIA;IAqMI;;;;OAIG;IACH,yCAFW,eAAe,EAyDzB;IA/PD;;;;OAIG;IACH,wBAAkC;IA4BlC;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAoBD;;OAEG;IACH,sCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IA6JD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAqBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA4DC;IAkJD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD,eAWC;IAGD,gBAMC;;CACJ;8BAh2BY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAnB5C,oCAAoC;AAatE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.js

@@ -21,6 +21,7 @@ import { INDIRECT_MATERIAL_ARRAY_TYPE } from "./INDIRECT_MATERIAL_ARRAY_TYPE.js"
 import { INDIRECT_MATERIAL_STRUCT } from "./INDIRECT_MATERIAL_STRUCT.js";
 import {
     RESIDENT_MATERIAL_TEXTURE_LAYER_SIZE,
+    RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT,
     RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
     RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION
 } from "./RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
@@ -381,7 +382,8 @@ export class GPUResidentMaterialContext {
         descriptor.format = "rgba8unorm";
         descriptor.dimension = "2d";
         descriptor.size = [RESIDENT_MATERIAL_TEXTURE_LAYER_SIZE, RESIDENT_MATERIAL_TEXTURE_LAYER_SIZE, 1];
-        descriptor.mipLevelCount = 1;
+        // a slot's chain down to one texel; see RESIDENT_MATERIAL_TEXTURE_LAYOUT
+        descriptor.mipLevelCount = RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT;
         descriptor.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_DST;
 
     }
@@ -548,8 +550,6 @@ export class GPUResidentMaterialContext {
             Math.ceil(texture_count / slice_slot_count)
         );
 
-        const target_texture = this.buffer_textures;
-
         const texture_manager = this.#texture_manager;
 
         {
@@ -582,80 +582,13 @@ export class GPUResidentMaterialContext {
 
             const source_ctx = texture_manager.obtain(source);
 
-            const is_square = source_ctx.width === source_ctx.height;
-
-            /*
-             The fast path is a copyTextureToTexture, which requires the two formats to be
-             copy-compatible. `!is_srgb` used to stand in for that and was true only by accident: every
-             material texture was rgba8unorm, so the only way to differ was the srgb suffix. A BC7
-             source would have reached the copy and failed validation.
-
-             Asking the question directly costs nothing and covers every format at once — a source
-             that does not match takes the render path below, which samples it into the atlas and is
-             what that path exists for.
-            */
-            const format_matches = source_ctx.gpu_texture.format === target_texture.gpu_texture.format;
-
-            const is_pot_w = isPowerOfTwo(source_ctx.width) && isPowerOfTwo(source_ctx.height);
-
-            const source_mip_w = Math.log2(source_ctx.width / RESIDENT_MATERIAL_TEXTURE_RESOLUTION)
-            const source_mip_h = Math.log2(source_ctx.height / RESIDENT_MATERIAL_TEXTURE_RESOLUTION)
-
-
             const texture_slot_z = Math.floor(info.id / slice_slot_count);
             const id_in_slice = info.id % slice_slot_count;
             const texture_slot_y = Math.floor(id_in_slice / RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION);
             const texture_slot_x = id_in_slice % RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION;
 
-            if (is_square && is_pot_w && source_mip_w >= 0 && source_ctx.gpu_texture.mipLevelCount >= source_mip_w && format_matches) {
-
-                encoder.copyTextureToTexture(
-                    {
-                        texture: source_ctx.gpu_texture,
-                        mipLevel: source_mip_w,
-                    },
-                    {
-                        texture: target_texture.gpu_texture,
-                        mipLevel: 0,
-                        origin: [
-                            texture_slot_x * RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
-                            texture_slot_y * RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
-                            texture_slot_z
-                        ]
-                    },
-                    [RESIDENT_MATERIAL_TEXTURE_RESOLUTION, RESIDENT_MATERIAL_TEXTURE_RESOLUTION]
-                );
-
-            } else {
-                const nearest_mip = Math.max(0, Math.floor(Math.min(source_mip_w, source_mip_h)));
-
-                // needs resizing and potentially color-space conversion
-                render_copy_texture(
-                    {
-                        graphics: this.#graphics,
-                        encoder: encoder,
-                        target_format: target_texture.gpu_texture.format,
-                        output_view: target_texture.obtainView(TextureViewDescriptor.from({
-                            baseArrayLayer: texture_slot_z,
-                            dimension: "2d"
-                        })),
-                        source_view: source_ctx.obtainView(TextureViewDescriptor.from({
-                            baseMipLevel: nearest_mip
-                        })),
-                        source_clip: [
-                            0, 0,
-                            source_ctx.width >> nearest_mip, source_ctx.height >> nearest_mip
-                        ],
-                        output_clip: [
-                            texture_slot_x * RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
-                            texture_slot_y * RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
-
-                            RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
-                            RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
-                        ]
-                    },
-                );
-
+            for (let level = 0; level < RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT; level++) {
+                this.#write_slot_level(encoder, source_ctx, texture_slot_x, texture_slot_y, texture_slot_z, level);
             }
         }
 
@@ -665,6 +598,91 @@ export class GPUResidentMaterialContext {
 
     }
 
+    /**
+     * Mip `level` of a texture's slot, from the texture's own chain: copied from the source level the
+     * slot's level is the size of, or drawn from the source level nearest above its size where no level
+     * can be copied as it is. The source's chain does the filtering either way.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {GPUTextureContext} source_ctx
+     * @param {number} slot_x
+     * @param {number} slot_y
+     * @param {number} slot_z
+     * @param {number} level
+     */
+    #write_slot_level(encoder, source_ctx, slot_x, slot_y, slot_z, level) {
+        const target_texture = this.#buffer_textures;
+        const source_texture = source_ctx.gpu_texture;
+
+        const size = RESIDENT_MATERIAL_TEXTURE_RESOLUTION >> level;
+
+        const is_square = source_ctx.width === source_ctx.height;
+
+        /*
+         The fast path is a copyTextureToTexture, which requires the two formats to be
+         copy-compatible. `!is_srgb` used to stand in for that and was true only by accident: every
+         material texture was rgba8unorm, so the only way to differ was the srgb suffix. A BC7
+         source would have reached the copy and failed validation.
+
+         Asking the question directly costs nothing and covers every format at once — a source
+         that does not match takes the render path below, which samples it into the atlas and is
+         what that path exists for.
+        */
+        const format_matches = source_texture.format === target_texture.gpu_texture.format;
+
+        const is_pot_w = isPowerOfTwo(source_ctx.width) && isPowerOfTwo(source_ctx.height);
+
+        const source_mip_w = Math.log2(source_ctx.width / size);
+        const source_mip_h = Math.log2(source_ctx.height / size);
+
+        if (is_square && is_pot_w && source_mip_w >= 0 && source_mip_w < source_texture.mipLevelCount && format_matches) {
+
+            encoder.copyTextureToTexture(
+                {
+                    texture: source_texture,
+                    mipLevel: source_mip_w,
+                },
+                {
+                    texture: target_texture.gpu_texture,
+                    mipLevel: level,
+                    origin: [slot_x * size, slot_y * size, slot_z]
+                },
+                [size, size]
+            );
+
+        } else {
+            // a chain that stops short draws from its last level
+            const nearest_mip = Math.min(
+                Math.max(0, Math.floor(Math.min(source_mip_w, source_mip_h))),
+                source_texture.mipLevelCount - 1
+            );
+
+            // needs resizing and potentially color-space conversion
+            render_copy_texture(
+                {
+                    graphics: this.#graphics,
+                    encoder: encoder,
+                    target_format: target_texture.gpu_texture.format,
+                    output_view: target_texture.obtainView(TextureViewDescriptor.from({
+                        baseArrayLayer: slot_z,
+                        dimension: "2d",
+                        baseMipLevel: level,
+                        mipLevelCount: 1,
+                    })),
+                    source_view: source_ctx.obtainView(TextureViewDescriptor.from({
+                        baseMipLevel: nearest_mip
+                    })),
+                    source_clip: [
+                        0, 0,
+                        source_ctx.width >> nearest_mip, source_ctx.height >> nearest_mip
+                    ],
+                    output_clip: [slot_x * size, slot_y * size, size, size]
+                },
+            );
+
+        }
+    }
+
     /**
      * Every texture slot's mean, after the slots are written (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6):
      * the rows' sums, then the slots' means, which {@link buffer_texture_means} holds.

package/src/shade/renderer/material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.d.ts

@@ -3,6 +3,11 @@
  * @type {number}
  */
 export const RESIDENT_MATERIAL_TEXTURE_RESOLUTION: number;
+/**
+ * Mip levels a slot has, the last one texel.
+ * @type {number}
+ */
+export const RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT: number;
 /**
  * Texels a side of a layer.
  * @type {number}

package/src/shade/renderer/material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RESIDENT_MATERIAL_TEXTURE_LAYOUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,mDAFU,MAAM,CAEuC;AAEvD;;;GAGG;AACH,mDAFU,MAAM,CAEyC;AAEzD;;;GAGG;AACH,wDAFU,MAAM,CAEiI;AAEjJ;;;GAGG;AACH,wDAFU,MAAM,CAE+H"}
+{"version":3,"file":"RESIDENT_MATERIAL_TEXTURE_LAYOUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH,mDAFU,MAAM,CAEuC;AAEvD;;;GAGG;AACH,oDAFU,MAAM,CAEyF;AAEzG;;;GAGG;AACH,mDAFU,MAAM,CAEyC;AAEzD;;;GAGG;AACH,wDAFU,MAAM,CAEiI;AAEjJ;;;GAGG;AACH,wDAFU,MAAM,CAE+H"}

package/src/shade/renderer/material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js

@@ -3,6 +3,9 @@
  each texture a square slot, the slots in rows across a layer, the layers stacked. Slot `s` is in layer
  `⌊s / SLOTS_PER_LAYER⌋`, at column `s mod SLOT_RESOLUTION` and row `⌊s / SLOT_RESOLUTION⌋ mod
  SLOT_RESOLUTION` of it.
+
+ The array has LEVEL_COUNT mip levels, a slot's chain down to one texel: level k of a slot is
+ (RESOLUTION >> k)² texels at the slot's level-0 origin >> k, in level k of the same layer.
 */
 
 /**
@@ -11,6 +14,12 @@
  */
 export const RESIDENT_MATERIAL_TEXTURE_RESOLUTION = 64;
 
+/**
+ * Mip levels a slot has, the last one texel.
+ * @type {number}
+ */
+export const RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT = Math.log2(RESIDENT_MATERIAL_TEXTURE_RESOLUTION) + 1;
+
 /**
  * Texels a side of a layer.
  * @type {number}