@woosh/meep-engine 3.30.0 → 3.31.0

package/src/shade/renderer/buffer/table/GPUTableLink.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @typedef {import("./GPUDatabaseDefinition.js").GPUDatabaseDefinition} GPUDatabaseDefinition
+ * @typedef {import("./GPUTypedTableDescriptor.js").GPUTypedTableDescriptor} GPUTypedTableDescriptor
+ */
+/**
+ * One `u32` word of a table's record that names a row of another table — or of the same one — as a
+ * {@link GPUDatabaseDefinition} resolved it from {@link GPUDatabaseDefinition#add_link}.
+ *
+ * The word holds a row index, or {@link GPU_DATABASE_NULL} for no row at all. Nothing about the
+ * record's type changes: to WGSL and to every serializer the field is the `u32` it always was, and
+ * the declaration sits beside the struct rather than in it.
+ *
+ * Immutable.
+ */
+export class GPUTableLink {
+    /**
+     * Definition the link belongs to — the one holding {@link table}.
+     * @type {GPUDatabaseDefinition}
+     */
+    database: GPUDatabaseDefinition;
+    /**
+     * Table whose records hold the link.
+     * @type {GPUTypedTableDescriptor}
+     */
+    table: GPUTypedTableDescriptor;
+    /**
+     * Path to the word within the record, as declared: `'node'`, `'joints[3].node'`, `'curves[2]'`.
+     * @type {string}
+     */
+    field: string;
+    /**
+     * Offset of the word from the start of the record, in u32 words.
+     * @type {number}
+     */
+    word: number;
+    /**
+     * Definition holding the table the word points into. {@link database} itself for a link within
+     * one database.
+     * @type {GPUDatabaseDefinition}
+     */
+    target_database: GPUDatabaseDefinition;
+    /**
+     * Table the word points into.
+     * @type {GPUTypedTableDescriptor}
+     */
+    target_table: GPUTypedTableDescriptor;
+    /**
+     * Whether an occupied row may hold {@link GPU_DATABASE_NULL} in this word.
+     * @type {boolean}
+     */
+    nullable: boolean;
+    /**
+     * Whether the row this word names belongs to the row holding it. Owning links stay within one
+     * database.
+     * @type {boolean}
+     */
+    owning: boolean;
+    toString(): string;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isGPUTableLink: boolean;
+}
+export type GPUDatabaseDefinition = import("./GPUDatabaseDefinition.js").GPUDatabaseDefinition;
+export type GPUTypedTableDescriptor = import("./GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+//# sourceMappingURL=GPUTableLink.d.ts.map

package/src/shade/renderer/buffer/table/GPUTableLink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUTableLink.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTableLink.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;GASG;AACH;IACI;;;OAGG;IACH,UAFU,qBAAqB,CAEtB;IAET;;;OAGG;IACH,OAFU,uBAAuB,CAE3B;IAEN;;;OAGG;IACH,OAFU,MAAM,CAEV;IAEN;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,iBAFU,qBAAqB,CAEf;IAEhB;;;OAGG;IACH,cAFU,uBAAuB,CAEpB;IAEb;;;OAGG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;OAIG;IACH,QAFU,OAAO,CAEF;IAEf,mBAEC;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CANpC;oCApEY,OAAO,4BAA4B,EAAE,qBAAqB;sCAC1D,OAAO,8BAA8B,EAAE,uBAAuB"}

package/src/shade/renderer/buffer/table/GPUTableLink.js

@@ -0,0 +1,76 @@
+/**
+ * @typedef {import("./GPUDatabaseDefinition.js").GPUDatabaseDefinition} GPUDatabaseDefinition
+ * @typedef {import("./GPUTypedTableDescriptor.js").GPUTypedTableDescriptor} GPUTypedTableDescriptor
+ */
+
+/**
+ * One `u32` word of a table's record that names a row of another table — or of the same one — as a
+ * {@link GPUDatabaseDefinition} resolved it from {@link GPUDatabaseDefinition#add_link}.
+ *
+ * The word holds a row index, or {@link GPU_DATABASE_NULL} for no row at all. Nothing about the
+ * record's type changes: to WGSL and to every serializer the field is the `u32` it always was, and
+ * the declaration sits beside the struct rather than in it.
+ *
+ * Immutable.
+ */
+export class GPUTableLink {
+    /**
+     * Definition the link belongs to — the one holding {@link table}.
+     * @type {GPUDatabaseDefinition}
+     */
+    database;
+
+    /**
+     * Table whose records hold the link.
+     * @type {GPUTypedTableDescriptor}
+     */
+    table;
+
+    /**
+     * Path to the word within the record, as declared: `'node'`, `'joints[3].node'`, `'curves[2]'`.
+     * @type {string}
+     */
+    field;
+
+    /**
+     * Offset of the word from the start of the record, in u32 words.
+     * @type {number}
+     */
+    word = 0;
+
+    /**
+     * Definition holding the table the word points into. {@link database} itself for a link within
+     * one database.
+     * @type {GPUDatabaseDefinition}
+     */
+    target_database;
+
+    /**
+     * Table the word points into.
+     * @type {GPUTypedTableDescriptor}
+     */
+    target_table;
+
+    /**
+     * Whether an occupied row may hold {@link GPU_DATABASE_NULL} in this word.
+     * @type {boolean}
+     */
+    nullable = false;
+
+    /**
+     * Whether the row this word names belongs to the row holding it. Owning links stay within one
+     * database.
+     * @type {boolean}
+     */
+    owning = false;
+
+    toString() {
+        return `${this.table.name}.${this.field} -> ${this.target_table.name}`;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+GPUTableLink.prototype.isGPUTableLink = true;

package/src/shade/renderer/buffer/table/GPUTableRange.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @typedef {import("./GPUDatabaseDefinition.js").GPUDatabaseDefinition} GPUDatabaseDefinition
+ * @typedef {import("./GPUTypedTableDescriptor.js").GPUTypedTableDescriptor} GPUTypedTableDescriptor
+ */
+/**
+ * Two `u32` words of a table's record that name a contiguous run of rows of another table — or of
+ * the same one — as a {@link GPUDatabaseDefinition} resolved it from
+ * {@link GPUDatabaseDefinition#add_range}: the first row, and how many.
+ *
+ * An empty range is `(GPU_DATABASE_NULL, 0)`. Like a link, it changes nothing about the record's
+ * type; the declaration sits beside the struct.
+ *
+ * Immutable.
+ */
+export class GPUTableRange {
+    /**
+     * Definition the range belongs to — the one holding {@link table}.
+     * @type {GPUDatabaseDefinition}
+     */
+    database: GPUDatabaseDefinition;
+    /**
+     * Table whose records hold the range.
+     * @type {GPUTypedTableDescriptor}
+     */
+    table: GPUTypedTableDescriptor;
+    /**
+     * Path to the word holding the run's first row, as declared.
+     * @type {string}
+     */
+    first_field: string;
+    /**
+     * Path to the word holding the run's length, as declared.
+     * @type {string}
+     */
+    count_field: string;
+    /**
+     * Offset of {@link first_field} from the start of the record, in u32 words.
+     * @type {number}
+     */
+    first_word: number;
+    /**
+     * Offset of {@link count_field} from the start of the record, in u32 words.
+     * @type {number}
+     */
+    count_word: number;
+    /**
+     * Definition holding the table the run is in. {@link database} itself for a range within one
+     * database.
+     * @type {GPUDatabaseDefinition}
+     */
+    target_database: GPUDatabaseDefinition;
+    /**
+     * Table the run is in.
+     * @type {GPUTypedTableDescriptor}
+     */
+    target_table: GPUTypedTableDescriptor;
+    /**
+     * Whether the rows of the run belong to the row holding the range. Owning ranges stay within one
+     * database.
+     * @type {boolean}
+     */
+    owning: boolean;
+    toString(): string;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isGPUTableRange: boolean;
+}
+export type GPUDatabaseDefinition = import("./GPUDatabaseDefinition.js").GPUDatabaseDefinition;
+export type GPUTypedTableDescriptor = import("./GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+//# sourceMappingURL=GPUTableRange.d.ts.map

package/src/shade/renderer/buffer/table/GPUTableRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUTableRange.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTableRange.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;GASG;AACH;IACI;;;OAGG;IACH,UAFU,qBAAqB,CAEtB;IAET;;;OAGG;IACH,OAFU,uBAAuB,CAE3B;IAEN;;;OAGG;IACH,aAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,aAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,iBAFU,qBAAqB,CAEf;IAEhB;;;OAGG;IACH,cAFU,uBAAuB,CAEpB;IAEb;;;;OAIG;IACH,QAFU,OAAO,CAEF;IAEf,mBAEC;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;oCA1EY,OAAO,4BAA4B,EAAE,qBAAqB;sCAC1D,OAAO,8BAA8B,EAAE,uBAAuB"}

package/src/shade/renderer/buffer/table/GPUTableRange.js

@@ -0,0 +1,82 @@
+/**
+ * @typedef {import("./GPUDatabaseDefinition.js").GPUDatabaseDefinition} GPUDatabaseDefinition
+ * @typedef {import("./GPUTypedTableDescriptor.js").GPUTypedTableDescriptor} GPUTypedTableDescriptor
+ */
+
+/**
+ * Two `u32` words of a table's record that name a contiguous run of rows of another table — or of
+ * the same one — as a {@link GPUDatabaseDefinition} resolved it from
+ * {@link GPUDatabaseDefinition#add_range}: the first row, and how many.
+ *
+ * An empty range is `(GPU_DATABASE_NULL, 0)`. Like a link, it changes nothing about the record's
+ * type; the declaration sits beside the struct.
+ *
+ * Immutable.
+ */
+export class GPUTableRange {
+    /**
+     * Definition the range belongs to — the one holding {@link table}.
+     * @type {GPUDatabaseDefinition}
+     */
+    database;
+
+    /**
+     * Table whose records hold the range.
+     * @type {GPUTypedTableDescriptor}
+     */
+    table;
+
+    /**
+     * Path to the word holding the run's first row, as declared.
+     * @type {string}
+     */
+    first_field;
+
+    /**
+     * Path to the word holding the run's length, as declared.
+     * @type {string}
+     */
+    count_field;
+
+    /**
+     * Offset of {@link first_field} from the start of the record, in u32 words.
+     * @type {number}
+     */
+    first_word = 0;
+
+    /**
+     * Offset of {@link count_field} from the start of the record, in u32 words.
+     * @type {number}
+     */
+    count_word = 0;
+
+    /**
+     * Definition holding the table the run is in. {@link database} itself for a range within one
+     * database.
+     * @type {GPUDatabaseDefinition}
+     */
+    target_database;
+
+    /**
+     * Table the run is in.
+     * @type {GPUTypedTableDescriptor}
+     */
+    target_table;
+
+    /**
+     * Whether the rows of the run belong to the row holding the range. Owning ranges stay within one
+     * database.
+     * @type {boolean}
+     */
+    owning = false;
+
+    toString() {
+        return `${this.table.name}.(${this.first_field}, ${this.count_field}) -> ${this.target_table.name}`;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+GPUTableRange.prototype.isGPUTableRange = true;

package/src/shade/renderer/buffer/table/GPUTypedTable.d.ts

@@ -70,6 +70,40 @@ export class GPUTypedTable<T> {
      * @type {PageBufferPool|undefined}
      */
     page_buffer_pool: PageBufferPool | undefined;
+    /**
+     * Word offsets, within one record, of every word that names a row: each link word the table's
+     * definition declared (see {@link GPUDatabaseDefinition#add_link}), and the first word of each
+     * range ({@link GPUDatabaseDefinition#add_range}), whose count needs nothing — zero is the empty
+     * range's. Each holds {@link GPU_DATABASE_NULL} wherever nothing has been written: on a freed
+     * row, in its CPU shadow and in the record the GPU is sent, and on every row of a new page. A 0
+     * there would name row 0.
+     *
+     * Set by the database after construction, like {@link page_buffer_pool}. Empty for a table
+     * built on its own.
+     * @type {Uint32Array}
+     */
+    null_words: Uint32Array;
+    /**
+     * The owning links of the table's records, each with the table it points into: the rows
+     * {@link remove} takes with a row. Set by the database once every table exists, since a link
+     * can point into a table built after this one. Empty for a table built on its own.
+     * @type {ReadonlyArray<{word: number, target: GPUTypedTable}>}
+     */
+    owning_links: ReadonlyArray<{
+        word: number;
+        target: GPUTypedTable<any>;
+    }>;
+    /**
+     * The owning ranges of the table's records, each with the table its runs are in: the runs
+     * {@link remove} takes with a row. Set by the database alongside {@link owning_links}. Empty for a
+     * table built on its own.
+     * @type {ReadonlyArray<{first_word: number, count_word: number, target: GPUTypedTable}>}
+     */
+    owning_ranges: ReadonlyArray<{
+        first_word: number;
+        count_word: number;
+        target: GPUTypedTable<any>;
+    }>;
     /**
      * Add a new element to the table, automatically finding a free slot.
      *
@@ -87,8 +121,47 @@ export class GPUTypedTable<T> {
      */
     add_record(value: T, writer: GPURecordWriter): number;
     /**
-     * Remove an element from the table, freeing its slot.
-     * The slot will be zero-filled in the CPU shadow and an upload will be queued.
+     * Add `values` as a run — consecutive rows, in order — at the lowest place they fit, and return
+     * the first row. What a range names (see {@link GPUDatabaseDefinition#add_range}).
+     *
+     * First fit over occupancy: holes shorter than the run are skipped, a word of the bitset at a
+     * time. {@link add} is the same search for a run of one, so the two share one idea of which rows
+     * are free. A run may cross a page boundary — every reader looks a row's page up for itself —
+     * and it never moves once handed out.
+     *
+     * No values is no run: {@link GPU_DATABASE_NULL} comes back and no row is taken, so
+     * `(add_run(values), values.length)` is always a range — the empty one, `(NULL, 0)`, when there
+     * is nothing to hold.
+     *
+     * @param {T[]} values
+     * @returns {number} the run's first row, or {@link GPU_DATABASE_NULL} for no values
+     */
+    add_run(values: T[]): number;
+    /**
+     * {@link add_run} through a generated writer, as {@link add_record} is {@link add} through one.
+     *
+     * @param {T[]} values
+     * @param {GPURecordWriter} writer generated against this table's type
+     * @returns {number} the run's first row, or {@link GPU_DATABASE_NULL} for no values
+     */
+    add_run_records(values: T[], writer: GPURecordWriter): number;
+    /**
+     * Remove an element from the table, freeing its slot — and every row it owns.
+     *
+     * The slot is emptied in the CPU shadow — zeros, with {@link GPU_DATABASE_NULL} in its link
+     * words and in the first word of its ranges — and the same record is queued for the GPU.
+     *
+     * A row whose owning links and ranges (see {@link GPUDatabaseDefinition#add_link} and
+     * {@link GPUDatabaseDefinition#add_range}) name rows takes them with it, and those take theirs: a
+     * clip its run of bindings, a skin its joints, a chain's node the one after it. The rows are
+     * found through a worklist rather than by recursion, so a chain of any length cannot run the stack
+     * out, and a row that is already free is skipped — so a second removal of the same row does
+     * nothing, and a chain that loops back ends where it started. Each row goes through the same path
+     * a removal on its own takes.
+     *
+     * Only rows cascade. Whatever a row stood for outside the database — a clip's pose targets, a
+     * skin's skinning bindings — is the caller's to give back. And only removal cascades: see
+     * {@link GPUDatabaseDefinition#add_link} for what ownership does not do.
      *
      * @param {number} element_index
      */
@@ -114,11 +187,28 @@ export class GPUTypedTable<T> {
      *
      * The CPU data shadow is left as-is — subsequent {@link add} /
      * {@link set} calls overwrite slots before anything reads them, and
-     * marshalling reads don't honour occupancy. Only occupancy state
-     * is reset and page headers are marked dirty so the GPU's bitmap
-     * matches.
+     * marshalling reads don't honour occupancy — except the
+     * {@link null_words} of the rows it frees, which get
+     * {@link GPU_DATABASE_NULL} as a removal would leave them, so a later
+     * value that leaves a link or range out names no row. Nothing is
+     * shipped: only occupancy state is reset and page headers are marked
+     * dirty so the GPU's bitmap matches.
+     *
+     * Refused for a table that owns rows: clearing takes no owned rows with it, and doing so would
+     * mean visiting every row it is meant to skip. Remove the owners instead.
      */
     clear(): void;
+    /**
+     * One `u32` word of an occupied row's record, from the CPU shadow: a field read without
+     * deserializing the record, at the word a link or range declaration names — or a field's
+     * `offset / 4`. The shadow holds the bytes the row's next upload copies from, so this is what the
+     * GPU holds once the database has been updated. `undefined` for a free row, as {@link get} is.
+     *
+     * @param {number} element_index
+     * @param {number} word offset from the start of the record, in `u32` words
+     * @returns {number|undefined}
+     */
+    get_word(element_index: number, word: number): number | undefined;
     /**
      * Reads CPU-resident data, or whatever is in the upload buffer if the element is not CPU-resident.
      *
@@ -258,6 +348,17 @@ export class GPUTypedTable<T> {
      * Called after the upload buffers have been consumed during {@link GPUDatabase.update}.
      */
     trim_upload_buffer(): void;
+    /**
+     * Whether anything written to this table has yet to reach the GPU: a record or a range in
+     * either upload stream, a page whose header the GPU holds stale, or a page it has not been
+     * given a slot for. Exactly what {@link GPUDatabase.update} consumes and clears.
+     *
+     * A freed row counts. {@link remove} writes no record of its own, but it queues a zeroed one
+     * and marks the page's header, and until those go up the GPU holds the row as it was.
+     *
+     * @returns {boolean}
+     */
+    get has_pending_upload(): boolean;
     /**
      * @return {number} number of occupied element slots
      */

package/src/shade/renderer/buffer/table/GPUTypedTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUTypedTable.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTypedTable.js"],"names":[],"mappings":"AAwEA;;;GAGG;AACH;IAyKI;;;OAGG;IACH,wBAFW,uBAAuB,EASjC;IAlLD;;OAEG;IACH,YAFU,uBAAuB,CAEtB;IAEX;;;;OAIG;IACH,OAFU,IAAI,MAAM,EAAC,eAAe,CAAC,CAEnB;IAElB;;;;OAIG;IACH,uBAFU,YAAY,CAE6D;IAEnF;;;;;;;;;;;OAWG;IACH,4BAFU,YAAY,CAE6B;IAEnD;;;;;OAKG;IACH,qBAFU,YAAY,CAEsB;IAiF5C;;;;;OAKG;IACH,iBAFU,MAAM,CAEe;IAE/B;;;;OAIG;IACH,WAFU,MAAM,CAES;IAmBzB;;;;;;OAMG;IACH,oBAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,kBAFU,cAAc,GAAC,SAAS,CAEjB;IAejB;;;;;OAKG;IACH,WAHW,CAAC,GACC,MAAM,CAQlB;IAED;;;;;;;OAOG;IACH,kBAJW,CAAC,UACD,eAAe,GACb,MAAM,CAQlB;IAED;;;;;OAKG;IACH,sBAFW,MAAM,QAsChB;IAED;;;;OAIG;IACH,0BAIC;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAUlB;IAsBD;;;;;;;;;;OAUG;IACH,cAuBC;IAmGD;;;;;;OAMG;IACH,mBAJW,MAAM,GACJ,CAAC,GAAC,SAAS,CA0CvB;IAgDD;;;OAGG;IACH,cAsBC;IA+BD;;;;OAIG;IACH,mBAHW,MAAM,SACN,CAAC,QAyEX;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,0BAJW,MAAM,SACN,CAAC,UACD,eAAe,QA4DzB;IAED;;;;;;;;;;;;;OAaG;IACH,yBALW,MAAM,eACN,MAAM,oBAEN,UAAU,QAqBpB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACH,yBANW,MAAM,eACN,MAAM,UACN,WAAW,GAAC,eAAe,kBAC3B,MAAM,gBACN,MAAM,QA+DhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,0BAJW,MAAM,SACN,CAAC,UACD,eAAe,QA6GzB;IA0KD;;;OAGG;IACH,8BASC;IAED;;;OAGG;IACH,2BAYC;IAED;;OAEG;IACH,oBAEC;IAED;;;;;;;;;;OAUG;IACH,+BAEC;IAED;;;;;;;;;;OAUG;IACH,mCAJW,WAAW,UACX,MAAM,GACL,MAAM,CAoBjB;IAED;;;;;;;;;;;;OAYG;IACH,kCAMC;IAED;;;;;;;;;;;;;;OAcG;IACH,mCAHW,MAAM,GACL,MAAM,CAKjB;IAED,mBAEC;;CACJ;sCAl2CY,OAAO,8BAA8B,EAAE,uBAAuB;6BAC9D,OAAO,qBAAqB,EAAE,cAAc;yBAC5C,OAAO,iCAAiC,EAAE,UAAU;8BACpD,OAAO,mCAAmC,EAAE,eAAe;gCAPxC,sBAAsB;6BAhBzB,yCAAyC;uBAC/C,mCAAmC"}
+{"version":3,"file":"GPUTypedTable.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUTypedTable.js"],"names":[],"mappings":"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"}