@woosh/meep-engine 3.58.0 → 3.60.0

package/src/shade/renderer/geometry/sdf/cards/MeshCardCaptureMode.d.ts

@@ -0,0 +1,11 @@
+/**
+ * How a card set's pages are captured (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.5). Both write the
+ * same atlas texels in the same encoding; they differ in how a texel finds its surface and samples
+ * its material. {@link Raster } is the default: see `ProbeClipmapSettings#card_capture_mode`.
+ */
+export type MeshCardCaptureMode = number;
+export namespace MeshCardCaptureMode {
+    let Trace: number;
+    let Raster: number;
+}
+//# sourceMappingURL=MeshCardCaptureMode.d.ts.map

package/src/shade/renderer/geometry/sdf/cards/MeshCardCaptureMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeshCardCaptureMode.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/MeshCardCaptureMode.js"],"names":[],"mappings":";;;;;kCAMU,MAAM"}

package/src/shade/renderer/geometry/sdf/cards/MeshCardCaptureMode.js

@@ -0,0 +1,21 @@
+/**
+ * How a card set's pages are captured (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.5). Both write the
+ * same atlas texels in the same encoding; they differ in how a texel finds its surface and samples
+ * its material. {@link Raster} is the default: see `ProbeClipmapSettings#card_capture_mode`.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const MeshCardCaptureMode = {
+    /**
+     * A ray a texel through its card's slab against the geometry's BLAS, the material sampled at the
+     * hit as the path tracer samples it: the resident 64² copies, level 0, one stochastic tap.
+     */
+    Trace: 0,
+    /**
+     * Each card drawn orthographically along its direction, the slab its depth range, through the
+     * material's own template and bind group: its textures with their mips and hardware filtering.
+     * A template that cannot be drawn this way (no surface function) is traced.
+     */
+    Raster: 1,
+};

package/src/shade/renderer/geometry/sdf/cards/mesh_cards_raster_pass_descriptor.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @typedef {import("../../../../descriptor/binding/BindGroupLayoutDescriptor.js").BindGroupLayoutDescriptor} BindGroupLayoutDescriptor
+ * @typedef {import("../../../material/template/ShadeMaterialTemplate.js").ShadeMaterialTemplate} ShadeMaterialTemplate
+ */
+/**
+ * Cells across a raster run's region: the region is MESH_CARD_MAX cells, this many a row.
+ * @type {number}
+ */
+export const MESH_CARD_RASTER_CELLS_X: number;
+/**
+ * Rows of cells in a raster run's region.
+ * @type {number}
+ */
+export const MESH_CARD_RASTER_CELLS_Y: number;
+/**
+ * The scratch the cards are drawn into, before the scatter moves their pages into the atlas.
+ * @type {GPUTextureFormat[]}
+ */
+export const MESH_CARD_RASTER_TARGET_FORMATS: GPUTextureFormat[];
+/**
+ * @type {GPUTextureFormat}
+ */
+export const MESH_CARD_RASTER_DEPTH_FORMAT: GPUTextureFormat;
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_CARDS_RASTER_SETTINGS: WebGPUStruct;
+/**
+ * Group 1: where the vertex stage pulls the geometry and its cards from. Vertex-only.
+ *
+ * `mesh_card_raster_runs` is a `vec4<u32>` a run: (first scatter thread, card set, the region's
+ * corner in the scratch as x | y << 16, the side of its cells in texels).
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const MESH_CARDS_RASTER_GROUP: ShaderResourceGroupDescriptor;
+/**
+ * @type {BindGroupLayoutDescriptor}
+ */
+export const MESH_CARDS_RASTER_LAYOUT: BindGroupLayoutDescriptor;
+/**
+ * Card capture by raster ({@link MeshCardCaptureMode.Raster}): one pipeline per material template,
+ * the template's group 0 — the material's one bind group, which the G-buffer pass binds — then
+ * {@link MESH_CARDS_RASTER_GROUP}, and {@link MESH_CARDS_RASTER_SETTINGS} as immediate data.
+ *
+ * A run's draw covers every card of its card set, each into its cell of the run's region of the
+ * scratch: `rgba8unorm` √(diffuse albedo) and depth, `rgba8unorm` emissive / s_e, and a
+ * `depth32float` depth through the slab. Draw it with culling off: a card sees either side.
+ *
+ * Only a template with a surface function can be drawn.
+ *
+ * @type {TemplatePassDescriptor}
+ */
+export const mesh_cards_raster_pass_descriptor: TemplatePassDescriptor;
+/**
+ * Bytes of {@link MESH_CARDS_RASTER_SETTINGS} the draws hand `setImmediates`.
+ * @type {number}
+ */
+export const MESH_CARDS_RASTER_IMMEDIATE_SIZE: number;
+export type BindGroupLayoutDescriptor = import("../../../../descriptor/binding/BindGroupLayoutDescriptor.js").BindGroupLayoutDescriptor;
+export type ShadeMaterialTemplate = import("../../../material/template/ShadeMaterialTemplate.js").ShadeMaterialTemplate;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { TemplatePassDescriptor } from "../../../rasterize/TemplatePassDescriptor.js";
+//# sourceMappingURL=mesh_cards_raster_pass_descriptor.d.ts.map

