@opentui/three 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 opentui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/SpriteResourceManager.d.ts

@@ -0,0 +1,74 @@
+import * as THREE from "three";
+import type { Scene } from "three";
+export interface ResourceConfig {
+    imagePath: string;
+    sheetNumFrames: number;
+}
+export interface SheetProperties {
+    imagePath: string;
+    sheetTilesetWidth: number;
+    sheetTilesetHeight: number;
+    sheetNumFrames: number;
+}
+export interface InstanceManagerOptions {
+    maxInstances: number;
+    renderOrder?: number;
+    depthWrite?: boolean;
+    name?: string;
+    frustumCulled?: boolean;
+    matrix?: THREE.Matrix4;
+}
+export interface MeshPoolOptions {
+    geometry: () => THREE.BufferGeometry;
+    material: THREE.Material;
+    maxInstances: number;
+    name?: string;
+}
+export declare class MeshPool {
+    private pools;
+    acquireMesh(poolId: string, options: MeshPoolOptions): THREE.InstancedMesh;
+    releaseMesh(poolId: string, mesh: THREE.InstancedMesh): void;
+    fill(poolId: string, options: MeshPoolOptions, count: number): void;
+    clearPool(poolId: string): void;
+    clearAllPools(): void;
+}
+export declare class InstanceManager {
+    private scene;
+    private instancedMesh;
+    private material;
+    private maxInstances;
+    private _freeIndices;
+    private instanceCount;
+    private _matrix;
+    constructor(scene: Scene, geometry: THREE.BufferGeometry, material: THREE.Material, options: InstanceManagerOptions);
+    acquireInstanceSlot(): number;
+    releaseInstanceSlot(instanceIndex: number): void;
+    getInstanceCount(): number;
+    getMaxInstances(): number;
+    get hasFreeIndices(): boolean;
+    get mesh(): THREE.InstancedMesh;
+    dispose(): void;
+}
+export declare class SpriteResource {
+    private _texture;
+    private _sheetProperties;
+    private scene;
+    private _meshPool;
+    constructor(texture: THREE.DataTexture, sheetProperties: SheetProperties, scene: Scene);
+    get texture(): THREE.DataTexture;
+    get sheetProperties(): SheetProperties;
+    get meshPool(): MeshPool;
+    createInstanceManager(geometry: THREE.BufferGeometry, material: THREE.Material, options: InstanceManagerOptions): InstanceManager;
+    get uvTileSize(): THREE.Vector2;
+    dispose(): void;
+}
+export declare class SpriteResourceManager {
+    private resources;
+    private textureCache;
+    private scene;
+    constructor(scene: Scene);
+    private getResourceKey;
+    getOrCreateResource(texture: THREE.DataTexture, sheetProps: SheetProperties): Promise<SpriteResource>;
+    createResource(config: ResourceConfig): Promise<SpriteResource>;
+    clearCache(): void;
+}

package/SpriteUtils.d.ts

@@ -0,0 +1,13 @@
+import { Sprite, SpriteMaterial, type SpriteMaterialParameters } from "three";
+export declare class SheetSprite extends Sprite {
+    private _frameIndex;
+    private _numFrames;
+    constructor(material: SpriteMaterial, numFrames: number);
+    setIndex: (index: number) => void;
+}
+export declare class SpriteUtils {
+    static fromFile(path: string, { materialParameters, }?: {
+        materialParameters?: Omit<SpriteMaterialParameters, "map">;
+    }): Promise<Sprite>;
+    static sheetFromFile(path: string, numFrames: number): Promise<SheetSprite>;
+}

package/TextureUtils.d.ts

@@ -0,0 +1,24 @@
+import { Color, Texture, DataTexture } from "three";
+export declare class TextureUtils {
+    /**
+     * Loads a texture from a file path using sharp.
+     * Returns a THREE.Texture with ImageData attached to its .image property.
+     */
+    static loadTextureFromFile(path: string): Promise<DataTexture | null>;
+    /**
+     * Alias for loadTextureFromFile for convenience.
+     */
+    static fromFile(path: string): Promise<DataTexture | null>;
+    /**
+     * Creates a THREE.Texture with a checkerboard pattern.
+     */
+    static createCheckerboard(size?: number, color1?: Color, color2?: Color, checkSize?: number): Texture;
+    /**
+     * Creates a THREE.Texture with a gradient pattern.
+     */
+    static createGradient(size?: number, startColor?: Color, endColor?: Color, direction?: "horizontal" | "vertical" | "radial"): Texture;
+    /**
+     * Creates a THREE.Texture with a procedural noise pattern.
+     */
+    static createNoise(size?: number, scale?: number, octaves?: number, color1?: Color, color2?: Color): Texture;
+}

