@woosh/meep-engine 3.58.0 → 3.60.0

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_tangent_normal.js

@@ -4,9 +4,10 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { chunk_indirect_sample_texture } from "./chunk_indirect_sample_texture.js";
 
 /**
- * A resident material's tangent-space normal at `uv`, from its normal texture in the atlas — or +Z,
- * the geometric normal exactly, when it has none (`id` is GPU_DATABASE_NULL; see
- * INDIRECT_MATERIAL_STRUCT's `texture_normal` for why there is no default texture to read instead).
+ * A resident material's tangent-space normal at `uv`, from its normal texture in the atlas at `level`
+ * (see {@link chunk_indirect_sample_texture}) — or +Z, the geometric normal exactly, when it has none
+ * (`id` is GPU_DATABASE_NULL; see INDIRECT_MATERIAL_STRUCT's `texture_normal` for why there is no
+ * default texture to read instead).
  *
  * Reads the `textures` atlas binding, which {@link chunk_indirect_sample_texture} leaves to the
  * shader that includes it.
@@ -16,12 +17,12 @@ import { chunk_indirect_sample_texture } from "./chunk_indirect_sample_texture.j
 export const chunk_indirect_sample_tangent_normal = CodeChunk.from(
     //language=WGSL
     `
-fn indirect_sample_tangent_normal(id: u32, sampler_packed: u32, uv: vec2<f32>) -> vec3<f32> {
+fn indirect_sample_tangent_normal(id: u32, sampler_packed: u32, uv: vec2<f32>, level: f32) -> vec3<f32> {
     if (id == ${GPU_DATABASE_NULL}u) {
         return vec3<f32>(0.0, 0.0, 1.0);
     }
 
-    return decode_tangent_normal(indirect_sample_texture(id, sampler_packed, uv));
+    return decode_tangent_normal(indirect_sample_texture(id, sampler_packed, uv, level));
 }
 `, [
         chunk_decode_tangent_normal,

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture.d.ts

@@ -1,3 +1,18 @@
-export const chunk_indirect_sample_texture: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+/**
+ * A resident material texture filtered at a level:
+ * `indirect_sample_texture(id: u32, sampler_packed: u32, uv: vec2<f32>, level: f32) -> vec4<f32>`, texture
+ * `id` of the atlas with its packed sampler's wrap and filter, trilinearly at `level`: log2 of the texels
+ * of a slot's level 0 the read's footprint spans, clamped to the slot's chain. A read at level 0 is
+ * level 0's bilinear filter.
+ *
+ * By the pass's {@link INDIRECT_TEXTURE_FILTER}: one tap of the filter
+ * ({@link chunk_indirect_sample_texture_stochastic}, the default), or the filter itself
+ * ({@link chunk_indirect_sample_texture_exact}).
+ *
+ * Reads the `textures` atlas binding, which the shader that includes it declares.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_indirect_sample_texture: CodeChunkChoice;
+import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
 //# sourceMappingURL=chunk_indirect_sample_texture.d.ts.map

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_indirect_sample_texture.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture.js"],"names":[],"mappings":"AAWA,sDA6CE;0BApDwB,oCAAoC"}
+{"version":3,"file":"chunk_indirect_sample_texture.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,4CAFU,eAAe,CAEkE;gCArB3D,0CAA0C"}

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture.js

@@ -1,57 +1,25 @@
-import { chunk_coordinate_wrap } from "../../shader/chunk/texture/chunk_coordinate_wrap.js";
-import { chunk_texture_sampler_enums } from "../../shader/chunk/texture/chunk_texture_sampler_enums.js";
-import { chunk_sampler_descriptor_unpack } from "../../shader/chunk/texture/chunk_sampler_descriptor_unpack.js";
-import { chunk_random_round_vec2 } from "../../shader/chunk/random/chunk_random_round_vec2.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import {
-    RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
-    RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION,
-    RESIDENT_MATERIAL_TEXTURE_SLOTS_PER_LAYER
-} from "../../material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
-
-export const chunk_indirect_sample_texture = CodeChunk.from(
-//language=WGSL
-    `
-fn indirect_sample_texture(id: u32, sampler_packed: u32, uv: vec2<f32>) -> vec4<f32>{
-
-    let sampler = sampler_descriptor_unpack(sampler_packed);
-
-    // figure out slot
-    let slot_z = id / ${RESIDENT_MATERIAL_TEXTURE_SLOTS_PER_LAYER};
-
-    let in_slice_id = id - slot_z * ${RESIDENT_MATERIAL_TEXTURE_SLOTS_PER_LAYER};
-
-    let slot_y = in_slice_id / ${RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION};
-    let slot_x = in_slice_id % ${RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION};
-
-    let texture_texel_coord = uv * vec2<f32>( ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION} ) - 0.5;
-
-    // Texture Filtering: Nearest snaps to the closest texel; everything else
-    // (Linear and the higher-order filters) resolves to a stochastic bilinear
-    // tap, which converges to the filtered result across many samples. Mip
-    // level is ignored in the indirect path - we always read level 0.
-    var sample_coord: vec2<f32>;
-    if (sampler.mag_filter == TEXTURE_FILTER_NEAREST) {
-        sample_coord = round(texture_texel_coord);
-    } else {
-        sample_coord = random_round_vec2(texture_texel_coord);
-    }
-
-    // Texture Wrapping (per-axis, S->U / T->V)
-    let wrapped_coord = vec2(
-        coordinate_wrap(sample_coord.x, ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}, sampler.address_mode_u),
-        coordinate_wrap(sample_coord.y, ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}, sampler.address_mode_v),
-    );
-
-    // Convert to atlas space
-    let pixel_coord = vec2<u32>(slot_x, slot_y) * ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION} +  vec2<u32>(wrapped_coord);
-
-    return textureLoad(textures, pixel_coord, slot_z, 0 );
-}
-    `, [
-        chunk_random_round_vec2,
-        chunk_coordinate_wrap,
-        chunk_texture_sampler_enums,
-        chunk_sampler_descriptor_unpack,
-    ]
-);
+import { CodeChunkChoice } from "../../shader/compiler/CodeChunkChoice.js";
+import { chunk_indirect_sample_texture_exact } from "./chunk_indirect_sample_texture_exact.js";
+import { chunk_indirect_sample_texture_stochastic } from "./chunk_indirect_sample_texture_stochastic.js";
+import { INDIRECT_TEXTURE_FILTER } from "./INDIRECT_TEXTURE_FILTER.js";
+import { IndirectTextureFilter } from "./IndirectTextureFilter.js";
+
+/**
+ * A resident material texture filtered at a level:
+ * `indirect_sample_texture(id: u32, sampler_packed: u32, uv: vec2<f32>, level: f32) -> vec4<f32>`, texture
+ * `id` of the atlas with its packed sampler's wrap and filter, trilinearly at `level`: log2 of the texels
+ * of a slot's level 0 the read's footprint spans, clamped to the slot's chain. A read at level 0 is
+ * level 0's bilinear filter.
+ *
+ * By the pass's {@link INDIRECT_TEXTURE_FILTER}: one tap of the filter
+ * ({@link chunk_indirect_sample_texture_stochastic}, the default), or the filter itself
+ * ({@link chunk_indirect_sample_texture_exact}).
+ *
+ * Reads the `textures` atlas binding, which the shader that includes it declares.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_indirect_sample_texture = CodeChunkChoice.from(INDIRECT_TEXTURE_FILTER);
+
+chunk_indirect_sample_texture.add(IndirectTextureFilter.Stochastic, chunk_indirect_sample_texture_stochastic);
+chunk_indirect_sample_texture.add(IndirectTextureFilter.Exact, chunk_indirect_sample_texture_exact);

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture_exact.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `indirect_sample_texture(id, sampler_packed, uv, level)` as the filter itself
+ * ({@link INDIRECT_TEXTURE_FILTER} `Exact`): bilinear at the levels on either side of `level`, lerped by
+ * where it falls between them. No draw, so the same read gives the same value every time.
+ *
+ * Between a level's texels the filter is the sampler's mag filter, at every level, as the stochastic
+ * read takes it: Nearest snaps to the closest texel.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_indirect_sample_texture_exact: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_indirect_sample_texture_exact.d.ts.map

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture_exact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_indirect_sample_texture_exact.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture_exact.js"],"names":[],"mappings":"AAUA;;;;;;;;;GASG;AACH,kDAFU,SAAS,CAmDjB;0BA9DwB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture_exact.js

@@ -0,0 +1,70 @@
+import {
+    RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT,
+    RESIDENT_MATERIAL_TEXTURE_RESOLUTION
+} from "../../material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
+import { chunk_sampler_descriptor_unpack } from "../../shader/chunk/texture/chunk_sampler_descriptor_unpack.js";
+import { chunk_texture_sampler_enums } from "../../shader/chunk/texture/chunk_texture_sampler_enums.js";
+import { SAMPLER_DESCRIPTOR_STRUCT } from "../../shader/chunk/texture/SAMPLER_DESCRIPTOR_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_indirect_texture_load } from "./chunk_indirect_texture_load.js";
+
+/**
+ * `indirect_sample_texture(id, sampler_packed, uv, level)` as the filter itself
+ * ({@link INDIRECT_TEXTURE_FILTER} `Exact`): bilinear at the levels on either side of `level`, lerped by
+ * where it falls between them. No draw, so the same read gives the same value every time.
+ *
+ * Between a level's texels the filter is the sampler's mag filter, at every level, as the stochastic
+ * read takes it: Nearest snaps to the closest texel.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_indirect_sample_texture_exact = CodeChunk.from(
+//language=WGSL
+    `
+fn indirect_sample_texture_level(id: u32, sampler: ${SAMPLER_DESCRIPTOR_STRUCT.wgsl_ref}, uv: vec2<f32>, mip: u32) -> vec4<f32>{
+
+    let texture_texel_coord = uv * f32(${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}u >> mip) - 0.5;
+
+    if (sampler.mag_filter == TEXTURE_FILTER_NEAREST) {
+        return indirect_texture_load(id, sampler, round(texture_texel_coord), mip);
+    }
+
+    let corner = floor(texture_texel_coord);
+    let weight = texture_texel_coord - corner;
+
+    let row_0 = mix(
+        indirect_texture_load(id, sampler, corner, mip),
+        indirect_texture_load(id, sampler, corner + vec2<f32>(1.0, 0.0), mip),
+        weight.x
+    );
+    let row_1 = mix(
+        indirect_texture_load(id, sampler, corner + vec2<f32>(0.0, 1.0), mip),
+        indirect_texture_load(id, sampler, corner + vec2<f32>(1.0, 1.0), mip),
+        weight.x
+    );
+
+    return mix(row_0, row_1, weight.y);
+}
+
+fn indirect_sample_texture(id: u32, sampler_packed: u32, uv: vec2<f32>, level: f32) -> vec4<f32>{
+
+    let sampler = sampler_descriptor_unpack(sampler_packed);
+
+    let within = clamp(level, 0.0, ${RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT - 1}.0);
+
+    let lower = u32(within);
+    let upper = min(lower + 1u, ${RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT - 1}u);
+
+    return mix(
+        indirect_sample_texture_level(id, sampler, uv, lower),
+        indirect_sample_texture_level(id, sampler, uv, upper),
+        within - f32(lower)
+    );
+}
+    `, [
+        SAMPLER_DESCRIPTOR_STRUCT.declaration_chunk,
+        chunk_texture_sampler_enums,
+        chunk_sampler_descriptor_unpack,
+        chunk_indirect_texture_load,
+    ]
+);

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture_stochastic.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `indirect_sample_texture(id, sampler_packed, uv, level)` as one tap of the filter
+ * ({@link INDIRECT_TEXTURE_FILTER} `Stochastic`, the default): what the filter gives on average, which
+ * a pass converges to across many reads.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_indirect_sample_texture_stochastic: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_indirect_sample_texture_stochastic.d.ts.map

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture_stochastic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_indirect_sample_texture_stochastic.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture_stochastic.js"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH,uDAFU,SAAS,CA0CjB;0BAlDwB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_texture_stochastic.js

@@ -0,0 +1,59 @@
+import {
+    RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT,
+    RESIDENT_MATERIAL_TEXTURE_RESOLUTION
+} from "../../material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
+import { chunk_random } from "../../shader/chunk/random/chunk_random.js";
+import { chunk_random_round_vec2 } from "../../shader/chunk/random/chunk_random_round_vec2.js";
+import { chunk_sampler_descriptor_unpack } from "../../shader/chunk/texture/chunk_sampler_descriptor_unpack.js";
+import { chunk_texture_sampler_enums } from "../../shader/chunk/texture/chunk_texture_sampler_enums.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_indirect_texture_load } from "./chunk_indirect_texture_load.js";
+
+/**
+ * `indirect_sample_texture(id, sampler_packed, uv, level)` as one tap of the filter
+ * ({@link INDIRECT_TEXTURE_FILTER} `Stochastic`, the default): what the filter gives on average, which
+ * a pass converges to across many reads.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_indirect_sample_texture_stochastic = CodeChunk.from(
+//language=WGSL
+    `
+fn indirect_sample_texture(id: u32, sampler_packed: u32, uv: vec2<f32>, level: f32) -> vec4<f32>{
+
+    let sampler = sampler_descriptor_unpack(sampler_packed);
+
+    // a level between two is the upper one with the probability of its fraction: a draw, and none at a
+    // whole level, so a read at level 0 takes the random numbers it always did
+    let within = clamp(level, 0.0, ${RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT - 1}.0);
+
+    var mip = u32(within);
+
+    let fraction = within - f32(mip);
+
+    if (fraction > 0.0 && random() < fraction) {
+        mip += 1u;
+    }
+
+    let texture_texel_coord = uv * f32(${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}u >> mip) - 0.5;
+
+    // Texture Filtering: Nearest snaps to the closest texel; everything else
+    // (Linear and the higher-order filters) resolves to a stochastic bilinear
+    // tap, which converges to the filtered result across many samples.
+    var sample_coord: vec2<f32>;
+    if (sampler.mag_filter == TEXTURE_FILTER_NEAREST) {
+        sample_coord = round(texture_texel_coord);
+    } else {
+        sample_coord = random_round_vec2(texture_texel_coord);
+    }
+
+    return indirect_texture_load(id, sampler, sample_coord, mip);
+}
+    `, [
+        chunk_random,
+        chunk_random_round_vec2,
+        chunk_texture_sampler_enums,
+        chunk_sampler_descriptor_unpack,
+        chunk_indirect_texture_load,
+    ]
+);

package/src/shade/renderer/path_tracer/shader/chunk_indirect_texture_load.d.ts

@@ -0,0 +1,12 @@
+/**
+ * One texel of a resident material texture: `indirect_texture_load(id, sampler, texel, level)`, the texel
+ * at the integer-valued coordinate `texel` of texture `id`'s slot at mip `level`, the coordinate wrapped
+ * within the slot at that level by the sampler's address modes (RESIDENT_MATERIAL_TEXTURE_LAYOUT).
+ *
+ * Reads the `textures` atlas binding, which the shader that includes it declares.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_indirect_texture_load: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_indirect_texture_load.d.ts.map

package/src/shade/renderer/path_tracer/shader/chunk_indirect_texture_load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_indirect_texture_load.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_indirect_texture_load.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH,0CAFU,SAAS,CAgCjB;0BAzCwB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_indirect_texture_load.js

@@ -0,0 +1,49 @@
+import {
+    RESIDENT_MATERIAL_TEXTURE_RESOLUTION,
+    RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION,
+    RESIDENT_MATERIAL_TEXTURE_SLOTS_PER_LAYER
+} from "../../material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
+import { chunk_coordinate_wrap } from "../../shader/chunk/texture/chunk_coordinate_wrap.js";
+import { SAMPLER_DESCRIPTOR_STRUCT } from "../../shader/chunk/texture/SAMPLER_DESCRIPTOR_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * One texel of a resident material texture: `indirect_texture_load(id, sampler, texel, level)`, the texel
+ * at the integer-valued coordinate `texel` of texture `id`'s slot at mip `level`, the coordinate wrapped
+ * within the slot at that level by the sampler's address modes (RESIDENT_MATERIAL_TEXTURE_LAYOUT).
+ *
+ * Reads the `textures` atlas binding, which the shader that includes it declares.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_indirect_texture_load = CodeChunk.from(
+//language=WGSL
+    `
+fn indirect_texture_load(id: u32, sampler: ${SAMPLER_DESCRIPTOR_STRUCT.wgsl_ref}, texel: vec2<f32>, level: u32) -> vec4<f32> {
+
+    // figure out slot
+    let slot_z = id / ${RESIDENT_MATERIAL_TEXTURE_SLOTS_PER_LAYER};
+
+    let in_slice_id = id - slot_z * ${RESIDENT_MATERIAL_TEXTURE_SLOTS_PER_LAYER};
+
+    let slot_y = in_slice_id / ${RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION};
+    let slot_x = in_slice_id % ${RESIDENT_MATERIAL_TEXTURE_SLOT_RESOLUTION};
+
+    let size = ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}u >> level;
+
+    // Texture Wrapping (per-axis, S->U / T->V)
+    let wrapped_coord = vec2(
+        coordinate_wrap(texel.x, f32(size), sampler.address_mode_u),
+        coordinate_wrap(texel.y, f32(size), sampler.address_mode_v),
+    );
+
+    // Convert to atlas space
+    let pixel_coord = vec2<u32>(slot_x, slot_y) * size + vec2<u32>(wrapped_coord);
+
+    return textureLoad(textures, pixel_coord, slot_z, level);
+}
+    `, [
+        SAMPLER_DESCRIPTOR_STRUCT.declaration_chunk,
+        chunk_coordinate_wrap,
+    ]
+);

package/src/shade/renderer/path_tracer/shader/chunk_ray_hit_to_opacity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ray_hit_to_opacity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_ray_hit_to_opacity.js"],"names":[],"mappings":"AASA,iDAmCC;0BAvCyB,oCAAoC"}
+{"version":3,"file":"chunk_ray_hit_to_opacity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_ray_hit_to_opacity.js"],"names":[],"mappings":"AASA,iDAoCC;0BAxCyB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_ray_hit_to_opacity.js

@@ -33,6 +33,7 @@ fn ray_hit_to_opacity(
         triangle_lambda,
         node.global,
         ray_direction,
+        0.0,
     );
 }
     `, [

package/src/shade/renderer/path_tracer/shader/chunk_render_trace_path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_render_trace_path.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js"],"names":[],"mappings":"AA2CA,oDAIG;AAEH;;;;;;GAMG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;;;GAOG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,gCAFU,MAAM,CAEsB;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,gDAwhBE;6BA5pB2B,mCAAmC;0BA2BtC,oCAAoC"}
+{"version":3,"file":"chunk_render_trace_path.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js"],"names":[],"mappings":"AA2CA,oDAIG;AAEH;;;;;;GAMG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;;;GAOG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,gCAFU,MAAM,CAEsB;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,gDAyhBE;6BA7pB2B,mCAAmC;0BA2BtC,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js

@@ -272,6 +272,7 @@ fn render_trace_path(
             triangle_info,
             triangle_lambda,
             node.global,
+            0.0,
         );
 
         shading_closure_from_material_data(

package/src/shade/renderer/path_tracer/shader/chunk_sample_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material.js"],"names":[],"mappings":"AASA,8CAmCO;0BAxCmB,oCAAoC"}
+{"version":3,"file":"chunk_sample_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material.js"],"names":[],"mappings":"AASA,8CAoCO;0BAzCmB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material.js

@@ -25,7 +25,8 @@ fn sample_material(
         material,
         triangle,
         lambda,
-        instance_transform
+        instance_transform,
+        0.0
     );
     
     shading_closure_from_material_data(

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.d.ts

@@ -3,6 +3,13 @@
  * @type {CodeChunk}
  */
 export const chunk_sample_material_alpha: CodeChunk;
