@woosh/meep-engine 3.61.1 → 3.61.3

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_resolve.js

@@ -0,0 +1,343 @@
+import { chunk_generate_next_linear_congruential_index } from "../../../gpu_primitive/hash_table/chunk_generate_next_linear_congruential_index.js";
+import { chunk_slot_stack } from "../../../gpu_primitive/slot_stack/chunk_slot_stack.js";
+import { chunk_hash_lowbias32 } from "../../../shader/chunk/random/chunk_hash_lowbias32.js";
+import { chunk_subgroup_atomic_add } from "../../../shader/chunk/subgroup/chunk_subgroup_atomic_add.js";
+import { chunk_subgroup_atomic_load } from "../../../shader/chunk/subgroup/chunk_subgroup_atomic_load.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.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";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { chunk_tile_atlas_slot_origin } from "../../../texture/atlas/chunk_tile_atlas_slot_origin.js";
+import { MESH_SDF_ATLAS_RESOURCE, MESH_SDF_HEADERS_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { chunk_mesh_sdf_bake, MESH_SDF_ARENA_RESOURCE } from "./chunk_mesh_sdf_bake.js";
+import {
+    chunk_mesh_sdf_contents,
+    MESH_SDF_CONTENT_TABLE_RESOURCE,
+    MESH_SDF_CONTENTS_RESOURCE
+} from "./chunk_mesh_sdf_contents.js";
+import { MESH_SDF_BAKE_WORKGROUP_SIZE } from "./MESH_SDF_BAKE.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_RESOLVE_SETTINGS = WebGPUStruct.from({
+    /** entries of `mesh_sdf_ring`, a power of two; the staging starts here */
+    ring_capacity: u32,
+    /** slots the stack holds */
+    slot_capacity: u32,
+    /** where the frame's log starts in the arena */
+    log_offset: u32,
+    /** where the records of the frame's bricks taken start in the arena, MESH_SDF_TAKEN_WORDS each */
+    tally_offset: u32,
+    /** where the frame's claims start in the arena */
+    claim_offset: u32,
+    /** records of the frame's claims, a power of two, no fewer than the probe limit */
+    claim_size: u32,
+}, "MeshSDFResolveSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_SDF_RESOLVE_SETTINGS);
+
+resources.createGroup()
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .addStorageBuffer("mesh_sdf_ring", WebGPUArray.from(vec4u))
+    .addStorageBuffer("mesh_sdf_take", WebGPUArray.u32)
+    .add(MESH_SDF_ARENA_RESOURCE)
+    .addStorageBuffer("mesh_sdf_slots", WebGPUArray.u32, true)
+    .add(MESH_SDF_CONTENTS_RESOURCE)
+    .add(MESH_SDF_CONTENT_TABLE_RESOURCE);
+
+const compare_resources = new ShaderResourceSetDescriptor();
+
+compare_resources.setImmediate("settings", MESH_SDF_RESOLVE_SETTINGS);
+
+compare_resources.createGroup()
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .addStorageBuffer("mesh_sdf_ring", WebGPUArray.from(vec4u))
+    .addStorageBuffer("mesh_sdf_take", WebGPUArray.u32)
+    .add(MESH_SDF_ARENA_RESOURCE)
+    .add(MESH_SDF_ATLAS_RESOURCE);
+
+/**
+ * What the passes of resolve share: the brick a thread is of, by its place in the take, its record's
+ * word, its content key and its staged bytes.
+ *
+ * ```wgsl
+ * fn mesh_sdf_resolve_entry(taken: u32) -> u32              // the brick's entry when it is PENDING, else MESH_SDF_NO_CONTENT
+ * fn mesh_sdf_resolve_record(taken: u32) -> u32             // its record's first word
+ * fn mesh_sdf_resolve_key(record: u32) -> u32               // its content key
+ * fn mesh_sdf_resolve_byte(taken: u32, texel: u32) -> u32   // a texel's byte as evaluate staged it, texel x + 8y + 64z
+ * ```
+ */
+const chunk_mesh_sdf_resolve = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_sdf_resolve_entry(taken: u32) -> u32 {
+    if (taken >= mesh_sdf_take[MESH_SDF_TAKE_COUNT]) {
+        return MESH_SDF_NO_CONTENT;
+    }
+
+    let item = mesh_sdf_ring[(mesh_sdf_take[MESH_SDF_TAKE_START] + taken) & (settings.ring_capacity - 1u)];
+    let header = mesh_sdf_headers[item.x];
+
+    if (header.state != MESH_SDF_STATE_BAKING || header.generation != item.y) {
+        return MESH_SDF_NO_CONTENT;
+    }
+
+    let entry = header.indirection + item.z;
+
+    if (atomicLoad(&mesh_sdf_indirection[entry]) != MESH_SDF_PENDING) {
+        return MESH_SDF_NO_CONTENT;
+    }
+
+    return entry;
+}
+
+fn mesh_sdf_resolve_record(taken: u32) -> u32 {
+    return settings.tally_offset + taken * MESH_SDF_TAKEN_WORDS;
+}
+
+fn mesh_sdf_resolve_key(record: u32) -> u32 {
+    return atomicLoad(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_KEY]);
+}
+
+fn mesh_sdf_resolve_byte(taken: u32, texel: u32) -> u32 {
+    // a word a texel, four words an entry of the staging
+    return mesh_sdf_ring[settings.ring_capacity + taken * MESH_SDF_STAGING_VEC4S + texel / 4u][texel % 4u];
+}
+`, [
+        chunk_mesh_sdf_bake,
+    ]);
+
+/**
+ * @param {string} label
+ * @param {string} text the pass's body, in `main` after `taken`
+ * @param {CodeChunk[]} dependencies
+ * @returns {ComputeShader}
+ */
+function resolve_pass(label, text, dependencies) {
+    return ComputeShader.from({
+        label,
+        resources,
+        body: CodeChunk.from(
+            //language=WGSL
+            `
+@compute @workgroup_size(${MESH_SDF_BAKE_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let taken = id.x;
+${text}
+}
+`, [chunk_mesh_sdf_resolve, chunk_mesh_sdf_contents, ...dependencies]),
+    });
+}
+
+/**
+ * Bake step 5, resolve, first pass, find: a thread a brick taken, over the frame's budget. A PENDING
+ * brick finds a slot listed under its content key (`chunk_mesh_sdf_contents`), which compare holds its
+ * bytes against, and keeps it in its record. One that finds none claims its key in the frame's
+ * claims, a table of the frame's bricks by key: the first to claim a key is its representative, which
+ * fresh gives a slot, and every brick names its key's representative in its record, whose bytes
+ * compare holds its own against.
+ *
+ * The keys are key's, read after its dispatch. No list shares this dispatch, so every find meets the
+ * table as the last frame left it.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_resolve_find = resolve_pass("Mesh SDF Resolve Find", `
+    let entry = mesh_sdf_resolve_entry(taken);
+
+    if (entry == MESH_SDF_NO_CONTENT) {
+        return;
+    }
+
+    let record = mesh_sdf_resolve_record(taken);
+    let key = mesh_sdf_resolve_key(record);
+    let slot = mesh_sdf_content_find(key);
+
+    atomicStore(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_SLOT], slot);
+    atomicStore(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_REP], taken);
+
+    if (slot != MESH_SDF_NO_CONTENT) {
+        return;
+    }
+
+    // the frame's first brick of the key, by claim: a bucket holds a brick's place + 1
+    let mask = settings.claim_size - 1u;
+
+    var bucket = hash_lowbias32(key) & mask;
+
+    for (var probe = 0u; probe < HASH_TABLE_PROBE_LIMIT; probe++) {
+        let word = settings.claim_offset + bucket;
+        let stored = atomicLoad(&mesh_sdf_indirection[word]);
+
+        if (stored == 0u) {
+            let claim = atomicCompareExchangeWeak(&mesh_sdf_indirection[word], 0u, taken + 1u);
+
+            if (claim.exchanged) {
+                return;
+            }
+
+            if (claim.old_value == 0u) {
+                // a weak exchange may fail on a bucket still empty: the same bucket again
+                continue;
+            }
+
+            if (mesh_sdf_resolve_key(mesh_sdf_resolve_record(claim.old_value - 1u)) == key) {
+                atomicStore(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_REP], claim.old_value - 1u);
+                return;
+            }
+        } else if (mesh_sdf_resolve_key(mesh_sdf_resolve_record(stored - 1u)) == key) {
+            atomicStore(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_REP], stored - 1u);
+            return;
+        }
+
+        bucket = generate_next_linear_congruential_index(bucket, mask);
+    }
+
+    // claims run out: its own representative, its bytes in a slot of their own
+`, [chunk_hash_lowbias32, chunk_generate_next_linear_congruential_index]);
+
+/**
+ * Bake step 5, resolve, second pass, compare: a thread a texel of each brick taken, eight workgroups a
+ * brick, dispatched by take. A PENDING brick that found a slot holds each of its staged bytes against
+ * the byte the slot holds there, and one that names a representative other than itself against the
+ * representative's staged byte, and the texels that differ are counted in the brick's record. A key
+ * finds the bricks its bytes may be those of; this pass says whether they are.
+ *
+ * A subgroup's lanes are of one brick, a workgroup's 64 texels being, so the brick's words are loaded
+ * and its count added once a subgroup (`chunk_subgroup_atomic_load`, `chunk_subgroup_atomic_add`).
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_resolve_compare = ComputeShader.from({
+    label: "Mesh SDF Resolve Compare",
+    resources: compare_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${MESH_SDF_BAKE_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let taken = workgroup_id.x / MESH_SDF_GROUPS_PER_BRICK;
+    let item = mesh_sdf_ring[(mesh_sdf_take[MESH_SDF_TAKE_START] + taken) & (settings.ring_capacity - 1u)];
+    let header = mesh_sdf_headers[item.x];
+
+    // the same for every lane of the workgroup, and of each of its subgroups: one brick
+    if (header.state != MESH_SDF_STATE_BAKING || header.generation != item.y) {
+        return;
+    }
+
+    if (subgroup_atomic_load_u32(&mesh_sdf_indirection[header.indirection + item.z]) != MESH_SDF_PENDING) {
+        return;
+    }
+
+    let record = mesh_sdf_resolve_record(taken);
+    let slot = subgroup_atomic_load_u32(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_SLOT]);
+    let rep = subgroup_atomic_load_u32(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_REP]);
+    let texel = (workgroup_id.x % MESH_SDF_GROUPS_PER_BRICK) * MESH_SDF_BAKE_WORKGROUP_SIZE + lane;
+
+    var other: u32;
+
+    if (slot != MESH_SDF_NO_CONTENT) {
+        let t = MESH_SDF_BRICK_TEXELS;
+        let slots = textureDimensions(mesh_sdf_atlas) / t;
+        let origin = tile_atlas_slot_origin(slot, slots.xy, vec3<u32>(t));
+
+        // r8unorm reads a byte back as byte / 255
+        other = u32(round(textureLoad(mesh_sdf_atlas, origin + vec3<u32>(texel % t, (texel / t) % t, texel / (t * t)), 0).x * 255.0));
+    } else if (rep != taken) {
+        other = mesh_sdf_resolve_byte(rep, texel);
+    } else {
+        // a representative: the first of its key in the frame, nothing to hold it against
+        return;
+    }
+
+    subgroup_atomic_add_u32(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_DIFFERS], select(0u, 1u, mesh_sdf_resolve_byte(taken, texel) != other));
+}
+`, [
+            chunk_mesh_sdf_resolve,
+            chunk_subgroup_atomic_add,
+            chunk_subgroup_atomic_load,
+            chunk_tile_atlas_slot_origin,
+        ]),
+});
+
+/**
+ * Bake step 5, resolve, third pass, fresh: a thread a brick taken. A representative pops a slot and
+ * lists it under its key, and its record says the slot is fresh, which store fills. A brick whose
+ * bytes differ from those it was compared with pops a fresh slot of its own, listed nowhere, so no
+ * brick after shares it: its key is another bytes' too, and the log counts it collided. Take held the
+ * frame's bricks to the free slots, and a brick pops one slot at most, so no pop here is refused.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_resolve_fresh = resolve_pass("Mesh SDF Resolve Fresh", `
+    let entry = mesh_sdf_resolve_entry(taken);
+
+    if (entry == MESH_SDF_NO_CONTENT) {
+        return;
+    }
+
+    let record = mesh_sdf_resolve_record(taken);
+    let differs = atomicLoad(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_DIFFERS]) != 0u;
+
+    // the slot found, or the representative's, is the brick's
+    if (!differs
+        && (atomicLoad(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_SLOT]) != MESH_SDF_NO_CONTENT
+            || atomicLoad(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_REP]) != taken)) {
+        return;
+    }
+
+    let slot = slot_stack_pop(&mesh_sdf_indirection[MESH_SDF_COUNTER_SLOTS], &mesh_sdf_slots, settings.slot_capacity);
+
+    if (differs) {
+        atomicAdd(&mesh_sdf_indirection[settings.log_offset + MESH_SDF_LOG_COLLIDED], 1u);
+    } else {
+        mesh_sdf_content_list(slot, mesh_sdf_resolve_key(record));
+    }
+
+    atomicStore(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_SLOT], slot);
+    atomicStore(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_FRESH], 1u);
+`, [chunk_slot_stack]);
+
+/**
+ * Bake step 5, resolve, last pass, hold: a thread a brick taken. A PENDING brick takes its slot, the
+ * one it found or popped, or its representative's when it has none, holds it one entry more, and its
+ * entry holds it. Logs the bricks that took a slot already holding their bytes, or their
+ * representative's.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_resolve_hold = resolve_pass("Mesh SDF Resolve Hold", `
+    let entry = mesh_sdf_resolve_entry(taken);
+
+    if (entry == MESH_SDF_NO_CONTENT) {
+        return;
+    }
+
+    let record = mesh_sdf_resolve_record(taken);
+
+    var slot = atomicLoad(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_SLOT]);
+
+    if (slot == MESH_SDF_NO_CONTENT) {
+        let rep = atomicLoad(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_REP]);
+
+        slot = atomicLoad(&mesh_sdf_indirection[mesh_sdf_resolve_record(rep) + MESH_SDF_TAKEN_SLOT]);
+
+        atomicStore(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_SLOT], slot);
+    }
+
+    mesh_sdf_content_hold(slot);
+
+    atomicStore(&mesh_sdf_indirection[entry], slot);
+
+    if (atomicLoad(&mesh_sdf_indirection[record + MESH_SDF_TAKEN_FRESH]) == 0u) {
+        atomicAdd(&mesh_sdf_indirection[settings.log_offset + MESH_SDF_LOG_SHARED], 1u);
+    }
+`, []);

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_store.d.ts

@@ -3,9 +3,9 @@
  */
 export const MESH_SDF_STORE_SETTINGS: WebGPUStruct;
 /**
- * Bake step 4, store: a thread a texel of each brick taken, eight workgroups a brick, dispatched by
- * take. A brick evaluate gave a slot has its staged bytes written there; an EMPTY one and a stale
- * one write nothing.
+ * Bake step 6, store: a thread a texel of each brick taken, eight workgroups a brick, dispatched by
+ * take. A brick resolve gave a fresh slot has its staged bytes written there; one that took a slot
+ * holding its bytes already, an EMPTY one and a stale one write nothing.
  *
  * The bytes go back as `byte / 255`, which `r8unorm` stores as the same byte, so the atlas holds what
  * evaluate rounded and no second rounding.

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_mesh_sdf_store.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_store.js"],"names":[],"mappings":"AAWA;;GAEG;AACH,sCAFU,YAAY,CAKK;AAa3B;;;;;;;;;GASG;AACH,oCAFU,aAAa,CA6CpB;6BA9E0B,sCAAsC;8BAJrC,kCAAkC"}
+{"version":3,"file":"shader_mesh_sdf_store.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_store.js"],"names":[],"mappings":"AAWA;;GAEG;AACH,sCAFU,YAAY,CAOK;AAa3B;;;;;;;;;GASG;AACH,oCAFU,aAAa,CA+CpB;6BAlF0B,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_store.js

@@ -15,6 +15,8 @@ import { MESH_SDF_BAKE_WORKGROUP_SIZE } from "./MESH_SDF_BAKE.js";
 export const MESH_SDF_STORE_SETTINGS = WebGPUStruct.from({
     /** entries of `mesh_sdf_ring`, a power of two; the staging starts here */
     ring_capacity: u32,
