@basmilius/sparkle 2.0.0 → 2.1.0

package/src/shooting-stars/system.ts

@@ -0,0 +1,149 @@
+import type { ShootingStar } from './types';
+
+export interface ShootingStarSystemConfig {
+    readonly interval: [number, number];
+    readonly color?: [number, number, number];
+    readonly trailLength?: number;
+    readonly trailAlphaFactor?: number;
+    readonly speed?: number;
+    readonly scale?: number;
+    readonly alphaMin?: number;
+    readonly alphaRange?: number;
+    readonly decayMin?: number;
+    readonly decayRange?: number;
+    readonly verticalFade?: [number, number];
+}
+
+export class ShootingStarSystem {
+    readonly #interval: [number, number];
+    readonly #color: [number, number, number];
+    readonly #trailLength: number;
+    readonly #trailAlphaFactor: number;
+    readonly #speed: number;
+    readonly #scale: number;
+    readonly #alphaMin: number;
+    readonly #alphaRange: number;
+    readonly #decayMin: number;
+    readonly #decayRange: number;
+    readonly #verticalFade: [number, number] | null;
+    readonly #rng: () => number;
+    #cooldown: number;
+    #height: number = 0;
+    #stars: ShootingStar[] = [];
+
+    constructor(config: ShootingStarSystemConfig, rng: () => number) {
+        this.#interval = config.interval;
+        this.#color = config.color ?? [200, 230, 255];
+        this.#trailLength = config.trailLength ?? 18;
+        this.#trailAlphaFactor = config.trailAlphaFactor ?? 0.5;
+        this.#speed = config.speed ?? 1;
+        this.#scale = config.scale ?? 1;
+        this.#alphaMin = config.alphaMin ?? 0.7;
+        this.#alphaRange = config.alphaRange ?? 0.3;
+        this.#decayMin = config.decayMin ?? 0.008;
+        this.#decayRange = config.decayRange ?? 0.01;
+        this.#verticalFade = config.verticalFade ?? null;
+        this.#rng = rng;
+        this.#cooldown = this.#interval[0] + this.#rng() * (this.#interval[1] - this.#interval[0]);
+    }
+
+    tick(dt: number, width: number, height: number): void {
+        this.#height = height;
+        this.#cooldown -= dt;
+
+        if (this.#cooldown <= 0) {
+            this.#stars.push(this.#create(width, height));
+            this.#cooldown = this.#interval[0] + this.#rng() * (this.#interval[1] - this.#interval[0]);
+        }
+
+        let alive = 0;
+
+        for (let i = 0; i < this.#stars.length; i++) {
+            const star = this.#stars[i];
+
+            star.trail.push({x: star.x, y: star.y});
+
+            if (star.trail.length > this.#trailLength) {
+                star.trail.shift();
+            }
+
+            star.x += star.vx * this.#speed * dt;
+            star.y += star.vy * this.#speed * dt;
+            star.alpha -= star.decay * dt;
+
+            const inBounds = star.alpha > 0 && star.x > -50 && star.x < width + 50 && star.y < height + 50;
+            const fullyFaded = this.#verticalFade !== null && star.y / height >= this.#verticalFade[1];
+
+            if (inBounds && !fullyFaded) {
+                this.#stars[alive++] = star;
+            }
+        }
+
+        this.#stars.length = alive;
+    }
+
+    draw(ctx: CanvasRenderingContext2D): void {
+        const [cr, cg, cb] = this.#color;
+
+        ctx.globalCompositeOperation = 'lighter';
+
+        for (const star of this.#stars) {
+            let fadeFactor = 1;
+
+            if (this.#verticalFade && this.#height > 0) {
+                const [fadeStart, fadeEnd] = this.#verticalFade;
+                fadeFactor = 1 - Math.max(0, Math.min(1, (star.y / this.#height - fadeStart) / (fadeEnd - fadeStart)));
+            }
+
+            for (let t = 0; t < star.trail.length; t++) {
+                const progress = t / star.trail.length;
+                const trailAlpha = star.alpha * progress * this.#trailAlphaFactor * fadeFactor;
+                const trailSize = star.size * progress * this.#scale;
+
+                if (trailAlpha < 0.01) {
+                    continue;
+                }
+
+                ctx.globalAlpha = trailAlpha;
+                ctx.beginPath();
+                ctx.arc(star.trail[t].x, star.trail[t].y, trailSize, 0, Math.PI * 2);
+                ctx.fillStyle = `rgb(${cr}, ${cg}, ${cb})`;
+                ctx.fill();
+            }
+
+            const alpha = star.alpha * fadeFactor;
+            const headSize = star.size * 2 * this.#scale;
+            const glow = ctx.createRadialGradient(star.x, star.y, 0, star.x, star.y, headSize);
+            glow.addColorStop(0, `rgba(${cr}, ${cg}, ${cb}, ${alpha})`);
+            glow.addColorStop(0.5, `rgba(${cr}, ${cg}, ${cb}, ${alpha * 0.3})`);
+            glow.addColorStop(1, `rgba(${cr}, ${cg}, ${cb}, 0)`);
+
+            ctx.globalAlpha = 1;
+            ctx.beginPath();
+            ctx.arc(star.x, star.y, headSize, 0, Math.PI * 2);
+            ctx.fillStyle = glow;
+            ctx.fill();
+        }
+
+        ctx.globalCompositeOperation = 'source-over';
+        ctx.globalAlpha = 1;
+    }
+
+    #create(width: number, height: number): ShootingStar {
+        const startX = this.#rng() * width * 0.8;
+        const startY = this.#rng() * height * 0.4;
+        const angle = 0.3 + this.#rng() * 0.5;
+        const speed = 8 + this.#rng() * 12;
+
+        return {
+            x: startX,
+            y: startY,
+            vx: Math.cos(angle) * speed * this.#scale,
+            vy: Math.sin(angle) * speed * this.#scale,
+            alpha: this.#alphaMin + this.#rng() * this.#alphaRange,
+            size: 1.5 + this.#rng() * 2,
+            decay: this.#decayMin + this.#rng() * this.#decayRange,
+            trail: []
+        };
+    }
+}

package/src/shooting-stars/types.ts

@@ -0,0 +1,10 @@
+export type ShootingStar = {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    alpha: number;
+    size: number;
+    decay: number;
+    trail: {x: number; y: number}[];
+};

package/src/simulation-canvas.ts

@@ -0,0 +1,47 @@
+import { LimitedFrameRateCanvas } from './canvas';
+import type { SimulationLayer } from './layer';
+
+export class SimulationCanvas extends LimitedFrameRateCanvas {
+    readonly #simulation: SimulationLayer;
+
+    constructor(canvas: HTMLCanvasElement, simulation: SimulationLayer, frameRate: number = 60, options: CanvasRenderingContext2DSettings = {colorSpace: 'display-p3'}) {
+        super(canvas, frameRate, options);
+        this.#simulation = simulation;
+
+        canvas.style.position = 'absolute';
+        canvas.style.top = '0';
+        canvas.style.left = '0';
+        canvas.style.height = '100%';
+        canvas.style.width = '100%';
+    }
+
+    start(): void {
+        this.#simulation.onMount(this.canvas);
+        super.start();
+    }
+
+    destroy(): void {
+        this.#simulation.onUnmount(this.canvas);
+        super.destroy();
+    }
+
+    draw(): void {
+        this.canvas.height = this.height;
+        this.canvas.width = this.width;
+
+        const ctx = this.context;
+        ctx.save();
+        this.#simulation.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;
+        this.#simulation.tick(dt, this.width, this.height);
+    }
+
+    onResize(): void {
+        super.onResize();
+        this.#simulation.onResize(this.width, this.height);
+    }
+}

package/src/snow/consts.ts

@@ -1,3 +1,3 @@
-import { mulberry32 } from '@basmilius/utils';
+import { type Mulberry32, mulberry32 } from '@basmilius/utils';
 
-export const MULBERRY = mulberry32(13);
+export const MULBERRY: Mulberry32 = mulberry32(13);

package/src/snow/index.ts

@@ -1,2 +1,3 @@
+export { SnowLayer } from './layer';
 export { SnowSimulation } from './simulation';
 export type { SnowSimulationConfig } from './simulation';

package/src/snow/layer.ts

@@ -0,0 +1,263 @@
+import { parseColor } from '../color';
+import { SimulationLayer } from '../layer';
+import { MULBERRY } from './consts';
+import type { SnowSimulationConfig } from './simulation';
+import type { Snowflake } from './snowflake';
+
+const SPRITE_SIZE = 64;
+const SPRITE_CENTER = SPRITE_SIZE / 2;
+const SPRITE_RADIUS = SPRITE_SIZE / 2;
+
+export class SnowLayer extends SimulationLayer {
+    readonly #scale: number;
+    readonly #size: number;
+    readonly #speed: number;
+    readonly #baseOpacity: number;
+    #maxParticles: number;
+    #time: number = 0;
+    #ratio: number = 1;
+    #snowflakes: Snowflake[] = [];
+    #sprites: HTMLCanvasElement[] = [];
+    #height: number = 540;
+
+    constructor(config: SnowSimulationConfig = {}) {
+        super();
+
+        this.#scale = config.scale ?? 1;
+        this.#maxParticles = config.particles ?? 200;
+        this.#size = (config.size ?? 9) * this.#scale;
+        this.#speed = config.speed ?? 2;
+
+        const {r, g, b, a} = parseColor(config.fillStyle ?? 'rgb(255 255 255 / .75)');
+        this.#baseOpacity = a;
+
+        if (innerWidth < 991) {
+            this.#maxParticles = Math.floor(this.#maxParticles / 2);
+        }
+
+        this.#sprites = this.#createSprites(r, g, b);
+
+        for (let i = 0; i < this.#maxParticles; ++i) {
+            this.#snowflakes.push(this.#createSnowflake(true));
+        }
+    }
+
+    onResize(_width: number, height: number): void {
+        this.#height = height;
+    }
+
+    tick(dt: number, _width: number, height: number): void {
+        this.#height = height;
+
+        const speedFactor = height / (420 * this.#ratio) / this.#speed;
+
+        this.#time += 0.015 * speedFactor * dt;
+
+        const wind = Math.sin(this.#time * 0.7) * 0.5
+                   + Math.sin(this.#time * 1.9 + 3) * 0.25
+                   + Math.sin(this.#time * 4.3 + 1) * 0.1;
+
+        for (let index = 0; index < this.#snowflakes.length; index++) {
+            const snowflake = this.#snowflakes[index];
+
+            const swing = Math.sin(this.#time * snowflake.swingFrequency + snowflake.swingOffset) * snowflake.swingAmplitude;
+
+            snowflake.x += (swing + wind * snowflake.depth * 2) * dt / (4000 * speedFactor);
+            snowflake.y += (snowflake.fallSpeed * 2 + snowflake.depth + snowflake.radius * 0.15) * dt / (700 * speedFactor);
+
+            snowflake.rotation += snowflake.rotationSpeed * dt / speedFactor;
+
+            if (snowflake.x > 1.15 || snowflake.x < -0.15 || snowflake.y > 1.05) {
+                const recycled = this.#createSnowflake(false);
+
+                if (index % 3 > 0) {
+                    recycled.x = MULBERRY.next();
+                    recycled.y = -0.05 - MULBERRY.next() * 0.15;
+                } else if (wind > 0.2) {
+                    recycled.x = -0.15;
+                    recycled.y = MULBERRY.next() * 0.8;
+                } else if (wind < -0.2) {
+                    recycled.x = 1.15;
+                    recycled.y = MULBERRY.next() * 0.8;
+                } else {
+                    recycled.x = MULBERRY.next();
+                    recycled.y = -0.05 - MULBERRY.next() * 0.15;
+                }
+
+                this.#snowflakes[index] = recycled;
+            }
+        }
+    }
+
+    draw(ctx: CanvasRenderingContext2D, width: number, height: number): void {
+
+        for (const snowflake of this.#snowflakes) {
+            const px = snowflake.x * width;
+            const py = snowflake.y * height;
+            const displayRadius = snowflake.radius * snowflake.depth * this.#ratio;
+            const displaySize = displayRadius * 2;
+
+            if (displaySize < 0.5) {
+                continue;
+            }
+
+            ctx.globalAlpha = this.#baseOpacity * (0.15 + snowflake.depth * 0.85);
+
+            if (snowflake.spriteIndex === 3) {
+                ctx.save();
+                ctx.translate(px, py);
+                ctx.rotate(snowflake.rotation);
+                ctx.drawImage(
+                    this.#sprites[snowflake.spriteIndex],
+                    -displayRadius,
+                    -displayRadius,
+                    displaySize,
+                    displaySize
+                );
+                ctx.restore();
+            } else {
+                ctx.drawImage(
+                    this.#sprites[snowflake.spriteIndex],
+                    px - displayRadius,
+                    py - displayRadius,
+                    displaySize,
+                    displaySize
+                );
+            }
+        }
+
+        ctx.globalAlpha = 1;
+    }
+
+    #createSprites(r: number, g: number, b: number): HTMLCanvasElement[] {
+        const sprites: HTMLCanvasElement[] = [];
+
+        const gradientProfiles: [number, number][][] = [
+            [[0, 0.8], [0.3, 0.4], [0.7, 0.1], [1, 0]],
+            [[0, 1], [0.15, 0.7], [0.5, 0.2], [1, 0]],
+            [[0, 0.9], [0.25, 0.5], [0.5, 0.1], [1, 0]]
+        ];
+
+        for (const profile of gradientProfiles) {
+            const canvas = document.createElement('canvas');
+            canvas.width = SPRITE_SIZE;
+            canvas.height = SPRITE_SIZE;
+            const ctx = canvas.getContext('2d')!;
+
+            const gradient = ctx.createRadialGradient(
+                SPRITE_CENTER, SPRITE_CENTER, 0,
+                SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS
+            );
+
+            for (const [stop, alpha] of profile) {
+                gradient.addColorStop(stop, `rgba(${r}, ${g}, ${b}, ${alpha})`);
+            }
+
+            ctx.fillStyle = gradient;
+            ctx.beginPath();
+            ctx.arc(SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS, 0, Math.PI * 2);
+            ctx.fill();
+
+            sprites.push(canvas);
+        }
+
+        sprites.push(this.#createCrystalSprite(r, g, b));
+
+        return sprites;
+    }
+
+    #createCrystalSprite(r: number, g: number, b: number): HTMLCanvasElement {
+        const canvas = document.createElement('canvas');
+        canvas.width = SPRITE_SIZE;
+        canvas.height = SPRITE_SIZE;
+        const ctx = canvas.getContext('2d')!;
+
+        const glow = ctx.createRadialGradient(
+            SPRITE_CENTER, SPRITE_CENTER, 0,
+            SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS
+        );
+        glow.addColorStop(0, `rgba(${r}, ${g}, ${b}, 0.6)`);
+        glow.addColorStop(0.25, `rgba(${r}, ${g}, ${b}, 0.25)`);
+        glow.addColorStop(0.6, `rgba(${r}, ${g}, ${b}, 0.05)`);
+        glow.addColorStop(1, `rgba(${r}, ${g}, ${b}, 0)`);
+        ctx.fillStyle = glow;
+        ctx.beginPath();
+        ctx.arc(SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS, 0, Math.PI * 2);
+        ctx.fill();
+
+        ctx.strokeStyle = `rgba(${r}, ${g}, ${b}, 0.7)`;
+        ctx.lineWidth = 1.5;
+        ctx.lineCap = 'round';
+
+        const armLength = SPRITE_RADIUS * 0.75;
+
+        for (let arm = 0; arm < 6; arm++) {
+            const angle = (arm / 6) * Math.PI * 2 - Math.PI / 2;
+            const tipX = SPRITE_CENTER + Math.cos(angle) * armLength;
+            const tipY = SPRITE_CENTER + Math.sin(angle) * armLength;
+
+            ctx.beginPath();
+            ctx.moveTo(SPRITE_CENTER, SPRITE_CENTER);
+            ctx.lineTo(tipX, tipY);
+            ctx.stroke();
+
+            for (const position of [0.4, 0.65]) {
+                const branchX = SPRITE_CENTER + Math.cos(angle) * armLength * position;
+                const branchY = SPRITE_CENTER + Math.sin(angle) * armLength * position;
+                const branchLength = armLength * (0.4 - position * 0.3);
+
+                for (const side of [-1, 1]) {
+                    const branchAngle = angle + side * Math.PI / 3;
+                    ctx.beginPath();
+                    ctx.moveTo(branchX, branchY);
+                    ctx.lineTo(
+                        branchX + Math.cos(branchAngle) * branchLength,
+                        branchY + Math.sin(branchAngle) * branchLength
+                    );
+                    ctx.stroke();
+                }
+            }
+        }
+
+        const centerGlow = ctx.createRadialGradient(
+            SPRITE_CENTER, SPRITE_CENTER, 0,
+            SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS * 0.12
+        );
+        centerGlow.addColorStop(0, `rgba(${r}, ${g}, ${b}, 0.9)`);
+        centerGlow.addColorStop(1, `rgba(${r}, ${g}, ${b}, 0)`);
+        ctx.fillStyle = centerGlow;
+        ctx.beginPath();
+        ctx.arc(SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS * 0.12, 0, Math.PI * 2);
+        ctx.fill();
+
+        return canvas;
+    }
+
+    #createSnowflake(initialSpread: boolean): Snowflake {
+        const depth = 0.3 + MULBERRY.next() * 0.7;
+        const radius = MULBERRY.next() * this.#size + 2 * this.#scale;
+
+        let spriteIndex: number;
+        if (depth > 0.85 && radius > this.#size * 0.6 && MULBERRY.next() > 0.65) {
+            spriteIndex = 3;
+        } else if (depth < 0.45) {
+            spriteIndex = 2;
+        } else {
+            spriteIndex = MULBERRY.next() > 0.5 ? 0 : 1;
+        }
+
+        return {
+            x: MULBERRY.next(),
+            y: initialSpread ? MULBERRY.next() * 2 - 1 : -0.05 - MULBERRY.next() * 0.15,
+            depth,
+            radius,
+            rotation: MULBERRY.next() * Math.PI * 2,
+            rotationSpeed: (MULBERRY.next() - 0.5) * 0.03,
+            swingAmplitude: 0.3 + MULBERRY.next() * 0.7,
+            swingFrequency: 0.5 + MULBERRY.next() * 1.5,
+            swingOffset: MULBERRY.next() * Math.PI * 2,
+            fallSpeed: 0.5 + MULBERRY.next() * 0.5,
+            spriteIndex
+        };
+    }
+}