package/ThreeRenderable.d.ts

@@ -0,0 +1,38 @@
+import { OrthographicCamera, PerspectiveCamera, Scene } from "three";
+import { Renderable, type OptimizedBuffer, type RenderableOptions, type RenderContext } from "@opentui/core";
+import { ThreeCliRenderer, type ThreeCliRendererOptions } from "./WGPURenderer.js";
+export interface ThreeRenderableOptions extends RenderableOptions<ThreeRenderable> {
+    scene?: Scene | null;
+    camera?: PerspectiveCamera | OrthographicCamera;
+    renderer?: Omit<ThreeCliRendererOptions, "width" | "height" | "autoResize">;
+    autoAspect?: boolean;
+}
+export declare class ThreeRenderable extends Renderable {
+    private engine;
+    private scene;
+    private autoAspect;
+    private initPromise;
+    private initFailed;
+    private drawInFlight;
+    private frameCallback;
+    private frameCallbackRegistered;
+    private cliRenderer;
+    private clearColor;
+    constructor(ctx: RenderContext, options: ThreeRenderableOptions);
+    get aspectRatio(): number;
+    get renderer(): ThreeCliRenderer;
+    getScene(): Scene | null;
+    setScene(scene: Scene | null): void;
+    getActiveCamera(): PerspectiveCamera | OrthographicCamera;
+    setActiveCamera(camera: PerspectiveCamera | OrthographicCamera): void;
+    setAutoAspect(autoAspect: boolean): void;
+    protected onResize(width: number, height: number): void;
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    protected destroySelf(): void;
+    private registerFrameCallback;
+    private renderToBuffer;
+    private ensureInitialized;
+    private updateCameraAspect;
+    private getAspectRatio;
+    private getRenderSize;
+}

package/WGPURenderer.d.ts

@@ -0,0 +1,59 @@
+import { PerspectiveCamera, OrthographicCamera, Scene } from "three";
+import { RGBA, type CliRenderer, type OptimizedBuffer } from "@opentui/core";
+import { SuperSampleAlgorithm } from "./canvas.js";
+export declare enum SuperSampleType {
+    NONE = "none",
+    GPU = "gpu",
+    CPU = "cpu"
+}
+export interface ThreeCliRendererOptions {
+    width: number;
+    height: number;
+    focalLength?: number;
+    backgroundColor?: RGBA;
+    superSample?: SuperSampleType;
+    alpha?: boolean;
+    autoResize?: boolean;
+    libPath?: string;
+}
+export declare class ThreeCliRenderer {
+    private readonly cliRenderer;
+    private outputWidth;
+    private outputHeight;
+    private renderWidth;
+    private renderHeight;
+    private superSample;
+    private backgroundColor;
+    private alpha;
+    private threeRenderer?;
+    private canvas?;
+    private device;
+    private activeCamera;
+    private _aspectRatio;
+    private doRenderStats;
+    private resizeHandler;
+    private debugToggleHandler;
+    private destroyHandler;
+    private renderTimeMs;
+    private readbackTimeMs;
+    private totalDrawTimeMs;
+    private renderMethod;
+    get aspectRatio(): number;
+    constructor(cliRenderer: CliRenderer, options: ThreeCliRendererOptions);
+    toggleDebugStats(): void;
+    init(): Promise<void>;
+    getSuperSampleAlgorithm(): SuperSampleAlgorithm;
+    setSuperSampleAlgorithm(superSampleAlgorithm: SuperSampleAlgorithm): void;
+    saveToFile(filePath: string): Promise<void>;
+    setActiveCamera(camera: PerspectiveCamera | OrthographicCamera): void;
+    getActiveCamera(): PerspectiveCamera | OrthographicCamera;
+    setBackgroundColor(color: RGBA): void;
+    setSize(width: number, height: number, forceUpdate?: boolean): void;
+    drawScene(root: Scene, buffer: OptimizedBuffer, deltaTime: number): Promise<void>;
+    private rendering;
+    private destroyed;
+    doDrawScene(root: Scene, camera: PerspectiveCamera | OrthographicCamera, buffer: OptimizedBuffer, deltaTime: number): Promise<void>;
+    toggleSuperSampling(): void;
+    renderStats(buffer: OptimizedBuffer): void;
+    destroy(): void;
+}