package/src/shade/renderer/geometry/sdf/cards/mesh_cards_raster_pass_descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh_cards_raster_pass_descriptor.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/mesh_cards_raster_pass_descriptor.js"],"names":[],"mappings":"AAkCA;;;GAGG;AAEH;;;GAGG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,uCAFU,MAAM,CAE4E;AAE5F;;;GAGG;AACH,8CAFU,kBAAkB,CAEgD;AAE5E;;GAEG;AACH,6DAA4D;AAE5D;;GAEG;AACH,yCAFU,YAAY,CASQ;AAE9B;;;;;;;GAOG;AACH,sCAFU,6BAA6B,CAEoC;AAe3E;;GAEG;AACH,uCAFU,yBAAyB,CAEiE;AAiOpG;;;;;;;;;;;;GAYG;AACH,gDAFU,sBAAsB,CAiC7B;AAEH;;;GAGG;AACH,+CAFU,MAAM,CAE+D;wCApVlE,OAAO,6DAA6D,EAAE,yBAAyB;oCAC/F,OAAO,qDAAqD,EAAE,qBAAqB;6BAVnE,sCAAsC;8CALrB,2DAA2D;uCARlE,8CAA8C"}

package/src/shade/renderer/geometry/sdf/cards/mesh_cards_raster_pass_descriptor.js

