@woosh/meep-engine 3.38.0 → 3.40.0

package/src/shade/renderer/shadow/vsm/VSM_COVER_LEVEL_STEP.d.ts

@@ -0,0 +1,14 @@
+/**
+ * How many levels above an uncovered page the one page that covers it is taken from.
+ *
+ * A page is uncovered when it is missing and nothing coarser is resident to stand in for it, so the
+ * pixels asking for it are unshadowed until it arrives. Rendering its ancestor this many levels up
+ * first gives them a shadow straight away — one page covers `4^step` pages of the level asked for —
+ * and the page itself follows under the budget. At 3, a cover is eight times coarser than what was
+ * asked for, and one cover answers a 64-page patch: after a light change, when everything is
+ * uncovered, a 1080p view is covered by a handful of pages in its first frame.
+ *
+ * @type {number}
+ */
+export const VSM_COVER_LEVEL_STEP: number;
+//# sourceMappingURL=VSM_COVER_LEVEL_STEP.d.ts.map

package/src/shade/renderer/shadow/vsm/VSM_COVER_LEVEL_STEP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VSM_COVER_LEVEL_STEP.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSM_COVER_LEVEL_STEP.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,mCAFU,MAAM,CAEsB"}

package/src/shade/renderer/shadow/vsm/VSM_COVER_LEVEL_STEP.js

@@ -0,0 +1,13 @@
+/**
+ * How many levels above an uncovered page the one page that covers it is taken from.
+ *
+ * A page is uncovered when it is missing and nothing coarser is resident to stand in for it, so the
+ * pixels asking for it are unshadowed until it arrives. Rendering its ancestor this many levels up
+ * first gives them a shadow straight away — one page covers `4^step` pages of the level asked for —
+ * and the page itself follows under the budget. At 3, a cover is eight times coarser than what was
+ * asked for, and one cover answers a 64-page patch: after a light change, when everything is
+ * uncovered, a 1080p view is covered by a handful of pages in its first frame.
+ *
+ * @type {number}
+ */
+export const VSM_COVER_LEVEL_STEP = 3;

package/src/shade/renderer/shadow/vsm/VSM_FEEDBACK_LAYOUT.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Words of a feedback buffer for a capacity and a pool.
+ *
+ * @param {number} request_capacity
+ * @param {number} slot_count
+ * @returns {number}
+ */
+export function vsm_feedback_word_count(request_capacity: number, slot_count: number): number;
+/**
+ * First word of the stale slot list.
+ *
+ * @param {number} request_capacity
+ * @returns {number}
+ */
+export function vsm_feedback_stale_offset(request_capacity: number): number;
+/**
+ * The words a virtual shadow map's feedback buffer holds, as the GPU writes them and the CPU reads
+ * them back. One buffer per map per frame, zeroed before the passes that fill it.
+ *
+ * ```
+ * [ header: HEADER_WORDS ]
+ * [ requests: request_capacity × REQUEST_WORDS ]   level, world x, world y, importance, depth
+ * [ stale slots: slot_count words ]
+ * ```
+ *
+ * Counts in the header are the atomics the passes appended with, so a count past its capacity says
+ * how many were dropped.
+ */
+export const VSM_FEEDBACK_LAYOUT: Readonly<{
+    /**
+     * Pages the demand pass asked for this frame, including any past the request capacity.
+     */
+    REQUEST_COUNT: 0;
+    /**
+     * Slots the stale pass found under a mover. Never past the slot count.
+     */
+    STALE_COUNT: 1;
+    /**
+     * Movers this frame, as the scene's mover pass counted them, including any past its capacity.
+     */
+    MOVER_COUNT: 2;
+    HEADER_WORDS: 4;
+    /**
+     * Per request: the level, the world page's x and y (i32 bits), the importance of the pixels that
+     * asked for it — the sum of their weights under the screen importance mask,
+     * {@link SCREEN_IMPORTANCE_STEPS} for a pixel of full importance — and the light depth of the first
+     * of them (f32 bits), a point on a receiver the page shadows.
+     */
+    REQUEST_WORDS: 5;
+    REQUEST_LEVEL: 0;
+    REQUEST_X: 1;
+    REQUEST_Y: 2;
+    REQUEST_IMPORTANCE: 3;
+    REQUEST_DEPTH: 4;
+}>;
+/**
+ * Requests a feedback buffer holds by default: distinct pages one frame can ask for before the rest
+ * are dropped and asked for again the next frame. A 1080p view asks for a few hundred.
+ *
+ * @type {number}
+ */
+export const VSM_DEFAULT_REQUEST_CAPACITY: number;
+//# sourceMappingURL=VSM_FEEDBACK_LAYOUT.d.ts.map