package/animation/ExplodingSpriteEffect.d.ts

@@ -0,0 +1,71 @@
+import * as THREE from "three";
+import { NodeMaterial } from "three/webgpu";
+import type { TiledSprite, SpriteDefinition, SpriteAnimator } from "./SpriteAnimator.js";
+import type { SpriteResource } from "../SpriteResourceManager.js";
+export interface ExplosionEffectParameters {
+    numRows: number;
+    numCols: number;
+    durationMs: number;
+    strength: number;
+    strengthVariation: number;
+    gravity: number;
+    gravityScale: number;
+    fadeOut: boolean;
+    angularVelocityMin: THREE.Vector3;
+    angularVelocityMax: THREE.Vector3;
+    initialVelocityYBoost: number;
+    zVariationStrength: number;
+    materialFactory: () => NodeMaterial;
+}
+export declare const DEFAULT_EXPLOSION_PARAMETERS: ExplosionEffectParameters;
+export interface ExplosionCreationData {
+    resource: SpriteResource;
+    frameUvOffset: THREE.Vector2;
+    frameUvSize: THREE.Vector2;
+    spriteWorldTransform: THREE.Matrix4;
+}
+export interface SpriteRecreationData {
+    definition: SpriteDefinition;
+    currentTransform: {
+        position: THREE.Vector3;
+        quaternion: THREE.Quaternion;
+        scale: THREE.Vector3;
+    };
+}
+export interface ExplosionHandle {
+    readonly effect: ExplodingSpriteEffect;
+    readonly recreationData: SpriteRecreationData;
+    hasBeenRestored: boolean;
+    restoreSprite: (spriteAnimator: SpriteAnimator) => Promise<TiledSprite | null>;
+}
+export declare class ExplodingSpriteEffect {
+    private static baseMaterialCache;
+    private scene;
+    private resource;
+    private frameUvOffset;
+    private frameUvSize;
+    private spriteWorldTransform;
+    private params;
+    private instancedMesh;
+    private material;
+    private numParticles;
+    private uniformRefs;
+    isActive: boolean;
+    private timeElapsedMs;
+    constructor(scene: THREE.Scene, resource: SpriteResource, frameUvOffset: THREE.Vector2, frameUvSize: THREE.Vector2, spriteWorldTransform: THREE.Matrix4, userParams?: Partial<ExplosionEffectParameters>);
+    private _createGPUParticles;
+    private _createGPUMaterial;
+    static _buildTemplateMaterial(texture: THREE.DataTexture, params: ExplosionEffectParameters, materialFactory: () => NodeMaterial): NodeMaterial;
+    update(deltaTimeMs: number): void;
+    dispose(): void;
+}
+export declare class ExplosionManager {
+    private scene;
+    private activeExplosions;
+    constructor(scene: THREE.Scene);
+    fillPool(resource: SpriteResource, count: number, params?: Partial<ExplosionEffectParameters>): void;
+    private _createEffectCreationData;
+    createExplosionForSprite(spriteToExplode: TiledSprite, userParams?: Partial<ExplosionEffectParameters>): ExplosionHandle | null;
+    update(deltaTimeMs: number): void;
+    disposeAll(): void;
+}

package/animation/PhysicsExplodingSpriteEffect.d.ts

