@woosh/meep-engine 3.61.2 → 3.61.3

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

@@ -0,0 +1,294 @@
+import { chunk_slot_stack } from "../../../gpu_primitive/slot_stack/chunk_slot_stack.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 { atomic_u32, u32 } 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 { chunk_mesh_sdf_brick_key } from "../chunk_mesh_sdf_brick_key.js";
+import { MESH_SDF_BRICK_TEXEL_COUNT } from "../MESH_SDF.js";
+import { MESH_SDF_ATLAS_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { chunk_mesh_sdf_bake, chunk_mesh_sdf_range_find, MESH_SDF_ARENA_RESOURCE, MESH_SDF_RANGES_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";
+
+/** An uploaded brick's record in `mesh_sdf_upload_bricks`: its content key. */
+const MESH_SDF_UPLOAD_KEY = 0;
+/** An uploaded brick's record: the slot find found under its key, then the slot it takes. */
+const MESH_SDF_UPLOAD_SLOT = 1;
+/** An uploaded brick's record: 1 when its slot is fresh, which store fills. */
+const MESH_SDF_UPLOAD_FRESH = 2;
+/** An uploaded brick's record: its texels whose bytes differ from the slot's it found. */
+const MESH_SDF_UPLOAD_DIFFERS = 3;
+
+/**
+ * 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 = 4;
+
+/**
+ * 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 = MESH_SDF_BRICK_TEXEL_COUNT / 4;
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_UPLOAD_SETTINGS = WebGPUStruct.from({
+    /** bricks uploaded */
+    brick_count: u32,
+    /** 1 when the bricks share slots with what is resident and are listed for later bricks to share */
+    deduplicate: u32,
+    /** slots the stack holds */
+    slot_capacity: u32,
+    /** runs in `mesh_sdf_ranges`: an uploaded field's entries each */
+    range_count: u32,
+    /** entries over every run */
+    entry_count: u32,
+    /** workgroups along x, the rest folded into y */
+    groups_x: u32,
+}, "MeshSDFUploadSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_SDF_UPLOAD_SETTINGS);
+
+resources.createGroup()
+    .addStorageBuffer("mesh_sdf_upload_bytes", WebGPUArray.u32)
+    .addStorageBuffer("mesh_sdf_upload_bricks", WebGPUArray.from(atomic_u32), true)
+    .add(MESH_SDF_ARENA_RESOURCE)
+    .addStorageBuffer("mesh_sdf_slots", WebGPUArray.u32, true)
+    .add(MESH_SDF_CONTENTS_RESOURCE)
+    .add(MESH_SDF_CONTENT_TABLE_RESOURCE)
+    .add(MESH_SDF_RANGES_RESOURCE)
+    .addStorageTexture("mesh_sdf_atlas_store", "r8unorm", "3d", "write-only");
+
+const compare_resources = new ShaderResourceSetDescriptor();
+
+compare_resources.setImmediate("settings", MESH_SDF_UPLOAD_SETTINGS);
+
+compare_resources.createGroup()
+    .addStorageBuffer("mesh_sdf_upload_bytes", WebGPUArray.u32)
+    .addStorageBuffer("mesh_sdf_upload_bricks", WebGPUArray.from(atomic_u32), true)
+    .add(MESH_SDF_ATLAS_RESOURCE);
+
+/**
+ * What the upload's passes share: the thread a workgroup and lane are, folded over y, and an
+ * uploaded brick's record and bytes. A pass a thread a texel has a workgroup's 64 lanes, and so each
+ * of its subgroups, of one brick, whose words it loads once a subgroup (`chunk_subgroup_atomic_load`).
+ */
+const chunk_mesh_sdf_upload = CodeChunk.from(
+    //language=WGSL
+    `
+const MESH_SDF_UPLOAD_BRICK_WORDS = ${MESH_SDF_UPLOAD_BRICK_WORDS}u;
+const MESH_SDF_UPLOAD_BYTE_WORDS = ${MESH_SDF_UPLOAD_BYTE_WORDS}u;
+const MESH_SDF_UPLOAD_KEY = ${MESH_SDF_UPLOAD_KEY}u;
+const MESH_SDF_UPLOAD_SLOT = ${MESH_SDF_UPLOAD_SLOT}u;
+const MESH_SDF_UPLOAD_FRESH = ${MESH_SDF_UPLOAD_FRESH}u;
+const MESH_SDF_UPLOAD_DIFFERS = ${MESH_SDF_UPLOAD_DIFFERS}u;
+
+fn mesh_sdf_upload_thread(workgroup_id: vec3<u32>, lane: u32) -> u32 {
+    return (workgroup_id.y * settings.groups_x + workgroup_id.x) * MESH_SDF_BAKE_WORKGROUP_SIZE + lane;
+}
+
+fn mesh_sdf_upload_byte(brick: u32, texel: u32) -> u32 {
+    return (mesh_sdf_upload_bytes[brick * MESH_SDF_UPLOAD_BYTE_WORDS + texel / 4u] >> (8u * (texel % 4u))) & 0xffu;
+}
+
+fn mesh_sdf_upload_key(brick: u32) -> u32 {
+    return atomicLoad(&mesh_sdf_upload_bricks[brick * MESH_SDF_UPLOAD_BRICK_WORDS + MESH_SDF_UPLOAD_KEY]);
+}
+`, [
+        chunk_mesh_sdf_bake,
+    ]);
+
+/**
+ * @param {string} label
+ * @param {string} text the body of `main`, after `thread`
+ * @param {CodeChunk[]} dependencies
+ * @param {string} [before] code ahead of `main`
+ * @param {ShaderResourceSetDescriptor} [set]
+ * @returns {{body: CodeChunk, shader: ComputeShader}}
+ */
+function upload_pass(label, text, dependencies, before = "", set = resources) {
+    const body = CodeChunk.from(
+        //language=WGSL
+        `
+${before}
+@compute @workgroup_size(${MESH_SDF_BAKE_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let thread = mesh_sdf_upload_thread(workgroup_id, lane);
+${text}
+}
+`, [chunk_mesh_sdf_upload, ...dependencies]);
+
+    return { body, shader: ComputeShader.from({ label, resources: set, body }) };
+}
+
+const key_pass = upload_pass("Mesh SDF Upload Key", `
+    if (thread >= settings.brick_count * ${MESH_SDF_BRICK_TEXEL_COUNT}u) {
+        return;
+    }
+
+    let brick = thread / ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+    let texel = thread % ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+
+    subgroup_atomic_add_u32(&mesh_sdf_upload_bricks[brick * MESH_SDF_UPLOAD_BRICK_WORDS + MESH_SDF_UPLOAD_KEY], mesh_sdf_brick_key_term(texel, mesh_sdf_upload_byte(brick, texel)));
+`, [chunk_mesh_sdf_brick_key, chunk_subgroup_atomic_add]);
+
+/**
+ * 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 = key_pass.shader;
+
+/**
+ * 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 = upload_pass("Mesh SDF Upload Find", `
+    if (thread >= settings.brick_count) {
+        return;
+    }
+
+    atomicStore(&mesh_sdf_upload_bricks[thread * MESH_SDF_UPLOAD_BRICK_WORDS + MESH_SDF_UPLOAD_SLOT], mesh_sdf_content_find(mesh_sdf_upload_key(thread)));
+`, [chunk_mesh_sdf_contents]).shader;
+
+/**
+ * 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 = upload_pass("Mesh SDF Upload Compare", `
+    if (thread >= settings.brick_count * ${MESH_SDF_BRICK_TEXEL_COUNT}u) {
+        return;
+    }
+
+    let brick = thread / ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+    let texel = thread % ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+    let word = brick * MESH_SDF_UPLOAD_BRICK_WORDS;
+    let slot = subgroup_atomic_load_u32(&mesh_sdf_upload_bricks[word + MESH_SDF_UPLOAD_SLOT]);
+
+    if (slot == MESH_SDF_NO_CONTENT) {
+        return;
+    }
+
+    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
+    let held = u32(round(textureLoad(mesh_sdf_atlas, origin + vec3<u32>(texel % t, (texel / t) % t, texel / (t * t)), 0).x * 255.0));
+
+    subgroup_atomic_add_u32(&mesh_sdf_upload_bricks[word + MESH_SDF_UPLOAD_DIFFERS], select(0u, 1u, mesh_sdf_upload_byte(brick, texel) != held));
+`, [chunk_subgroup_atomic_add, chunk_subgroup_atomic_load, chunk_tile_atlas_slot_origin], "", compare_resources).shader;
+
+/**
+ * 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 = upload_pass("Mesh SDF Upload Fresh", `
+    if (thread >= settings.brick_count) {
+        return;
+    }
+
+    let word = thread * MESH_SDF_UPLOAD_BRICK_WORDS;
+    let found = settings.deduplicate != 0u && atomicLoad(&mesh_sdf_upload_bricks[word + MESH_SDF_UPLOAD_SLOT]) != MESH_SDF_NO_CONTENT;
+
+    if (found && atomicLoad(&mesh_sdf_upload_bricks[word + MESH_SDF_UPLOAD_DIFFERS]) == 0u) {
+        return;
+    }
+
+    let slot = slot_stack_pop(&mesh_sdf_indirection[MESH_SDF_COUNTER_SLOTS], &mesh_sdf_slots, settings.slot_capacity);
+
+    if (settings.deduplicate != 0u && !found) {
+        mesh_sdf_content_list(slot, mesh_sdf_upload_key(thread));
+    }
+
+    atomicStore(&mesh_sdf_upload_bricks[word + MESH_SDF_UPLOAD_SLOT], slot);
+    atomicStore(&mesh_sdf_upload_bricks[word + MESH_SDF_UPLOAD_FRESH], 1u);
+`, [chunk_mesh_sdf_contents, chunk_slot_stack]).shader;
+
+/**
+ * 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 = upload_pass("Mesh SDF Upload Store", `
+    if (thread >= settings.brick_count * ${MESH_SDF_BRICK_TEXEL_COUNT}u) {
+        return;
+    }
+
+    let brick = thread / ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+    let texel = thread % ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+    let word = brick * MESH_SDF_UPLOAD_BRICK_WORDS;
+
+    if (subgroup_atomic_load_u32(&mesh_sdf_upload_bricks[word + MESH_SDF_UPLOAD_FRESH]) == 0u) {
+        return;
+    }
+
+    let t = MESH_SDF_BRICK_TEXELS;
+    let slots = textureDimensions(mesh_sdf_atlas_store) / t;
+    let origin = tile_atlas_slot_origin(subgroup_atomic_load_u32(&mesh_sdf_upload_bricks[word + MESH_SDF_UPLOAD_SLOT]), slots.xy, vec3<u32>(t));
+
+    textureStore(
+        mesh_sdf_atlas_store,
+        origin + vec3<u32>(texel % t, (texel / t) % t, texel / (t * t)),
+        vec4<f32>(f32(mesh_sdf_upload_byte(brick, texel)) / 255.0, 0.0, 0.0, 0.0)
+    );
+`, [chunk_subgroup_atomic_load, chunk_tile_atlas_slot_origin]).shader;
+
+/**
+ * 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 = upload_pass("Mesh SDF Upload Link", `
+    if (thread >= settings.entry_count) {
+        return;
+    }
+
+    let range = mesh_sdf_range_find(settings.range_count, thread);
+    let at = mesh_sdf_ranges[range].y + thread - mesh_sdf_ranges[range].x;
+    let entry = atomicLoad(&mesh_sdf_indirection[at]);
+
+    if (!mesh_sdf_entry_holds_slot(entry)) {
+        return;
+    }
+
+    let slot = atomicLoad(&mesh_sdf_upload_bricks[entry * MESH_SDF_UPLOAD_BRICK_WORDS + MESH_SDF_UPLOAD_SLOT]);
+
+    mesh_sdf_content_hold(slot);
+    atomicStore(&mesh_sdf_indirection[at], slot);
+`, [chunk_mesh_sdf_contents, chunk_mesh_sdf_range_find]).shader;

package/src/shade/renderer/geometry/sdf/bundle/MODEL_CACHE_BUNDLE.d.ts

@@ -0,0 +1,16 @@
+/**
+ * "MCBN", read as a little-endian u32.
+ * @type {number}
+ */
+export const MODEL_CACHE_BUNDLE_MAGIC: number;
+/**
+ * The format this code writes.
+ * @type {number}
+ */
+export const MODEL_CACHE_BUNDLE_FORMAT_VERSION: number;
+/**
+ * The oldest reader that takes what this code writes.
+ * @type {number}
+ */
+export const MODEL_CACHE_BUNDLE_MIN_READER_VERSION: number;
+//# sourceMappingURL=MODEL_CACHE_BUNDLE.d.ts.map

package/src/shade/renderer/geometry/sdf/bundle/MODEL_CACHE_BUNDLE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MODEL_CACHE_BUNDLE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bundle/MODEL_CACHE_BUNDLE.js"],"names":[],"mappings":"AAmBA;;;GAGG;AACH,uCAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;GAGG;AACH,oDAFU,MAAM,CAEuC"}

package/src/shade/renderer/geometry/sdf/bundle/MODEL_CACHE_BUNDLE.js

@@ -0,0 +1,36 @@
+/*
+ A ModelCacheBundle as bytes, little-endian, every count before what it counts:
+
+   header    u32 magic, u16 format version, u16 version a reader needs at least
+             f32 voxel_size, u32 max_bricks
+             u32 bricks, u32 fields, u32 caches
+   bricks    MESH_SDF_BRICK_TEXEL_COUNT bytes each
+   field     f32×3 origin, f32 voxel, u32×3 bricks, u32 level_count, u32 two_sided
+             u32 entries, u32 each: a brick's index, or MESH_SDF_EMPTY or MESH_SDF_EMPTY_INSIDE
+             u32 stored, u32 each: the entry of stored brick n
+             u32 blocks, u32 table words (0 or stored), u32 each
+   cache     u32 field, u32 texels, u32×3 codes by plane
+             u32 presence words, u32 each
+             for each plane, in SURFACE_MATERIAL.js's order: u32 words, u32 each
+
+ A reader takes a file whose version a reader needs is at most its own, and refuses one that names a
+ brick, an entry or a field it does not hold.
+*/
+
+/**
+ * "MCBN", read as a little-endian u32.
+ * @type {number}
+ */
+export const MODEL_CACHE_BUNDLE_MAGIC = 0x4E42434D;
+
+/**
+ * The format this code writes.
+ * @type {number}
+ */
+export const MODEL_CACHE_BUNDLE_FORMAT_VERSION = 1;
+
+/**
+ * The oldest reader that takes what this code writes.
+ * @type {number}
+ */
+export const MODEL_CACHE_BUNDLE_MIN_READER_VERSION = 1;

package/src/shade/renderer/geometry/sdf/bundle/ModelCacheBundle.d.ts

@@ -0,0 +1,126 @@
+/**
+ * A geometry's Model SDF in a {@link ModelCacheBundle}: its layout as its header holds it, its entries
+ * naming the bundle's bricks, the order its stored bricks were numbered in, and the block table its
+ * Model Surface Caches are laid out by.
+ */
+export class ModelCacheBundleField {
+    /**
+     * The grid's smallest corner, the geometry's local units.
+     * @type {Float32Array}
+     */
+    origin: Float32Array;
+    /**
+     * Level 0's voxel, local units.
+     * @type {number}
+     */
+    voxel: number;
+    /**
+     * Level 0's bricks along x, y and z.
+     * @type {Uint32Array}
+     */
+    bricks: Uint32Array;
+    /**
+     * @type {number}
+     */
+    level_count: number;
+    /**
+     * 1 when baked for a holder that draws both sides, which nothing is inside of.
+     * @type {number}
+     */
+    two_sided: number;
+    /**
+     * Every brick's entry, level after level in `MeshSDFLayout`'s order: a brick of the bundle's, by
+     * index, or `MESH_SDF_EMPTY` or `MESH_SDF_EMPTY_INSIDE`.
+     * @type {Uint32Array}
+     */
+    entries: Uint32Array;
+    /**
+     * The field's stored bricks by number: brick n's entry index. Every entry naming a brick is numbered
+     * once.
+     * @type {Uint32Array}
+     */
+    numbered: Uint32Array;
+    /**
+     * Blocks its stored bricks keep (`MESH_SURFACE_BLOCK.js`), 0 without a table.
+     * @type {number}
+     */
+    blocks: number;
+    /**
+     * Its block table, a word a stored brick by number, or empty when no cache of it kept a plane.
+     * @type {Uint32Array}
+     */
+    table: Uint32Array;
+}
+/**
+ * A (geometry, material) pair's Model Surface Cache in a {@link ModelCacheBundle}, laid out by one of
+ * the bundle's fields.
+ */
+export class ModelCacheBundleCache {
+    /**
+     * The field of the bundle it is laid out by, by index.
+     * @type {number}
+     */
+    field: number;
+    /**
+     * Bit `1 << plane` for each plane it keeps blocks of (`SURFACE_MATERIAL.js`).
+     * @type {number}
+     */
+    texels: number;
+    /**
+     * Each plane's code, by plane: what a plane it keeps no blocks of holds everywhere.
+     * @type {Uint32Array}
+     */
+    codes: Uint32Array;
+    /**
+     * Its presence, `MESH_SURFACE_PRESENCE_BLOCK_WORDS` a block for each of its field's blocks, or empty
+     * when it keeps no plane.
+     * @type {Uint32Array}
+     */
+    presence: Uint32Array;
+    /**
+     * Each plane's blocks, by plane, `MESH_SURFACE_PLANE_BLOCK_WORDS` a block for each of its field's
+     * blocks, or empty for a plane it does not keep.
+     * @type {Uint32Array[]}
+     */
+    planes: Uint32Array[];
+}
+/**
+ * Model SDFs and Model Surface Caches in one package: the bricks once each, the fields naming them by
+ * index, so a brick two fields hold is kept once, and the caches naming their fields. Baked at
+ * `voxel_size` and `max_bricks`, the configuration of the `GPUGeometrySDFManager` that made it, which
+ * takes it only at the same.
+ *
+ * `GPUGeometrySDFManager.export_bundle` makes one of what is resident; `upload_bundle` takes one back,
+ * with or without sharing its bricks with those resident; `model_cache_bundle_write` and
+ * `model_cache_bundle_read` keep it as bytes.
+ */
+export class ModelCacheBundle {
+    /**
+     * The voxel the fields were baked at, `GPUGeometrySDFManager.configure`'s.
+     * @type {number}
+     */
+    voxel_size: number;
+    /**
+     * The cap on bricks along a geometry's longest axis they were baked under.
+     * @type {number}
+     */
+    max_bricks: number;
+    /**
+     * The bricks the fields hold, `MESH_SDF_BRICK_TEXEL_COUNT` bytes each, texel x + 8y + 64z.
+     * @type {Uint8Array}
+     */
+    bricks: Uint8Array;
+    /**
+     * @type {ModelCacheBundleField[]}
+     */
+    fields: ModelCacheBundleField[];
+    /**
+     * @type {ModelCacheBundleCache[]}
+     */
+    caches: ModelCacheBundleCache[];
+    /**
+     * @returns {number}
+     */
+    get brick_count(): number;
+}
+//# sourceMappingURL=ModelCacheBundle.d.ts.map

package/src/shade/renderer/geometry/sdf/bundle/ModelCacheBundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelCacheBundle.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bundle/ModelCacheBundle.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH;IACI;;;OAGG;IACH,QAFU,YAAY,CAEO;IAE7B;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,WAAW,CAEO;IAE5B;;OAEG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,SAFU,WAAW,CAEQ;IAE7B;;;;OAIG;IACH,UAFU,WAAW,CAES;IAE9B;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,OAFU,WAAW,CAEM;CAC9B;AAED;;;GAGG;AACH;IACI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,OAFU,WAAW,CAEM;IAE3B;;;;OAIG;IACH,UAFU,WAAW,CAES;IAE9B;;;;OAIG;IACH,QAFU,WAAW,EAAE,CAE+C;CACzE;AAED;;;;;;;;;GASG;AACH;IACI;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,QAFU,UAAU,CAEO;IAE3B;;OAEG;IACH,QAFU,qBAAqB,EAAE,CAErB;IAEZ;;OAEG;IACH,QAFU,qBAAqB,EAAE,CAErB;IAEZ;;OAEG;IACH,0BAEC;CACJ"}

package/src/shade/renderer/geometry/sdf/bundle/ModelCacheBundle.js

@@ -0,0 +1,148 @@
+import { MESH_SDF_BRICK_TEXEL_COUNT } from "../MESH_SDF.js";
+
+/**
+ * A geometry's Model SDF in a {@link ModelCacheBundle}: its layout as its header holds it, its entries
+ * naming the bundle's bricks, the order its stored bricks were numbered in, and the block table its
+ * Model Surface Caches are laid out by.
+ */
+export class ModelCacheBundleField {
+    /**
+     * The grid's smallest corner, the geometry's local units.
+     * @type {Float32Array}
+     */
+    origin = new Float32Array(3);
+
+    /**
+     * Level 0's voxel, local units.
+     * @type {number}
+     */
+    voxel = 0;
+
+    /**
+     * Level 0's bricks along x, y and z.
+     * @type {Uint32Array}
+     */
+    bricks = new Uint32Array(3);
+
+    /**
+     * @type {number}
+     */
+    level_count = 0;
+
+    /**
+     * 1 when baked for a holder that draws both sides, which nothing is inside of.
+     * @type {number}
+     */
+    two_sided = 0;
+
+    /**
+     * Every brick's entry, level after level in `MeshSDFLayout`'s order: a brick of the bundle's, by
+     * index, or `MESH_SDF_EMPTY` or `MESH_SDF_EMPTY_INSIDE`.
+     * @type {Uint32Array}
+     */
+    entries = new Uint32Array(0);
+
+    /**
+     * The field's stored bricks by number: brick n's entry index. Every entry naming a brick is numbered
+     * once.
+     * @type {Uint32Array}
+     */
+    numbered = new Uint32Array(0);
+
+    /**
+     * Blocks its stored bricks keep (`MESH_SURFACE_BLOCK.js`), 0 without a table.
+     * @type {number}
+     */
+    blocks = 0;
+
+    /**
+     * Its block table, a word a stored brick by number, or empty when no cache of it kept a plane.
+     * @type {Uint32Array}
+     */
+    table = new Uint32Array(0);
+}
+
+/**
+ * A (geometry, material) pair's Model Surface Cache in a {@link ModelCacheBundle}, laid out by one of
+ * the bundle's fields.
+ */
+export class ModelCacheBundleCache {
+    /**
+     * The field of the bundle it is laid out by, by index.
+     * @type {number}
+     */
+    field = 0;
+
+    /**
+     * Bit `1 << plane` for each plane it keeps blocks of (`SURFACE_MATERIAL.js`).
+     * @type {number}
+     */
+    texels = 0;
+
+    /**
+     * Each plane's code, by plane: what a plane it keeps no blocks of holds everywhere.
+     * @type {Uint32Array}
+     */
+    codes = new Uint32Array(3);
+
+    /**
+     * Its presence, `MESH_SURFACE_PRESENCE_BLOCK_WORDS` a block for each of its field's blocks, or empty
+     * when it keeps no plane.
+     * @type {Uint32Array}
+     */
+    presence = new Uint32Array(0);
+
+    /**
+     * Each plane's blocks, by plane, `MESH_SURFACE_PLANE_BLOCK_WORDS` a block for each of its field's
+     * blocks, or empty for a plane it does not keep.
+     * @type {Uint32Array[]}
+     */
+    planes = [new Uint32Array(0), new Uint32Array(0), new Uint32Array(0)];
+}
+
+/**
+ * Model SDFs and Model Surface Caches in one package: the bricks once each, the fields naming them by
+ * index, so a brick two fields hold is kept once, and the caches naming their fields. Baked at
+ * `voxel_size` and `max_bricks`, the configuration of the `GPUGeometrySDFManager` that made it, which
+ * takes it only at the same.
+ *
+ * `GPUGeometrySDFManager.export_bundle` makes one of what is resident; `upload_bundle` takes one back,
+ * with or without sharing its bricks with those resident; `model_cache_bundle_write` and
+ * `model_cache_bundle_read` keep it as bytes.
+ */
+export class ModelCacheBundle {
+    /**
+     * The voxel the fields were baked at, `GPUGeometrySDFManager.configure`'s.
+     * @type {number}
+     */
+    voxel_size = 0;
+
+    /**
+     * The cap on bricks along a geometry's longest axis they were baked under.
+     * @type {number}
+     */
+    max_bricks = 0;
+
+    /**
+     * The bricks the fields hold, `MESH_SDF_BRICK_TEXEL_COUNT` bytes each, texel x + 8y + 64z.
+     * @type {Uint8Array}
+     */
+    bricks = new Uint8Array(0);
+
+    /**
+     * @type {ModelCacheBundleField[]}
+     */
+    fields = [];
+
+    /**
+     * @type {ModelCacheBundleCache[]}
+     */
+    caches = [];
+
+    /**
+     * @returns {number}
+     */
+    get brick_count() {
+        return this.bricks.length / MESH_SDF_BRICK_TEXEL_COUNT;
+    }
+}

package/src/shade/renderer/geometry/sdf/bundle/model_cache_bundle_read.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A bundle from bytes (`MODEL_CACHE_BUNDLE.js`). Throws on a file of another kind, one that needs a
+ * newer reader, or one whose references or lengths do not hold together.
+ *
+ * @param {Uint8Array} bytes
+ * @returns {ModelCacheBundle}
+ */
+export function model_cache_bundle_read(bytes: Uint8Array): ModelCacheBundle;
+import { ModelCacheBundle } from "./ModelCacheBundle.js";
+//# sourceMappingURL=model_cache_bundle_read.d.ts.map

package/src/shade/renderer/geometry/sdf/bundle/model_cache_bundle_read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model_cache_bundle_read.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bundle/model_cache_bundle_read.js"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,+CAHW,UAAU,GACR,gBAAgB,CA6G5B;iCAxI8E,uBAAuB"}