@autumnsgrove/gossamer 0.1.0 → 0.2.0

package/dist/patterns.js

@@ -0,0 +1,539 @@
+/**
+ * Gossamer Pattern Generators
+ *
+ * Provides noise and pattern generation functions for ambient ASCII effects.
+ * Includes Perlin noise, wave patterns, and static noise.
+ */
+/**
+ * Default pattern configuration
+ */
+export const DEFAULT_PATTERN_CONFIG = {
+    frequency: 0.05,
+    amplitude: 1.0,
+    speed: 0.5,
+};
+// Permutation table for Perlin noise
+const PERMUTATION = new Uint8Array(512);
+const P = new Uint8Array([
+    151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142,
+    8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203,
+    117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165,
+    71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92,
+    41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208,
+    89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217,
+    226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58,
+    17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155,
+    167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218,
+    246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249,
+    14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4,
+    150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156,
+    180,
+]);
+// Initialize permutation table
+for (let i = 0; i < 256; i++) {
+    PERMUTATION[i] = P[i];
+    PERMUTATION[i + 256] = P[i];
+}
+/**
+ * Fade function for smooth interpolation (6t^5 - 15t^4 + 10t^3)
+ */
+function fade(t) {
+    return t * t * t * (t * (t * 6 - 15) + 10);
+}
+/**
+ * Linear interpolation
+ */
+function lerp(a, b, t) {
+    return a + t * (b - a);
+}
+/**
+ * Gradient function for Perlin noise
+ */
+function grad(hash, x, y) {
+    const h = hash & 3;
+    const u = h < 2 ? x : y;
+    const v = h < 2 ? y : x;
+    return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v);
+}
+/**
+ * 2D Perlin noise function
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @returns Noise value between -1 and 1
+ */
+export function perlinNoise2D(x, y) {
+    // Find unit square containing point
+    const xi = Math.floor(x) & 255;
+    const yi = Math.floor(y) & 255;
+    // Find relative position in square
+    const xf = x - Math.floor(x);
+    const yf = y - Math.floor(y);
+    // Fade curves
+    const u = fade(xf);
+    const v = fade(yf);
+    // Hash coordinates of square corners
+    const aa = PERMUTATION[PERMUTATION[xi] + yi];
+    const ab = PERMUTATION[PERMUTATION[xi] + yi + 1];
+    const ba = PERMUTATION[PERMUTATION[xi + 1] + yi];
+    const bb = PERMUTATION[PERMUTATION[xi + 1] + yi + 1];
+    // Blend results from 4 corners
+    const x1 = lerp(grad(aa, xf, yf), grad(ba, xf - 1, yf), u);
+    const x2 = lerp(grad(ab, xf, yf - 1), grad(bb, xf - 1, yf - 1), u);
+    return lerp(x1, x2, v);
+}
+/**
+ * Fractal Brownian Motion (fBm) using Perlin noise
+ * Creates more organic-looking noise by layering multiple octaves
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param octaves - Number of noise layers (default: 4)
+ * @param persistence - Amplitude decay per octave (default: 0.5)
+ * @returns Noise value between -1 and 1
+ */
+export function fbmNoise(x, y, octaves = 4, persistence = 0.5) {
+    let total = 0;
+    let frequency = 1;
+    let amplitude = 1;
+    let maxValue = 0;
+    for (let i = 0; i < octaves; i++) {
+        total += perlinNoise2D(x * frequency, y * frequency) * amplitude;
+        maxValue += amplitude;
+        amplitude *= persistence;
+        frequency *= 2;
+    }
+    return total / maxValue;
+}
+/**
+ * Wave pattern generator
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param time - Time value for animation
+ * @param config - Pattern configuration
+ * @returns Value between -1 and 1
+ */
+export function wavePattern(x, y, time, config = DEFAULT_PATTERN_CONFIG) {
+    const { frequency, amplitude, speed } = config;
+    const wave1 = Math.sin(x * frequency + time * speed);
+    const wave2 = Math.cos(y * frequency + time * speed * 0.7);
+    const wave3 = Math.sin((x + y) * frequency * 0.5 + time * speed * 0.5);
+    return ((wave1 + wave2 + wave3) / 3) * amplitude;
+}
+/**
+ * Ripple pattern (concentric waves from center)
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param centerX - Ripple center X
+ * @param centerY - Ripple center Y
+ * @param time - Time value for animation
+ * @param config - Pattern configuration
+ * @returns Value between -1 and 1
+ */
+export function ripplePattern(x, y, centerX, centerY, time, config = DEFAULT_PATTERN_CONFIG) {
+    const { frequency, amplitude, speed } = config;
+    const dx = x - centerX;
+    const dy = y - centerY;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    return Math.sin(distance * frequency - time * speed) * amplitude;
+}
+/**
+ * Static noise generator (random values)
+ *
+ * @param seed - Optional seed for reproducible noise
+ * @returns Value between 0 and 1
+ */
+export function staticNoise(seed) {
+    if (seed !== undefined) {
+        // Simple seeded random using sine
+        const x = Math.sin(seed * 12.9898) * 43758.5453;
+        return x - Math.floor(x);
+    }
+    return Math.random();
+}
+/**
+ * Seeded 2D noise for reproducible patterns
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param seed - Seed value
+ * @returns Value between 0 and 1
+ */
+export function seededNoise2D(x, y, seed = 0) {
+    const n = Math.sin(x * 12.9898 + y * 78.233 + seed) * 43758.5453;
+    return n - Math.floor(n);
+}
+/**
+ * Clouds pattern - soft, billowy fbm with gentle movement
+ * The signature Gossamer effect!
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param time - Time value for animation
+ * @param config - Pattern configuration
+ * @returns Value between -1 and 1
+ */
+export function cloudsPattern(x, y, time, config = DEFAULT_PATTERN_CONFIG) {
+    const { frequency, amplitude, speed } = config;
+    // Slow, drifting movement
+    const drift = time * speed * 0.02;
+    const nx = x * frequency * 0.5 + drift;
+    const ny = y * frequency * 0.5 + drift * 0.7;
+    // Layer multiple octaves with high persistence for soft, puffy look
+    const base = fbmNoise(nx, ny, 5, 0.6);
+    // Add subtle secondary drift layer
+    const detail = fbmNoise(nx * 2 + drift * 0.5, ny * 2 - drift * 0.3, 3, 0.5) * 0.3;
+    // Combine and bias toward lighter values (more sky, less dense cloud)
+    const combined = base + detail;
+    return Math.tanh(combined * 1.5) * amplitude;
+}
+/**
+ * Plasma pattern - classic demoscene effect
+ * Combines sine waves at different frequencies and phases
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param time - Time value for animation
+ * @param config - Pattern configuration
+ * @returns Value between -1 and 1
+ */
+export function plasmaPattern(x, y, time, config = DEFAULT_PATTERN_CONFIG) {
+    const { frequency, amplitude, speed } = config;
+    const t = time * speed;
+    // Classic plasma: sum of sines at different scales and rotations
+    const v1 = Math.sin(x * frequency + t);
+    const v2 = Math.sin(y * frequency + t * 0.7);
+    const v3 = Math.sin((x + y) * frequency * 0.5 + t * 0.5);
+    const v4 = Math.sin(Math.sqrt(x * x + y * y) * frequency * 0.3 + t * 0.8);
+    // Add some swirl
+    const cx = x - 40;
+    const cy = y - 20;
+    const v5 = Math.sin(Math.atan2(cy, cx) * 3 + t * 0.4);
+    return ((v1 + v2 + v3 + v4 + v5) / 5) * amplitude;
+}
+/**
+ * Vortex pattern - swirling spiral around center
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param centerX - Vortex center X
+ * @param centerY - Vortex center Y
+ * @param time - Time value for animation
+ * @param config - Pattern configuration
+ * @returns Value between -1 and 1
+ */
+export function vortexPattern(x, y, centerX, centerY, time, config = DEFAULT_PATTERN_CONFIG) {
+    const { frequency, amplitude, speed } = config;
+    const dx = x - centerX;
+    const dy = y - centerY;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const angle = Math.atan2(dy, dx);
+    // Spiral: angle + distance creates the swirl
+    const spiral = angle + distance * frequency * 0.1 - time * speed;
+    // Add some turbulence based on distance
+    const turbulence = perlinNoise2D(distance * 0.1, time * speed * 0.5) * 0.3;
+    return (Math.sin(spiral * 3) + turbulence) * amplitude;
+}
+/**
+ * Matrix pattern - falling columns like digital rain
+ *
+ * @param x - X coordinate (column)
+ * @param y - Y coordinate (row)
+ * @param time - Time value for animation
+ * @param config - Pattern configuration
+ * @returns Value between -1 and 1
+ */
+export function matrixPattern(x, y, time, config = DEFAULT_PATTERN_CONFIG) {
+    const { frequency, amplitude, speed } = config;
+    // Each column has its own speed and phase based on x position
+    const columnSeed = seededNoise2D(x, 0, 42);
+    const columnSpeed = 0.5 + columnSeed * 1.5;
+    const columnPhase = columnSeed * 100;
+    // Calculate falling position
+    const fallPosition = (y * frequency + time * speed * columnSpeed + columnPhase) % 20;
+    // Create "head" of the rain drop (brightest) with trailing fade
+    const headBrightness = fallPosition < 1 ? 1 : 0;
+    const trailLength = 8;
+    const trailBrightness = fallPosition < trailLength ? Math.pow(1 - fallPosition / trailLength, 2) : 0;
+    // Add some randomness for flickering effect
+    const flicker = seededNoise2D(x, Math.floor(time * 10), y) * 0.2;
+    const value = Math.max(headBrightness, trailBrightness) + flicker;
+    return (value * 2 - 1) * amplitude;
+}
+/**
+ * Gradient pattern - smooth animated gradients
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param cols - Total columns (for normalization)
+ * @param rows - Total rows (for normalization)
+ * @param time - Time value for animation
+ * @param config - Pattern configuration
+ * @returns Value between -1 and 1
+ */
+export function gradientPattern(x, y, cols, rows, time, config = DEFAULT_PATTERN_CONFIG) {
+    const { frequency, amplitude, speed } = config;
+    // Normalize coordinates to 0-1
+    const nx = x / cols;
+    const ny = y / rows;
+    // Animated angle for gradient direction
+    const angle = time * speed * 0.2;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    // Rotate the gradient
+    const rotated = nx * cos + ny * sin;
+    // Add some wave distortion
+    const distortion = Math.sin(ny * Math.PI * 2 * frequency + time * speed) * 0.1;
+    const value = (rotated + distortion) * 2 - 1;
+    return Math.sin(value * Math.PI) * amplitude;
+}
+/**
+ * Diamond pattern - interference creating diamond shapes
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param time - Time value for animation
+ * @param config - Pattern configuration
+ * @returns Value between -1 and 1
+ */
+export function diamondPattern(x, y, time, config = DEFAULT_PATTERN_CONFIG) {
+    const { frequency, amplitude, speed } = config;
+    const t = time * speed;
+    // Diamond pattern using absolute value (Manhattan distance creates diamonds)
+    const wave1 = Math.sin((Math.abs(x - 40) + Math.abs(y - 20)) * frequency + t);
+    const wave2 = Math.sin((Math.abs(x - 40) - Math.abs(y - 20)) * frequency * 0.7 - t * 0.8);
+    // Add some rotation over time
+    const angle = t * 0.1;
+    const rx = x * Math.cos(angle) - y * Math.sin(angle);
+    const ry = x * Math.sin(angle) + y * Math.cos(angle);
+    const wave3 = Math.sin((Math.abs(rx) + Math.abs(ry)) * frequency * 0.5 + t * 0.5);
+    return ((wave1 + wave2 + wave3) / 3) * amplitude;
+}
+/**
+ * Fractal pattern - animated Mandelbrot/Julia set
+ *
+ * @param x - X coordinate
+ * @param y - Y coordinate
+ * @param cols - Total columns (for centering)
+ * @param rows - Total rows (for centering)
+ * @param time - Time value for animation
+ * @param config - Pattern configuration
+ * @returns Value between -1 and 1
+ */
+export function fractalPattern(x, y, cols, rows, time, config = DEFAULT_PATTERN_CONFIG) {
+    const { frequency, amplitude, speed } = config;
+    // Map to complex plane, centered and scaled
+    const scale = 3.5 * frequency;
+    const zx = ((x / cols) * scale - scale / 2) + Math.sin(time * speed * 0.1) * 0.2;
+    const zy = ((y / rows) * scale - scale / 2) + Math.cos(time * speed * 0.1) * 0.2;
+    // Julia set with animated c parameter
+    const cx = -0.7 + Math.sin(time * speed * 0.05) * 0.1;
+    const cy = 0.27 + Math.cos(time * speed * 0.07) * 0.1;
+    let zrx = zx;
+    let zry = zy;
+    const maxIter = 20;
+    let iter = 0;
+    // Iterate z = z² + c
+    while (zrx * zrx + zry * zry < 4 && iter < maxIter) {
+        const tmp = zrx * zrx - zry * zry + cx;
+        zry = 2 * zrx * zry + cy;
+        zrx = tmp;
+        iter++;
+    }
+    // Smooth coloring
+    if (iter === maxIter) {
+        return -1 * amplitude; // Inside the set
+    }
+    // Normalize iteration count to [-1, 1]
+    const smooth = iter - Math.log2(Math.log2(zrx * zrx + zry * zry));
+    return ((smooth / maxIter) * 2 - 1) * amplitude;
+}
+/**
+ * Generate a brightness grid for pattern rendering
+ *
+ * @param cols - Number of columns
+ * @param rows - Number of rows
+ * @param pattern - Pattern type
+ * @param time - Current time in seconds
+ * @param config - Pattern configuration
+ * @returns 2D array of brightness values (0-255)
+ */
+export function generateBrightnessGrid(cols, rows, pattern, time = 0, config = DEFAULT_PATTERN_CONFIG) {
+    const grid = [];
+    const { frequency, amplitude, speed } = config;
+    for (let row = 0; row < rows; row++) {
+        grid[row] = [];
+        for (let col = 0; col < cols; col++) {
+            let value;
+            switch (pattern) {
+                case 'perlin':
+                    value = perlinNoise2D(col * frequency + time * speed * 0.1, row * frequency + time * speed * 0.05);
+                    break;
+                case 'fbm':
+                    value = fbmNoise(col * frequency + time * speed * 0.1, row * frequency + time * speed * 0.05, 4, 0.5);
+                    break;
+                case 'waves':
+                    value = wavePattern(col, row, time, config);
+                    break;
+                case 'ripple':
+                    value = ripplePattern(col, row, cols / 2, rows / 2, time, config);
+                    break;
+                case 'static':
+                    // For static, use time as seed for animated static
+                    value = seededNoise2D(col, row, Math.floor(time * speed * 10)) * 2 - 1;
+                    break;
+                case 'clouds':
+                    value = cloudsPattern(col, row, time, config);
+                    break;
+                case 'plasma':
+                    value = plasmaPattern(col, row, time, config);
+                    break;
+                case 'vortex':
+                    value = vortexPattern(col, row, cols / 2, rows / 2, time, config);
+                    break;
+                case 'matrix':
+                    value = matrixPattern(col, row, time, config);
+                    break;
+                case 'gradient':
+                    value = gradientPattern(col, row, cols, rows, time, config);
+                    break;
+                case 'diamond':
+                    value = diamondPattern(col, row, time, config);
+                    break;
+                case 'fractal':
+                    value = fractalPattern(col, row, cols, rows, time, config);
+                    break;
+                default:
+                    value = seededNoise2D(col, row, Math.floor(time * speed * 10)) * 2 - 1;
+                    break;
+            }
+            // Normalize from [-1, 1] to [0, 255] with amplitude
+            const normalized = (value + 1) * 0.5 * amplitude;
+            const brightness = Math.max(0, Math.min(255, Math.floor(normalized * 255)));
+            grid[row][col] = brightness;
+        }
+    }
+    return grid;
+}
+/**
+ * Generate ImageData from a brightness grid
+ *
+ * @param grid - 2D array of brightness values
+ * @param cellWidth - Width of each cell
+ * @param cellHeight - Height of each cell
+ * @returns ImageData object
+ */
+export function gridToImageData(grid, cellWidth, cellHeight) {
+    const rows = grid.length;
+    const cols = grid[0]?.length || 0;
+    const width = cols * cellWidth;
+    const height = rows * cellHeight;
+    const data = new Uint8ClampedArray(width * height * 4);
+    for (let row = 0; row < rows; row++) {
+        for (let col = 0; col < cols; col++) {
+            const brightness = grid[row][col];
+            // Fill cell region with brightness value
+            for (let cy = 0; cy < cellHeight; cy++) {
+                for (let cx = 0; cx < cellWidth; cx++) {
+                    const px = ((row * cellHeight + cy) * width + (col * cellWidth + cx)) * 4;
+                    data[px] = brightness; // R
+                    data[px + 1] = brightness; // G
+                    data[px + 2] = brightness; // B
+                    data[px + 3] = 255; // A
+                }
+            }
+        }
+    }
+    return new ImageData(data, width, height);
+}
+/**
+ * Create a reusable brightness buffer
+ * Call once at init, then reuse with fillBrightnessBuffer
+ *
+ * @param cols - Number of columns
+ * @param rows - Number of rows
+ * @returns Reusable buffer object
+ */
+export function createBrightnessBuffer(cols, rows) {
+    return {
+        data: new Uint8Array(cols * rows),
+        cols,
+        rows,
+    };
+}
+/**
+ * Fill an existing brightness buffer with pattern data (zero allocation)
+ * Use this in animation loops for best performance
+ *
+ * @param buffer - Pre-allocated buffer from createBrightnessBuffer
+ * @param pattern - Pattern type to generate
+ * @param time - Current time in seconds
+ * @param config - Pattern configuration
+ */
+export function fillBrightnessBuffer(buffer, pattern, time = 0, config = DEFAULT_PATTERN_CONFIG) {
+    const { data, cols, rows } = buffer;
+    const { frequency, amplitude, speed } = config;
+    let idx = 0;
+    for (let row = 0; row < rows; row++) {
+        for (let col = 0; col < cols; col++) {
+            let value;
+            switch (pattern) {
+                case 'perlin':
+                    value = perlinNoise2D(col * frequency + time * speed * 0.1, row * frequency + time * speed * 0.05);
+                    break;
+                case 'fbm':
+                    value = fbmNoise(col * frequency + time * speed * 0.1, row * frequency + time * speed * 0.05, 4, 0.5);
+                    break;
+                case 'waves':
+                    value = wavePattern(col, row, time, config);
+                    break;
+                case 'ripple':
+                    value = ripplePattern(col, row, cols / 2, rows / 2, time, config);
+                    break;
+                case 'static':
+                    value = seededNoise2D(col, row, Math.floor(time * speed * 10)) * 2 - 1;
+                    break;
+                case 'clouds':
+                    value = cloudsPattern(col, row, time, config);
+                    break;
+                case 'plasma':
+                    value = plasmaPattern(col, row, time, config);
+                    break;
+                case 'vortex':
+                    value = vortexPattern(col, row, cols / 2, rows / 2, time, config);
+                    break;
+                case 'matrix':
+                    value = matrixPattern(col, row, time, config);
+                    break;
+                case 'gradient':
+                    value = gradientPattern(col, row, cols, rows, time, config);
+                    break;
+                case 'diamond':
+                    value = diamondPattern(col, row, time, config);
+                    break;
+                case 'fractal':
+                    value = fractalPattern(col, row, cols, rows, time, config);
+                    break;
+                default:
+                    value = seededNoise2D(col, row, Math.floor(time * speed * 10)) * 2 - 1;
+                    break;
+            }
+            // Normalize from [-1, 1] to [0, 255] with amplitude
+            // Using bitwise OR for fast floor: (x | 0) is faster than Math.floor(x)
+            const normalized = (value + 1) * 0.5 * amplitude;
+            data[idx++] = normalized * 255 | 0;
+        }
+    }
+}
+/**
+ * Get brightness value from buffer at (col, row)
+ * @param buffer - Brightness buffer
+ * @param col - Column index
+ * @param row - Row index
+ * @returns Brightness value 0-255
+ */
+export function getBufferValue(buffer, col, row) {
+    return buffer.data[row * buffer.cols + col];
+}