@@ -0,0 +1,76 @@
+import * as THREE from "three";
+import { NodeMaterial } from "three/webgpu";
+import type { TiledSprite, SpriteDefinition, SpriteAnimator } from "./SpriteAnimator.js";
+import type { PhysicsWorld } from "../physics/physics-interface.js";
+import type { SpriteResource } from "../SpriteResourceManager.js";
+export interface PhysicsExplosionEffectParameters {
+    numRows: number;
+    numCols: number;
+    durationMs: number;
+    explosionForce: number;
+    forceVariation: number;
+    torqueStrength: number;
+    gravityScale: number;
+    fadeOut: boolean;
+    linearDamping: number;
+    angularDamping: number;
+    restitution: number;
+    friction: number;
+    density: number;
+    materialFactory: () => NodeMaterial;
+}
+export declare const DEFAULT_PHYSICS_EXPLOSION_PARAMETERS: PhysicsExplosionEffectParameters;
+export interface PhysicsExplosionCreationData {
+    resource: SpriteResource;
+    frameUvOffset: THREE.Vector2;
+    frameUvSize: THREE.Vector2;
+    spriteWorldTransform: THREE.Matrix4;
+}
+export interface PhysicsSpriteRecreationData {
+    definition: SpriteDefinition;
+    currentTransform: {
+        position: THREE.Vector3;
+        quaternion: THREE.Quaternion;
+        scale: THREE.Vector3;
+    };
+}
+export interface PhysicsExplosionHandle {
+    readonly effect: PhysicsExplodingSpriteEffect;
+    readonly recreationData: PhysicsSpriteRecreationData;
+    hasBeenRestored: boolean;
+    restoreSprite: (spriteAnimator: SpriteAnimator) => Promise<TiledSprite | null>;
+}
+export declare class PhysicsExplodingSpriteEffect {
+    private static materialCache;
+    private scene;
+    private physicsWorld;
+    private resource;
+    private frameUvOffset;
+    private frameUvSize;
+    private spriteWorldTransform;
+    private params;
+    private particles;
+    private numParticles;
+    private instancedMesh;
+    private material;
+    private uvOffsetAttribute;
+    isActive: boolean;
+    private timeElapsedMs;
+    private particleIdCounter;
+    constructor(scene: THREE.Scene, physicsWorld: PhysicsWorld, resource: SpriteResource, frameUvOffset: THREE.Vector2, frameUvSize: THREE.Vector2, spriteWorldTransform: THREE.Matrix4, userParams?: Partial<PhysicsExplosionEffectParameters>);
+    private _createPhysicsParticles;
+    static getSharedMaterial(texture: THREE.DataTexture, materialFactory: () => NodeMaterial): NodeMaterial;
+    update(deltaTimeMs: number): void;
+    dispose(): void;
+}
+export declare class PhysicsExplosionManager {
+    private scene;
+    private physicsWorld;
+    private activeExplosions;
+    constructor(scene: THREE.Scene, physicsWorld: PhysicsWorld);
+    fillPool(resource: SpriteResource, count: number, params?: Partial<PhysicsExplosionEffectParameters>): void;
+    private _createEffectCreationData;
+    createExplosionForSprite(spriteToExplode: TiledSprite, userParams?: Partial<PhysicsExplosionEffectParameters>): Promise<PhysicsExplosionHandle | null>;
+    update(deltaTimeMs: number): void;
+    disposeAll(): void;
+}

package/animation/SpriteAnimator.d.ts