+/**
+ * The resident material at a hit: `sample_material_data(incoming_ray, material, triangle, lambda,
+ * instance_transform, texture_level)`, its textures read at `texture_level` — see
+ * {@link chunk_indirect_sample_texture}. Every texture's slot is the same size, so one level serves all
+ * four.
+ * @type {CodeChunk}
+ */
 export const chunk_sample_material_data: CodeChunk;
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_sample_material_data.d.ts.map

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,0CAFU,SAAS,CA+FlB;AAED,mDAwIC;0BAnPyB,oCAAoC"}
+{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,0CAFU,SAAS,CAgGlB;AAED;;;;;;GAMG;AACH,yCAFU,SAAS,CA2IlB;0BA5PyB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js

@@ -45,6 +45,7 @@ fn sample_material_alpha(
     lambda: vec3<f32>,
     instance_transform: mat4x4<f32>,
     ray_direction: vec3<f32>,
+    texture_level: f32,
 ) -> ${RAY_HIT_TRANSPARENT_SURFACE_DESCRIPTION_STRUCT.wgsl_ref}{
 
     let vertex_0 = triangle.a;
@@ -63,7 +64,7 @@ fn sample_material_alpha(
         lambda
     );
 
-    var texture_sample_diffuse = indirect_sample_texture(material.texture_albedo, material.sampler_albedo, uv).rgba;
+    var texture_sample_diffuse = indirect_sample_texture(material.texture_albedo, material.sampler_albedo, uv, texture_level).rgba;
 
     var normal_model_matrix = compute_normal_matrix_from_m4(instance_transform);
 
@@ -131,6 +132,13 @@ fn sample_material_alpha(
     ]
 )
 
+/**
+ * The resident material at a hit: `sample_material_data(incoming_ray, material, triangle, lambda,
+ * instance_transform, texture_level)`, its textures read at `texture_level` — see
+ * {@link chunk_indirect_sample_texture}. Every texture's slot is the same size, so one level serves all
+ * four.
+ * @type {CodeChunk}
+ */
 export const chunk_sample_material_data = CodeChunk.from(
     //language=WGSL
     `
@@ -139,7 +147,8 @@ fn sample_material_data(
     material:${INDIRECT_MATERIAL_STRUCT.wgsl_ref},
     triangle:${TRIANGLE_VERTICES_STRUCT.wgsl_ref},
     lambda: vec3<f32>,
-    instance_transform: mat4x4<f32>, 
+    instance_transform: mat4x4<f32>,
+    texture_level: f32,
 ) -> ${STANDARD_MATERIAL_DATA_STRUCT.wgsl_ref}{
 
     let vertex_0 = triangle.a;
@@ -165,10 +174,10 @@ fn sample_material_data(
         lambda
     );
     
-    var texture_sample_diffuse = indirect_sample_texture(material.texture_albedo, material.sampler_albedo, uv).rgba;
+    var texture_sample_diffuse = indirect_sample_texture(material.texture_albedo, material.sampler_albedo, uv, texture_level).rgba;
 
 
-    var texture_sample_orm = indirect_sample_texture(material.texture_orm, material.sampler_orm, uv).rgba;
+    var texture_sample_orm = indirect_sample_texture(material.texture_orm, material.sampler_orm, uv, texture_level).rgba;
 
     var geometry_normal = interpolate_attribute_3f32( 
         vertex_0.normal,
@@ -216,7 +225,7 @@ fn sample_material_data(
 
     let world_tangent_frame = build_orthonormal_matrix_nt(world_vertex_normal, vec4(world_tangent, tangent_handedness));
 
-    var normal_sample = indirect_sample_tangent_normal(material.texture_normal, material.sampler_normal, uv);
+    var normal_sample = indirect_sample_tangent_normal(material.texture_normal, material.sampler_normal, uv, texture_level);
     
     var output: ${STANDARD_MATERIAL_DATA_STRUCT.wgsl_ref};
     
@@ -238,7 +247,7 @@ fn sample_material_data(
      the encoding of one texture, and this is the renderer the other is compared against.
     */
     let dithered_diffuse_sample = max(vec3(0.0), albedo_unpremultiply(texture_sample_diffuse) + (random_vec3() - 0.5 ) * bit_step);
-    let texture_sample_emissive = max(vec3(0.0), indirect_sample_texture(material.texture_emissive, material.sampler_emissive, uv).rgb + (random_vec3() - 0.5 ) * bit_step);
+    let texture_sample_emissive = max(vec3(0.0), indirect_sample_texture(material.texture_emissive, material.sampler_emissive, uv, texture_level).rgb + (random_vec3() - 0.5 ) * bit_step);
 
 
     output.albedo = dithered_diffuse_sample * material.color_albedo.rgb * geometry_color;

package/src/shade/renderer/postprocess/PostProcess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PostProcess.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/postprocess/PostProcess.js"],"names":[],"mappings":"AAGA;IAYI;;;OAGG;IACH,uCAIC;IAnBD;;OAEG;IACH,MAFU,IAAI,CAEV;IAGJ;;OAEG;IACH,KAFU,GAAG,CAEV;IAYH;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED,sBAEC;CACJ;qBApCoB,gBAAgB;oBACjB,cAAc"}
+{"version":3,"file":"PostProcess.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/postprocess/PostProcess.js"],"names":[],"mappings":"AAGA;IAYI;;;OAGG;IACH,uCAIC;IAnBD;;OAEG;IACH,MAFU,IAAI,CAEV;IAGJ;;OAEG;IACH,KAFU,GAAG,CAEV;IAYH;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED,sBAGC;CACJ;qBArCoB,gBAAgB;oBACjB,cAAc"}

package/src/shade/renderer/postprocess/PostProcess.js

@@ -31,7 +31,8 @@ export class PostProcess {
         this.ssr.frame_index = frame_index;
     }
 
-    reset_history() {
+    reset_history() {
+        this.ssao.reset_history = true;
         this.ssr.reset_history = true;
     }
 }

package/src/shade/renderer/postprocess/gtao/GTAO.d.ts

@@ -8,11 +8,11 @@ export class GTAO {
      */
     constructor(graphics: GraphicsContext);
     /**
-     *
-     * @param {number} x
-     * @param {number} y
+     * When set, the next {@link graph_pass} takes this frame's AO alone and blends nothing of the
+     * history. For a cut the history cannot see: the camera jumped, or the scene changed.
+     * @type {boolean}
      */
-    resize(x: number, y: number): void;
+    reset_history: boolean;
     /**
      * Offer the pipelines {@link graph_pass} draws with — see {@link PipelineEnquiry}.
      *
@@ -21,24 +21,36 @@ export class GTAO {
     enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      *
-     * @param {FrameGraph} graph
-     * @param {number} camera
-     * @param {number} input_depth
-     * @param {number} input_hzb
-     * @param {number} input_color
-     * @param {number} input_depth_previous
-     * @param {number} input_normal
-     * @param {number} input_velocity
-     * @param {number} input_occlusion
-     * @param {number} frame_index
-     * @param {number} output
-     * @param {number[]} resolution
-     * @returns {{occlusion:number, bent_normals:number, diffuse_indirect:number}}
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {number} options.camera this frame's camera uniform
+     * @param {number} options.input_depth this frame's depth
+     * @param {number} options.input_hzb hierarchical depth built from it
+     * @param {number} options.input_normal G-buffer normals
+     * @param {number} options.input_velocity per-pixel velocity, in this frame's pixels
+     * @param {number} options.input_occlusion depth-clip pass output: history confidence in r
+     * @param {number} options.frame_index the renderer's frame counter: drives the noise, the history
+     *   ping-pong, and whether the history follows on from the last frame drawn
+     * @param {number} options.output G-buffer albedo; AO is blended into its alpha
+     * @param {number[]} options.resolution this frame's render size
+     * @returns {{visibility:number, occlusion:number, bent_normals:number}} the accumulated visibility
+     *   moments, `output` after the composite, and the raw bent normals
      */
-    graph_pass({ graph, camera, input_depth, input_hzb, input_depth_previous, input_normal, input_velocity, input_occlusion, frame_index, output, resolution }: FrameGraph): {
+    graph_pass({ graph, camera, input_depth, input_hzb, input_normal, input_velocity, input_occlusion, frame_index, output, resolution }: {
+        graph: FrameGraph;
+        camera: number;
+        input_depth: number;
+        input_hzb: number;
+        input_normal: number;
+        input_velocity: number;
+        input_occlusion: number;
+        frame_index: number;
+        output: number;
+        resolution: number[];
+    }): {
+        visibility: number;
         occlusion: number;
         bent_normals: number;
-        diffuse_indirect: number;
     };
     #private;
 }

package/src/shade/renderer/postprocess/gtao/GTAO.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GTAO.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/GTAO.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;IAQI;;;OAGG;IACH,uCAUC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,0BAFW,eAAe,QAOzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yKAFa;QAAC,SAAS,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,gBAAgB,EAAC,MAAM,CAAA;KAAC,CAiG5E;;CACJ;8BAjKY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"GTAO.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/GTAO.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;IAqBI;;;OAGG;IACH,uCAUC;IA5BD;;;;OAIG;IACH,eAFU,OAAO,CAEI;IAyBrB;;;;OAIG;IACH,0BAFW,eAAe,QAOzB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAd+B,KAAK;QACT,MAAM,EAAtB,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,WAAW,EAA3B,MAAM;QAEU,MAAM,EAAtB,MAAM;QACY,UAAU,EAA5B,MAAM,EAAE;QACN;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,SAAS,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CA4GtE;;CACJ;8BA/KY,OAAO,6CAA6C,EAAE,eAAe"}