@@ -0,0 +1,376 @@
+import { GPUShaderStage } from "../../../../descriptor/GPUShaderStage.js";
+import { PipelineLayoutDescriptor } from "../../../../descriptor/pipeline/PipelineLayoutDescriptor.js";
+import { DepthStencilState } from "../../../../descriptor/pipeline/render/DepthStencilState.js";
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { GEOMETRY_ATTRIBUTE_DATA_RESOURCE } from "../../GEOMETRY_ATTRIBUTE_DATA_RESOURCE.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_METADATA_RESOURCE } from "../../meshlet/MESHLET_METADATA_RESOURCE.js";
+import {
+    chunk_material_opacity_contract,
+    chunk_material_opacity_opaque,
+    chunk_material_surface_contract
+} from "../../../material/template/chunk_material_surface.js";
+import { rasterization_primitive_state } from "../../../rasterize/native/rasterization_primitive_state.js";
+import { TemplatePassDescriptor } from "../../../rasterize/TemplatePassDescriptor.js";
+import {
+    chunk_read_meshlet_vertex_by_draw_index
+} from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex_by_draw_index.js";
+import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
+import { chunk_random_initialize } from "../../../shader/chunk/random/chunk_random_initialize.js";
+import { GRADIENT_SAMPLING_INFO_STRUCT } from "../../../shader/chunk/texture/GRADIENT_SAMPLING_INFO_STRUCT.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { f32, u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { MESH_SDF_HEADERS_RESOURCE, MESH_SDF_INDIRECTION_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { MESH_SDF_STRUCT } from "../MESH_SDF_STRUCT.js";
+import { chunk_mesh_cards } from "./chunk_mesh_cards.js";
+import { MESH_CARD_SETS_RESOURCE } from "./MESH_CARD_RESOURCES.js";
+import { MESH_CARD_SET_STRUCT } from "./MESH_CARD_SET_STRUCT.js";
+import { MESH_CARD_MAX } from "./MESH_CARDS.js";
+
+/**
+ * @typedef {import("../../../../descriptor/binding/BindGroupLayoutDescriptor.js").BindGroupLayoutDescriptor} BindGroupLayoutDescriptor
+ * @typedef {import("../../../material/template/ShadeMaterialTemplate.js").ShadeMaterialTemplate} ShadeMaterialTemplate
+ */
+
+/**
+ * Cells across a raster run's region: the region is MESH_CARD_MAX cells, this many a row.
+ * @type {number}
+ */
+export const MESH_CARD_RASTER_CELLS_X = 8;
+
+/**
+ * Rows of cells in a raster run's region.
+ * @type {number}
+ */
+export const MESH_CARD_RASTER_CELLS_Y = Math.ceil(MESH_CARD_MAX / MESH_CARD_RASTER_CELLS_X);
+
+/**
+ * The scratch the cards are drawn into, before the scatter moves their pages into the atlas.
+ * @type {GPUTextureFormat[]}
+ */
+export const MESH_CARD_RASTER_TARGET_FORMATS = ["rgba8unorm", "rgba8unorm"];
+
+/**
+ * @type {GPUTextureFormat}
+ */
+export const MESH_CARD_RASTER_DEPTH_FORMAT = "depth32float";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_CARDS_RASTER_SETTINGS = WebGPUStruct.from({
+    /** the run drawn, its entry in `mesh_card_raster_runs` */
+    run: u32,
+    /** the scratch's texels across */
+    width: f32,
+    /** the scratch's texels down */
+    height: f32,
+}, "MeshCardsRasterSettings");
+
+/**
+ * Group 1: where the vertex stage pulls the geometry and its cards from. Vertex-only.
+ *
+ * `mesh_card_raster_runs` is a `vec4<u32>` a run: (first scatter thread, card set, the region's
+ * corner in the scratch as x | y << 16, the side of its cells in texels).
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const MESH_CARDS_RASTER_GROUP = new ShaderResourceGroupDescriptor();
+
+MESH_CARDS_RASTER_GROUP.label = "mesh cards raster";
+
+MESH_CARDS_RASTER_GROUP
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .add(MESH_SDF_INDIRECTION_RESOURCE)
+    .add(MESH_CARD_SETS_RESOURCE)
+    .addStorageBuffer("mesh_card_raster_runs", WebGPUArray.from(vec4u))
+    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+    .add(MESHLET_METADATA_RESOURCE)
+    .add(GEOMETRY_ATTRIBUTE_DATA_RESOURCE);
+
+MESH_CARDS_RASTER_GROUP.addVisibility(GPUShaderStage.VERTEX);
+
+/**
+ * @type {BindGroupLayoutDescriptor}
+ */
+export const MESH_CARDS_RASTER_LAYOUT = MESH_CARDS_RASTER_GROUP.generateBindGroupLayoutDescriptor();
+
+const vertex_resources = new ShaderResourceSetDescriptor();
+
+vertex_resources.setImmediate("settings", MESH_CARDS_RASTER_SETTINGS);
+vertex_resources.createGroup({ index: 0, label: "material (fragment only)" });
+vertex_resources.addGroup(MESH_CARDS_RASTER_GROUP);
+
+const VARYINGS = `
+struct MeshCardRasterVertex {
+    @builtin(position) position: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+    @location(1) uv1: vec2<f32>,
+    @location(2) position_os: vec3<f32>,
+    @location(3) normal: vec3<f32>,
+    @location(4) color: vec3<f32>,
+    @location(5) @interpolate(flat) card_set: u32,
+    @location(6) @interpolate(flat) card: u32,
+    @location(7) @interpolate(flat) emissive_scale: f32,
+    @location(8) @interpolate(flat) along: vec3<f32>,
+}
+`;
+
+/*
+ Instance i of run r's draw is card i / m's meshlet i mod m, m the geometry's meshlets; vertex v is
+ its triangle v / 3's corner, as the alpha-tested raster reads a meshlet. A card maps the geometry's
+ local space onto its cell: lattice (u, v) across the card to texel (u, v) of the cell, its centre on
+ the lattice point, which is where the trace starts its ray; depth from the near face over the slab's
+ depth to [0, 1], so the hardware clips to the slab as the trace's t ≤ depth does. The geometry lies
+ inside its grid, so nothing it draws falls outside the card's face, and the cells need no clip.
+*/
+const vertex_body = CodeChunk.from(
+    //language=WGSL
+    `
+${VARYINGS}
+
+@vertex
+fn main(
+    @builtin(vertex_index) vertex_draw_index: u32,
+    @builtin(instance_index) instance: u32,
+) -> MeshCardRasterVertex {
+    var out: MeshCardRasterVertex;
+
+    let run = mesh_card_raster_runs[settings.run];
+    let card_set = mesh_card_sets[run.y];
+    let geometry = geometries[card_set.geometry];
+    let header = mesh_sdf_headers[card_set.geometry];
+
+    // the args draw no instance of a geometry without meshlets
+    let meshlets = max(geometry.meshlets_count, 1u);
+    let card = instance / meshlets;
+    let meshlet_header = meshlet_metadata[geometry.meshlets_address + instance % meshlets];
+
+    if (vertex_draw_index >= meshlet_header.primitive_count * 3u) {
+        // past the meshlet's triangles: a degenerate one, which draws nothing
+        return out;
+    }
+
+    let attributes = read_meshlet_vertex_by_draw_index(meshlet_header, vertex_draw_index);
+
+    let record = header.cards + MESH_CARD_LAYOUT_RECORDS + card * MESH_CARD_RECORD_WORDS;
+    let direction = mesh_sdf_indirection[record + MESH_CARD_RECORD_DIRECTION];
+    let near = mesh_sdf_indirection[record + MESH_CARD_RECORD_NEAR];
+    let far = mesh_sdf_indirection[record + MESH_CARD_RECORD_FAR];
+
+    let axes = mesh_card_axes(direction);
+    let toward_plus = (direction & 1u) == 0u;
+
+    // voxels from the grid's corner
+    let p = (attributes.position - header.origin) / header.voxel;
+
+    let face = f32(select(header.bricks[axes.x] - near, near, toward_plus) * MESH_SDF_BRICK_VOXELS);
+    let depth = select(face - p[axes.x], p[axes.x] - face, toward_plus);
+    let slab = f32((far - near) * MESH_SDF_BRICK_VOXELS);
+
+    let corner = vec2<f32>(f32(run.z & 0xffffu), f32(run.z >> 16u))
+        + vec2<f32>(f32(card % ${MESH_CARD_RASTER_CELLS_X}u), f32(card / ${MESH_CARD_RASTER_CELLS_X}u)) * f32(run.w);
+    let texel = corner + vec2<f32>(p[axes.y], p[axes.z]) + 0.5;
+
+    out.position = vec4<f32>(
+        texel.x / settings.width * 2.0 - 1.0,
+        1.0 - texel.y / settings.height * 2.0,
+        depth / slab,
+        1.0
+    );
+
+    var along = vec3<f32>(0.0);
+
+    along[axes.x] = select(-1.0, 1.0, toward_plus);
+
+    out.uv = attributes.uv;
+    out.uv1 = attributes.uv1;
+    out.position_os = attributes.position;
+    out.normal = attributes.normal;
+    out.color = attributes.color;
+    out.card_set = run.y;
+    out.card = card;
+    out.emissive_scale = card_set.emissive_scale;
+    out.along = along;
+
+    return out;
+}
+`, [
+        MESH_SDF_STRUCT.declaration_chunk,
+        MESH_CARD_SET_STRUCT.declaration_chunk,
+        GEOMETRY_METADATA_STRUCT.declaration_chunk,
+        chunk_mesh_cards,
+        chunk_read_meshlet_vertex_by_draw_index,
+    ]);
+
+const vertex_code = ShaderDescriptor.from({
+    label: "Mesh Cards Raster / vertex",
+    resources: vertex_resources,
+    body: vertex_body,
+}).source;
+
+/*
+ The template is handed what the G-buffer pass hands it, in the geometry's local space, the card
+ being there: real derivatives, as this is a raster with neighbours of its own triangle, unbiased, as
+ UE's card capture leaves its material mip bias at 0. Both functions run first, in uniform control
+ flow, so a template may sample with implicit derivatives.
+
+ Coverage is drawn as the trace draws it, a texel's surface opaque with probability its opacity, from
+ a seed fixed by the card set, the card and the texel; the depth test keeps the nearest opaque draw.
+ The planes are the trace's: √(albedo × (1 − metalness)) and depth through the slab on [1/255, 1];
+ emissive over s_e.
+*/
+const fragment_body = CodeChunk.from(
+    //language=WGSL
+    `
+${VARYINGS}
+
+struct MeshCardRasterTargets {
+    @location(0) albedo: vec4<f32>,
+    @location(1) emissive: vec4<f32>,
+}
+
+@fragment
+fn main(in: MeshCardRasterVertex) -> MeshCardRasterTargets {
+    let uv = ${GRADIENT_SAMPLING_INFO_STRUCT.wgsl_ref}(in.uv, dpdx(in.uv), dpdy(in.uv));
+    let uv1 = ${GRADIENT_SAMPLING_INFO_STRUCT.wgsl_ref}(in.uv1, dpdx(in.uv1), dpdy(in.uv1));
+    let position_ddx = dpdx(in.position_os);
+    let position_ddy = dpdy(in.position_os);
+
+    var opacity_input: MaterialOpacityInput;
+
+    opacity_input.uv = uv;
+    opacity_input.mip_bias = 0.0;
+    opacity_input.position_ws = in.position_os;
+
+    let opacity = material_opacity(opacity_input);
+
+    var surface_input: MaterialSurfaceInput;
+
+    surface_input.uv = uv;
+    surface_input.uv1 = uv1;
+    surface_input.gradient_bias = vec2<f32>(1.0);
+    surface_input.position_os = in.position_os;
+    surface_input.position_os_ddx = position_ddx;
+    surface_input.position_os_ddy = position_ddy;
+    surface_input.position_ws = in.position_os;
+    surface_input.normal_ws = normalize(in.normal);
+    surface_input.face_normal_ws = normalize(cross(position_ddx, position_ddy));
+    surface_input.view_direction_ws = -in.along;
+    surface_input.vertex_color = in.color;
+    surface_input.pixel = in.position.xy;
+
+    let surface = material_surface(surface_input);
+
+    random_initialize(vec3<u32>(vec2<u32>(in.position.xy), in.card), vec3<u32>(in.card_set, 0u, 0u));
+
+    if (random() >= opacity) {
+        discard;
+    }
+
+    let diffuse = surface.albedo * (1.0 - surface.metalness);
+
+    var out: MeshCardRasterTargets;
+
+    out.albedo = vec4<f32>(sqrt(max(diffuse, vec3<f32>(0.0))), (1.0 + 254.0 * saturate(in.position.z)) / 255.0);
+
+    if (in.emissive_scale > 0.0) {
+        out.emissive = vec4<f32>(surface.emissive / in.emissive_scale, 0.0);
+    }
+
+    return out;
+}
+`, [
+        GRADIENT_SAMPLING_INFO_STRUCT.declaration_chunk,
+        chunk_material_surface_contract,
+        chunk_material_opacity_contract,
+        chunk_random,
+        chunk_random_initialize,
+    ]);
+
+/**
+ * @type {WeakMap<ShadeMaterialTemplate, ShaderResourceSetDescriptor>}
+ */
+const fragment_resources = new WeakMap();
+
+/**
+ * @param {ShadeMaterialTemplate} template
+ * @returns {ShaderResourceSetDescriptor}
+ */
+function fragment_resources_of(template) {
+    let resources = fragment_resources.get(template);
+
+    if (resources === undefined) {
+        resources = new ShaderResourceSetDescriptor();
+
+        resources.addGroup(template.resources);
+
+        fragment_resources.set(template, resources);
+    }
+
+    return resources;
+}
+
+const depth_state = DepthStencilState.from({
+    depthWriteEnabled: true,
+    // depth through the slab from its near face: the nearest is the least
+    depthCompare: 'less',
+    format: MESH_CARD_RASTER_DEPTH_FORMAT,
+});
+
+/**
+ * Card capture by raster ({@link MeshCardCaptureMode.Raster}): one pipeline per material template,
+ * the template's group 0 — the material's one bind group, which the G-buffer pass binds — then
+ * {@link MESH_CARDS_RASTER_GROUP}, and {@link MESH_CARDS_RASTER_SETTINGS} as immediate data.
+ *
+ * A run's draw covers every card of its card set, each into its cell of the run's region of the
+ * scratch: `rgba8unorm` √(diffuse albedo) and depth, `rgba8unorm` emissive / s_e, and a
+ * `depth32float` depth through the slab. Draw it with culling off: a card sees either side.
+ *
+ * Only a template with a surface function can be drawn.
+ *
+ * @type {TemplatePassDescriptor}
+ */
+export const mesh_cards_raster_pass_descriptor = new TemplatePassDescriptor("Mesh Card Capture / Raster", template => {
+    const fragment_code = ShaderDescriptor.from({
+        label: `Mesh Cards Raster / ${template.name}`,
+        resources: fragment_resources_of(template),
+        body: CodeChunk.from('', [
+            template.surface,
+            template.opacity ?? chunk_material_opacity_opaque,
+            fragment_body,
+        ]),
+    }).source;
+
+    return RenderPipelineDescriptor.from({
+        label: `Mesh Card Capture / Raster / ${template.name}`,
+        layout: PipelineLayoutDescriptor.from([
+            template.resources.generateBindGroupLayoutDescriptor(),
+            MESH_CARDS_RASTER_LAYOUT,
+        ], vertex_resources.immediateSize),
+        vertex: {
+            module: {
+                code: vertex_code
+            }
+        },
+        fragment: {
+            module: {
+                code: fragment_code
+            },
+            targets: MESH_CARD_RASTER_TARGET_FORMATS.map(format => ({ format })),
+        },
+        depthStencil: depth_state,
+        primitive: rasterization_primitive_state,
+    });
+});
+
+/**
+ * Bytes of {@link MESH_CARDS_RASTER_SETTINGS} the draws hand `setImmediates`.
+ * @type {number}
+ */
+export const MESH_CARDS_RASTER_IMMEDIATE_SIZE = vertex_resources.immediateSize;

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_capture.d.ts

