@doki-land/live2d-renderer 0.0.0 → 0.0.11

package/README.md

@@ -1,3 +1,3 @@
 # @doki-land/live2d-renderer
 
-Placeholder package (0.0.0). Reserved for doki-land/live2d.ts.
+live2d.ts package 0.0.11.

package/dist/index.d.ts

@@ -0,0 +1,540 @@
+import { ParameterProgram, ModelProgram, ModelInstance, FrameSnapshot, ModelFormat, ModelSettings, AssetResolver, InternalModel } from '@doki-land/live2d-core';
+export { detectModelSettingsFormat } from '@doki-land/live2d-core';
+
+/** Implemented renderer kinds. */
+type RendererKind = "webgpu" | "webgl2" | "canvas2d";
+/** Blend modes for Live2D drawable compositing. */
+declare const BlendMode: {
+    readonly Normal: 0;
+    readonly Additive: 1;
+    readonly Multiplicative: 2;
+};
+type BlendMode = (typeof BlendMode)[keyof typeof BlendMode];
+/** A single drawable mesh submitted to the GPU backend. */
+interface DrawableMesh {
+    index: number;
+    textureIndex: number;
+    vertexPositions: Float32Array;
+    uvs: Float32Array;
+    indices: Uint16Array;
+    opacity: number;
+    blendMode: BlendMode;
+    invertedMask: boolean;
+    renderOrder: number;
+    dynamicFlag: boolean;
+    maskIndices: number[];
+    visible: boolean;
+}
+interface TextureData {
+    index: number;
+    image: HTMLImageElement | ImageBitmap;
+    width: number;
+    height: number;
+}
+interface ModelDrawPass {
+    setTextures(textures: TextureData[]): void;
+    draw(drawables: DrawableMesh[], modelMatrix: Float32Array): void;
+    destroy(): void;
+}
+/** Top-level renderer bound to a canvas. */
+interface Renderer {
+    readonly kind: RendererKind;
+    initialize(canvas: HTMLCanvasElement): Promise<void>;
+    createModelDrawPass(): ModelDrawPass;
+    beginFrame(): void;
+    endFrame(): void;
+    resize(width: number, height: number): void;
+    destroy(): void;
+}
+interface WebGpuRenderer extends Renderer {
+    readonly kind: "webgpu";
+    getDevice(): GPUDevice | null;
+}
+interface WebGl2Renderer extends Renderer {
+    readonly kind: "webgl2";
+    getGL(): WebGL2RenderingContext | null;
+}
+
+interface Canvas2DRendererOptions {
+    /** Fill color for deformed triangles (CSS). */
+    fill?: string;
+    stroke?: string;
+}
+/** Canvas2D soft renderer — CPU FrameSnapshot preview without WebGPU/WebGL. */
+declare class Canvas2DRendererImpl implements Renderer {
+    #private;
+    readonly kind: "canvas2d";
+    constructor(options?: Canvas2DRendererOptions);
+    initialize(canvas: HTMLCanvasElement): Promise<void>;
+    createModelDrawPass(): ModelDrawPass;
+    beginFrame(): void;
+    endFrame(): void;
+    resize(width: number, height: number): void;
+    destroy(): void;
+}
+declare function createCanvas2DRenderer(options?: Canvas2DRendererOptions): Renderer;
+declare function isCanvas2DAvailable(): boolean;
+
+/**
+ * WebGL2 renderer with soft clipping-mask support.
+ *
+ * Mask path: render mask meshes into an offscreen FBO (NDC→UV 1:1), then
+ * multiply drawable alpha by the mask (or 1−mask when inverted).
+ */
+
+interface WebGl2RendererOptions {
+    antialias?: boolean;
+    alpha?: boolean;
+    /**
+     * Keep color buffer after present so `canvas.toDataURL` / `toBlob` work.
+     * Default true (preview / gallery capture). Set false for max FPS if unused.
+     */
+    preserveDrawingBuffer?: boolean;
+}
+/** WebGL2 renderer. */
+declare class WebGl2RendererImpl implements WebGl2Renderer {
+    #private;
+    readonly kind: "webgl2";
+    constructor(options?: WebGl2RendererOptions);
+    initialize(canvas: HTMLCanvasElement): Promise<void>;
+    createModelDrawPass(): ModelDrawPass;
+    beginFrame(): void;
+    endFrame(): void;
+    resize(width: number, height: number): void;
+    getGL(): WebGL2RenderingContext | null;
+    destroy(): void;
+}
+declare function createWebGl2Renderer(options?: WebGl2RendererOptions): WebGl2Renderer;
+declare function isWebGl2Available(): boolean;
+
+/**
+ * WebGPU renderer with soft clipping-mask support (parity with WebGL2).
+ *
+ * Frame flow: beginFrame creates an encoder; drawMeshes writes all mask
+ * contexts into one atlas texture, then one color pass samples per-drawable
+ * atlas layout; endFrame submits.
+ */
+
+interface WebGpuRendererOptions {
+    /** Prefer high-performance adapter when available. */
+    powerPreference?: GPUPowerPreference;
+}
+/** WebGPU renderer. */
+declare class WebGpuRendererImpl implements WebGpuRenderer {
+    #private;
+    readonly kind: "webgpu";
+    constructor(options?: WebGpuRendererOptions);
+    initialize(canvas: HTMLCanvasElement): Promise<void>;
+    setTextures(textures: TextureData[]): void;
+    createModelDrawPass(): ModelDrawPass;
+    beginFrame(): void;
+    drawMeshes(drawables: DrawableMesh[]): void;
+    endFrame(): void;
+    resize(width: number, height: number): void;
+    getDevice(): GPUDevice | null;
+    destroy(): void;
+}
+declare function createWebGpuRenderer(options?: WebGpuRendererOptions): WebGpuRenderer;
+declare function isWebGpuAvailable(): boolean;
+
+/**
+ * Map Live2D blend modes to WebGL / Canvas compositing.
+ */
+
+/** Apply premultiplied-friendly Live2D blend factors on a WebGL2 context. */
+declare function applyWebGl2BlendMode(gl: WebGL2RenderingContext, mode: BlendMode): void;
+/** Canvas2D globalCompositeOperation for Live2D blend modes. */
+declare function canvasCompositeForBlendMode(mode: BlendMode): GlobalCompositeOperation;
+/** WebGPU blend state for Live2D modes (straight alpha draw path). */
+declare function webGpuBlendState(mode: BlendMode): GPUBlendState;
+
+/**
+ * Clipping-mask context grouping + mask atlas layout.
+ *
+ * Two packing modes:
+ * - `uv-grid`: √N UV cells, alpha channel only (Canvas2D / simple path)
+ * - `rgba`: Cubism-style channel × UV packing (≤4 → full UV on R/G/B/A)
+ */
+interface ClippingDrawableRef {
+    readonly index: number;
+    readonly maskIndices: readonly number[];
+    readonly invertedMask: boolean;
+}
+interface ClippingContext {
+    /** Stable key: invert flag + sorted mask drawable indices. */
+    readonly key: string;
+    readonly maskIndices: readonly number[];
+    readonly clippedIndices: readonly number[];
+    readonly invertedMask: boolean;
+}
+/** UV-space rectangle inside the shared mask atlas (0..1). */
+interface MaskLayoutRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** R/G/B/A write/sample selector (Cubism channelFlag). */
+type MaskChannelFlag = readonly [number, number, number, number];
+declare const MASK_CHANNEL_FLAGS: readonly MaskChannelFlag[];
+type MaskAtlasMode = "uv-grid" | "rgba";
+interface MaskAtlasOptions {
+    /** Packing strategy. Default `rgba` (Cubism density). */
+    readonly mode?: MaskAtlasMode;
+    /** Cell inset for `uv-grid` only (reduces neighbour bleed). */
+    readonly inset?: number;
+    /** Render-texture count for `rgba` (default 1 → max 36). */
+    readonly renderTextureCount?: number;
+}
+interface LaidOutClippingContext extends ClippingContext {
+    readonly layout: MaskLayoutRect;
+    /** 0=R … 3=A. `uv-grid` always uses A (3). */
+    readonly channelIndex: number;
+    readonly channelFlag: MaskChannelFlag;
+    /** Cubism multi-RT buffer index; currently always 0. */
+    readonly bufferIndex: number;
+    /**
+     * Expanded AABB of clipped drawables in vertex/NDC space.
+     * Mask write/sample map this rect into `layout` (Cubism bounds-fit).
+     * Default before `fitClippingContexts`: full NDC (-1..1)².
+     */
+    readonly modelBounds: MaskLayoutRect;
+}
+/** Full clip-space quad used when no valid clipped bounds exist. */
+declare const FULL_NDC_BOUNDS: MaskLayoutRect;
+interface ClippingPartition {
+    readonly contexts: readonly LaidOutClippingContext[];
+    /** Drawables that consume a mask (drawn after mask pass). */
+    readonly clipped: ReadonlySet<number>;
+    /** Drawables used as masks (mask buffer only, not color target). */
+    readonly maskOnly: ReadonlySet<number>;
+}
+/**
+ * Group drawables that consume clipping masks into shared contexts.
+ * Drawables with empty maskIndices are omitted.
+ */
+declare function buildClippingContexts(drawables: readonly ClippingDrawableRef[]): ClippingContext[];
+/**
+ * Pack clipping contexts into a square-ish UV grid on one atlas (alpha only).
+ */
+declare function layoutMaskAtlasUvGrid(contexts: readonly ClippingContext[], options?: {
+    inset?: number;
+}): LaidOutClippingContext[];
+/**
+ * Cubism `setupLayoutBounds`: pack across R/G/B/A then UV cells.
+ * Single RT → max 36 (4×9); multi-RT → 32 per sheet.
+ */
+declare function layoutMaskAtlasRgba(contexts: readonly ClippingContext[], options?: {
+    renderTextureCount?: number;
+}): LaidOutClippingContext[];
+/** Pack clipping contexts (default: Cubism RGBA density). */
+declare function layoutMaskAtlas(contexts: readonly ClippingContext[], options?: MaskAtlasOptions): LaidOutClippingContext[];
+/** Partition drawables and assign atlas layouts. */
+declare function partitionForClipping(drawables: readonly ClippingDrawableRef[], options?: MaskAtlasOptions): ClippingPartition;
+/** Axis-aligned bounds of interleaved xy vertex positions. */
+declare function calcVertexBounds(positions: Float32Array): MaskLayoutRect | null;
+/** Expand bounds by a relative margin on each axis (Cubism uses 0.05). */
+declare function expandBounds(bounds: MaskLayoutRect, margin?: number): MaskLayoutRect;
+interface MaskBoundsMeshRef {
+    readonly index: number;
+    readonly vertexPositions: Float32Array;
+}
+/**
+ * Union AABB of clipped drawables, expanded by margin (Cubism
+ * `calcClippedDrawableTotalBounds` + 0.05 expand).
+ */
+declare function calcClippedDrawableBounds(clippedIndices: readonly number[], byIndex: ReadonlyMap<number, MaskBoundsMeshRef>, margin?: number): MaskLayoutRect;
+/**
+ * Attach per-context `modelBounds` so mask write/sample fit the clipped
+ * drawable AABB into the atlas cell (higher mask texel density).
+ */
+declare function fitClippingContexts(contexts: readonly LaidOutClippingContext[], byIndex: ReadonlyMap<number, MaskBoundsMeshRef>, margin?: number): LaidOutClippingContext[];
+/** Flatten layout to `[x, y, w, h]` for GPU uniforms. */
+declare function maskLayoutVec4(layout: MaskLayoutRect): Float32Array;
+/** Flatten channel flag to `[r, g, b, a]` for GPU uniforms. */
+declare function maskChannelVec4(flag: MaskChannelFlag): Float32Array;
+
+declare const CPU_PROGRAM_KIND: "cpu-program";
+interface CpuProgramFile {
+    readonly kind: typeof CPU_PROGRAM_KIND;
+    readonly version: 1;
+    readonly program: {
+        readonly format: "moc2" | "moc3";
+        readonly parameters: readonly ParameterProgram[];
+        readonly drawables: readonly {
+            readonly index: number;
+            readonly textureIndex: number;
+            readonly positions: number[];
+            readonly uvs: number[];
+            readonly indices: number[];
+            readonly opacity: number;
+            readonly renderOrder: number;
+            readonly blendMode?: number;
+            readonly invertedMask?: boolean;
+            readonly maskIndices?: number[];
+            readonly visible?: boolean;
+            readonly deformParamIndex: number;
+            readonly deformDeltas: number[] | null;
+        }[];
+    };
+}
+/** Build a minimal one-quad CPU program for fixtures / homepage. */
+declare function createQuadProgram(options?: {
+    parameterId?: string;
+    /** Delta applied to top-right vertex at param max (x,y). */
+    topRightDelta?: readonly [number, number];
+}): ModelProgram;
+/** Serialize a CPU ModelProgram to UTF-8 JSON bytes. */
+declare function serializeCpuProgram(program: ModelProgram): ArrayBuffer;
+declare function isCpuProgramBytes(bytes: ArrayBuffer): boolean;
+/** Parse CPU program JSON bytes into a ModelProgram. */
+declare function parseCpuProgram(bytes: ArrayBuffer): ModelProgram;
+
+/** Create a runtime instance with default parameter values. */
+declare function createModelInstance(program: ModelProgram): ModelInstance;
+declare function setParameterValue(instance: ModelInstance, parameterId: string, value: number): void;
+/** CPU deform 鈫?FrameSnapshot. */
+declare function evaluateFrame(instance: ModelInstance): FrameSnapshot;
+/** Stable fingerprint for golden tests (positions + topology). */
+declare function fingerprintSnapshot(snapshot: FrameSnapshot): string;
+
+interface CreateRendererOptions {
+    /**
+     * Backend try order at initialize time.
+     * Default: `["webgpu", "webgl2", "canvas2d"]`.
+     */
+    prefer?: RendererKind[];
+    webgpu?: WebGpuRendererOptions;
+    webgl2?: WebGl2RendererOptions;
+    canvas2d?: Canvas2DRendererOptions;
+}
+/**
+ * Create a renderer provider. Actual backend is chosen on `initialize`
+ * (WebGPU → WebGL2 → Canvas2D by default).
+ */
+declare function createRenderer(options?: CreateRendererOptions): Renderer;
+
+/**
+ * moc binary format peek. Settings JSON detection lives in live2d-core
+ * (`detectModelSettingsFormat`) so loader and renderer share one helper.
+ */
+
+/** Peek moc2 vs moc3 from magic bytes. */
+declare function detectMocBinaryFormat(bytes: ArrayBuffer): ModelFormat | null;
+
+/**
+ * moc binary decode: ArrayBuffer → CPU ModelProgram.
+ */
+
+interface DecodedMoc2 {
+    readonly format: "moc2";
+    readonly program: ModelProgram;
+}
+interface DecodedMoc3 {
+    readonly format: "moc3";
+    readonly program: ModelProgram;
+}
+/** Decode official moc2 (`.moc`) bytes into a default-pose ModelProgram. */
+declare function decodeMoc2(bytes: ArrayBuffer): Promise<DecodedMoc2>;
+/**
+ * Decode official moc3 bytes into a ModelProgram.
+ * Applies keyform blending + warp/rotation deformer chains at the given pose
+ * (defaults when called via decodeMoc3).
+ */
+declare function decodeMoc3(bytes: ArrayBuffer): Promise<DecodedMoc3>;
+
+/**
+ * Shared moc2/moc3 drawable constant-flag decode → blend / invert-mask.
+ */
+/** Cubism Core constant drawable flag bits (moc3 art_mesh.drawable_flags). */
+declare const Moc3DrawableFlag: {
+    readonly BlendAdditive: number;
+    readonly BlendMultiplicative: number;
+    readonly IsDoubleSided: number;
+    readonly IsInvertedMask: number;
+};
+/** Decode moc3 constant flags into blend + invert-mask. */
+declare function decodeMoc3DrawableFlags(flags: number): {
+    blendMode: number;
+    invertedMask: boolean;
+    doubleSided: boolean;
+};
+/**
+ * Decode moc2 color-composition enum (after optionFlags bit0).
+ * 0 normal, 1 additive, 2 multiplicative.
+ */
+declare function decodeMoc2ColorComposition(composition: number): number;
+
+/**
+ * Model-format runtime contract (moc2 / moc3 / cpu-program).
+ * Not a graphics backend — those live under `backends/`.
+ */
+interface ModelBackendOptions {
+    /** Bound graphics renderer, if the runtime needs GPU handles. */
+    renderer?: Renderer | null;
+    /** Asset resolver for moc / textures. */
+    resolver?: AssetResolver;
+    /** Preloaded moc bytes (tests). */
+    mocBytes?: ArrayBuffer;
+}
+/** Live parameter binding for inspectors / playground. */
+interface ParameterBinding {
+    readonly id: string;
+    readonly min: number;
+    readonly max: number;
+    readonly defaultValue: number;
+    readonly value: number;
+}
+/** moc2 / moc3 model runtime. */
+interface ModelBackend {
+    readonly format: ModelFormat;
+    canHandle(json: unknown): boolean;
+    createModel(settings: ModelSettings, options?: ModelBackendOptions): Promise<InternalModel>;
+    updateModel(model: InternalModel, deltaTimeSeconds: number): void;
+    getDrawables(model: InternalModel): DrawableMesh[];
+    hitTest(model: InternalModel, x: number, y: number): string | null;
+    destroyModel(model: InternalModel): void;
+    /** Optional CPU snapshot (moc3 CPU path). */
+    captureFrame?(model: InternalModel): FrameSnapshot | null;
+    setParameter?(model: InternalModel, id: string, value: number): void;
+    /** Optional PartOpacity override (moc3 parts / pose / motion). */
+    setPartOpacity?(model: InternalModel, id: string, value: number): void;
+    listParameters?(model: InternalModel): readonly ParameterBinding[];
+}
+declare function selectModelBackend(backends: ModelBackend[], json: unknown): ModelBackend;
+
+/** moc2 (`.moc`) model backend — pure-TS decode → CPU evaluate. */
+declare class Moc2Backend implements ModelBackend {
+    readonly format: "moc2";
+    canHandle(json: unknown): boolean;
+    createModel(settings: ModelSettings, options?: ModelBackendOptions): Promise<InternalModel>;
+    updateModel(model: InternalModel, deltaTimeSeconds: number): void;
+    getDrawables(model: InternalModel): DrawableMesh[];
+    captureFrame(model: InternalModel): FrameSnapshot | null;
+    setParameter(model: InternalModel, id: string, value: number): void;
+    listParameters(model: InternalModel): readonly ParameterBinding[];
+    hitTest(_model: InternalModel, _x: number, _y: number): string | null;
+    destroyModel(model: InternalModel): void;
+}
+declare function createMoc2Backend(): Moc2Backend;
+
+/** moc3 model backend — official `.moc3` or CPU `.program.json` fixture. */
+declare class Moc3Backend implements ModelBackend {
+    readonly format: "moc3";
+    canHandle(json: unknown): boolean;
+    createModel(settings: ModelSettings, options?: ModelBackendOptions): Promise<InternalModel>;
+    updateModel(model: InternalModel, deltaTimeSeconds: number): void;
+    getDrawables(model: InternalModel): DrawableMesh[];
+    captureFrame(model: InternalModel): FrameSnapshot | null;
+    setParameter(model: InternalModel, id: string, value: number): void;
+    setPartOpacity(model: InternalModel, id: string, value: number): void;
+    listParameters(model: InternalModel): readonly ParameterBinding[];
+    hitTest(_model: InternalModel, _x: number, _y: number): string | null;
+    destroyModel(model: InternalModel): void;
+}
+declare function createMoc3Backend(): Moc3Backend;
+
+/**
+ * moc3 keyform binding bands → multilinear blend weights.
+ *
+ * A drawable/deformer references a binding band; the band lists parameter
+ * bindings; each binding has an ordered key table. Keyforms are laid out as
+ * the cartesian product of those bindings (same structure as moc2 pivots).
+ */
+interface Moc3KeyTables {
+    readonly bindingIndex: Int32Array;
+    readonly bandBegin: Int32Array;
+    readonly bandCount: Int32Array;
+    readonly keysBegin: Int32Array;
+    readonly keysCount: Int32Array;
+    readonly keys: Float32Array;
+    /** parameterIndex → bindings owned by that parameter */
+    readonly paramBindingBegin: Int32Array;
+    readonly paramBindingCount: Int32Array;
+    readonly paramCount: number;
+}
+
+/**
+ * Parse official MOC3 bytes into typed section tables (no deform evaluation).
+ */
+interface Moc3CanvasInfo {
+    readonly pixelsPerUnit: number;
+    readonly originX: number;
+    readonly originY: number;
+    readonly canvasWidth: number;
+    readonly canvasHeight: number;
+    readonly flags: number;
+}
+interface Moc3Document {
+    readonly version: number;
+    readonly littleEndian: boolean;
+    readonly counts: Int32Array;
+    readonly canvas: Moc3CanvasInfo;
+    readonly sections: ReadonlyMap<string, unknown>;
+}
+
+/**
+ * moc3 Glue: pull paired vertices on art meshes A/B together.
+ *
+ * Layout (observed on Mao): `glue_info.position_indices` and `.weights` are
+ * interleaved pairs `(idxA, idxB)` / `(weightA, weightB)` with weightA+weightB≈1.
+ * Keyform `intensities` are Cubism "compatibility" (0..1).
+ *
+ *   target = wA·posA + wB·posB
+ *   posA'  = lerp(posA, target, intensity)
+ *   posB'  = lerp(posB, target, intensity)
+ */
+
+interface Moc3GluePair {
+    readonly indexA: number;
+    readonly indexB: number;
+    readonly weightA: number;
+    readonly weightB: number;
+}
+interface Moc3GlueDef {
+    readonly meshA: number;
+    readonly meshB: number;
+    readonly pairs: readonly Moc3GluePair[];
+    readonly band: number;
+    readonly keyformBegin: number;
+    readonly keyformCount: number;
+}
+/** Parse glue tables from a MOC3 document (empty when model has no glues). */
+declare function loadMoc3Glues(doc: Moc3Document): Moc3GlueDef[];
+/**
+ * Apply all glues in-place to world-space per-mesh position buffers
+ * (length = vertexCount * 2). Missing meshes are skipped.
+ */
+declare function applyMoc3Glues(positionsByMesh: Map<number, Float32Array>, glues: readonly Moc3GlueDef[], keyTables: Moc3KeyTables, getParamByIndex: (index: number) => number, intensities: Float32Array): void;
+/** Mean Euclidean distance between glued vertex pairs (for tests). */
+declare function meanGlueSeamDistance(positionsByMesh: ReadonlyMap<number, Float32Array>, glue: Moc3GlueDef): number;
+
+/** Shared untextured preview colors (Canvas2D / WebGL2 / WebGPU parity). */
+declare const PREVIEW_FILL: {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a: 1;
+};
+declare const PREVIEW_STROKE: {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a: 1;
+};
+/** Expand triangle indices into a line-list (each edge twice-wound). */
+declare function triangleEdgesToLineList(indices: Uint16Array): Uint16Array;
+
+/**
+ * `@doki-land/live2d-renderer`
+ *
+ * Layout:
+ * - `backends/`  — graphics only (webgpu / webgl2 / canvas2d)
+ * - `moc/`       — moc2 / moc3 decode + model runtimes (not graphics backends)
+ * - `cpu/`       — CPU evaluate + cpu-program fixture codec
+ * - `tests/`     — all vitest suites (package root)
+ */
+
+declare const LIVE2D_RENDERER_VERSION: "0.0.0";
+
+export { BlendMode, CPU_PROGRAM_KIND, Canvas2DRendererImpl, type Canvas2DRendererOptions, type ClippingContext, type ClippingDrawableRef, type ClippingPartition, type CpuProgramFile, type CreateRendererOptions, type DecodedMoc2, type DecodedMoc3, type DrawableMesh, FULL_NDC_BOUNDS, LIVE2D_RENDERER_VERSION, type LaidOutClippingContext, MASK_CHANNEL_FLAGS, type MaskAtlasMode, type MaskAtlasOptions, type MaskChannelFlag, type MaskLayoutRect, Moc2Backend, Moc3Backend, Moc3DrawableFlag, type Moc3GlueDef, type Moc3GluePair, type ModelBackend, type ModelBackendOptions, type ModelDrawPass, PREVIEW_FILL, PREVIEW_STROKE, type ParameterBinding, type Renderer, type RendererKind, type TextureData, type WebGl2Renderer, WebGl2RendererImpl, type WebGl2RendererOptions, type WebGpuRenderer, WebGpuRendererImpl, type WebGpuRendererOptions, applyMoc3Glues, applyWebGl2BlendMode, buildClippingContexts, calcClippedDrawableBounds, calcVertexBounds, canvasCompositeForBlendMode, createCanvas2DRenderer, createMoc2Backend, createMoc3Backend, createModelInstance, createQuadProgram, createRenderer, createWebGl2Renderer, createWebGpuRenderer, decodeMoc2, decodeMoc2ColorComposition, decodeMoc3, decodeMoc3DrawableFlags, detectMocBinaryFormat, evaluateFrame, expandBounds, fingerprintSnapshot, fitClippingContexts, isCanvas2DAvailable, isCpuProgramBytes, isWebGl2Available, isWebGpuAvailable, layoutMaskAtlas, layoutMaskAtlasRgba, layoutMaskAtlasUvGrid, loadMoc3Glues, maskChannelVec4, maskLayoutVec4, meanGlueSeamDistance, parseCpuProgram, partitionForClipping, selectModelBackend, serializeCpuProgram, setParameterValue, triangleEdgesToLineList, webGpuBlendState };