@woosh/meep-engine 3.61.2 → 3.61.3

package/src/shade/renderer/geometry/sdf/surface/SURFACE_MATERIAL.js

@@ -0,0 +1,35 @@
+/*
+ A surface material texel: what a texel of a sparse field keeps of the surface it holds, its diffuse
+ albedo, metalness, roughness and emissive, each a constant over the texel's tent, L0. Each codec owns a
+ plane of its own, a texture of the atlas that holds the texels, on the lattice the field's bricks use,
+ 8³ a tile:
+
+   albedo        r32uint      the diffuse albedo, `albedo_compress`
+   metal_rough   r8uint       metalness and roughness, `metal_rough_compress`
+   emissive      r32uint      the emissive radiance, RGB9E5, `rgbe9995_encode`
+
+ The brick clipmap's material keeps all three planes, a tile of each for every slot, and a texel that
+ holds no material there is 0 throughout: the albedo codec never writes a code of 0, so the albedo plane
+ says which texels hold a material, for every plane.
+
+ A Model Surface Cache keeps a plane only where it varies over its surface, block-coded, a block for each
+ 4³ of its geometry's field's bricks some texel of which can hold surface, and a presence bit for each
+ texel to say which hold a material (`MESH_SURFACE_BLOCK.js`); a plane it does not keep is one code for
+ every texel (`MESH_SURFACE_STRUCT.js`).
+*/
+
+/**
+ * The planes' formats, in the order {@link SURFACE_MATERIAL_ALBEDO_PLANE},
+ * {@link SURFACE_MATERIAL_METAL_ROUGH_PLANE} and {@link SURFACE_MATERIAL_EMISSIVE_PLANE} name them.
+ * @type {ReadonlyArray<GPUTextureFormat>}
+ */
+export const SURFACE_MATERIAL_FORMATS = Object.freeze(["r32uint", "r8uint", "r32uint"]);
+
+/** The plane of the albedo codes. */
+export const SURFACE_MATERIAL_ALBEDO_PLANE = 0;
+
+/** The plane of the metalness and roughness codes. */
+export const SURFACE_MATERIAL_METAL_ROUGH_PLANE = 1;
+
+/** The plane of the emissive codes. */
+export const SURFACE_MATERIAL_EMISSIVE_PLANE = 2;

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_block.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Where a brick texel's material is among a cache's blocks (`MESH_SURFACE_BLOCK.js`):
+ *
+ * ```wgsl
+ * fn mesh_surface_block_of(t: vec3<u32>) -> u32       // its block of the brick, 0..7
+ * fn mesh_surface_block_texel(t: vec3<u32>) -> u32    // its texel of the block, 0..63
+ * fn mesh_surface_block_number(table: u32, block: u32) -> u32   // the block's number, or MESH_SURFACE_NO_BLOCK
+ * ```
+ *
+ * `table` is the brick's table word.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_block_index: CodeChunk;
+/**
+ * A texel of a cache's blocks, read from `mesh_surface_data` (`MESH_SURFACE_BLOCK.js`):
+ *
+ * ```wgsl
+ * fn mesh_surface_present_at(presence_blocks: u32, block: u32, texel: u32) -> bool
+ * fn mesh_surface_albedo_at(albedo_blocks: u32, block: u32, texel: u32) -> vec3<f32>          // linear
+ * fn mesh_surface_metal_rough_at(metal_rough_blocks: u32, block: u32, texel: u32) -> vec2<f32>
+ * fn mesh_surface_emissive_at(emissive_blocks: u32, block: u32, texel: u32) -> vec3<f32>
+ * ```
+ *
+ * The first argument is the record's word of the plane's block 0, `block` the block's number, `texel`
+ * its texel of the block.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_block: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_surface_block.d.ts.map

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_surface_block.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_block.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;GAYG;AACH,6CAFU,SAAS,CA0BhB;AAEH;;;;;;;;;;;;;;GAcG;AACH,uCAFU,SAAS,CAyCZ;0BA3GmB,uCAAuC"}

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_block.js

@@ -0,0 +1,111 @@
+import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import {
+    MESH_SURFACE_ALBEDO_BLOCK_WORDS,
+    MESH_SURFACE_ALBEDO_ENDPOINT_WORDS,
+    MESH_SURFACE_ALBEDO_LEVELS,
+    MESH_SURFACE_EMISSIVE_BLOCK_WORDS,
+    MESH_SURFACE_METAL_ROUGH_BLOCK_WORDS,
+    MESH_SURFACE_METAL_ROUGH_LEVELS,
+    MESH_SURFACE_NO_BLOCK,
+    MESH_SURFACE_PRESENCE_BLOCK_WORDS,
+    MESH_SURFACE_TABLE_MASK_BITS
+} from "./MESH_SURFACE_BLOCK.js";
+import { MESH_SURFACE_DATA_RESOURCE } from "./MESH_SURFACE_RESOURCES.js";
+
+/**
+ * Where a brick texel's material is among a cache's blocks (`MESH_SURFACE_BLOCK.js`):
+ *
+ * ```wgsl
+ * fn mesh_surface_block_of(t: vec3<u32>) -> u32       // its block of the brick, 0..7
+ * fn mesh_surface_block_texel(t: vec3<u32>) -> u32    // its texel of the block, 0..63
+ * fn mesh_surface_block_number(table: u32, block: u32) -> u32   // the block's number, or MESH_SURFACE_NO_BLOCK
+ * ```
+ *
+ * `table` is the brick's table word.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_block_index = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_surface_block_of(t: vec3<u32>) -> u32 {
+    let b = t >> vec3<u32>(2u);
+
+    return b.x + 2u * (b.y + 2u * b.z);
+}
+
+fn mesh_surface_block_texel(t: vec3<u32>) -> u32 {
+    let l = t & vec3<u32>(3u);
+
+    return l.x + 4u * (l.y + 4u * l.z);
+}
+
+fn mesh_surface_block_number(table: u32, block: u32) -> u32 {
+    let bit = 1u << block;
+
+    if ((table & bit) == 0u) {
+        return ${MESH_SURFACE_NO_BLOCK}u;
+    }
+
+    return (table >> ${MESH_SURFACE_TABLE_MASK_BITS}u) + countOneBits(table & (bit - 1u));
+}
+`);
+
+/**
+ * A texel of a cache's blocks, read from `mesh_surface_data` (`MESH_SURFACE_BLOCK.js`):
+ *
+ * ```wgsl
+ * fn mesh_surface_present_at(presence_blocks: u32, block: u32, texel: u32) -> bool
+ * fn mesh_surface_albedo_at(albedo_blocks: u32, block: u32, texel: u32) -> vec3<f32>          // linear
+ * fn mesh_surface_metal_rough_at(metal_rough_blocks: u32, block: u32, texel: u32) -> vec2<f32>
+ * fn mesh_surface_emissive_at(emissive_blocks: u32, block: u32, texel: u32) -> vec3<f32>
+ * ```
+ *
+ * The first argument is the record's word of the plane's block 0, `block` the block's number, `texel`
+ * its texel of the block.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_block = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_surface_present_at(presence_blocks: u32, block: u32, texel: u32) -> bool {
+    let word = mesh_surface_data[presence_blocks + block * ${MESH_SURFACE_PRESENCE_BLOCK_WORDS}u + (texel >> 5u)];
+
+    return ((word >> (texel & 31u)) & 1u) != 0u;
+}
+
+fn mesh_surface_albedo_at(albedo_blocks: u32, block: u32, texel: u32) -> vec3<f32> {
+    let at = albedo_blocks + block * ${MESH_SURFACE_ALBEDO_BLOCK_WORDS}u;
+
+    // a 4-bit field a texel after the endpoints: its subset above its level
+    let field = (mesh_surface_data[at + ${MESH_SURFACE_ALBEDO_ENDPOINT_WORDS}u + (texel >> 3u)] >> (4u * (texel & 7u))) & 15u;
+    let ends = at + 2u * (field >> 3u);
+    let e0 = unpack4x8unorm(mesh_surface_data[ends]).rgb;
+    let e1 = unpack4x8unorm(mesh_surface_data[ends + 1u]).rgb;
+    let root = mix(e0, e1, f32(field & 7u) / ${MESH_SURFACE_ALBEDO_LEVELS - 1}.0);
+
+    return root * root;
+}
+
+fn mesh_surface_metal_rough_at(metal_rough_blocks: u32, block: u32, texel: u32) -> vec2<f32> {
+    let at = metal_rough_blocks + block * ${MESH_SURFACE_METAL_ROUGH_BLOCK_WORDS}u;
+    let ends = mesh_surface_data[at];
+    let e0 = vec2<f32>(f32(ends & 15u), f32((ends >> 4u) & 15u)) / 15.0;
+    let e1 = vec2<f32>(f32((ends >> 8u) & 15u), f32((ends >> 12u) & 15u)) / 15.0;
+
+    let bit = 2u * texel;
+    let index = (mesh_surface_data[at + 1u + (bit >> 5u)] >> (bit & 31u)) & 3u;
+
+    return mix(e0, e1, f32(index) / ${MESH_SURFACE_METAL_ROUGH_LEVELS - 1}.0);
+}
+
+fn mesh_surface_emissive_at(emissive_blocks: u32, block: u32, texel: u32) -> vec3<f32> {
+    return rgbe9995_decode(mesh_surface_data[emissive_blocks + block * ${MESH_SURFACE_EMISSIVE_BLOCK_WORDS}u + texel]);
+}
+`, [
+        chunk_rgbe9995_decode,
+    ]);
+
+chunk_mesh_surface_block.requireResource(MESH_SURFACE_DATA_RESOURCE);

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_listed.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Whether a texel of a field's brick can hold surface, as a Model Surface Cache's bake and survey take
+ * it: its nearest surface point is under its tent. The field's distance d at the texel, its own byte,
+ * and the field's normal n there put that point d against n, which the tent holds when
+ * |d|·|n|∞ < 1 voxel of the brick's level.
+ *
+ * ```wgsl
+ * fn mesh_surface_listed(header: MeshSDF, b: u32, texel: vec3<u32>) -> bool
+ * ```
+ *
+ * `b` is the brick's index in the field's layout, stored; `texel` the texel of the brick.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_listed: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_surface_listed.d.ts.map

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_listed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_surface_listed.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_listed.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,wCAFU,SAAS,CAyBZ;0BA7CmB,uCAAuC"}

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_listed.js

@@ -0,0 +1,49 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_tile_atlas_slot_origin } from "../../../texture/atlas/chunk_tile_atlas_slot_origin.js";
+import { chunk_mesh_sdf } from "../chunk_mesh_sdf.js";
+import { chunk_mesh_sdf_normal } from "../chunk_mesh_sdf_normal.js";
+import { MESH_SDF_BRICK_TEXELS } from "../MESH_SDF.js";
+import { MESH_SDF_ATLAS_RESOURCE, MESH_SDF_INDIRECTION_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { MESH_SDF_STRUCT } from "../MESH_SDF_STRUCT.js";
+
+/**
+ * Whether a texel of a field's brick can hold surface, as a Model Surface Cache's bake and survey take
+ * it: its nearest surface point is under its tent. The field's distance d at the texel, its own byte,
+ * and the field's normal n there put that point d against n, which the tent holds when
+ * |d|·|n|∞ < 1 voxel of the brick's level.
+ *
+ * ```wgsl
+ * fn mesh_surface_listed(header: MeshSDF, b: u32, texel: vec3<u32>) -> bool
+ * ```
+ *
+ * `b` is the brick's index in the field's layout, stored; `texel` the texel of the brick.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_listed = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_surface_listed(header: ${MESH_SDF_STRUCT.wgsl_ref}, b: u32, texel: vec3<u32>) -> bool {
+    let slot = mesh_sdf_indirection[header.indirection + b];
+    let brick = mesh_sdf_brick_of(header, b);
+    let voxel = mesh_sdf_level_voxel(header, brick.x);
+
+    let t = ${MESH_SDF_BRICK_TEXELS}u;
+
+    // the texel's own byte, in voxels of its level
+    let field = tile_atlas_slot_origin(slot, textureDimensions(mesh_sdf_atlas, 0).xy / t, vec3<u32>(t)) + texel;
+    let d = mesh_sdf_decode(textureLoad(mesh_sdf_atlas, field, 0).r, 1.0);
+    let n = mesh_sdf_normal(header, brick.x, mesh_sdf_brick_corner(header, brick) + vec3<f32>(texel) * voxel);
+
+    // a flat field has no normal, and its NaN compares false
+    return abs(d) * max(max(abs(n.x), abs(n.y)), abs(n.z)) < 1.0;
+}
+`, [
+        MESH_SDF_STRUCT.declaration_chunk,
+        chunk_mesh_sdf,
+        chunk_mesh_sdf_normal,
+        chunk_tile_atlas_slot_origin,
+    ]);
+
+chunk_mesh_surface_listed.requireResource(MESH_SDF_INDIRECTION_RESOURCE);
+chunk_mesh_surface_listed.requireResource(MESH_SDF_ATLAS_RESOURCE);

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_run_find.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The run of a pass's `mesh_surface_runs` a thread is in: the last run starting at or before it, the
+ * runs being in order of their first thread, the first at 0.
+ *
+ * ```wgsl
+ * fn mesh_surface_run_find(count: u32, thread: u32) -> u32
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_run_find: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_surface_run_find.d.ts.map

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_run_find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_surface_run_find.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_run_find.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,0CAFU,SAAS,CAqBhB;0BAhCuB,uCAAuC"}

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_run_find.js

@@ -0,0 +1,35 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { MESH_SURFACE_RUNS_RESOURCE } from "./MESH_SURFACE_BAKE.js";
+
+/**
+ * The run of a pass's `mesh_surface_runs` a thread is in: the last run starting at or before it, the
+ * runs being in order of their first thread, the first at 0.
+ *
+ * ```wgsl
+ * fn mesh_surface_run_find(count: u32, thread: u32) -> u32
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_run_find = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_surface_run_find(count: u32, thread: u32) -> u32 {
+    var low = 0u;
+    var high = count;
+
+    while (high - low > 1u) {
+        let middle = (low + high) / 2u;
+
+        if (mesh_surface_runs[middle].x <= thread) {
+            low = middle;
+        } else {
+            high = middle;
+        }
+    }
+
+    return low;
+}
+`);
+
+chunk_mesh_surface_run_find.requireResource(MESH_SURFACE_RUNS_RESOURCE);

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_sample.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A Model Surface Cache's material at a point of its geometry's local space, at one level of the field:
+ *
+ * ```wgsl
+ * struct MeshSurfaceSample { found: bool, albedo: vec3<f32>, metal_rough: vec2<f32>, emissive: vec3<f32> }
+ * fn mesh_surface_sample(cache: MeshSurface, header: MeshSDF, level: u32, position: vec3<f32>, tolerance: f32) -> MeshSurfaceSample
+ * ```
+ *
+ * The brick of the level holding the point, as `mesh_sdf_sample` finds it. A cache that keeps no plane
+ * holds its record's material there. Otherwise the point is moved onto the surface by the field's
+ * distance against its normal there, and of the 8 texels around it (`surface_material_corners`) those
+ * that hold a material — their blocks kept by the brick's table word, their presence bits set — and
+ * whose surfaces lie within `tolerance` voxels of the nearest one's are blended: each plane the cache
+ * keeps decoded from its blocks (`MESH_SURFACE_BLOCK.js`), each other plane its record's code. `found`
+ * is false outside the grid, in a brick the field left EMPTY, and where no corner holds a material.
+ *
+ * `header` is the cache's geometry's, resident. Reads `mesh_sdf_indirection`, `mesh_sdf_atlas` and what
+ * `mesh_sdf_normal` reads, and the caches' words.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_sample: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_surface_sample.d.ts.map

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_surface_sample.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_sample.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wCAFU,SAAS,CA8HZ;0BAlKmB,uCAAuC"}

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_sample.js

@@ -0,0 +1,169 @@
+import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
+import { chunk_albedo_uncompress } from "../../../shader/chunk/material/chunk_albedo_uncompress.js";
+import { chunk_metal_rough_uncompress } from "../../../shader/chunk/material/chunk_metal_rough_uncompress.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_tile_atlas_slot_origin } from "../../../texture/atlas/chunk_tile_atlas_slot_origin.js";
+import { chunk_mesh_sdf } from "../chunk_mesh_sdf.js";
+import { chunk_mesh_sdf_normal } from "../chunk_mesh_sdf_normal.js";
+import { MESH_SDF_BRICK_TEXELS } from "../MESH_SDF.js";
+import { MESH_SDF_ATLAS_RESOURCE, MESH_SDF_INDIRECTION_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { MESH_SDF_STRUCT } from "../MESH_SDF_STRUCT.js";
+import { chunk_mesh_surface_block, chunk_mesh_surface_block_index } from "./chunk_mesh_surface_block.js";
+import { chunk_surface_material_corners } from "./chunk_surface_material_read.js";
+import { MESH_SURFACE_NO_BLOCK } from "./MESH_SURFACE_BLOCK.js";
+import { MESH_SURFACE_STRUCT } from "./MESH_SURFACE_STRUCT.js";
+import {
+    SURFACE_MATERIAL_ALBEDO_PLANE,
+    SURFACE_MATERIAL_EMISSIVE_PLANE,
+    SURFACE_MATERIAL_METAL_ROUGH_PLANE
+} from "./SURFACE_MATERIAL.js";
+
+/**
+ * A Model Surface Cache's material at a point of its geometry's local space, at one level of the field:
+ *
+ * ```wgsl
+ * struct MeshSurfaceSample { found: bool, albedo: vec3<f32>, metal_rough: vec2<f32>, emissive: vec3<f32> }
+ * fn mesh_surface_sample(cache: MeshSurface, header: MeshSDF, level: u32, position: vec3<f32>, tolerance: f32) -> MeshSurfaceSample
+ * ```
+ *
+ * The brick of the level holding the point, as `mesh_sdf_sample` finds it. A cache that keeps no plane
+ * holds its record's material there. Otherwise the point is moved onto the surface by the field's
+ * distance against its normal there, and of the 8 texels around it (`surface_material_corners`) those
+ * that hold a material — their blocks kept by the brick's table word, their presence bits set — and
+ * whose surfaces lie within `tolerance` voxels of the nearest one's are blended: each plane the cache
+ * keeps decoded from its blocks (`MESH_SURFACE_BLOCK.js`), each other plane its record's code. `found`
+ * is false outside the grid, in a brick the field left EMPTY, and where no corner holds a material.
+ *
+ * `header` is the cache's geometry's, resident. Reads `mesh_sdf_indirection`, `mesh_sdf_atlas` and what
+ * `mesh_sdf_normal` reads, and the caches' words.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_sample = CodeChunk.from(
+    //language=WGSL
+    `
+struct MeshSurfaceSample {
+    found: bool,
+    albedo: vec3<f32>,
+    /** (metalness, roughness) */
+    metal_rough: vec2<f32>,
+    emissive: vec3<f32>,
+}
+
+fn mesh_surface_sample(cache: ${MESH_SURFACE_STRUCT.wgsl_ref}, header: ${MESH_SDF_STRUCT.wgsl_ref}, level: u32, position: vec3<f32>, tolerance: f32) -> MeshSurfaceSample {
+    var out: MeshSurfaceSample;
+
+    let voxel = mesh_sdf_level_voxel(header, level);
+    let bricks = mesh_sdf_level_bricks(header, level);
+    let voxels = (position - header.origin) / voxel;
+
+    if (any(voxels < vec3<f32>(0.0)) || any(voxels > vec3<f32>(bricks * MESH_SDF_BRICK_VOXELS))) {
+        return out;
+    }
+
+    // the brick holding the point, a point on the grid's far face in the last brick, as mesh_sdf_sample finds it
+    let brick = min(vec3<u32>(voxels / f32(MESH_SDF_BRICK_VOXELS)), bricks - vec3<u32>(1u));
+    let b = mesh_sdf_level_offset(header, level) - header.indirection + brick.x + bricks.x * (brick.y + bricks.y * brick.z);
+    let slot = mesh_sdf_indirection[header.indirection + b];
+
+    if (!mesh_sdf_entry_holds_slot(slot)) {
+        return out;
+    }
+
+    if (cache.texels == 0u) {
+        // nothing varies: the record's material wherever the field holds the surface
+        out.found = true;
+        out.albedo = albedo_uncompress(cache.albedo);
+        out.metal_rough = metal_rough_uncompress(cache.metal_rough);
+        out.emissive = rgbe9995_decode(cache.emissive);
+
+        return out;
+    }
+
+    let number = mesh_sdf_indirection[mesh_sdf_numbers(header) + b];
+    let table = mesh_surface_data[cache.table + number];
+    let t = ${MESH_SDF_BRICK_TEXELS}u;
+    let field = tile_atlas_slot_origin(slot, textureDimensions(mesh_sdf_atlas, 0).xy / t, vec3<u32>(t));
+
+    let local = voxels - vec3<f32>(brick * MESH_SDF_BRICK_VOXELS);
+    let distance = mesh_sdf_sample(header, level, position) / voxel;
+    let gradient = mesh_sdf_normal(header, level, position);
+
+    // a flat field has no normal: the point is taken where it is
+    let normal = select(vec3<f32>(0.0), gradient, gradient == gradient);
+
+    let point = surface_material_point(local, distance, normal);
+    let base = surface_material_base(point);
+
+    var present = 0u;
+
+    for (var c = 0u; c < 8u; c++) {
+        let corner = base + vec3<u32>(c & 1u, (c >> 1u) & 1u, c >> 2u);
+        let block = mesh_surface_block_number(table, mesh_surface_block_of(corner));
+
+        if (block != ${MESH_SURFACE_NO_BLOCK}u && mesh_surface_present_at(cache.presence_blocks, block, mesh_surface_block_texel(corner))) {
+            present |= 1u << c;
+        }
+    }
+
+    let corners = surface_material_corners(mesh_sdf_atlas, field, point, present, normal, tolerance);
+
+    let keeps_albedo = (cache.texels & ${1 << SURFACE_MATERIAL_ALBEDO_PLANE}u) != 0u;
+    let keeps_metal_rough = (cache.texels & ${1 << SURFACE_MATERIAL_METAL_ROUGH_PLANE}u) != 0u;
+    let keeps_emissive = (cache.texels & ${1 << SURFACE_MATERIAL_EMISSIVE_PLANE}u) != 0u;
+
+    var albedo = vec3<f32>(0.0);
+    var metal_rough = vec2<f32>(0.0);
+    var emissive = vec3<f32>(0.0);
+    var weight = 0.0;
+
+    for (var c = 0u; c < 8u; c++) {
+        let corner = vec3<u32>(c & 1u, (c >> 1u) & 1u, c >> 2u);
+        let w = surface_material_corner_weight(mesh_sdf_atlas, corners, corner);
+
+        if (w > 0.0) {
+            let at = corners.base + corner;
+            let block = mesh_surface_block_number(table, mesh_surface_block_of(at));
+            let texel = mesh_surface_block_texel(at);
+
+            if (keeps_albedo) {
+                albedo += w * mesh_surface_albedo_at(cache.albedo_blocks, block, texel);
+            }
+
+            if (keeps_metal_rough) {
+                metal_rough += w * mesh_surface_metal_rough_at(cache.metal_rough_blocks, block, texel);
+            }
+
+            if (keeps_emissive) {
+                emissive += w * mesh_surface_emissive_at(cache.emissive_blocks, block, texel);
+            }
+
+            weight += w;
+        }
+    }
+
+    out.found = weight > 0.0;
+
+    if (out.found) {
+        out.albedo = select(albedo_uncompress(cache.albedo), albedo / weight, keeps_albedo);
+        out.metal_rough = select(metal_rough_uncompress(cache.metal_rough), metal_rough / weight, keeps_metal_rough);
+        out.emissive = select(rgbe9995_decode(cache.emissive), emissive / weight, keeps_emissive);
+    }
+
+    return out;
+}
+`, [
+        MESH_SURFACE_STRUCT.declaration_chunk,
+        chunk_mesh_sdf,
+        chunk_mesh_sdf_normal,
+        chunk_tile_atlas_slot_origin,
+        chunk_surface_material_corners,
+        chunk_mesh_surface_block_index,
+        chunk_mesh_surface_block,
+        chunk_albedo_uncompress,
+        chunk_metal_rough_uncompress,
+        chunk_rgbe9995_decode,
+    ]);
+
+chunk_mesh_surface_sample.requireResource(MESH_SDF_INDIRECTION_RESOURCE);
+chunk_mesh_surface_sample.requireResource(MESH_SDF_ATLAS_RESOURCE);

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_texel_ray.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The direction ray `ray` of a texel's {@link MESH_SURFACE_TEXEL_RAYS} leaves in, into the surface whose
+ * field normal is `n`:
+ *
+ * ```wgsl
+ * fn mesh_surface_texel_ray(seed: vec3<u32>, ray: u32, n: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * A Fibonacci set over the hemisphere facing the surface: ray i in the i-th of
+ * {@link MESH_SURFACE_TEXEL_RAYS} bands of equal solid angle, counted from -n out to the horizon. The
+ * texel's `seed` turns the whole set about n by one random angle and shifts every ray through its band
+ * by one random fraction, so that no two texels take the same directions, neither in azimuth nor in
+ * elevation. Initializes the random stream at `seed` and takes its first two draws.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_texel_ray: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_surface_texel_ray.d.ts.map

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_texel_ray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_surface_texel_ray.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_texel_ray.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,2CAFU,SAAS,CA0BZ;0BA3CmB,uCAAuC"}

package/src/shade/renderer/geometry/sdf/surface/chunk_mesh_surface_texel_ray.js

@@ -0,0 +1,49 @@
+import { chunk_build_orthonormal_matrix_n } from "../../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_n.js";
+import { chunk_sphere_fibonacci_point } from "../../../shader/chunk/geometry/sphere/chunk_sphere_fibonacci_point.js";
+import { PI_DECLARATION } from "../../../shader/chunk/math/PI_DECLARATION.js";
+import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
+import { chunk_random_initialize } from "../../../shader/chunk/random/chunk_random_initialize.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { MESH_SURFACE_TEXEL_RAYS } from "./MESH_SURFACE_BAKE.js";
+
+/**
+ * The direction ray `ray` of a texel's {@link MESH_SURFACE_TEXEL_RAYS} leaves in, into the surface whose
+ * field normal is `n`:
+ *
+ * ```wgsl
+ * fn mesh_surface_texel_ray(seed: vec3<u32>, ray: u32, n: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * A Fibonacci set over the hemisphere facing the surface: ray i in the i-th of
+ * {@link MESH_SURFACE_TEXEL_RAYS} bands of equal solid angle, counted from -n out to the horizon. The
+ * texel's `seed` turns the whole set about n by one random angle and shifts every ray through its band
+ * by one random fraction, so that no two texels take the same directions, neither in azimuth nor in
+ * elevation. Initializes the random stream at `seed` and takes its first two draws.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_surface_texel_ray = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_surface_texel_ray(seed: vec3<u32>, ray: u32, n: vec3<f32>) -> vec3<f32> {
+    random_initialize(seed, vec3<u32>(0u));
+
+    let turn = 2.0 * PI * random();
+    // the point of a 2N-point Fibonacci sphere is the middle of its band, which spans its index ± 0.5
+    let shift = random() - 0.5;
+    let point = sphere_fibonacci_point(f32(ray) + shift, ${2 * MESH_SURFACE_TEXEL_RAYS}.0);
+    let turned = vec3<f32>(
+        cos(turn) * point.x - sin(turn) * point.y,
+        sin(turn) * point.x + cos(turn) * point.y,
+        point.z,
+    );
+
+    return normalize(build_orthonormal_matrix_n(-n) * turned);
+}
+`, [
+        PI_DECLARATION,
+        chunk_random,
+        chunk_random_initialize,
+        chunk_sphere_fibonacci_point,
+        chunk_build_orthonormal_matrix_n,
+    ]);

package/src/shade/renderer/geometry/sdf/surface/chunk_surface_material_fit.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A surface material texel fitted from weighted surface samples (`SURFACE_MATERIAL.js`):
+ *
+ * ```wgsl
+ * fn surface_material_fit_add(fit: ptr<function, SurfaceMaterialFit>, weight: f32, albedo: vec3<f32>, metal_rough: vec2<f32>, emissive: vec3<f32>)
+ * fn surface_material_fit_solve(fit: SurfaceMaterialFit) -> SurfaceMaterialFitted
+ * ```
+ *
+ * A sample is a point of the surface under the texel's tent and the material there. Every property is
+ * fitted as a constant, the least-squares one: the samples' weighted mean. The sums add in any order,
+ * so a fit can be split and joined.
+ *
+ * `covered` is false for a fit of no weight: no surface was sampled under the tent.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_surface_material_fit: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_surface_material_fit.d.ts.map

package/src/shade/renderer/geometry/sdf/surface/chunk_surface_material_fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_surface_material_fit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/chunk_surface_material_fit.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,yCAFU,SAAS,CAkDhB;0BAlEuB,uCAAuC"}