@taole/giftstage 0.1.28 → 0.1.30

package/dist/parsers/vap-config-parser.d.ts

@@ -0,0 +1,20 @@
+import type { VAPConfig, VAPFrameItem } from '../types';
+export declare function parseVAPConfig(config: string | object): Promise<VAPConfig>;
+export declare function getVAPFrame(config: VAPConfig, frameIndex: number): VAPFrameItem | undefined;
+/**
+ * Logical content size for layout/aspect (matches visible RGB frame, not full mp4 frame).
+ * `videoW`/`videoH` often include separate alpha bands; use `w`/`h` or `rgbFrame` w×h.
+ */
+export declare function getVAPContentSize(info: VAPConfig['info']): {
+    w: number;
+    h: number;
+};
+/**
+ * Compute normalized UV coordinates for a frame region within the video texture.
+ */
+export declare function computeVAPUV(region: [number, number, number, number], videoW: number, videoH: number): {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};

package/dist/renderers/alpha-video-renderer.d.ts

@@ -0,0 +1,48 @@
+import type { GPUBackend, GiftSlot } from '../types';
+export declare class AlphaVideoRenderer {
+    private quadVB;
+    private quadIB;
+    /** Packed rect + atlas remap + opacity per instance (WebGPU + WebGL2 instanced path). */
+    private instancePackScratch;
+    private projCacheW;
+    private projCacheH;
+    private projCache;
+    private scratchTransform;
+    private readonly contentSizeScratch;
+    private readonly layoutScratch;
+    private readonly wcDbgFirstDraw;
+    private readonly wcDbgNullWarns;
+    private readonly htmlGate;
+    private readonly lastWcFrameRef;
+    private readonly scratchAtlasRemap;
+    private readonly processedHtmlGatesScratch;
+    private readonly instancedTexturesScratch;
+    private readonly instancedUniformsScratch;
+    private readonly instancedDrawCommand;
+    private readonly geometryTexturesScratch;
+    private readonly geometryUniformsScratch;
+    private readonly geometryDrawCommand;
+    private static alphaVideoContentSize;
+    private static readonly QUAD_VERTS;
+    private static readonly QUAD_INDICES;
+    syncVideoTextures(backend: GPUBackend, slots: Map<string, GiftSlot>): boolean;
+    draw(backend: GPUBackend, slots: Map<string, GiftSlot>): void;
+    drawSlot(backend: GPUBackend, slot: GiftSlot): void;
+    /**
+     * Emit consecutive texture batches without allocating per-frame lists or maps.
+     * RenderManager already groups normal runs by texture/object-fit; preserving input order also keeps
+     * the public renderer correct when callers provide mixed textures or cover slots.
+     * WebGPU: `drawIndexed` instance path; WebGL2: `drawElementsInstanced` + instance vertex attributes.
+     */
+    private drawInstancedAlphaBatches;
+    private flushInstancedBatch;
+    /** Writes rect + atlas remap + opacity at `floatOffset` into `out`. */
+    private fillAlphaInstanceData;
+    releaseHtmlVideo(slot: GiftSlot): void;
+    clearWebCodecsFrameRef(slotId: string): void;
+    private getHtmlVideoGateId;
+    private drawGeometry;
+    private ensureQuadBuffers;
+    private getProjection;
+    destroy(backend: GPUBackend): void;
+}

package/dist/renderers/image-renderer.d.ts

@@ -0,0 +1,13 @@
+import type { GPUBackend, GiftSlot } from '../types';
+export declare class ImageRenderer {
+    private quadVB;
+    private quadIB;
+    private readonly scratchTransform;
+    private projCacheW;
+    private projCacheH;
+    private projCache;
+    private static readonly QUAD_VERTS;
+    private static readonly QUAD_INDICES;
+    drawSlot(backend: GPUBackend, slot: GiftSlot): void;
+    destroy(backend: GPUBackend): void;
+}

package/dist/renderers/index.d.ts

@@ -0,0 +1,4 @@
+export { SVGABatchRenderer } from './svga-batch-renderer';
+export { VAPRenderer } from './vap-renderer';
+export { AlphaVideoRenderer } from './alpha-video-renderer';
+export { buildBatchVerticesJS } from './vertex-builder';

package/dist/renderers/svga-batch-renderer.d.ts