+    /** where the records of the frame's bricks taken start in the arena, MESH_SDF_TAKEN_WORDS each */
+    tally_offset: u32,
 }, "MeshSDFStoreSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -29,9 +31,9 @@ resources.createGroup()
     .addStorageTexture("mesh_sdf_atlas_store", "r8unorm", "3d", "write-only");
 
 /**
- * Bake step 4, store: a thread a texel of each brick taken, eight workgroups a brick, dispatched by
- * take. A brick evaluate gave a slot has its staged bytes written there; an EMPTY one and a stale
- * one write nothing.
+ * Bake step 6, store: a thread a texel of each brick taken, eight workgroups a brick, dispatched by
+ * take. A brick resolve gave a fresh slot has its staged bytes written there; one that took a slot
+ * holding its bytes already, an EMPTY one and a stale one write nothing.
  *
  * The bytes go back as `byte / 255`, which `r8unorm` stores as the same byte, so the atlas holds what
  * evaluate rounded and no second rounding.
@@ -57,12 +59,14 @@ fn main(
         return;
     }
 
-    let slot = mesh_sdf_indirection[header.indirection + item.z];
+    let record = settings.tally_offset + taken * MESH_SDF_TAKEN_WORDS;
 
-    if (!mesh_sdf_entry_holds_slot(slot)) {
+    if (mesh_sdf_indirection[record + MESH_SDF_TAKEN_FRESH] == 0u) {
         return;
     }
 
+    let slot = mesh_sdf_indirection[record + MESH_SDF_TAKEN_SLOT];
+
     // a word a texel, four words an entry of the staging
     let texel = (workgroup_id.x % MESH_SDF_GROUPS_PER_BRICK) * MESH_SDF_BAKE_WORKGROUP_SIZE + lane;
     let byte = mesh_sdf_ring[settings.ring_capacity + taken * MESH_SDF_STAGING_VEC4S + texel / 4u][texel % 4u];

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_take.d.ts

@@ -8,8 +8,8 @@ export const MESH_SDF_TAKE_SETTINGS: WebGPUStruct;
  * bound no pop of evaluate's can fail. A take held back by the slots logs itself starved, which is
  * how the host learns to grow the atlas.
  *
- * Writes the dispatch evaluate and store share, eight workgroups a brick, and where on the ring the
- * frame's bricks start; logs what it took and what is left queued.
+ * Writes the dispatch evaluate, key and store share, eight workgroups a brick, where on the ring the
+ * frame's bricks start, and how many resolve walks; logs what it took and what is left queued.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_take.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_mesh_sdf_take.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_take.js"],"names":[],"mappings":"AAQA;;GAEG;AACH,qCAFU,YAAY,CAOI;AAU1B;;;;;;;;;;GAUG;AACH,mCAFU,aAAa,CAoCpB;6BAlE0B,sCAAsC;8BAJrC,kCAAkC"}
+{"version":3,"file":"shader_mesh_sdf_take.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_take.js"],"names":[],"mappings":"AAQA;;GAEG;AACH,qCAFU,YAAY,CAOI;AAU1B;;;;;;;;;;GAUG;AACH,mCAFU,aAAa,CAqCpB;6BAnE0B,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_take.js

@@ -30,8 +30,8 @@ resources.createGroup()
  * bound no pop of evaluate's can fail. A take held back by the slots logs itself starved, which is
  * how the host learns to grow the atlas.
  *
- * Writes the dispatch evaluate and store share, eight workgroups a brick, and where on the ring the
- * frame's bricks start; logs what it took and what is left queued.
+ * Writes the dispatch evaluate, key and store share, eight workgroups a brick, where on the ring the
+ * frame's bricks start, and how many resolve walks; logs what it took and what is left queued.
  *
  * @type {ComputeShader}
  */