package/src/shade/renderer/shadow/vsm/VSM_FEEDBACK_LAYOUT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VSM_FEEDBACK_LAYOUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSM_FEEDBACK_LAYOUT.js"],"names":[],"mappings":"AAkDA;;;;;;GAMG;AACH,0DAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,4DAHW,MAAM,GACJ,MAAM,CAIlB;AArED;;;;;;;;;;;;GAYG;AACH;IACI;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;;IAIH;;;;;OAKG;;;;;;;GAOJ;AAEH;;;;;GAKG;AACH,2CAFU,MAAM,CAEiC"}

package/src/shade/renderer/shadow/vsm/VSM_FEEDBACK_LAYOUT.js

@@ -0,0 +1,70 @@
+/**
+ * The words a virtual shadow map's feedback buffer holds, as the GPU writes them and the CPU reads
+ * them back. One buffer per map per frame, zeroed before the passes that fill it.
+ *
+ * ```
+ * [ header: HEADER_WORDS ]
+ * [ requests: request_capacity × REQUEST_WORDS ]   level, world x, world y, importance, depth
+ * [ stale slots: slot_count words ]
+ * ```
+ *
+ * Counts in the header are the atomics the passes appended with, so a count past its capacity says
+ * how many were dropped.
+ */
+export const VSM_FEEDBACK_LAYOUT = Object.freeze({
+    /**
+     * Pages the demand pass asked for this frame, including any past the request capacity.
+     */
+    REQUEST_COUNT: 0,
+    /**
+     * Slots the stale pass found under a mover. Never past the slot count.
+     */
+    STALE_COUNT: 1,
+    /**
+     * Movers this frame, as the scene's mover pass counted them, including any past its capacity.
+     */
+    MOVER_COUNT: 2,
+    HEADER_WORDS: 4,
+
+    /**
+     * Per request: the level, the world page's x and y (i32 bits), the importance of the pixels that
+     * asked for it — the sum of their weights under the screen importance mask,
+     * {@link SCREEN_IMPORTANCE_STEPS} for a pixel of full importance — and the light depth of the first
+     * of them (f32 bits), a point on a receiver the page shadows.
+     */
+    REQUEST_WORDS: 5,
+    REQUEST_LEVEL: 0,
+    REQUEST_X: 1,
+    REQUEST_Y: 2,
+    REQUEST_IMPORTANCE: 3,
+    REQUEST_DEPTH: 4,
+});
+
+/**
+ * Requests a feedback buffer holds by default: distinct pages one frame can ask for before the rest
+ * are dropped and asked for again the next frame. A 1080p view asks for a few hundred.
+ *
+ * @type {number}
+ */
+export const VSM_DEFAULT_REQUEST_CAPACITY = 2048;
+
+/**
+ * Words of a feedback buffer for a capacity and a pool.
+ *
+ * @param {number} request_capacity
+ * @param {number} slot_count
+ * @returns {number}
+ */
+export function vsm_feedback_word_count(request_capacity, slot_count) {
+    return VSM_FEEDBACK_LAYOUT.HEADER_WORDS + request_capacity * VSM_FEEDBACK_LAYOUT.REQUEST_WORDS + slot_count;
+}
+
+/**
+ * First word of the stale slot list.
+ *
+ * @param {number} request_capacity
+ * @returns {number}
+ */
+export function vsm_feedback_stale_offset(request_capacity) {
+    return VSM_FEEDBACK_LAYOUT.HEADER_WORDS + request_capacity * VSM_FEEDBACK_LAYOUT.REQUEST_WORDS;
+}

package/src/shade/renderer/shadow/vsm/VSM_LEVEL_LIMIT.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The most clipmap levels a virtual shadow map may have — the length of the per-level window origin
+ * array in its record, and so the bound on every per-level walk a shader makes over it.
+ *
+ * Sixteen levels at the default first texel of 1 cm reach a coarsest texel of 328 m; nothing a
+ * directional light shadows needs more.
+ *
+ * @type {number}
+ */
+export const VSM_LEVEL_LIMIT: number;
+//# sourceMappingURL=VSM_LEVEL_LIMIT.d.ts.map

