@woosh/meep-engine 3.61.2 → 3.61.3

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

@@ -0,0 +1,118 @@
+/**
+ * Rays a listed texel is sampled with, a thread each: a Fibonacci set over the hemisphere facing its
+ * surface, turned about the surface's normal by a random angle for each texel, each one's first opaque
+ * hit under the texel's tent a sample.
+ * @type {number}
+ */
+export const MESH_SURFACE_TEXEL_RAYS: number;
+/**
+ * How far out from a texel's surface point its rays leave, in voxels of its level: where a ray of
+ * the GI coming in over the surface stands on it, UE's half voxel (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
+ * §7.9), so that the texel holds the surface as such rays meet it.
+ * @type {number}
+ */
+export const MESH_SURFACE_LIFT_VOXELS: number;
+/**
+ * Transparent hits a texel's ray steps past, at most, before it gives no sample.
+ * @type {number}
+ */
+export const MESH_SURFACE_ALPHA_CONTINUATIONS: number;
+/** Counter: texels the list pass listed, appended to atomically. */
+export const MESH_SURFACE_COUNTER_LISTED: 0;
+/** Counter: texels the trace takes, the listed ones the list holds; the command writes it. */
+export const MESH_SURFACE_COUNTER_TRACED: 1;
+/** Words of the counter. */
+export const MESH_SURFACE_COUNTER_WORDS: 2;
+/** Words of the trace's command: the three workgroup counts. */
+export const MESH_SURFACE_COMMAND_WORDS: 3;
+/**
+ * Words of a texel's staging: its albedo, metalness and roughness, and emissive codes, the albedo's 0
+ * where the trace found no surface (the codec never writes 0).
+ * @type {number}
+ */
+export const MESH_SURFACE_STAGING_WORDS: number;
+/**
+ * Words of a survey's result: the ticket it was asked under, and its field's count of blocks.
+ * @type {number}
+ */
+export const MESH_SURFACE_SURVEY_RESULT_WORDS: number;
+/**
+ * A texel the trace samples, as the list pass resolved it: whose triangles and material, which brick
+ * and texel of the field, and its staging slot, the list pass's thread.
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_TEXEL_STRUCT: WebGPUStruct;
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_LIST_SETTINGS: WebGPUStruct;
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_COMMAND_SETTINGS: WebGPUStruct;
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_ENCODE_SETTINGS: WebGPUStruct;
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_SURVEY_SETTINGS: WebGPUStruct;
+/**
+ * A pass's runs, a `vec4<u32>` each, in order of their first thread, the first at 0. To the bake's
+ * passes: its first thread, the cache, its first brick number, 0. To the survey: its first thread, the
+ * geometry, its first brick number, its table's word. To the numbering: its first thread, its table's
+ * word, its result, its ticket.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_RUNS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The frame's survey results, {@link MESH_SURFACE_SURVEY_RESULT_WORDS} each, read back.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_SURVEY_RESULTS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_TEXELS_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_TEXELS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_COUNTER_RESOURCE: ShaderResourceDescriptor;
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_COUNTER_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_COMMAND_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The frame's texels' staging, {@link MESH_SURFACE_STAGING_WORDS} a slot, as the list pass clears it and
+ * the trace writes it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_STAGING_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The staging as the encode reads it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_STAGING_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The caches' words (`MESH_SURFACE_DATA_RESOURCE`) as the encode writes its blocks into them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_DATA_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The caches' words as the survey and the numbering write the block tables into them, a texel's bit at
+ * a time.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_DATA_ATOMIC_RESOURCE: ShaderResourceDescriptor;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+//# sourceMappingURL=MESH_SURFACE_BAKE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_SURFACE_BAKE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/MESH_SURFACE_BAKE.js"],"names":[],"mappings":"AA8BA;;;;;GAKG;AACH,sCAFU,MAAM,CAE0B;AAE1C;;;;;GAKG;AACH,uCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,+CAFU,MAAM,CAEkC;AAElD,oEAAoE;AACpE,4CAA6C;AAE7C,8FAA8F;AAC9F,4CAA6C;AAE7C,4BAA4B;AAC5B,2CAA4C;AAE5C,gEAAgE;AAChE,2CAA4C;AAE5C;;;;GAIG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,+CAFU,MAAM,CAEkC;AAElD;;;;GAIG;AACH,wCAFU,YAAY,CAWC;AAEvB;;GAEG;AACH,yCAFU,YAAY,CAWQ;AAE9B;;GAEG;AACH,4CAFU,YAAY,CAKW;AAEjC;;GAEG;AACH,2CAFU,YAAY,CASU;AAEhC;;GAEG;AACH,2CAFU,YAAY,CASU;AAEhC;;;;;;GAMG;AACH,yCAFU,wBAAwB,CAE6F;AAE/H;;;GAGG;AACH,mDAFU,wBAAwB,CAE4H;AAE9J;;GAEG;AACH,iDAFU,wBAAwB,CAEiI;AAEnK;;GAEG;AACH,gDAFU,wBAAwB,CAE0H;AAE5J;;GAEG;AACH,4CAFU,wBAAwB,CAE8G;AAEhJ;;GAEG;AACH,iDAFU,wBAAwB,CAEgG;AAElI;;GAEG;AACH,4CAFU,wBAAwB,CAEiG;AAEnI;;;;GAIG;AACH,kDAFU,wBAAwB,CAEuG;AAEzI;;;GAGG;AACH,iDAFU,wBAAwB,CAEgG;AAElI;;;GAGG;AACH,+CAFU,wBAAwB,CAEiG;AAEnI;;;;GAIG;AACH,gDAFU,wBAAwB,CAE+G;6BAxMpH,sCAAsC;yCAH1B,sDAAsD"}

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

@@ -0,0 +1,204 @@
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { atomic_u32, u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+
+/*
+ A Model Surface Cache's survey and bake (`GPUMeshSurfaceCaches`).
+
+ The survey, once a field, over runs of its stored bricks:
+
+   survey    a thread a texel: sets its block's bit in its brick's table word when it can hold
+             surface (chunk_mesh_surface_listed)
+   number    a thread a brick of a field whose survey is done: gives the brick's blocks numbers, the
+             field's count of them read back
+
+ The bake, over the frame's runs, a run a stretch of one cache's bricks by number:
+
+   list      a thread a texel of the runs' bricks: clears its staging, and lists it when it can hold
+             surface
+   command   one thread: the trace's dispatch, a workgroup a listed texel
+   trace     a workgroup a listed texel: MESH_SURFACE_TEXEL_RAYS rays from it into its geometry's
+             triangles, the surface they find under its tent fitted into its staging's codes
+   encode    a workgroup a block the runs' bricks keep, a thread a texel: the block's presence, and its
+             code in each plane the cache keeps (MESH_SURFACE_BLOCK.js)
+
+ Once per cache, and again when its material changes: the rays read the geometry's BLAS and the
+ material's resident row, which nothing that reads the cache does. A cache that keeps no plane is
+ never baked: its record's codes are all it holds.
+*/
+
+/**
+ * Rays a listed texel is sampled with, a thread each: a Fibonacci set over the hemisphere facing its
+ * surface, turned about the surface's normal by a random angle for each texel, each one's first opaque
+ * hit under the texel's tent a sample.
+ * @type {number}
+ */
+export const MESH_SURFACE_TEXEL_RAYS = 64;
+
+/**
+ * How far out from a texel's surface point its rays leave, in voxels of its level: where a ray of
+ * the GI coming in over the surface stands on it, UE's half voxel (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
+ * §7.9), so that the texel holds the surface as such rays meet it.
+ * @type {number}
+ */
+export const MESH_SURFACE_LIFT_VOXELS = 0.5;
+
+/**
+ * Transparent hits a texel's ray steps past, at most, before it gives no sample.
+ * @type {number}
+ */
+export const MESH_SURFACE_ALPHA_CONTINUATIONS = 4;
+
+/** Counter: texels the list pass listed, appended to atomically. */
+export const MESH_SURFACE_COUNTER_LISTED = 0;
+
+/** Counter: texels the trace takes, the listed ones the list holds; the command writes it. */
+export const MESH_SURFACE_COUNTER_TRACED = 1;
+
+/** Words of the counter. */
+export const MESH_SURFACE_COUNTER_WORDS = 2;
+
+/** Words of the trace's command: the three workgroup counts. */
+export const MESH_SURFACE_COMMAND_WORDS = 3;
+
+/**
+ * Words of a texel's staging: its albedo, metalness and roughness, and emissive codes, the albedo's 0
+ * where the trace found no surface (the codec never writes 0).
+ * @type {number}
+ */
+export const MESH_SURFACE_STAGING_WORDS = 3;
+
+/**
+ * Words of a survey's result: the ticket it was asked under, and its field's count of blocks.
+ * @type {number}
+ */
+export const MESH_SURFACE_SURVEY_RESULT_WORDS = 2;
+
+/**
+ * A texel the trace samples, as the list pass resolved it: whose triangles and material, which brick
+ * and texel of the field, and its staging slot, the list pass's thread.
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_TEXEL_STRUCT = WebGPUStruct.from({
+    geometry: u32,
+    material: u32,
+    /** the brick's index in the field's layout */
+    brick: u32,
+    /** t.x + 8 (t.y + 8 t.z) */
+    texel: u32,
+    /** its staging: the list pass's thread */
+    slot: u32,
+}, "MeshSurfaceTexel");
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_LIST_SETTINGS = WebGPUStruct.from({
+    /** runs in `mesh_surface_runs` */
+    run_count: u32,
+    /** texels over every run: the threads that do work */
+    thread_count: u32,
+    /** workgroups along x, the rest folded into y */
+    groups_x: u32,
+    /** texels `mesh_surface_texels` holds */
+    capacity: u32,
+}, "MeshSurfaceListSettings");
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_COMMAND_SETTINGS = WebGPUStruct.from({
+    /** texels `mesh_surface_texels` holds */
+    capacity: u32,
+}, "MeshSurfaceCommandSettings");
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_ENCODE_SETTINGS = WebGPUStruct.from({
+    /** runs in `mesh_surface_runs` */
+    run_count: u32,
+    /** bricks over every run: the workgroups that do work are 8 of each */
+    brick_count: u32,
+    /** workgroups along x, the rest folded into y */
+    groups_x: u32,
+}, "MeshSurfaceEncodeSettings");
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_SURVEY_SETTINGS = WebGPUStruct.from({
+    /** runs in `mesh_surface_survey_runs` */
+    run_count: u32,
+    /** threads over every run */
+    thread_count: u32,
+    /** workgroups along x, the rest folded into y */
+    groups_x: u32,
+}, "MeshSurfaceSurveySettings");
+
+/**
+ * A pass's runs, a `vec4<u32>` each, in order of their first thread, the first at 0. To the bake's
+ * passes: its first thread, the cache, its first brick number, 0. To the survey: its first thread, the
+ * geometry, its first brick number, its table's word. To the numbering: its first thread, its table's
+ * word, its result, its ticket.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_RUNS_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_runs", WebGPUArray.from(vec4u));
+
+/**
+ * The frame's survey results, {@link MESH_SURFACE_SURVEY_RESULT_WORDS} each, read back.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_SURVEY_RESULTS_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_survey_results", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_TEXELS_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_texels", WebGPUArray.from(MESH_SURFACE_TEXEL_STRUCT), true);
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_TEXELS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_texels", WebGPUArray.from(MESH_SURFACE_TEXEL_STRUCT));
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_COUNTER_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_counter", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_COUNTER_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_counter", WebGPUArray.u32);
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_COMMAND_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_command", WebGPUArray.u32, true);
+
+/**
+ * The frame's texels' staging, {@link MESH_SURFACE_STAGING_WORDS} a slot, as the list pass clears it and
+ * the trace writes it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_STAGING_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_staging", WebGPUArray.u32, true);
+
+/**
+ * The staging as the encode reads it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_STAGING_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_staging", WebGPUArray.u32);
+
+/**
+ * The caches' words (`MESH_SURFACE_DATA_RESOURCE`) as the encode writes its blocks into them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_DATA_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_data", WebGPUArray.u32, true);
+
+/**
+ * The caches' words as the survey and the numbering write the block tables into them, a texel's bit at
+ * a time.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_DATA_ATOMIC_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_data", WebGPUArray.from(atomic_u32), true);

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

@@ -0,0 +1,66 @@
+/**
+ * Texels along a side of a block.
+ * @type {number}
+ */
+export const MESH_SURFACE_BLOCK_TEXELS: number;
+/**
+ * Texels in a block.
+ * @type {number}
+ */
+export const MESH_SURFACE_BLOCK_TEXEL_COUNT: number;
+/**
+ * Blocks a brick keeps at most: 2³.
+ * @type {number}
+ */
+export const MESH_SURFACE_BRICK_BLOCKS: number;
+/**
+ * Bits of a table word below the brick's first block number: its mask of blocks.
+ * @type {number}
+ */
+export const MESH_SURFACE_TABLE_MASK_BITS: number;
+/**
+ * Words of a block's presence.
+ * @type {number}
+ */
+export const MESH_SURFACE_PRESENCE_BLOCK_WORDS: number;
+/**
+ * Words of a block's albedo.
+ * @type {number}
+ */
+export const MESH_SURFACE_ALBEDO_BLOCK_WORDS: number;
+/**
+ * Words of a block's albedo ahead of its texels' fields: two endpoints for each of its two subsets.
+ * @type {number}
+ */
+export const MESH_SURFACE_ALBEDO_ENDPOINT_WORDS: number;
+/**
+ * Levels of each albedo subset's line: a 3-bit index.
+ * @type {number}
+ */
+export const MESH_SURFACE_ALBEDO_LEVELS: number;
+/**
+ * Words of a block's metalness and roughness.
+ * @type {number}
+ */
+export const MESH_SURFACE_METAL_ROUGH_BLOCK_WORDS: number;
+/**
+ * Levels of the metalness and roughness's line: a 2-bit index.
+ * @type {number}
+ */
+export const MESH_SURFACE_METAL_ROUGH_LEVELS: number;
+/**
+ * Words of a block's emissive.
+ * @type {number}
+ */
+export const MESH_SURFACE_EMISSIVE_BLOCK_WORDS: number;
+/**
+ * Words of a block in each plane, by `SURFACE_MATERIAL.js` plane.
+ * @type {ReadonlyArray<number>}
+ */
+export const MESH_SURFACE_PLANE_BLOCK_WORDS: ReadonlyArray<number>;
+/**
+ * A block number no brick holds: its block is not kept.
+ * @type {number}
+ */
+export const MESH_SURFACE_NO_BLOCK: number;
+//# sourceMappingURL=MESH_SURFACE_BLOCK.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_SURFACE_BLOCK.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/MESH_SURFACE_BLOCK.js"],"names":[],"mappings":"AAsBA;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,2CAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,8CAFU,MAAM,CAEkC;AAElD;;;GAGG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,mDAFU,MAAM,CAEsC;AAEtD;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,gDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,6CAFU,cAAc,MAAM,CAAC,CAM5B;AAEH;;;GAGG;AACH,oCAFU,MAAM,CAEgC"}

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