@@ -0,0 +1,124 @@
+import * as THREE from "three";
+import { NodeMaterial } from "three/webgpu";
+import type { Scene } from "three";
+import { type SpriteResource, InstanceManager } from "../SpriteResourceManager.js";
+export interface AnimationStateConfig {
+    imagePath: string;
+    sheetNumFrames: number;
+    animNumFrames: number;
+    animFrameOffset: number;
+    frameDuration?: number;
+    loop?: boolean;
+    initialFrame?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+}
+export type ResolvedAnimationState = Required<AnimationStateConfig> & {
+    sheetTilesetWidth: number;
+    sheetTilesetHeight: number;
+    texture: THREE.DataTexture;
+};
+export interface AnimationDefinition {
+    resource: SpriteResource;
+    animNumFrames?: number;
+    animFrameOffset?: number;
+    frameDuration?: number;
+    loop?: boolean;
+    initialFrame?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+}
+export interface SpriteDefinition {
+    id?: string;
+    renderOrder?: number;
+    depthWrite?: boolean;
+    maxInstances?: number;
+    scale?: number;
+    initialAnimation: string;
+    animations: Record<string, AnimationDefinition>;
+}
+declare class Animation {
+    readonly name: string;
+    state: ResolvedAnimationState;
+    private resource;
+    instanceIndex: number;
+    private instanceManager;
+    private frameAttribute;
+    private flipAttribute;
+    currentLocalFrame: number;
+    timeAccumulator: number;
+    isPlaying: boolean;
+    private _isActive;
+    constructor(name: string, state: ResolvedAnimationState, resource: SpriteResource, instanceIndex: number, instanceManager: InstanceManager, frameAttribute: THREE.InstancedBufferAttribute, flipAttribute: THREE.InstancedBufferAttribute);
+    activate(worldTransform: THREE.Matrix4): void;
+    deactivate(): void;
+    updateVisuals(worldTransform: THREE.Matrix4): void;
+    updateTime(deltaTimeMs: number): boolean;
+    play(): void;
+    stop(): void;
+    goToFrame(localFrame: number): void;
+    setFrameDuration(newFrameDuration: number): void;
+    getResource(): SpriteResource;
+    releaseInstanceSlot(): void;
+}
+export declare class TiledSprite {
+    readonly id: string;
+    private animator;
+    private _animations;
+    private _currentAnimation;
+    private _transformObject;
+    private _reusableMatrix;
+    private _reusableAnimGeomScale;
+    private _isVisibleState;
+    private originalDefinition;
+    constructor(id: string, userSpriteDefinition: SpriteDefinition, animator: SpriteAnimator, animationInstanceParams: Array<{
+        name: string;
+        state: ResolvedAnimationState;
+        resource: SpriteResource;
+        index: number;
+        instanceManager: InstanceManager;
+        frameAttribute: THREE.InstancedBufferAttribute;
+        flipAttribute: THREE.InstancedBufferAttribute;
+    }>);
+    private _calculateAnimationWorldMatrix;
+    get currentAnimation(): Animation;
+    private updateCurrentAnimationVisuals;
+    setPosition(position: THREE.Vector3): void;
+    setRotation(rotation: THREE.Quaternion): void;
+    setScale(scale: THREE.Vector3): void;
+    getScale(): THREE.Vector3;
+    setTransform(position: THREE.Vector3, rotation: THREE.Quaternion, newScale: THREE.Vector3): void;
+    play(): void;
+    stop(): void;
+    goToFrame(frame: number): void;
+    setFrameDuration(newFrameDuration: number): void;
+    isPlaying(): boolean;
+    setAnimation(animationName: string): Promise<void>;
+    update(deltaTime: number): void;
+    destroy(): void;
+    getCurrentAnimationName(): string;
+    getWorldTransform(): THREE.Matrix4;
+    getWorldPlaneSize(): THREE.Vector2;
+    get visible(): boolean;
+    set visible(value: boolean);
+    get definition(): SpriteDefinition;
+    get currentTransform(): {
+        position: THREE.Vector3;
+        quaternion: THREE.Quaternion;
+        scale: THREE.Vector3;
+    };
+}
+export declare class SpriteAnimator {
+    private scene;
+    private instances;
+    private _idCounter;
+    private instanceManagers;
+    constructor(scene: Scene);
+    private createSpriteAnimationMaterial;
+    private getOrCreateInstanceManager;
+    createSprite(userSpriteDefinition: SpriteDefinition, materialFactory?: () => NodeMaterial): Promise<TiledSprite>;
+    update(deltaTime: number): void;
+    removeSprite(id: string): void;
+    removeAllSprites(): void;
+}
+export {};

package/animation/SpriteParticleGenerator.d.ts