@@ -0,0 +1,113 @@
+import type { GPUBackend, GPUBufferHandle, GiftSlot, VideoEntity } from '../types';
+export interface ClipMeshCache {
+    vertices: Float32Array;
+    indices: Uint32Array;
+    /**
+     * Axis-aligned rectangle in local SVGA space when the clip mesh is a simple quad
+     * (scissor fast path). `undefined` = not yet analyzed, `null` = not a rectangle.
+     */
+    rect?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | null;
+    /** Lazily created static GPU buffers (local-space vertices, transformed via u_transform). */
+    vertexBuf?: GPUBufferHandle | null;
+    indexBuf?: GPUBufferHandle | null;
+}
+interface SVGAClipPrewarmOptions {
+    frameBudgetMs?: number;
+    workerTimeSliceMs?: number;
+    checkActive?: () => void;
+    useWorker?: boolean;
+    signal?: AbortSignal;
+}
+export type SVGAClipMeshMap = Map<string, ClipMeshCache>;
+export declare class SVGABatchRenderer {
+    private static readonly INSTANCED_QUAD_VERTS;
+    private static readonly INSTANCED_QUAD_INDICES;
+    private pool;
+    private vertexBufHandles;
+    private indexBufHandles;
+    private clipSpriteVertBufHandles;
+    private clipSpriteIdxBufHandles;
+    private batchDrawCursor;
+    private clipSpriteDrawCursor;
+    private canvasWidth;
+    private canvasHeight;
+    private projCacheW;
+    private projCacheH;
+    private projCache;
+    private clipMeshCache;
+    /** Meshes with lazily created GPU buffers (released in destroy). */
+    private clipMeshesWithBuffers;
+    private clipFrameDataScratch;
+    private instancedFrameDataScratch;
+    private clipSpriteVertsScratch;
+    private clipSpriteIndicesScratch;
+    private shapeVertsScratch;
+    private instancedQuadVB;
+    private instancedQuadIB;
+    private whiteTexture;
+    private shapeMeshCache;
+    /** Column-major mat4 scratch for clip-mask u_transform (uploaded synchronously per draw). */
+    private clipTransformMat;
+    /** Scissor rect of the slot currently being drawn (canvas pixels), for clip intersection/restore. */
+    private slotScissor;
+    /** Grow-only SpriteWork pool; cursor resets each flushGroup. */
+    private spriteWorkPool;
+    private spriteWorkCursor;
+    /** Reused scratch arrays (consumed synchronously). */
+    private batchSpritesScratch;
+    private drawGroupScratch;
+    /** Per-entity result of the "any frame has shapes" scan (no-atlas render check). */
+    private entityHasShapesCache;
+    private readonly affineScratch;
+    beginFrame(backend: GPUBackend): void;
+    flush(backend: GPUBackend, slots: Map<string, GiftSlot>): void;
+    drawSlot(backend: GPUBackend, slot: GiftSlot): void;
+    drawSlots(backend: GPUBackend, slots: Iterable<GiftSlot>): void;
+    prewarmClipMeshes(entity: Pick<VideoEntity, 'spriteTable'>, options?: SVGAClipPrewarmOptions): Promise<number>;
+    hydrateClipMeshes(meshes: SVGAClipMeshMap | null | undefined): void;
+    snapshotClipMeshes(entity: Pick<VideoEntity, 'spriteTable'>): SVGAClipMeshMap;
+    private flushGroup;
+    private acquireSpriteWork;
+    /** Drop object references so removed slots/entities are not retained by the pool. */
+    private releaseSpriteWorks;
+    private getProjection;
+    private drawBatch;
+    private drawBatchInstancedWebGL;
+    private drawClippedSprite;
+    /** Rect clip in canvas space intersected with the slot scissor. Returns false when fully clipped. */
+    private applyClipRectScissor;
+    private restoreSlotScissor;
+    private getClipRect;
+    private ensureClipMeshBuffers;
+    private packClipTransform;
+    private drawSingleSprite;
+    private clearClipStencil;
+    private rotateTransform;
+    private packFrameData;
+    /** Resolve atlas/override texture into a pooled SpriteWork entry. Returns false when missing. */
+    private resolveSpriteTextureInto;
+    private drawShapeFrame;
+    private hasAtlasTexture;
+    private hasRenderableSVGA;
+    private getWhiteTexture;
+    private getShapeMesh;
+    private appendShape;
+    private buildShapeSubPaths;
+    private appendFill;
+    private appendStroke;
+    private clamp01;
+    private cleanupPoints;
+    private getClipMesh;
+    private ensureVertexBuffer;
+    private ensureIndexBuffer;
+    private ensureClipSpriteVertexBuffer;
+    private ensureClipSpriteIndexBuffer;
+    private ensureInstancedQuadBuffers;
+    destroy(backend: GPUBackend): void;
+}
+export {};

