@basmilius/sparkle 2.1.0 → 2.2.0

package/src/waves/types.ts

@@ -6,4 +6,5 @@ export type Wave = {
     baseY: number;
     color: string;
     foamThreshold: number;
+    rgb: [number, number, number];
 };

package/src/wormhole/index.ts

@@ -1,4 +1,10 @@
-export { WormholeLayer } from './layer';
-export { WormholeSimulation } from './simulation';
-export type { WormholeSimulationConfig } from './simulation';
+import { Wormhole } from './layer';
+import type { WormholeConfig } from './layer';
+import type { Effect } from '../effect';
+
+export function createWormhole(config?: WormholeConfig): Effect<WormholeConfig> {
+    return new Wormhole(config);
+}
+
+export type { WormholeConfig };
 export type { WormholeDirection, WormholeParticle } from './types';

package/src/wormhole/layer.ts

@@ -1,21 +1,28 @@
 import { hexToRGB } from '@basmilius/utils';
-import { SimulationLayer } from '../layer';
+import { Effect } from '../effect';
 import { MULBERRY } from './consts';
-import type { WormholeSimulationConfig } from './simulation';
 import type { WormholeDirection, WormholeParticle } from './types';
 
-export class WormholeLayer extends SimulationLayer {
-    readonly #speed: number;
+export interface WormholeConfig {
+    readonly count?: number;
+    readonly speed?: number;
+    readonly color?: string;
+    readonly direction?: WormholeDirection;
+    readonly scale?: number;
+}
+
+export class Wormhole extends Effect<WormholeConfig> {
+    #speed: number;
     readonly #colorRGB: [number, number, number];
     readonly #direction: WormholeDirection;
-    readonly #scale: number;
+    #scale: number;
     #count: number;
     #particles: WormholeParticle[] = [];
     #width: number = 960;
     #height: number = 540;
     #initialized: boolean = false;
 
-    constructor(config: WormholeSimulationConfig = {}) {
+    constructor(config: WormholeConfig = {}) {
         super();
 
         let count = config.count ?? 200;
@@ -46,6 +53,15 @@ export class WormholeLayer extends SimulationLayer {
         }
     }
 
+    configure(config: Partial<WormholeConfig>): void {
+        if (config.speed !== undefined) {
+            this.#speed = config.speed;
+        }
+        if (config.scale !== undefined) {
+            this.#scale = config.scale;
+        }
+    }
+
     tick(dt: number, width: number, height: number): void {
         this.#width = width;
         this.#height = height;

package/src/aurora/simulation.ts

@@ -1,19 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { AuroraLayer } from './layer';
-
-export interface AuroraSimulationConfig {
-    readonly bands?: number;
-    readonly colors?: string[];
-    readonly speed?: number;
-    readonly intensity?: number;
-    readonly waveAmplitude?: number;
-    readonly verticalPosition?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class AuroraSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: AuroraSimulationConfig = {}) {
-        super(canvas, new AuroraLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/balloons/simulation.ts

@@ -1,19 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { BalloonLayer } from './layer';
-
-export interface BalloonSimulationConfig {
-    readonly count?: number;
-    readonly colors?: string[];
-    readonly sizeRange?: [number, number];
-    readonly speed?: number;
-    readonly driftAmount?: number;
-    readonly stringLength?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class BalloonSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: BalloonSimulationConfig = {}) {
-        super(canvas, new BalloonLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/bubbles/simulation.ts

@@ -1,20 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { BubbleLayer } from './layer';
-
-export interface BubbleSimulationConfig {
-    readonly count?: number;
-    readonly sizeRange?: [number, number];
-    readonly speed?: number;
-    readonly popOnClick?: boolean;
-    readonly popRadius?: number;
-    readonly colors?: string[];
-    readonly wobbleAmount?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class BubbleSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: BubbleSimulationConfig = {}) {
-        super(canvas, new BubbleLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/confetti/simulation.ts

@@ -1,27 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { ConfettiLayer } from './layer';
-import type { Config } from './types';
-
-export interface ConfettiSimulationConfig {
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class ConfettiSimulation extends SimulationCanvas {
-    readonly #layer: ConfettiLayer;
-
-    constructor(canvas: HTMLCanvasElement, config: ConfettiSimulationConfig = {}) {
-        const layer = new ConfettiLayer(config);
-        super(canvas, layer, 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-        this.#layer = layer;
-    }
-
-    fire(config: Partial<Config>): void {
-        this.onResize();
-        this.#layer.fire(config);
-
-        if (!this.isTicking) {
-            this.start();
-        }
-    }
-}

package/src/donuts/simulation.ts

@@ -1,25 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { DonutLayer } from './layer';
-
-export interface DonutSimulationConfig {
-    readonly background?: string;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-    readonly collisionPadding?: number;
-    readonly colors?: string[];
-    readonly count?: number;
-    readonly mouseAvoidance?: boolean;
-    readonly mouseAvoidanceRadius?: number;
-    readonly mouseAvoidanceStrength?: number;
-    readonly radiusRange?: [number, number];
-    readonly repulsionStrength?: number;
-    readonly rotationSpeedRange?: [number, number];
-    readonly scale?: number;
-    readonly speedRange?: [number, number];
-    readonly thickness?: number;
-}
-
-export class DonutSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: DonutSimulationConfig = {}) {
-        super(canvas, new DonutLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/fireflies/simulation.ts

@@ -1,18 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { FireflyLayer } from './layer';
-
-export interface FireflySimulationConfig {
-    readonly count?: number;
-    readonly color?: string;
-    readonly size?: number;
-    readonly speed?: number;
-    readonly glowSpeed?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class FireflySimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: FireflySimulationConfig = {}) {
-        super(canvas, new FireflyLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/firepit/simulation.ts

@@ -1,17 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { FirepitLayer } from './layer';
-
-export interface FirepitSimulationConfig {
-    readonly embers?: number;
-    readonly flameWidth?: number;
-    readonly flameHeight?: number;
-    readonly intensity?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class FirepitSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: FirepitSimulationConfig = {}) {
-        super(canvas, new FirepitLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/fireworks/simulation.ts

@@ -1,18 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { FireworkLayer } from './layer';
-import type { Point } from '../point';
-import type { FireworkSimulationConfig, FireworkVariant } from './types';
-
-export class FireworkSimulation extends SimulationCanvas {
-    readonly #layer: FireworkLayer;
-
-    constructor(canvas: HTMLCanvasElement, config: FireworkSimulationConfig = {}) {
-        const layer = new FireworkLayer(config);
-        super(canvas, layer, 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-        this.#layer = layer;
-    }
-
-    fireExplosion(variant: FireworkVariant, position?: Point): void {
-        this.#layer.fireExplosion(variant, position);
-    }
-}

package/src/glitter/simulation.ts

@@ -1,19 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { GlitterLayer } from './layer';
-
-export interface GlitterSimulationConfig {
-    readonly count?: number;
-    readonly colors?: string[];
-    readonly size?: number;
-    readonly speed?: number;
-    readonly groundLevel?: number;
-    readonly maxSettled?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class GlitterSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: GlitterSimulationConfig = {}) {
-        super(canvas, new GlitterLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/lanterns/simulation.ts

@@ -1,17 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { LanternLayer } from './layer';
-
-export interface LanternSimulationConfig {
-    readonly count?: number;
-    readonly colors?: string[];
-    readonly size?: number;
-    readonly speed?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class LanternSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: LanternSimulationConfig = {}) {
-        super(canvas, new LanternLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/layered.ts

@@ -1,185 +0,0 @@
-import { LimitedFrameRateCanvas } from './canvas';
-import type { EdgeFade, EdgeFadeSide, SimulationLayer } from './layer';
-
-function parseSide(side: EdgeFadeSide): [number, number] {
-    return typeof side === 'number' ? [0, side] : side;
-}
-
-
-function applyEdgeFade(ctx: CanvasRenderingContext2D, width: number, height: number, fade: EdgeFade): void {
-    ctx.globalCompositeOperation = 'destination-out';
-
-    if (fade.top !== undefined) {
-        const [near, far] = parseSide(fade.top);
-        const nearPx = near * height;
-        const farPx = far * height;
-
-        if (nearPx > 0) {
-            ctx.fillStyle = 'rgba(0,0,0,1)';
-            ctx.fillRect(0, 0, width, nearPx);
-        }
-
-        if (farPx > nearPx) {
-            const gradient = ctx.createLinearGradient(0, nearPx, 0, farPx);
-            gradient.addColorStop(0, 'rgba(0,0,0,1)');
-            gradient.addColorStop(1, 'rgba(0,0,0,0)');
-            ctx.fillStyle = gradient;
-            ctx.fillRect(0, nearPx, width, farPx - nearPx);
-        }
-    }
-
-    if (fade.bottom !== undefined) {
-        const [near, far] = parseSide(fade.bottom);
-        const nearPx = near * height;
-        const farPx = far * height;
-
-        if (nearPx > 0) {
-            ctx.fillStyle = 'rgba(0,0,0,1)';
-            ctx.fillRect(0, height - nearPx, width, nearPx);
-        }
-
-        if (farPx > nearPx) {
-            const gradient = ctx.createLinearGradient(0, height - farPx, 0, height - nearPx);
-            gradient.addColorStop(0, 'rgba(0,0,0,0)');
-            gradient.addColorStop(1, 'rgba(0,0,0,1)');
-            ctx.fillStyle = gradient;
-            ctx.fillRect(0, height - farPx, width, farPx - nearPx);
-        }
-    }
-
-    if (fade.left !== undefined) {
-        const [near, far] = parseSide(fade.left);
-        const nearPx = near * width;
-        const farPx = far * width;
-
-        if (nearPx > 0) {
-            ctx.fillStyle = 'rgba(0,0,0,1)';
-            ctx.fillRect(0, 0, nearPx, height);
-        }
-
-        if (farPx > nearPx) {
-            const gradient = ctx.createLinearGradient(nearPx, 0, farPx, 0);
-            gradient.addColorStop(0, 'rgba(0,0,0,1)');
-            gradient.addColorStop(1, 'rgba(0,0,0,0)');
-            ctx.fillStyle = gradient;
-            ctx.fillRect(nearPx, 0, farPx - nearPx, height);
-        }
-    }
-
-    if (fade.right !== undefined) {
-        const [near, far] = parseSide(fade.right);
-        const nearPx = near * width;
-        const farPx = far * width;
-
-        if (nearPx > 0) {
-            ctx.fillStyle = 'rgba(0,0,0,1)';
-            ctx.fillRect(width - nearPx, 0, nearPx, height);
-        }
-
-        if (farPx > nearPx) {
-            const gradient = ctx.createLinearGradient(width - farPx, 0, width - nearPx, 0);
-            gradient.addColorStop(0, 'rgba(0,0,0,0)');
-            gradient.addColorStop(1, 'rgba(0,0,0,1)');
-            ctx.fillStyle = gradient;
-            ctx.fillRect(width - farPx, 0, farPx - nearPx, height);
-        }
-    }
-
-    ctx.globalCompositeOperation = 'source-over';
-}
-
-export class LayeredSimulation extends LimitedFrameRateCanvas {
-    readonly #layers: SimulationLayer[] = [];
-    readonly #contextOptions: CanvasRenderingContext2DSettings;
-    #offscreen: HTMLCanvasElement | null = null;
-    #offscreenCtx: CanvasRenderingContext2D | null = null;
-
-    constructor(canvas: HTMLCanvasElement, frameRate: number = 60, options: CanvasRenderingContext2DSettings = {colorSpace: 'display-p3'}) {
-        super(canvas, frameRate, options);
-        this.#contextOptions = options;
-
-        canvas.style.position = 'absolute';
-        canvas.style.top = '0';
-        canvas.style.left = '0';
-        canvas.style.height = '100%';
-        canvas.style.width = '100%';
-    }
-
-    add(layer: SimulationLayer): this {
-        this.#layers.push(layer);
-
-        if (this.isTicking) {
-            layer.onMount(this.canvas);
-        }
-
-        return this;
-    }
-
-    start(): void {
-        for (const layer of this.#layers) {
-            layer.onMount(this.canvas);
-        }
-        super.start();
-    }
-
-    destroy(): void {
-        for (const layer of this.#layers) {
-            layer.onUnmount(this.canvas);
-        }
-        super.destroy();
-    }
-
-    draw(): void {
-        this.canvas.height = this.height;
-        this.canvas.width = this.width;
-
-        const ctx = this.context;
-        ctx.clearRect(0, 0, this.width, this.height);
-
-        for (const layer of this.#layers) {
-            if (layer.fade) {
-                const offCtx = this.#getOffscreenCtx(this.width, this.height);
-                offCtx.clearRect(0, 0, this.width, this.height);
-                layer.draw(offCtx, this.width, this.height);
-                applyEdgeFade(offCtx, this.width, this.height, layer.fade);
-                ctx.drawImage(this.#offscreen!, 0, 0);
-            } else {
-                ctx.save();
-                layer.draw(ctx, this.width, this.height);
-                ctx.restore();
-            }
-        }
-    }
-
-    tick(): void {
-        const dt = (this.delta > 0 && this.delta < 200 ? this.delta / (1000 / 60) : 1) * this.speed * LimitedFrameRateCanvas.globalSpeed;
-
-        for (const layer of this.#layers) {
-            layer.tick(dt, this.width, this.height);
-        }
-    }
-
-    onResize(): void {
-        super.onResize();
-
-        if (this.#offscreen) {
-            this.#offscreen.width = this.width;
-            this.#offscreen.height = this.height;
-        }
-
-        for (const layer of this.#layers) {
-            layer.onResize(this.width, this.height);
-        }
-    }
-
-    #getOffscreenCtx(width: number, height: number): CanvasRenderingContext2D {
-        if (!this.#offscreen) {
-            this.#offscreen = document.createElement('canvas');
-            this.#offscreen.width = width;
-            this.#offscreen.height = height;
-            this.#offscreenCtx = this.#offscreen.getContext('2d', this.#contextOptions)!;
-        }
-
-        return this.#offscreenCtx!;
-    }
-}

package/src/leaves/simulation.ts

@@ -1,18 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { LeafLayer } from './layer';
-
-export interface LeafSimulationConfig {
-    readonly count?: number;
-    readonly colors?: string[];
-    readonly size?: number;
-    readonly speed?: number;
-    readonly wind?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class LeafSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: LeafSimulationConfig = {}) {
-        super(canvas, new LeafLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/lightning/simulation.ts

@@ -1,17 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { LightningLayer } from './layer';
-
-export interface LightningSimulationConfig {
-    readonly frequency?: number;
-    readonly color?: string;
-    readonly branches?: boolean;
-    readonly flash?: boolean;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class LightningSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: LightningSimulationConfig = {}) {
-        super(canvas, new LightningLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/matrix/simulation.ts

@@ -1,18 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { MatrixLayer } from './layer';
-
-export interface MatrixSimulationConfig {
-    readonly columns?: number;
-    readonly speed?: number;
-    readonly color?: string;
-    readonly fontSize?: number;
-    readonly trailLength?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class MatrixSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: MatrixSimulationConfig = {}) {
-        super(canvas, new MatrixLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/orbits/simulation.ts

@@ -1,19 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { OrbitLayer } from './layer';
-
-export interface OrbitSimulationConfig {
-    readonly centers?: number;
-    readonly orbitersPerCenter?: number;
-    readonly speed?: number;
-    readonly colors?: string[];
-    readonly trailLength?: number;
-    readonly showCenters?: boolean;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class OrbitSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: OrbitSimulationConfig = {}) {
-        super(canvas, new OrbitLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/particles/simulation.ts

@@ -1,26 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { ParticleLayer } from './layer';
-
-export interface ParticleSimulationConfig {
-    readonly count?: number;
-    readonly color?: string;
-    readonly lineColor?: string;
-    readonly size?: [number, number];
-    readonly speed?: [number, number];
-    readonly connectionDistance?: number;
-    readonly lineWidth?: number;
-    readonly mouseMode?: import('./types').ParticleMouseMode;
-    readonly mouseRadius?: number;
-    readonly mouseStrength?: number;
-    readonly particleForces?: boolean;
-    readonly glow?: boolean;
-    readonly background?: string | null;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class ParticleSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: ParticleSimulationConfig = {}) {
-        super(canvas, new ParticleLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/petals/simulation.ts

@@ -1,18 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { PetalLayer } from './layer';
-
-export interface PetalSimulationConfig {
-    readonly count?: number;
-    readonly colors?: string[];
-    readonly size?: number;
-    readonly speed?: number;
-    readonly wind?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class PetalSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: PetalSimulationConfig = {}) {
-        super(canvas, new PetalLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/plasma/simulation.ts

@@ -1,17 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { PlasmaLayer } from './layer';
-import type { PlasmaColor } from './types';
-
-export interface PlasmaSimulationConfig {
-    readonly speed?: number;
-    readonly scale?: number;
-    readonly resolution?: number;
-    readonly palette?: PlasmaColor[];
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class PlasmaSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: PlasmaSimulationConfig = {}) {
-        super(canvas, new PlasmaLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/rain/simulation.ts

@@ -1,21 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { RainLayer } from './layer';
-import type { RainVariant } from './types';
-
-export interface RainSimulationConfig {
-    readonly variant?: RainVariant;
-    readonly drops?: number;
-    readonly wind?: number;
-    readonly speed?: number;
-    readonly splashes?: boolean;
-    readonly color?: string;
-    readonly groundLevel?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class RainSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: RainSimulationConfig = {}) {
-        super(canvas, new RainLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/sandstorm/simulation.ts

@@ -1,18 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { SandstormLayer } from './layer';
-
-export interface SandstormSimulationConfig {
-    readonly count?: number;
-    readonly wind?: number;
-    readonly turbulence?: number;
-    readonly color?: string;
-    readonly hazeOpacity?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class SandstormSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: SandstormSimulationConfig = {}) {
-        super(canvas, new SandstormLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/snow/simulation.ts

@@ -1,17 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { SnowLayer } from './layer';
-
-export interface SnowSimulationConfig {
-    readonly fillStyle?: string;
-    readonly particles?: number;
-    readonly scale?: number;
-    readonly size?: number;
-    readonly speed?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class SnowSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: SnowSimulationConfig = {}) {
-        super(canvas, new SnowLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}