@@ -0,0 +1,62 @@
+import * as THREE from "three";
+import { NodeMaterial } from "three/webgpu";
+import type { SpriteResource } from "../SpriteResourceManager.js";
+export interface ParticleEffectParameters {
+    resource: SpriteResource;
+    animNumFrames?: number;
+    animFrameOffset?: number;
+    frameDuration?: number;
+    loop?: boolean;
+    scale?: number;
+    renderOrder?: number;
+    depthWrite?: boolean;
+    maxParticles: number;
+    lifetimeMsMin: number;
+    lifetimeMsMax: number;
+    origins: THREE.Vector3[];
+    spawnRadius: number | THREE.Vector3;
+    initialVelocityMin: THREE.Vector3;
+    initialVelocityMax: THREE.Vector3;
+    angularVelocityMin: THREE.Vector3;
+    angularVelocityMax: THREE.Vector3;
+    gravity?: THREE.Vector3;
+    randomGravityFactorMinMax?: THREE.Vector2;
+    scaleOverLifeMinMax?: THREE.Vector2;
+    fadeOut?: boolean;
+    materialFactory?: () => NodeMaterial;
+}
+export declare class SpriteParticleGenerator {
+    private scene;
+    private baseConfig;
+    private autoSpawnConfig;
+    private _currentOriginIndex;
+    private instanceManager;
+    private material;
+    private texture;
+    private particleDataAttribute;
+    private velocityAttribute;
+    private angularVelAttribute;
+    private scaleDataAttribute;
+    private timeUniform;
+    private gravityUniform;
+    private animationUniform;
+    private sheetNumFramesUniform;
+    private particleSlots;
+    private currentTime;
+    private maxParticles;
+    private isInitialized;
+    constructor(scene: THREE.Scene, initialBaseConfig: ParticleEffectParameters);
+    private _ensureInitialized;
+    private _initializeGPUParticleSystem;
+    private _createGPUMaterial;
+    private _resolveCurrentOrigin;
+    getActiveParticleCount(): number;
+    private _resolveSpawnRadius;
+    private _spawnParticle;
+    spawnParticles(count: number, overrides?: Partial<ParticleEffectParameters>): Promise<void>;
+    setAutoSpawn(ratePerSecond: number, autoSpawnParamOverrides?: Partial<ParticleEffectParameters>): void;
+    hasAutoSpawn(): boolean;
+    stopAutoSpawn(): void;
+    update(deltaTimeMs: number): Promise<void>;
+    dispose(): void;
+}

package/canvas.d.ts

@@ -0,0 +1,44 @@
+import { GPUCanvasContextMock } from "bun-webgpu";
+import { type OptimizedBuffer } from "@opentui/core";
+import { SuperSampleType } from "./WGPURenderer.js";
+export declare enum SuperSampleAlgorithm {
+    STANDARD = 0,
+    PRE_SQUEEZED = 1
+}
+export declare class CLICanvas {
+    private device;
+    private readbackBuffer;
+    private width;
+    private height;
+    private gpuCanvasContext;
+    superSampleDrawTimeMs: number;
+    mapAsyncTimeMs: number;
+    superSample: SuperSampleType;
+    private computePipeline;
+    private computeBindGroupLayout;
+    private computeOutputBuffer;
+    private computeParamsBuffer;
+    private computeReadbackBuffer;
+    private updateScheduled;
+    private screenshotGPUBuffer;
+    private superSampleAlgorithm;
+    private destroyed;
+    constructor(device: GPUDevice, width: number, height: number, superSample: SuperSampleType, sampleAlgo?: SuperSampleAlgorithm);
+    destroy(): void;
+    setSuperSampleAlgorithm(superSampleAlgorithm: SuperSampleAlgorithm): void;
+    getSuperSampleAlgorithm(): SuperSampleAlgorithm;
+    getContext(type: string, attrs?: WebGLContextAttributes): GPUCanvasContextMock;
+    setSize(width: number, height: number): void;
+    addEventListener(event: string, listener: any, options?: any): void;
+    removeEventListener(event: string, listener: any, options?: any): void;
+    dispatchEvent(event: Event): void;
+    setSuperSample(superSample: SuperSampleType): void;
+    saveToFile(filePath: string): Promise<void>;
+    private initComputePipeline;
+    private updateComputeParams;
+    private scheduleUpdateComputeBuffers;
+    private updateComputeBuffers;
+    private runComputeShaderSuperSampling;
+    private updateReadbackBuffer;
+    readPixelsIntoBuffer(buffer: OptimizedBuffer): Promise<void>;
+}

package/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./WGPURenderer.js";
+export * from "./ThreeRenderable.js";
+export * from "./TextureUtils.js";
+export * from "./canvas.js";
+export * from "./SpriteUtils.js";
+export * from "./SpriteResourceManager.js";
+export * from "./animation/SpriteAnimator.js";
+export * from "./animation/ExplodingSpriteEffect.js";
+export * from "./animation/SpriteParticleGenerator.js";
+export * from "./animation/PhysicsExplodingSpriteEffect.js";
+export * from "./physics/RapierPhysicsAdapter.js";
+export * from "./physics/PlanckPhysicsAdapter.js";
+export * as THREE from "three";