package/dist/renderers/vap-renderer.d.ts

@@ -0,0 +1,58 @@
+import type { GPUBackend, GiftSlot } from '../types';
+export declare class VAPRenderer {
+    private instancedQuadVB;
+    private instancedQuadIB;
+    private quadVB;
+    private quadIB;
+    private rgbaWebGLQuadVB;
+    private rgbaTopLeftQuadVB;
+    private rgbaQuadIB;
+    private readonly wcDbgFirstDraw;
+    private readonly wcDbgNullWarns;
+    private readonly htmlGate;
+    /** Skip GPU upload when `getFrameForTime` returns the same `VideoFrame` instance (rAF > clip FPS). */
+    private readonly lastWcFrameRef;
+    private readonly scratchAtlasRemap;
+    private instancePackScratch;
+    private scratchTransform;
+    private readonly processedHtmlGatesScratch;
+    private readonly vapVertexScratch;
+    private projCacheW;
+    private projCacheH;
+    private projCache;
+    private static readonly QUAD_VERTS;
+    /**
+     * WebGL canvas/image uploads keep the classic texture-origin mismatch, so we still need
+     * the vertically flipped UVs here.
+     */
+    private static readonly RGBA_QUAD_VERTS_WEBGL;
+    /**
+     * WebGPU `copyExternalImageToTexture` uses top-left image origin, so mixed RGBA canvases
+     * should sample without the extra vertical flip.
+     */
+    private static readonly RGBA_QUAD_VERTS_WEBGPU;
+    private static readonly QUAD_INDICES;
+    /**
+     * Upload video frames **before** `beginFrame` so WebGPU queue copies complete before the render pass
+     * (avoids subtle ordering / starvation when many videos update in one rAF).
+     */
+    syncVideoTextures(backend: GPUBackend, slots: Map<string, GiftSlot>): boolean;
+    draw(backend: GPUBackend, slots: Map<string, GiftSlot>): void;
+    drawSlot(backend: GPUBackend, slot: GiftSlot): void;
+    /**
+     * Group by shared `videoTextureHandle` (atlas or same texture), one instanced draw per group.
+     */
+    private drawInstancedVapBatches;
+    /** mat4 + atlasRemap + rgb/alpha UV rects (`computeVAPUV` order). */
+    private fillVapInstanceData;
+    private syncMixedTexture;
+    releaseHtmlVideo(slot: GiftSlot): void;
+    clearWebCodecsFrameRef(slotId: string): void;
+    private drawGeometry;
+    private drawMixedGeometry;
+    private drawMixedDirectGeometry;
+    private ensureBuffer;
+    destroy(backend: GPUBackend): void;
+    private getMixedFrameIndex;
+    private getHtmlVideoGateId;
+}

package/dist/renderers/vertex-builder.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pure JS port of Unity BuildBatchMeshJob.Execute() and WASM build_batch_vertices().
+ * Used as fallback when WASM is unavailable or on main thread.
+ */
+export declare function buildBatchVerticesJS(frames: Float32Array, outVertices: Float32Array, outIndices: Uint32Array): number;

package/dist/shaders/index.d.ts

@@ -0,0 +1,49 @@
+export declare const glsl: {
+    readonly svgaBatchPremul: {
+        readonly vert: string;
+        readonly frag: string;
+    };
+    readonly svgaInstancedPremul: {
+        readonly vert: string;
+        readonly frag: string;
+    };
+    readonly vap: {
+        readonly vert: string;
+        readonly frag: string;
+    };
+    readonly vapMixOverlay: {
+        readonly vert: string;
+        readonly frag: string;
+    };
+    readonly vapInstanced: {
+        readonly vert: string;
+        readonly frag: string;
+    };
+    readonly alphaVideo: {
+        readonly vert: string;
+        readonly frag: string;
+    };
+    readonly alphaVideoInstanced: {
+        readonly vert: string;
+        readonly frag: string;
+    };
+    readonly rgbaTextured: {
+        readonly vert: string;
+        readonly frag: string;
+    };
+    readonly clipMask: {
+        readonly vert: string;
+        readonly frag: string;
+    };
+};
+export declare const wgsl: {
+    readonly svgaBatchPremul: string;
+    readonly svgaInstancedPremul: string;
+    readonly vap: string;
+    readonly vapMixOverlay: string;
+    readonly vapInstanced: string;
+    readonly alphaVideo: string;
+    readonly alphaVideoInstanced: string;
+    readonly rgbaTextured: string;
+    readonly clipMask: string;
+};