@@ -0,0 +1,103 @@
+/*
+ A Model Surface Cache's material blocks: 4³ texels of a field brick's 8³, the brick halved along each
+ axis, kept only where some texel of the block can hold surface, each plane block-coded.
+
+   block of brick texel t      (t >> 2): b = b.x + 2 (b.y + 2 b.z), 8 a brick
+   texel of its block          (t & 3):  l = l.x + 4 (l.y + 4 l.z), 64 a block
+
+ A geometry's block table holds a word for each brick its field stored, by number: the brick's first
+ block number above an 8-bit mask of the blocks it keeps, block b numbered first + the mask's bits
+ below b. Every cache of the geometry keeps its planes' blocks by those numbers.
+
+   presence      2 words     a bit a texel: the texels the bake found surface under
+   albedo        12 words    two subsets of the texels, each a line through the square roots of
+                             the diffuse albedo: subset s's endpoints in words 2s and 2s + 1, unorm8
+                             each (pack4x8unorm), then a 4-bit field a texel, texel l at bit
+                             4 (l % 8) of word 4 + l / 8, its subset s above its 3-bit level k:
+                             albedo (e0 + (k / 7) (e1 - e0))² on subset s's line
+   metal_rough   5 words     two endpoints, 4 bits of metalness and 4 of roughness each, in the
+                             first word, then a 2-bit index a texel: e0 + (k / 3) (e1 - e0)
+   emissive      64 words    a code a texel, RGB9E5 (rgbe9995_encode)
+*/
+
+/**
+ * Texels along a side of a block.
+ * @type {number}
+ */
+export const MESH_SURFACE_BLOCK_TEXELS = 4;
+
+/**
+ * Texels in a block.
+ * @type {number}
+ */
+export const MESH_SURFACE_BLOCK_TEXEL_COUNT = 64;
+
+/**
+ * Blocks a brick keeps at most: 2³.
+ * @type {number}
+ */
+export const MESH_SURFACE_BRICK_BLOCKS = 8;
+
+/**
+ * Bits of a table word below the brick's first block number: its mask of blocks.
+ * @type {number}
+ */
+export const MESH_SURFACE_TABLE_MASK_BITS = 8;
+
+/**
+ * Words of a block's presence.
+ * @type {number}
+ */
+export const MESH_SURFACE_PRESENCE_BLOCK_WORDS = 2;
+
+/**
+ * Words of a block's albedo.
+ * @type {number}
+ */
+export const MESH_SURFACE_ALBEDO_BLOCK_WORDS = 12;
+
+/**
+ * Words of a block's albedo ahead of its texels' fields: two endpoints for each of its two subsets.
+ * @type {number}
+ */
+export const MESH_SURFACE_ALBEDO_ENDPOINT_WORDS = 4;
+
+/**
+ * Levels of each albedo subset's line: a 3-bit index.
+ * @type {number}
+ */
+export const MESH_SURFACE_ALBEDO_LEVELS = 8;
+
+/**
+ * Words of a block's metalness and roughness.
+ * @type {number}
+ */
+export const MESH_SURFACE_METAL_ROUGH_BLOCK_WORDS = 5;
+
+/**
+ * Levels of the metalness and roughness's line: a 2-bit index.
+ * @type {number}
+ */
+export const MESH_SURFACE_METAL_ROUGH_LEVELS = 4;
+
+/**
+ * Words of a block's emissive.
+ * @type {number}
+ */
+export const MESH_SURFACE_EMISSIVE_BLOCK_WORDS = 64;
+
+/**
+ * Words of a block in each plane, by `SURFACE_MATERIAL.js` plane.
+ * @type {ReadonlyArray<number>}
+ */
+export const MESH_SURFACE_PLANE_BLOCK_WORDS = Object.freeze([
+    MESH_SURFACE_ALBEDO_BLOCK_WORDS,
+    MESH_SURFACE_METAL_ROUGH_BLOCK_WORDS,
+    MESH_SURFACE_EMISSIVE_BLOCK_WORDS,
+]);
+
+/**
+ * A block number no brick holds: its block is not kept.
+ * @type {number}
+ */
+export const MESH_SURFACE_NO_BLOCK = 0xffffffff;

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