@@ -20,9 +20,13 @@ export const MESH_CARDS_CAPTURE_SETTINGS: WebGPUStruct;
  * 3. At the opaque hit, `sample_material_data` with the material's resident row and an identity
  *    transform, the card being in local space.
  *
- * The random state is seeded from the card set and the texel, which fixes every draw: the alpha's,
- * and the material's stochastic bilinear taps and dither. A recapture of an unchanged material
- * therefore writes the same bytes.
+ * Both read the material's textures at the texel's footprint (`mesh_card_texture_level`), filtered
+ * exactly ({@link IndirectTextureFilter.Exact}): nothing averages a card texel after it is stored, so a
+ * single tap would be kept as the texel, and a tap landing on a thin feature of the texture would put
+ * it in one row of texels and not the next.
+ *
+ * The random state is seeded from the card set and the texel, which fixes every draw: the alpha's and
+ * the material's dither. A recapture of an unchanged material therefore writes the same bytes.
  *
  * The albedo plane holds √(albedo × (1 − metalness)), Lumen's diffuse colour as UE stores it, and
  * the hit's depth through the slab mapped onto [1/255, 1]. The emissive plane holds emissive / s_e.

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_capture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_mesh_cards_capture.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_capture.js"],"names":[],"mappings":"AAsBA;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,0CAFU,YAAY,CASS;AAqB/B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wCAFU,aAAa,CA4JpB;6BA7N0B,sCAAsC;8BAJrC,kCAAkC"}
+{"version":3,"file":"shader_mesh_cards_capture.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_capture.js"],"names":[],"mappings":"AA8BA;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,0CAFU,YAAY,CASS;AAqB/B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wCAFU,aAAa,CAgNsE;6BArRhE,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_capture.js