package/src/shade/renderer/shadow/vsm/VSM_LEVEL_LIMIT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VSM_LEVEL_LIMIT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSM_LEVEL_LIMIT.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,8BAFU,MAAM,CAEkB"}

package/src/shade/renderer/shadow/vsm/VSM_LEVEL_LIMIT.js

@@ -0,0 +1,10 @@
+/**
+ * The most clipmap levels a virtual shadow map may have — the length of the per-level window origin
+ * array in its record, and so the bound on every per-level walk a shader makes over it.
+ *
+ * Sixteen levels at the default first texel of 1 cm reach a coarsest texel of 328 m; nothing a
+ * directional light shadows needs more.
+ *
+ * @type {number}
+ */
+export const VSM_LEVEL_LIMIT = 16;

package/src/shade/renderer/shadow/vsm/VSM_MOVER_LAYOUT.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Movers a frame lists at most: casters whose bounds or transform changed since the last frame, each
+ * with the world box it covers now and covered then. Past this many, every occupied page of every
+ * virtual shadow map is taken to be stale for the frame, and the overflow is counted.
+ *
+ * @type {number}
+ */
+export const VSM_MOVER_CAPACITY: number;
+/**
+ * The scene's mover list, written by the mover passes and read by every map's stale pass.
+ *
+ * `count` is the atomic the movers appended with, so a count past {@link VSM_MOVER_CAPACITY} says the
+ * list overflowed. `boxes` holds two vec4s per mover: the world box's min and max corners in `xyz`.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VSM_MOVERS_STRUCT: WebGPUStruct;
+/**
+ * The same buffer as the stale pass reads it: the count as a plain word.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VSM_MOVERS_READ_STRUCT: WebGPUStruct;
+/**
+ * Bytes of the mover list at {@link VSM_MOVER_CAPACITY}.
+ *
+ * @type {number}
+ */
+export const VSM_MOVERS_BYTE_SIZE: number;
+/**
+ * What a world box holds when it holds nothing: min past max on every axis, so that `min` and `max`
+ * against it return the other box unchanged. The largest finite f32, since WGSL will not fold an
+ * infinity.
+ *
+ * @type {number}
+ */
+export const VSM_EMPTY_BOUND: number;
+/**
+ * Words the mover pass remembers a `meshes` row by, from one frame to the next: the world box it saw
+ * the row with — six f32s, by their bits, empty for a row that held nothing — then the row's
+ * geometry and material, {@link GPU_DATABASE_NULL} for a row that held nothing.
+ *
+ * @type {number}
+ */
+export const VSM_LAST_SEEN_WORDS: number;
+/**
+ * Where a row's geometry and material sit among its {@link VSM_LAST_SEEN_WORDS}.
+ *
+ * @type {number}
+ */
+export const VSM_LAST_SEEN_GEOMETRY: number;
+export const VSM_LAST_SEEN_MATERIAL: 7;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=VSM_MOVER_LAYOUT.d.ts.map

package/src/shade/renderer/shadow/vsm/VSM_MOVER_LAYOUT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VSM_MOVER_LAYOUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSM_MOVER_LAYOUT.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,iCAFU,MAAM,CAEuB;AAEvC;;;;;;;GAOG;AACH,gCAFU,YAAY,CAQN;AAEhB;;;;GAIG;AACH,qCAFU,YAAY,CAQF;AAEpB;;;;GAIG;AACH,mCAFU,MAAM,CAEqD;AAErE;;;;;;GAMG;AACH,8BAFU,MAAM,CAE2B;AAE3C;;;;;;GAMG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AACxC,uCAAwC;6BAvEX,mCAAmC"}

package/src/shade/renderer/shadow/vsm/VSM_MOVER_LAYOUT.js

