@swf2es/player 0.0.0-stage → 0.1.0

package/dist/render/table.d.ts

@@ -0,0 +1,213 @@
+import { ExtensionType, type GpuGraphicsContext, type Graphics, type Instruction, type InstructionSet, type WebGLRenderer } from "pixi.js";
+declare const NAME = "flashTable";
+/**
+ * Draw Graphics alone through the table, or not, from the next frame: a
+ * switch to time the two apart. Runs already built draw through Pixi's
+ * pipe while it is off; a group built while it was off draws alone until
+ * it is built again. `shortest` is the fewest draws a run makes as one
+ * multi-draw, MIN_RUN by default: the tests have the table draw every run
+ * so with 1, and the bench times others. A shorter run is drawn from the
+ * atlas a call a draw, its rows passed in uniforms, or with `loop` false
+ * by Pixi's pipe; so is it with `shortest` past SHORT_RUN + 1, as the
+ * uniforms hold no more rows.
+ */
+export declare function setTransformTable(on: boolean, shortest?: number, loop?: boolean): void;
+/** What the atlas reads of a context's render data: its packed vertices, indices and batches. */
+export interface Packed {
+    batcher: {
+        attributeBuffer: {
+            float32View: Float32Array;
+        };
+        attributeSize: number;
+        indexBuffer: ArrayLike<number>;
+        indexSize: number;
+    };
+    /** Its batches, as Pixi's instruction set lists them. */
+    instructions: {
+        instructionSize: number;
+        instructions: ArrayLike<Instruction>;
+    };
+}
+/** Where a context's batches lie in the atlas: each one's index count and first byte. */
+export interface Placed {
+    vertices: number;
+    indices: number;
+    counts: number[];
+    offsets: number[];
+}
+/**
+ * Where an atlas' vertices and indices are kept: the GPU's buffers, which
+ * the table writes into and grows there (TablePipe), with no copy on the CPU.
+ */
+export interface AtlasStore {
+    /** Room for `vertices` and `indices`, the first `keptVertices` and `keptIndices` kept. */
+    resize(vertices: number, indices: number, keptVertices: number, keptIndices: number): void;
+    /** The first `floats` of `data` written from vertex `at` on. */
+    writeVertices(at: number, data: Float32Array, floats: number): void;
+    /** The first `count` of `data` written from index `at` on. */
+    writeIndices(at: number, data: Uint32Array, count: number): void;
+}
+/**
+ * The local vertices of every context the table has drawn, in one buffer
+ * with one index buffer, absolute: each context's are copied in once, as
+ * Pixi packed them for it, and stay until it is rebuilt or destroyed. The
+ * holes those leave are reclaimed by packing again (compact). They are
+ * kept on the GPU alone: a crowded room's atlas held some 130 MB on the CPU
+ * as well, which only a lost context, after which it starts again anyway,
+ * could have used.
+ */
+export declare class Atlas {
+    /** The vertices and indices placed, which the store holds or which are staged for it. */
+    vertexCount: number;
+    indexCount: number;
+    /** The vertices and indices the store has room for. */
+    capacity: number;
+    indexCapacity: number;
+    /** The vertices and indices the store holds; those placed since are staged. */
+    private sentVertices;
+    private sentIndices;
+    /** Whether the store has room made for the capacity: not as it starts, shrinks or is lost. */
+    private allocated;
+    /** What is staged, in arrays grown as a frame places more, up to STAGED_VERTICES. */
+    private staged;
+    private stagedIndices;
+    private readonly placed;
+    private live;
+    private liveIndices;
+    private holes;
+    /** The id of a texture that is no texture, which alone the table draws. */
+    private readonly white;
+    private readonly store;
+    constructor(white: number, store: AtlasStore);
+    /** Where `key`'s batches lie: null if the table cannot draw them, undefined if not yet placed. */
+    where(key: object): Placed | null | undefined;
+    /**
+     * Where `key`'s batches lie, `packed` copied in first if they are not
+     * there yet; null if the table cannot draw them. What is copied in is
+     * staged, and the store has it once send is called.
+     */
+    place(key: object, packed: Packed): Placed | null;
+    /** `key`'s context rebuilt or destroyed: its vertices become a hole. */
+    release(key: object): void;
+    /**
+     * Pack again from scratch if holes pass ATLAS_SLACK and the live
+     * vertices: between frames, as a run's draws read where their contexts
+     * lie until it is drawn.
+     */
+    compact(): void;
+    /**
+     * Forget every context, to be copied in again as each is next drawn: in
+     * a store cut down to what was live, with room to grow, when that needs
+     * less than half its capacity. Smaller reductions would undo the next
+     * growth as animated contexts leave holes and come back again.
+     */
+    clear(): void;
+    /** The store's buffers were lost with their context: every context is copied in again as drawn. */
+    lost(): void;
+    /** Write what was staged into the store, room made for it first if the store has none yet. */
+    send(): void;
+    destroy(): void;
+    private allocate;
+    /**
+     * Stage `floats` of `vertices` and `count` of `indices` after what is
+     * placed, the indices offset by the vertices before them; written
+     * straight into the store, after what was staged, if they would not fit.
+     */
+    private copyIn;
+    /** Staging arrays of at least `floats` and `count`, doubled as need be, what they stage kept. */
+    private stage;
+    /**
+     * Room in the store for `vertexCount` and `indexCount` more, grown by
+     * half if they do not fit, what it holds kept by the GPU's own copy.
+     */
+    private reserve;
+}
+/**
+ * A context's GPU data reset, as it is built again and as it is destroyed
+ * (render/hooks.ts): its place in each atlas goes then.
+ */
+export declare function releaseFromAtlases(gpu: GpuGraphicsContext): void;
+/** A run of Graphics drawn alone, in the order the build added them. */
+export interface TableInstruction extends Instruction {
+    renderPipeId: typeof NAME;
+    items: Graphics[];
+}
+/** Add `graphics` to the run `instructionSet` ends with, or start one: anything else ends a run. */
+export declare function addToRun(graphics: Graphics, instructionSet: InstructionSet): void;
+export declare class TablePipe {
+    static extension: {
+        readonly type: readonly [ExtensionType.WebGLPipes, ExtensionType.WebGPUPipes];
+        readonly name: "flashTable";
+    };
+    private readonly renderer;
+    private multi;
+    /** The most rows the table may hold: as many lines as a texture may be tall. */
+    private maxRows;
+    private shader;
+    private shortShader;
+    /** Where the short shader's program, as last linked, takes its rows and first row, and that row. */
+    private rows;
+    private readonly uniforms;
+    private readonly state;
+    /** The next row free this frame. */
+    private cursor;
+    private table;
+    private atlas;
+    private attributes;
+    private indexBuffer;
+    /** The bytes the GPU's copies of the atlas' buffers were last made to hold. */
+    private vertexBytes;
+    private indexBytes;
+    private geometry;
+    /** The run being gathered: its first row, blend mode, and its draws' counts and offsets. */
+    private counts;
+    private offsets;
+    private draws;
+    private runBase;
+    private runBlend;
+    /**
+     * The Graphics the run gathered, for Pixi's pipe to draw if it is too
+     * short for a multi-draw and the table leaves such runs to it (loops).
+     */
+    private segment;
+    constructor(renderer: WebGLRenderer);
+    contextChange(): void;
+    prerender(): void;
+    /** Whether the table draws for this renderer: switched on, and WebGL 2 with multi-draw. */
+    get active(): boolean;
+    /** Whether a run too short for a multi-draw is drawn from the atlas, a call a draw. */
+    private get loops();
+    add(graphics: Graphics, instructionSet: InstructionSet): void;
+    execute(instruction: TableInstruction): void;
+    /** The draws `instruction` makes at most: one for each batch of each Graphics' context. */
+    private mostDraws;
+    /** Write `graphics`' transform and tint into the next row, the table and run grown to hold it. */
+    private row;
+    /** The table twice as tall, at most maxRows, the rows this frame wrote so far brought along. */
+    private grow;
+    /**
+     * Draw the run gathered as one call, its rows passed in uniforms if few,
+     * uploaded if not. A run too short to repay a multi-draw is drawn from
+     * the atlas a call a draw, its rows passed in uniforms at once and each
+     * draw told its row: the atlas' buffers bound once, where Pixi's pipe
+     * binds each context's own and sets each Graphics' uniforms. Or, with
+     * that switched off, its Graphics go through Pixi's pipe.
+     */
+    private flush;
+    private tableShader;
+    private shortRunShader;
+    /** Pass the run's rows to the short shader, bound: Pixi knows nothing of its uRows and uFirst. */
+    private passRows;
+    /** Set the short shader's first row, bound, if it is not that already. */
+    private first;
+    /**
+     * Upload rows `from` up to `to` in one call: the part of the line they
+     * lie in, or the whole lines they span. A line's other rows go up again
+     * as the CPU holds them: rows a draw already read are as they were, and
+     * no draw yet to come reads the rest before writing and uploading them.
+     */
+    private upload;
+    destroy(): void;
+}
+export {};
+//# sourceMappingURL=table.d.ts.map

package/dist/render/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/render/table.ts"],"names":[],"mappings":"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"}