@@ -58,6 +58,7 @@ fn main() {
     mesh_sdf_take[MESH_SDF_TAKE_DISPATCH + 1u] = 1u;
     mesh_sdf_take[MESH_SDF_TAKE_DISPATCH + 2u] = 1u;
     mesh_sdf_take[MESH_SDF_TAKE_START] = head;
+    mesh_sdf_take[MESH_SDF_TAKE_COUNT] = taken;
 
     let log = settings.log_offset;
 

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_upload.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Words of an uploaded brick's record in `mesh_sdf_upload_bricks`: its content key, its slot, 1 when
+ * the slot is fresh, and its texels whose bytes differ from the slot's it found.
+ * @type {number}
+ */
+export const MESH_SDF_UPLOAD_BRICK_WORDS: number;
+/**
+ * Words of an uploaded brick's bytes in `mesh_sdf_upload_bytes`, four bytes a word, texel t in byte
+ * `t % 4` of word `t / 4`.
+ * @type {number}
+ */
+export const MESH_SDF_UPLOAD_BYTE_WORDS: number;
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_UPLOAD_SETTINGS: WebGPUStruct;
+/**
+ * Upload, first pass, key, when deduplicating: a thread a texel of the bricks uploaded, its term of
+ * its brick's content key added into the brick's record (`MESH_SDF_BRICK_KEY.js`), as the bake's key
+ * pass does.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_upload_key: ComputeShader;
+/**
+ * Upload, second pass, find, when deduplicating: a thread a brick uploaded, which finds a slot listed
+ * under its key (`chunk_mesh_sdf_contents`), or none.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_upload_find: ComputeShader;
+/**
+ * Upload, third pass, compare, when deduplicating: a thread a texel of the bricks uploaded. A brick
+ * that found a slot holds each of its bytes against the byte the slot holds there, and a texel that
+ * differs marks the brick's record.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_upload_compare: ComputeShader;
+/**
+ * Upload, fourth pass, fresh: a thread a brick uploaded. A brick that found a slot holding its bytes
+ * takes it; the rest pop a fresh slot, which store fills. Deduplicating, a brick that found no slot
+ * lists its own under its key, so later bricks of the same bytes share it, and one whose bytes differ
+ * from the slot's it found keeps its own listed nowhere: its key is another bytes' too. Two bricks of
+ * one key that found nothing are both listed, and a find takes the first. The host grew the atlas for
+ * every brick uploaded, so no pop here is refused.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_upload_fresh: ComputeShader;
+/**
+ * Upload, fifth pass, store: a thread a texel of the bricks uploaded, a fresh brick's byte into its
+ * slot.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_upload_store: ComputeShader;
+/**
+ * Upload, last pass, link: a thread an entry of the fields uploaded, a run each in `mesh_sdf_ranges`
+ * as `(first thread, first entry)`. An entry naming an uploaded brick, by its place in the upload,
+ * holds the brick's slot instead, one entry more (`chunk_mesh_sdf_contents`); an EMPTY one is left.
+ * Runs before free in its bake, so a field dropped since its upload gives back slots, never places.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_upload_link: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_sdf_upload.d.ts.map

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_sdf_upload.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_upload.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;;GAIG;AACH,yCAFU,MAAM,CAEyD;AAEzE;;GAEG;AACH,uCAFU,YAAY,CAeM;AA4F5B;;;;;;GAMG;AACH,yCAFU,aAAa,CAEmC;AAE1D;;;;;GAKG;AACH,0CAFU,aAAa,CAQc;AAErC;;;;;;GAMG;AACH,6CAFU,aAAa,CAwBiG;AAExH;;;;;;;;;GASG;AACH,2CAFU,aAAa,CAsBgC;AAEvD;;;;;GAKG;AACH,2CAFU,aAAa,CAwB+C;AAEtE;;;;;;;GAOG;AACH,0CAFU,aAAa,CAmByC;6BA7RnC,sCAAsC;8BAJrC,kCAAkC"}