@@ -0,0 +1,75 @@
+import { FLOAT32_MAX } from "../../../../core/binary/FLOAT32_MAX.js";
+import { atomic_u32, u32, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * Movers a frame lists at most: casters whose bounds or transform changed since the last frame, each
+ * with the world box it covers now and covered then. Past this many, every occupied page of every
+ * virtual shadow map is taken to be stale for the frame, and the overflow is counted.
+ *
+ * @type {number}
+ */
+export const VSM_MOVER_CAPACITY = 4096;
+
+/**
+ * The scene's mover list, written by the mover passes and read by every map's stale pass.
+ *
+ * `count` is the atomic the movers appended with, so a count past {@link VSM_MOVER_CAPACITY} says the
+ * list overflowed. `boxes` holds two vec4s per mover: the world box's min and max corners in `xyz`.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VSM_MOVERS_STRUCT = WebGPUStruct.from({
+    count: atomic_u32,
+    pad_0: u32,
+    pad_1: u32,
+    pad_2: u32,
+    boxes: WebGPUArray.from(vec4f),
+}, "VSMMovers");
+
+/**
+ * The same buffer as the stale pass reads it: the count as a plain word.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VSM_MOVERS_READ_STRUCT = WebGPUStruct.from({
+    count: u32,
+    pad_0: u32,
+    pad_1: u32,
+    pad_2: u32,
+    boxes: WebGPUArray.from(vec4f),
+}, "VSMMoversRead");
+
+/**
+ * Bytes of the mover list at {@link VSM_MOVER_CAPACITY}.
+ *
+ * @type {number}
+ */
+export const VSM_MOVERS_BYTE_SIZE = 16 + VSM_MOVER_CAPACITY * 2 * 16;
+
+/**
+ * What a world box holds when it holds nothing: min past max on every axis, so that `min` and `max`
+ * against it return the other box unchanged. The largest finite f32, since WGSL will not fold an
+ * infinity.
+ *
+ * @type {number}
+ */
+export const VSM_EMPTY_BOUND = FLOAT32_MAX;
+
+/**
+ * Words the mover pass remembers a `meshes` row by, from one frame to the next: the world box it saw
+ * the row with — six f32s, by their bits, empty for a row that held nothing — then the row's
+ * geometry and material, {@link GPU_DATABASE_NULL} for a row that held nothing.
+ *
+ * @type {number}
+ */
+export const VSM_LAST_SEEN_WORDS = 8;
+
+/**
+ * Where a row's geometry and material sit among its {@link VSM_LAST_SEEN_WORDS}.
+ *
+ * @type {number}
+ */
+export const VSM_LAST_SEEN_GEOMETRY = 6;
+export const VSM_LAST_SEEN_MATERIAL = 7;

package/src/shade/renderer/shadow/vsm/VSM_RECORD_STRUCT.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A virtual shadow map: a row of the light database's `shadow_virtual` table, which a directional
+ * light's `shadow_directional` record names through `virtual_map`. Everything a shader needs to find
+ * the page a world point is shadowed by, and everything the feedback passes need to say which pages
+ * were wanted and which went stale.
+ *
+ * **Light space** is the view space of an orthographic camera at the world origin turned as the
+ * light: `x` and `y` across the light, the light's depth along `-z` ({@link view}). The pages of
+ * level `k` are a grid on (x, y) anchored to the world, `page_size · first_texel_size · 2^k` world
+ * units on a side; world page `(wx, wy)` of that level covers `[wx, wx + 1) × [wy, wy + 1)` pages.
+ *
+ * **A level keeps a window** of `pages_per_level²` of its pages around the main camera, whose
+ * corner is the level's row of `shadow_virtual_level`; a page of the window sits in cell
+ * `(wx mod N, wy mod N)` of the level's run of `shadow_virtual_page` rows, so a window that
+ * scrolls keeps every page still inside it where it was.
+ *
+ * Written whole by the CPU every frame the map is drawn: the camera fields follow the main view.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VSM_RECORD_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=VSM_RECORD_STRUCT.d.ts.map

package/src/shade/renderer/shadow/vsm/VSM_RECORD_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VSM_RECORD_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSM_RECORD_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gCAFU,YAAY,CA+DC;6BAnFM,mCAAmC"}

package/src/shade/renderer/shadow/vsm/VSM_RECORD_STRUCT.js

@@ -0,0 +1,85 @@
+import { f32, mat4x4f, u32, vec2u, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * A virtual shadow map: a row of the light database's `shadow_virtual` table, which a directional
+ * light's `shadow_directional` record names through `virtual_map`. Everything a shader needs to find
+ * the page a world point is shadowed by, and everything the feedback passes need to say which pages
+ * were wanted and which went stale.
+ *
+ * **Light space** is the view space of an orthographic camera at the world origin turned as the
+ * light: `x` and `y` across the light, the light's depth along `-z` ({@link view}). The pages of
+ * level `k` are a grid on (x, y) anchored to the world, `page_size · first_texel_size · 2^k` world
+ * units on a side; world page `(wx, wy)` of that level covers `[wx, wx + 1) × [wy, wy + 1)` pages.
+ *
+ * **A level keeps a window** of `pages_per_level²` of its pages around the main camera, whose
+ * corner is the level's row of `shadow_virtual_level`; a page of the window sits in cell
+ * `(wx mod N, wy mod N)` of the level's run of `shadow_virtual_page` rows, so a window that
+ * scrolls keeps every page still inside it where it was.
+ *
+ * Written whole by the CPU every frame the map is drawn: the camera fields follow the main view.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VSM_RECORD_STRUCT = WebGPUStruct.from({
+    /**
+     * World to light space: the view matrix of the light camera at the world origin. Rotation only.
+     */
+    view: mat4x4f,
+    /**
+     * The main camera's world position, which the level a point is shadowed at is measured from.
+     */
+    camera_position: vec3f,
+    /**
+     * The main view's angle per pixel, in radians: how wide a pixel is at unit distance.
+     */
+    pixel_angle: f32,
+    /**
+     * The light's depth range, as distances along the light from light space's origin — the near
+     * and far of every page's orthographic camera.
+     */
+    near: f32,
+    far: f32,
+    /**
+     * World size of a texel of level 0. Level `k`'s texel is `2^k` of these.
+     */
+    first_texel_size: f32,
+    /**
+     * Added to the level a point would select, before rounding down. Positive is coarser.
+     */
+    lod_bias: f32,
+    /**
+     * The map's run of `shadow_virtual_level` rows, one per clipmap level, finest first: each the
+     * corner of the level's window — the smallest world page coordinate it holds on each axis.
+     */
+    first_level: u32,
+    level_count: u32,
+    /**
+     * A window's side, in pages. A power of two.
+     */
+    pages_per_level: u32,
+    /**
+     * Texels on a side of a page, without its border.
+     */
+    page_size: u32,
+    /**
+     * Texels of border around a page in its slot, each side.
+     */
+    border: u32,
+    /**
+     * Atlas texel of the pool's corner: slot `(x, y)` starts at `pool_origin + (x, y) · slot size`.
+     */
+    pool_origin: vec2u,
+    slots_per_axis: u32,
+    /**
+     * The map's run of `shadow_virtual_page` rows: `level_count · pages_per_level²` of them,
+     * level-major, each a page-table entry ({@link vt_entry_pack}).
+     */
+    first_page: u32,
+    page_count: u32,
+    /**
+     * The map's run of `shadow_virtual_slot` rows: one per slot of the pool.
+     */
+    first_slot: u32,
+    slot_count: u32,
+}, "VSMRecord").pack();

package/src/shade/renderer/shadow/vsm/VSM_SLOT_STRUCT.d.ts

@@ -0,0 +1,16 @@
+/**
+ * One slot of a virtual shadow map's pool: a row of the light database's `shadow_virtual_slot`
+ * table, saying which world page the slot holds, if any. The stale pass reads it to know where a
+ * slot's page lies in light space; the page table points the other way.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VSM_SLOT_STRUCT: WebGPUStruct;
+/**
+ * What an empty slot's `level` holds — the engine's one "nothing" word.
+ *
+ * @type {number}
+ */
+export const VSM_SLOT_EMPTY: number;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=VSM_SLOT_STRUCT.d.ts.map

package/src/shade/renderer/shadow/vsm/VSM_SLOT_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VSM_SLOT_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSM_SLOT_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,8BAFU,YAAY,CAYD;AAErB;;;;GAIG;AACH,6BAFU,MAAM,CAEgC;6BA1BnB,mCAAmC"}

package/src/shade/renderer/shadow/vsm/VSM_SLOT_STRUCT.js

@@ -0,0 +1,29 @@
+import { GPU_DATABASE_NULL } from "../../buffer/table/GPU_DATABASE_NULL.js";
+import { i32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * One slot of a virtual shadow map's pool: a row of the light database's `shadow_virtual_slot`
+ * table, saying which world page the slot holds, if any. The stale pass reads it to know where a
+ * slot's page lies in light space; the page table points the other way.
+ *
+ * @type {WebGPUStruct}
+ */
+export const VSM_SLOT_STRUCT = WebGPUStruct.from({
+    /**
+     * Level of the page the slot holds, or {@link VSM_SLOT_EMPTY}.
+     */
+    level: u32,
+    /**
+     * World page coordinates of that page, at its level.
+     */
+    x: i32,
+    y: i32,
+}, "VSMSlot").pack();
+
+/**
+ * What an empty slot's `level` holds — the engine's one "nothing" word.
+ *
+ * @type {number}
+ */
+export const VSM_SLOT_EMPTY = GPU_DATABASE_NULL;