@@ -0,0 +1,19 @@
+/**
+ * Every Model Surface Cache's record, by cache id.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_RECORDS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The caches' words (`MESH_SURFACE_BLOCK.js`): each geometry's block table, and each cache's blocks of
+ * presence and of every plane it keeps, at the words its record names.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_DATA_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A word a `meshes` row: the Model Surface Cache of the row's (geometry, material) pair, or
+ * `GPU_DATABASE_NULL` while it has none that readers may use.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_ROWS_RESOURCE: ShaderResourceDescriptor;
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+//# sourceMappingURL=MESH_SURFACE_RESOURCES.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_SURFACE_RESOURCES.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/MESH_SURFACE_RESOURCES.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,4CAFU,wBAAwB,CAEiH;AAEnJ;;;;GAIG;AACH,yCAFU,wBAAwB,CAEqF;AAEvH;;;;GAIG;AACH,yCAFU,wBAAwB,CAEqF;yCAtB9E,sDAAsD"}

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

@@ -0,0 +1,23 @@
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { MESH_SURFACE_STRUCT } from "./MESH_SURFACE_STRUCT.js";
+
+/**
+ * Every Model Surface Cache's record, by cache id.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_RECORDS_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_records", WebGPUArray.from(MESH_SURFACE_STRUCT));
+
+/**
+ * The caches' words (`MESH_SURFACE_BLOCK.js`): each geometry's block table, and each cache's blocks of
+ * presence and of every plane it keeps, at the words its record names.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_DATA_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_data", WebGPUArray.u32);
+
+/**
+ * A word a `meshes` row: the Model Surface Cache of the row's (geometry, material) pair, or
+ * `GPU_DATABASE_NULL` while it has none that readers may use.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SURFACE_ROWS_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_surface_rows", WebGPUArray.u32);

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

@@ -0,0 +1,15 @@
+/**
+ * A Model Surface Cache: one (geometry, material) pair's surface material (`SURFACE_MATERIAL.js`), by
+ * cache id. A plane that varies over the surface keeps blocks (`MESH_SURFACE_BLOCK.js`), one for each
+ * block its geometry's field keeps, by the block numbers of its geometry's table: block n of a plane at
+ * word `<plane>_blocks + n · <the plane's words a block>` of `mesh_surface_data`. A plane that does not
+ * vary keeps none, and its code here stands for every texel. A cache that keeps any plane keeps a
+ * block of presence for each block too.
+ *
+ * 52 bytes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=MESH_SURFACE_STRUCT.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MESH_SURFACE_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/MESH_SURFACE_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,kCAFU,YAAY,CAwDJ;6BApEW,sCAAsC"}

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

@@ -0,0 +1,70 @@
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+
+/**
+ * A Model Surface Cache: one (geometry, material) pair's surface material (`SURFACE_MATERIAL.js`), by
+ * cache id. A plane that varies over the surface keeps blocks (`MESH_SURFACE_BLOCK.js`), one for each
+ * block its geometry's field keeps, by the block numbers of its geometry's table: block n of a plane at
+ * word `<plane>_blocks + n · <the plane's words a block>` of `mesh_surface_data`. A plane that does not
+ * vary keeps none, and its code here stands for every texel. A cache that keeps any plane keeps a
+ * block of presence for each block too.
+ *
+ * 52 bytes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const MESH_SURFACE_STRUCT = WebGPUStruct.from({
+    /**
+     * The geometry id whose field the blocks follow and whose triangles they were baked from: the
+     * source's, for an aliased geometry.
+     */
+    geometry: u32,
+    /**
+     * The material's resident id, which the bake shades with.
+     */
+    material: u32,
+    /**
+     * The bricks the field stored.
+     */
+    tiles: u32,
+    /**
+     * The blocks the field's bricks keep: each run's length.
+     */
+    blocks: u32,
+    /**
+     * Bit `1 << plane` for each plane (`SURFACE_MATERIAL.js`) the cache keeps blocks of.
+     */
+    texels: u32,
+    /**
+     * The word of the geometry's block table holding its brick numbered 0.
+     */
+    table: u32,
+    /**
+     * The word of block 0's presence, with any plane's bit in {@link texels}.
+     */
+    presence_blocks: u32,
+    /**
+     * The word of block 0's albedo, with the albedo plane's bit.
+     */
+    albedo_blocks: u32,
+    /**
+     * The word of block 0's metalness and roughness, with that plane's bit.
+     */
+    metal_rough_blocks: u32,
+    /**
+     * The word of block 0's emissive, with the emissive plane's bit.
+     */
+    emissive_blocks: u32,
+    /**
+     * The diffuse albedo's code (`albedo_compress`) of every texel, without the albedo plane's bit.
+     */
+    albedo: u32,
+    /**
+     * The metalness and roughness's code (`metal_rough_compress`) of every texel, without that plane's bit.
+     */
+    metal_rough: u32,
+    /**
+     * The emissive's code (`rgbe9995_encode`) of every texel, without the emissive plane's bit.
+     */
+    emissive: u32,
+}, "MeshSurface");

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

@@ -0,0 +1,13 @@
+/**
+ * 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: ReadonlyArray<GPUTextureFormat>;
+/** 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;
+//# sourceMappingURL=SURFACE_MATERIAL.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SURFACE_MATERIAL.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/SURFACE_MATERIAL.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,uCAFU,+BAA+B,CAE+C;AAExF,qCAAqC;AACrC,8CAA+C;AAE/C,sDAAsD;AACtD,mDAAoD;AAEpD,uCAAuC;AACvC,gDAAiD"}