@@ -1,5 +1,11 @@
 import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
+import {
+    RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT,
+    RESIDENT_MATERIAL_TEXTURE_RESOLUTION
+} from "../../../material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
 import { chunk_sample_material_alpha, chunk_sample_material_data } from "../../../path_tracer/shader/chunk_sample_material_data.js";
+import { INDIRECT_TEXTURE_FILTER } from "../../../path_tracer/shader/INDIRECT_TEXTURE_FILTER.js";
+import { IndirectTextureFilter } from "../../../path_tracer/shader/IndirectTextureFilter.js";
 import { BVH_TRAVERSAL_STACK_SIZE } from "../../../shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
 import { chunk_geometry_read_triangle_vertices } from "../../../shader/chunk/geometry/format/chunk_geometry_read_triangle_vertices.js";
 import { MAT4_IDENTITY_DEFINITION } from "../../../shader/chunk/geometry/mat4/MAT4_IDENTITY_DEFINITION.js";
@@ -8,7 +14,9 @@ import { RAY_STRUCT } from "../../../shader/chunk/geometry/ray/RAY_STRUCT.js";
 import { chunk_index_to_grid2d } from "../../../shader/chunk/grid/chunk_index_to_grid2d.js";
 import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
 import { chunk_random_initialize } from "../../../shader/chunk/random/chunk_random_initialize.js";
