@vectojs/core 0.1.0 → 0.2.1

package/dist/index-C3Fd_XmG.d.ts

@@ -1,365 +0,0 @@
-import { I as IRenderer, E as Entity } from './Entity-D-rfAFCf.js';
-
-declare class CanvasRenderer implements IRenderer {
-    private ctx;
-    private width;
-    private height;
-    /**
-     * Max circles per batched `fill()`. A single Canvas 2D `fill()` over a path is
-     * superlinear in sub-path count, so an unbounded batch is *slower* than many
-     * small fills at high entity counts. Capping bounds each fill's path
-     * complexity while still amortizing per-draw overhead. Tuned via the benchmark.
-     */
-    static readonly MAX_BATCH = 64;
-    private batchActive;
-    private batchColor;
-    private batchAlpha;
-    private batchCount;
-    constructor(canvas: HTMLCanvasElement);
-    /**
-     * Expose the underlying `CanvasRenderingContext2D` for operations not
-     * covered by the {@link IRenderer} interface.
-     *
-     * @returns The raw 2D rendering context.
-     */
-    getContext(): CanvasRenderingContext2D;
-    /**
-     * Resize the backing canvas buffer and re-apply DPR scaling.
-     *
-     * Called automatically by {@link Scene} on `window.resize` events.
-     *
-     * @param width - New logical width in CSS pixels.
-     * @param height - New logical height in CSS pixels.
-     */
-    resize(width: number, height: number): void;
-    /** @inheritdoc */
-    clear(): void;
-    /** @inheritdoc */
-    save(): void;
-    /** @inheritdoc */
-    restore(): void;
-    /** @inheritdoc */
-    translate(x: number, y: number): void;
-    /** @inheritdoc */
-    scale(x: number, y: number): void;
-    /** @inheritdoc */
-    rotate(angle: number): void;
-    /** @inheritdoc */
-    setGlobalAlpha(alpha: number): void;
-    /** @inheritdoc */
-    clip(x: number, y: number, width: number, height: number): void;
-    /** @inheritdoc */
-    beginPath(): void;
-    /** @inheritdoc */
-    moveTo(x: number, y: number): void;
-    /** @inheritdoc */
-    lineTo(x: number, y: number): void;
-    /** @inheritdoc */
-    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
-    /** @inheritdoc */
-    closePath(): void;
-    /** @inheritdoc */
-    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
-    /** @inheritdoc */
-    roundRect(x: number, y: number, width: number, height: number, radii: number | number[]): void;
-    /** @inheritdoc */
-    drawImage(source: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
-    /** @inheritdoc */
-    fillCircle(cx: number, cy: number, radius: number, color: string, alpha?: number): void;
-    /** @inheritdoc */
-    flush(): void;
-    /** @inheritdoc */
-    fill(color: string | any): void;
-    /** @inheritdoc */
-    stroke(color: string | any, lineWidth?: number): void;
-    /** @inheritdoc */
-    fillText(text: string, x: number, y: number, font: string, color: string | any): void;
-    /** @inheritdoc */
-    createLinearGradient(x0: number, y0: number, x1: number, y1: number, colorStops: {
-        stop: number;
-        color: string;
-    }[]): any;
-}
-
-interface SVGLinearGradient {
-    type: 'linear';
-    id?: string;
-    x0: number;
-    y0: number;
-    x1: number;
-    y1: number;
-    colorStops: {
-        stop: number;
-        color: string;
-    }[];
-    createMatrix: number[];
-}
-declare class SVGRenderer implements IRenderer {
-    private width;
-    private height;
-    private buffer;
-    private defsBuffer;
-    private currentPath;
-    private mStack;
-    private ma;
-    private mb;
-    private mc;
-    private md;
-    private me;
-    private mf;
-    private alphaStack;
-    private globalAlpha;
-    private clipDepthStack;
-    private clipDepth;
-    private clipCounter;
-    private batchCircles;
-    private batchMatrix;
-    private batchColor;
-    private batchAlpha;
-    private batchActive;
-    private gradientCounter;
-    private gradientCache;
-    constructor(width: number, height: number);
-    clear(): void;
-    save(): void;
-    restore(): void;
-    translate(dx: number, dy: number): void;
-    scale(sx: number, sy: number): void;
-    rotate(angle: number): void;
-    setGlobalAlpha(alpha: number): void;
-    beginPath(): void;
-    moveTo(x: number, y: number): void;
-    lineTo(x: number, y: number): void;
-    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
-    closePath(): void;
-    arc(x: number, y: number, r: number, startAngle: number, endAngle: number, ccw?: boolean): void;
-    roundRect(x: number, y: number, w: number, h: number, radii: number | number[]): void;
-    fill(colorOrGradient: string | SVGLinearGradient): void;
-    stroke(colorOrGradient: string | SVGLinearGradient, lineWidth?: number): void;
-    fillText(text: string, x: number, y: number, font: string, color: string | SVGLinearGradient): void;
-    fillCircle(cx: number, cy: number, radius: number, color: string, alpha?: number): void;
-    drawImage(source: any, dx: number, dy: number, dw: number, dh: number): void;
-    flush(): void;
-    createLinearGradient(x0: number, y0: number, x1: number, y1: number, colorStops: {
-        stop: number;
-        color: string;
-    }[]): SVGLinearGradient;
-    clip(x: number, y: number, width: number, height: number): void;
-    toXMLString(): string;
-    private resolveGradient;
-    private escapeXML;
-}
-
-/**
- * A GPU-accelerated layer that draws large sets of circles and rectangles in a
- * couple of draw calls. Used by {@link Scene} (via `pointBackend: 'webgl'`) to
- * render `getBatchCircle()` / `getBatchRect()` entities — the point-cloud /
- * particle case where Canvas2D tops out at ~7 fps for 100k primitives.
- */
-interface PointRenderer {
-    /** Resize the backing buffer + GL viewport to a logical `w × h` (DPR applied). */
-    resize(width: number, height: number): void;
-    /** Begin a frame: reset the accumulated primitive buffers. */
-    begin(): void;
-    /** Add one circle in world (CSS-pixel) coordinates; `alpha` multiplies the color's. */
-    addCircle(x: number, y: number, radius: number, color: string, alpha?: number): void;
-    /**
-     * Add one rectangle: top-left at world `(x, y)`, `width × height` in world units,
-     * rotated `rotation` radians about `(x, y)`; `alpha` multiplies the color's.
-     */
-    addRect(x: number, y: number, width: number, height: number, color: string, alpha?: number, rotation?: number): void;
-    /**
-     * Upload a texture atlas used by {@link addSprite}. Pass any `TexImageSource`
-     * (HTMLImageElement, HTMLCanvasElement, ImageBitmap, …). Call once (or whenever
-     * the atlas changes) before adding sprites.
-     */
-    setTexture(source: TexImageSource): void;
-    /**
-     * Add one textured sprite sampling the atlas region `[u0,v0]–[u1,v1]` (UVs in
-     * `0..1`): top-left at world `(x, y)`, `width × height` in world units, rotated
-     * `rotation` radians about `(x, y)`. `color` multiplies the sampled texel
-     * (white = unchanged; use it to tint white glyphs); `alpha` multiplies further.
-     * No-op until a texture is set via {@link setTexture}.
-     */
-    addSprite(x: number, y: number, width: number, height: number, u0: number, v0: number, u1: number, v1: number, color?: string, alpha?: number, rotation?: number): void;
-    /**
-     * Upload an MSDF (multi-channel signed distance field) glyph atlas used by
-     * {@link addGlyph}, kept separate from the {@link setTexture} atlas so both can
-     * be active. `distanceRange` is the field's pixel range (the atlas JSON's
-     * `atlas.distanceRange`) — it drives the shader's edge sharpness. Pair with
-     * `MSDFFont.layout` to position the glyphs.
-     */
-    setMSDFTexture(source: TexImageSource, distanceRange: number): void;
-    /**
-     * Add one MSDF glyph quad sampling `[u0,v0]–[u1,v1]` (UVs in `0..1`): top-left
-     * at world `(x, y)`, `width × height` in world units. The fragment shader
-     * reconstructs a crisp, resolution-independent edge from the distance field, so
-     * glyphs stay sharp at any scale. `color` tints the glyph (default white);
-     * `alpha` multiplies coverage. No-op until {@link setMSDFTexture} is called.
-     */
-    addGlyph(x: number, y: number, width: number, height: number, u0: number, v0: number, u1: number, v1: number, color?: string, alpha?: number, rotation?: number): void;
-    /** Clear the layer and draw all accumulated primitives. */
-    flush(): void;
-    /** Release GL resources. */
-    destroy(): void;
-}
-/**
- * Create a WebGL2-backed {@link PointRenderer} on `canvas`, or `null` when WebGL2
- * (or shader compilation) is unavailable — callers fall back to Canvas2D.
- *
- * @param canvas - A dedicated canvas (WebGL2 context); should be stacked over the
- *   scene's 2D canvas.
- * @returns A point renderer, or `null` if WebGL2 isn't supported.
- */
-declare function createWebGLPointRenderer(canvas: HTMLCanvasElement): PointRenderer | null;
-
-/**
- * Options for configuring a {@link ComputeParticleEntity}.
- */
-interface ComputeParticleOptions {
-    /** Maximum number of particles to simulate. Defaults to 10000. */
-    maxParticles?: number;
-    /** Spring stiffness coefficient for returning to origin. Defaults to 0.05. */
-    springK?: number;
-    /** Velocity damping factor in `[0, 1]`. Defaults to 0.95. */
-    damping?: number;
-    /** Bounce damping factor for boundary collisions in `[0, 1]`. Defaults to 0.5. */
-    bounceDamping?: number;
-    /** Speed limit for particles. Defaults to 500.0. */
-    maxVelocity?: number;
-    /** Base particle size in pixels. Defaults to 4. */
-    size?: number;
-    /** CSS color string for the particles. Defaults to '#00f0ff'. */
-    color?: string;
-    /** Whether the particle layer captures pointer/hit events. Defaults to false. */
-    pointerEvents?: boolean;
-}
-declare const PARTICLE_STRIDE_FLOATS = 8;
-declare const PARTICLE_OFFSET_POSITION_X = 0;
-declare const PARTICLE_OFFSET_POSITION_Y = 1;
-declare const PARTICLE_OFFSET_VELOCITY_X = 2;
-declare const PARTICLE_OFFSET_VELOCITY_Y = 3;
-declare const PARTICLE_OFFSET_ORIGIN_X = 4;
-declare const PARTICLE_OFFSET_ORIGIN_Y = 5;
-declare const PARTICLE_OFFSET_SIZE = 6;
-declare const PARTICLE_OFFSET_LIFE = 7;
-/**
- * An entity representing a high-performance WebGPU/CPU particle simulation layer.
- */
-declare class ComputeParticleEntity extends Entity {
-    maxParticles: number;
-    springK: number;
-    damping: number;
-    bounceDamping: number;
-    maxVelocity: number;
-    size: number;
-    baseColor: string;
-    pointerEvents: boolean;
-    /** Flat array containing layout of all particles: position, velocity, origin, size, life. */
-    particleData: Float32Array;
-    /** Flag indicating whether the particle coordinates need to be initialized. */
-    needsInit: boolean;
-    /** Active explosion impulse to apply in the next simulation step. */
-    pendingExplosion: {
-        x: number;
-        y: number;
-        force: number;
-    } | null;
-    /** WebGPU storage buffer containing particle states. */
-    gpuStorageBuffer: any;
-    /** WebGPU uniform buffer containing simulation parameters. */
-    gpuUniformBuffer: any;
-    /** WebGPU bind group for the compute shader pass. */
-    computeBindGroup: any;
-    /** WebGPU bind group for the render pass (usually same as compute). */
-    renderBindGroup: any;
-    constructor(options?: ComputeParticleOptions);
-    /**
-     * Disperses all particles randomly across the specified screen bounds.
-     * Sets initial positions, velocities, origins, and sizes.
-     *
-     * @param width - Simulation zone width.
-     * @param height - Simulation zone height.
-     */
-    initRandomParticles(width: number, height: number): void;
-    /**
-     * Sets the origins (ox, oy) for a subset or all particles.
-     * Also sets position to origin if requestPositionReset is true.
-     *
-     * @param points - Flat Float32Array containing [x0, y0, x1, y1, ...]
-     * @param requestPositionReset - Whether to set current positions to the new origins. Defaults to true.
-     */
-    setOrigins(points: Float32Array | number[], requestPositionReset?: boolean): void;
-    /**
-     * Sets the current positions (x, y) for a subset or all particles.
-     *
-     * @param positions - Flat Float32Array containing [x0, y0, x1, y1, ...]
-     */
-    setPositions(positions: Float32Array | number[]): void;
-    /**
-     * Sets the current velocities (vx, vy) for a subset or all particles.
-     *
-     * @param velocities - Flat Float32Array containing [vx0, vy0, vx1, vy1, ...]
-     */
-    setVelocities(velocities: Float32Array | number[]): void;
-    /**
-     * Triggers an explosion force center.
-     *
-     * @param x - Explosion center x-coordinate.
-     * @param y - Explosion center y-coordinate.
-     * @param force - Magnitude force scalar.
-     */
-    triggerExplosion(x: number, y: number, force: number): void;
-    isPointInside(_x: number, _y: number): boolean;
-    render(_r: IRenderer): void;
-    /**
-     * Updates particle simulation on the CPU.
-     * Handles spring forces, mouse repulsion, explosion impulses, velocity capping, and bounds bouncing/clamping.
-     *
-     * @param dt - Delta time in seconds.
-     * @param mouseX - Mouse x-coordinate, or a value below -9000 if inactive.
-     * @param mouseY - Mouse y-coordinate, or a value below -9000 if inactive.
-     * @param width - Boundary width.
-     * @param height - Boundary height.
-     */
-    updateCPU(dt: number, mouseX: number, mouseY: number, width: number, height: number): void;
-    destroy(): void;
-    /**
-     * Frees all GPU resources allocated for WebGPU simulation.
-     */
-    destroyGPUResources(): void;
-}
-
-declare class WebGPUParticleSystemManager {
-    private device;
-    private computePipeline;
-    private renderPipeline;
-    private computeBindGroupLayout;
-    private renderBindGroupLayout;
-    constructor(device: GPUDevice);
-    initPipelines(format: GPUTextureFormat): void;
-    setupEntityResources(entity: ComputeParticleEntity): void;
-    recordComputePass(pass: GPUComputePassEncoder, entity: ComputeParticleEntity, dt: number, mouseX: number, mouseY: number, width: number, height: number): void;
-    recordRenderPass(pass: GPURenderPassEncoder, entity: ComputeParticleEntity): void;
-    destroy(): void;
-}
-
-/**
- * Parsed color as normalized `[r, g, b, a]` floats in `[0, 1]`.
- */
-type RGBA = [number, number, number, number];
-/**
- * Parse a CSS color string into normalized `[r, g, b, a]` floats.
- *
- * Fast paths handle `#rgb`/`#rgba`/`#rrggbb`/`#rrggbbaa` and `rgb()`/`rgba()`;
- * other forms (named colors, `hsl()`, …) resolve via a cached 1×1 canvas when a
- * DOM is available. Results are cached per input string and shared by identity,
- * so callers must treat the returned array as read-only. Unparseable input with
- * no DOM yields opaque black `[0, 0, 0, 1]`.
- *
- * @param css - A CSS color string, e.g. `'#38bdf8'` or `'rgba(0,0,0,.5)'`.
- * @returns The cached `[r, g, b, a]` tuple in `[0, 1]`.
- */
-declare function parseColorToRGBA(css: string): RGBA;
-
-export { CanvasRenderer as C, PARTICLE_OFFSET_LIFE as P, type RGBA as R, type SVGLinearGradient as S, WebGPUParticleSystemManager as W, ComputeParticleEntity as a, type ComputeParticleOptions as b, PARTICLE_OFFSET_ORIGIN_X as c, PARTICLE_OFFSET_ORIGIN_Y as d, PARTICLE_OFFSET_POSITION_X as e, PARTICLE_OFFSET_POSITION_Y as f, PARTICLE_OFFSET_SIZE as g, PARTICLE_OFFSET_VELOCITY_X as h, PARTICLE_OFFSET_VELOCITY_Y as i, PARTICLE_STRIDE_FLOATS as j, type PointRenderer as k, SVGRenderer as l, createWebGLPointRenderer as m, parseColorToRGBA as p };