+import { TRIANGLE_VERTICES_STRUCT } from "../../../shader/chunk/geometry/triangle/TRIANGLE_VERTICES_STRUCT.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderSwitchSet } from "../../../shader/compiler/ShaderSwitchSet.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
@@ -70,9 +78,13 @@ mesh_sdf_add_blas_resources(resources.createGroup());
  * 3. At the opaque hit, `sample_material_data` with the material's resident row and an identity
  *    transform, the card being in local space.
  *
- * The random state is seeded from the card set and the texel, which fixes every draw: the alpha's,
- * and the material's stochastic bilinear taps and dither. A recapture of an unchanged material
- * therefore writes the same bytes.
+ * Both read the material's textures at the texel's footprint (`mesh_card_texture_level`), filtered
+ * exactly ({@link IndirectTextureFilter.Exact}): nothing averages a card texel after it is stored, so a
+ * single tap would be kept as the texel, and a tap landing on a thin feature of the texture would put
+ * it in one row of texels and not the next.
+ *
+ * The random state is seeded from the card set and the texel, which fixes every draw: the alpha's and
+ * the material's dither. A recapture of an unchanged material therefore writes the same bytes.
  *
  * The albedo plane holds √(albedo × (1 − metalness)), Lumen's diffuse colour as UE stores it, and
  * the hit's depth through the slab mapped onto [1/255, 1]. The emissive plane holds emissive / s_e.
@@ -86,6 +98,47 @@ export const shader_mesh_cards_capture = ComputeShader.from({
     body: CodeChunk.from(
         //language=WGSL
         `
+// The texture level a card texel reads a triangle's material at: its footprint, the card's texel steps
+// carried along the card's direction onto the triangle's plane and through the triangle's uv per
+// position, in texels of a slot's level 0. For a step s, direction d and normal n that is
+// s - d (n·s)/(n·d) on the plane, taken here times n·d, so a triangle turning edge-on, whose footprint
+// grows without bound, reaches the last level with nothing divided by 0, as a raster's would.
+fn mesh_card_texture_level(
+    triangle: ${TRIANGLE_VERTICES_STRUCT.wgsl_ref},
+    along: vec3<f32>,
+    step_u: vec3<f32>,
+    step_v: vec3<f32>,
+) -> f32 {
+    let edge_1 = triangle.b.position - triangle.a.position;
+    let edge_2 = triangle.c.position - triangle.a.position;
+    let normal = cross(edge_1, edge_2);
+
+    // an offset in the plane is a·edge_1 + b·edge_2, a and b its dots with these
+    let dual_1 = cross(edge_2, normal) / dot(normal, normal);
+    let dual_2 = cross(normal, edge_1) / dot(normal, normal);
+
+    let uv_1 = triangle.b.uv - triangle.a.uv;
+    let uv_2 = triangle.c.uv - triangle.a.uv;
+
+    let facing = dot(normal, along);
+
+    let on_plane_u = facing * step_u - along * dot(normal, step_u);
+    let on_plane_v = facing * step_v - along * dot(normal, step_v);
+
+    let uv_step_u = dot(on_plane_u, dual_1) * uv_1 + dot(on_plane_u, dual_2) * uv_2;
+    let uv_step_v = dot(on_plane_v, dual_1) * uv_1 + dot(on_plane_v, dual_2) * uv_2;
+
+    let span = ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}.0 * max(length(uv_step_u), length(uv_step_v));
+    let reach = abs(facing);
+
+    // a footprint of a slot or more, edge-on included, is the last level
+    return select(
+        ${RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT - 1}.0,
+        log2(max(span, reach) / reach),
+        span < ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}.0 * reach
+    );
+}
+
 @compute @workgroup_size(${MESH_SDF_BAKE_WORKGROUP_SIZE})
 fn main(
     @builtin(workgroup_id) workgroup_id: vec3<u32>,
@@ -148,6 +201,13 @@ fn main(
 
     along[axes.x] = select(-1.0, 1.0, toward_plus);
 
+    // the card's texel steps, a voxel each
+    var step_u = vec3<f32>(0.0);
+    var step_v = vec3<f32>(0.0);
+
+    step_u[axes.y] = header.voxel;
+    step_v[axes.z] = header.voxel;
+
     let depth = f32(far - near) * brick_span;
 
     random_initialize(vec3<u32>(page, texel), vec3<u32>(run.y, geometry, 0u));
@@ -167,6 +227,7 @@ fn main(
     var hit_t = 0.0;
     var lambda = vec3<f32>(0.0);
     var triangle_index = 0u;
+    var texture_level = 0.0;
 
     for (var step = 0u; step <= ${MESH_CARD_ALPHA_CONTINUATIONS}u; step++) {
         let hit = ray_query_blas_nearest(ray, geometry, &stack, 0u);
@@ -177,13 +238,15 @@ fn main(
 
         let triangle = geometry_read_triangle_vertices(geometries[geometry], hit.triangle);
         let at = vec3<f32>(1.0 - hit.barycentrics.x - hit.barycentrics.y, hit.barycentrics.x, hit.barycentrics.y);
-        let surface = sample_material_alpha(material, triangle, at, MAT4_IDENTITY, ray.direction);
+        let level = mesh_card_texture_level(triangle, along, step_u, step_v);
+        let surface = sample_material_alpha(material, triangle, at, MAT4_IDENTITY, ray.direction, level);
 
         if (random() < surface.opacity) {
             found = true;
             hit_t = travelled + hit.t;
             lambda = at;
             triangle_index = hit.triangle;
+            texture_level = level;
             break;
         }
 
@@ -204,7 +267,7 @@ fn main(
 
     if (found) {
         let triangle = geometry_read_triangle_vertices(geometries[geometry], triangle_index);
-        let data = sample_material_data(ray, material, triangle, lambda, MAT4_IDENTITY);
+        let data = sample_material_data(ray, material, triangle, lambda, MAT4_IDENTITY, texture_level);
 
         let diffuse = data.albedo * (1.0 - data.metalness);
 
@@ -224,6 +287,7 @@ fn main(
 `, [
             MAT4_IDENTITY_DEFINITION,
             RAY_STRUCT.declaration_chunk,
+            TRIANGLE_VERTICES_STRUCT.declaration_chunk,
             MESH_CARD_SET_STRUCT.declaration_chunk,
             chunk_mesh_cards,
             chunk_index_to_grid2d,
@@ -234,4 +298,4 @@ fn main(
             chunk_sample_material_alpha,
             chunk_sample_material_data,
         ]),
-});
+}).variant(ShaderSwitchSet.EMPTY.with(INDIRECT_TEXTURE_FILTER, IndirectTextureFilter.Exact));