git-hash-art 0.9.0 → 0.10.0

package/dist/main.js

@@ -541,6 +541,18 @@ function $d016ad53434219a1$export$6d1620b367f86f7a(rng) {
         intensity: intensity
     };
 }
+function $d016ad53434219a1$export$1793a1bfbe4f6ff5(hex, degrees) {
+    const [h, s, l] = $d016ad53434219a1$var$hexToHsl(hex);
+    return $d016ad53434219a1$var$hslToHex((h + degrees + 360) % 360, s, l);
+}
+function $d016ad53434219a1$export$703ba40a4347f77a(base, layerRatio, hueShiftPerLayer) {
+    const shift = layerRatio * hueShiftPerLayer;
+    return {
+        dominant: $d016ad53434219a1$export$1793a1bfbe4f6ff5(base.dominant, shift),
+        secondary: $d016ad53434219a1$export$1793a1bfbe4f6ff5(base.secondary, shift * 0.7),
+        accent: $d016ad53434219a1$export$1793a1bfbe4f6ff5(base.accent, shift * 0.5)
+    };
+}
 
 
 
@@ -1824,7 +1836,8 @@ const $c3de8257a8baa3b0$var$RENDER_STYLES = [
     "noise-grain",
     "wood-grain",
     "marble-vein",
-    "fabric-weave"
+    "fabric-weave",
+    "hand-drawn"
 ];
 function $c3de8257a8baa3b0$export$9fd4e64b2acd410e(rng) {
     return $c3de8257a8baa3b0$var$RENDER_STYLES[Math.floor(rng() * $c3de8257a8baa3b0$var$RENDER_STYLES.length)];
@@ -2205,6 +2218,33 @@ function $c3de8257a8baa3b0$export$71b514a25c47df50(ctx, shape, x, y, config) {
                 ctx.globalAlpha /= 0.3;
                 break;
             }
+        case "hand-drawn":
+            {
+                // Wobbly hand-drawn edge treatment — fill normally, then redraw
+                // the outline with perturbed control points for a sketchy feel
+                const savedAlphaHD = ctx.globalAlpha;
+                ctx.globalAlpha = savedAlphaHD * 0.85;
+                ctx.fill();
+                ctx.globalAlpha = savedAlphaHD;
+                // Draw 2-3 slightly offset wobbly strokes for a sketchy look
+                const wobblePasses = 2 + (rng ? Math.floor(rng() * 2) : 0);
+                ctx.lineWidth = strokeWidth * 0.8;
+                for(let wp = 0; wp < wobblePasses; wp++){
+                    ctx.globalAlpha = savedAlphaHD * (0.4 - wp * 0.1);
+                    ctx.save();
+                    // Slight random offset per pass
+                    const wobbleX = rng ? (rng() - 0.5) * size * 0.02 : 0;
+                    const wobbleY = rng ? (rng() - 0.5) * size * 0.02 : 0;
+                    ctx.translate(wobbleX, wobbleY);
+                    // Slightly different scale per pass for edge variation
+                    const wobbleScale = 1 + (rng ? (rng() - 0.5) * 0.03 : 0);
+                    ctx.scale(wobbleScale, wobbleScale);
+                    ctx.stroke();
+                    ctx.restore();
+                }
+                ctx.globalAlpha = savedAlphaHD;
+                break;
+            }
         case "fill-and-stroke":
         default:
             ctx.fill();
@@ -2340,7 +2380,8 @@ const $e73976f898150d4d$export$4343b39fe47bd82c = {
         bestStyles: [
             "fill-only",
             "watercolor",
-            "fill-and-stroke"
+            "fill-and-stroke",
+            "hand-drawn"
         ]
     },
     square: {
@@ -2377,7 +2418,8 @@ const $e73976f898150d4d$export$4343b39fe47bd82c = {
         bestStyles: [
             "fill-and-stroke",
             "fill-only",
-            "watercolor"
+            "watercolor",
+            "hand-drawn"
         ]
     },
     hexagon: {
@@ -2757,7 +2799,8 @@ const $e73976f898150d4d$export$4343b39fe47bd82c = {
         bestStyles: [
             "fill-only",
             "watercolor",
-            "fill-and-stroke"
+            "fill-and-stroke",
+            "hand-drawn"
         ]
     },
     ngon: {
@@ -3637,8 +3680,51 @@ const $f89bc858f7202849$var$ARCHETYPES = [
         invertForeground: false
     }
 ];
+/**
+ * Linearly interpolate between two archetype numeric parameters.
+ */ function $f89bc858f7202849$var$lerpNum(a, b, t) {
+    return a + (b - a) * t;
+}
+/**
+ * Blend two archetypes by interpolating their numeric parameters
+ * and merging their style arrays.
+ */ function $f89bc858f7202849$var$blendArchetypes(a, b, t) {
+    // Merge preferred styles — unique union, primary archetype first
+    const mergedStyles = [
+        ...new Set([
+            ...a.preferredStyles,
+            ...b.preferredStyles
+        ])
+    ];
+    return {
+        name: `${a.name}+${b.name}`,
+        gridSize: Math.round($f89bc858f7202849$var$lerpNum(a.gridSize, b.gridSize, t)),
+        layers: Math.round($f89bc858f7202849$var$lerpNum(a.layers, b.layers, t)),
+        baseOpacity: $f89bc858f7202849$var$lerpNum(a.baseOpacity, b.baseOpacity, t),
+        opacityReduction: $f89bc858f7202849$var$lerpNum(a.opacityReduction, b.opacityReduction, t),
+        minShapeSize: Math.round($f89bc858f7202849$var$lerpNum(a.minShapeSize, b.minShapeSize, t)),
+        maxShapeSize: Math.round($f89bc858f7202849$var$lerpNum(a.maxShapeSize, b.maxShapeSize, t)),
+        backgroundStyle: t < 0.5 ? a.backgroundStyle : b.backgroundStyle,
+        paletteMode: t < 0.5 ? a.paletteMode : b.paletteMode,
+        preferredStyles: mergedStyles,
+        flowLineMultiplier: $f89bc858f7202849$var$lerpNum(a.flowLineMultiplier, b.flowLineMultiplier, t),
+        heroShape: t < 0.5 ? a.heroShape : b.heroShape,
+        glowMultiplier: $f89bc858f7202849$var$lerpNum(a.glowMultiplier, b.glowMultiplier, t),
+        sizePower: $f89bc858f7202849$var$lerpNum(a.sizePower, b.sizePower, t),
+        invertForeground: t < 0.5 ? a.invertForeground : b.invertForeground
+    };
+}
 function $f89bc858f7202849$export$f1142fd7da4d6590(rng) {
-    return $f89bc858f7202849$var$ARCHETYPES[Math.floor(rng() * $f89bc858f7202849$var$ARCHETYPES.length)];
+    const primary = $f89bc858f7202849$var$ARCHETYPES[Math.floor(rng() * $f89bc858f7202849$var$ARCHETYPES.length)];
+    // ~15% chance of blending with a second archetype
+    if (rng() < 0.15) {
+        const secondary = $f89bc858f7202849$var$ARCHETYPES[Math.floor(rng() * $f89bc858f7202849$var$ARCHETYPES.length)];
+        if (secondary.name !== primary.name) {
+            const blendT = 0.25 + rng() * 0.25; // 25-50% blend toward secondary
+            return $f89bc858f7202849$var$blendArchetypes(primary, secondary, blendT);
+        }
+    }
+    return primary;
 }
 
 
@@ -3974,6 +4060,8 @@ function $4f72c5a314eddf25$export$29a844702096332e(ctx, gitHash, config = {}) {
     const colorGrade = (0, $d016ad53434219a1$export$6d1620b367f86f7a)(rng);
     // ── 0e. Light direction — consistent shadow angle ──────────────
     const lightAngle = rng() * Math.PI * 2;
+    // ── 0f. Palette evolution — hue drift direction across layers ──
+    const paletteHueShift = (rng() - 0.5) * 40; // -20° to +20° total drift
     const scaleFactor = Math.min(width, height) / 1024;
     const adjustedMinSize = minShapeSize * scaleFactor;
     const adjustedMaxSize = maxShapeSize * scaleFactor;
@@ -4148,6 +4236,41 @@ function $4f72c5a314eddf25$export$29a844702096332e(ctx, gitHash, config = {}) {
             ry + (nearest.y - ry) * pull
         ];
     }
+    // ── 3b. Void zone decoration — intentional negative space ────
+    for (const zone of voidZones){
+        // Subtle halo ring around void zones
+        ctx.globalAlpha = 0.04 + rng() * 0.04;
+        ctx.strokeStyle = (0, $d016ad53434219a1$export$f2121afcad3d553f)(colorHierarchy.accent, 0.2);
+        ctx.lineWidth = 1.5 * scaleFactor;
+        ctx.beginPath();
+        ctx.arc(zone.x, zone.y, zone.radius, 0, Math.PI * 2);
+        ctx.stroke();
+        // ~50% chance: scatter tiny dots inside the void
+        if (rng() < 0.5) {
+            const dotCount = 3 + Math.floor(rng() * 6);
+            ctx.globalAlpha = 0.06 + rng() * 0.04;
+            ctx.fillStyle = (0, $d016ad53434219a1$export$f2121afcad3d553f)(colorHierarchy.secondary, 0.15);
+            for(let d = 0; d < dotCount; d++){
+                const angle = rng() * Math.PI * 2;
+                const dist = rng() * zone.radius * 0.7;
+                const dotR = (1 + rng() * 3) * scaleFactor;
+                ctx.beginPath();
+                ctx.arc(zone.x + Math.cos(angle) * dist, zone.y + Math.sin(angle) * dist, dotR, 0, Math.PI * 2);
+                ctx.fill();
+            }
+        }
+        // ~30% chance: thin concentric ring inside
+        if (rng() < 0.3) {
+            ctx.globalAlpha = 0.03 + rng() * 0.03;
+            ctx.strokeStyle = (0, $d016ad53434219a1$export$f2121afcad3d553f)(colorHierarchy.dominant, 0.1);
+            ctx.lineWidth = 0.5 * scaleFactor;
+            const innerR = zone.radius * (0.4 + rng() * 0.3);
+            ctx.beginPath();
+            ctx.arc(zone.x, zone.y, innerR, 0, Math.PI * 2);
+            ctx.stroke();
+        }
+    }
+    ctx.globalAlpha = 1;
     // ── 4. Flow field seed values ──────────────────────────────────
     const fieldAngleBase = rng() * Math.PI * 2;
     const fieldFreq = 0.5 + rng() * 2;
@@ -4220,6 +4343,18 @@ function $4f72c5a314eddf25$export$29a844702096332e(ctx, gitHash, config = {}) {
         const dofFactor = 1 - layerRatio * 0.5; // 1.0 for front layer, 0.5 for back
         const dofStrokeScale = 0.4 + dofFactor * 0.6; // strokes thin out with depth
         const dofContrastReduction = layerRatio * 0.2; // colors fade toward bg
+        // Color palette evolution — hue-rotate the hierarchy per layer
+        const layerHierarchy = (0, $d016ad53434219a1$export$703ba40a4347f77a)(colorHierarchy, layerRatio, paletteHueShift);
+        // Focal depth: shapes near focal points get more detail
+        const focalDetailBoost = (px, py)=>{
+            let minFocalDist = Infinity;
+            for (const fp of focalPoints){
+                const d = Math.hypot(px - fp.x, py - fp.y);
+                if (d < minFocalDist) minFocalDist = d;
+            }
+            const maxDist = Math.hypot(width, height) * 0.5;
+            return Math.max(0, 1 - minFocalDist / maxDist); // 1.0 at focal, 0.0 at edges
+        };
         for(let i = 0; i < numShapes; i++){
             // Position from composition mode, then focal bias
             const rawPos = $4f72c5a314eddf25$var$getCompositionPosition(compositionMode, rng, width, height, i, numShapes, cx, cy);
@@ -4250,9 +4385,9 @@ function $4f72c5a314eddf25$export$29a844702096332e(ctx, gitHash, config = {}) {
                     rotation = rotation + (angleToHero - rotation) * blendFactor * 0.4;
                 }
             }
-            // Positional color from hierarchy + jitter
-            let fillBase = $4f72c5a314eddf25$var$getPositionalColor(x, y, width, height, colorHierarchy, rng);
-            const strokeBase = (0, $d016ad53434219a1$export$b49f62f0a99da0e8)(colorHierarchy, rng);
+            // Positional color from hierarchy + jitter (using evolved layer palette)
+            let fillBase = $4f72c5a314eddf25$var$getPositionalColor(x, y, width, height, layerHierarchy, rng);
+            const strokeBase = (0, $d016ad53434219a1$export$b49f62f0a99da0e8)(layerHierarchy, rng);
             // Desaturate colors on later layers for depth
             if (atmosphericDesat > 0) fillBase = (0, $d016ad53434219a1$export$fb75607d98509d9)(fillBase, atmosphericDesat);
             // Temperature contrast: shift foreground shapes opposite to background
@@ -4344,6 +4479,25 @@ function $4f72c5a314eddf25$export$29a844702096332e(ctx, gitHash, config = {}) {
                 mirrorGap: size * (0.1 + rng() * 0.3)
             });
             else (0, $c3de8257a8baa3b0$export$bb35a6995ddbf32d)(ctx, shape, finalX, finalY, shapeConfig);
+            // ── Glazing — luminous multi-pass transparency on ~20% of shapes ──
+            if (rng() < 0.2 && size > adjustedMinSize * 2) {
+                const glazePasses = 2 + Math.floor(rng() * 2);
+                for(let g = 0; g < glazePasses; g++){
+                    const glazeScale = 1 - (g + 1) * 0.12; // progressively smaller
+                    const glazeAlpha = 0.08 + g * 0.04; // progressively more opaque toward center
+                    ctx.globalAlpha = glazeAlpha;
+                    (0, $c3de8257a8baa3b0$export$bb35a6995ddbf32d)(ctx, shape, finalX, finalY, {
+                        fillColor: (0, $d016ad53434219a1$export$f2121afcad3d553f)(fillColor, 0.15 + g * 0.1),
+                        strokeColor: "rgba(0,0,0,0)",
+                        strokeWidth: 0,
+                        size: size * glazeScale,
+                        rotation: rotation,
+                        proportionType: "GOLDEN_RATIO",
+                        renderStyle: "fill-only",
+                        rng: rng
+                    });
+                }
+            }
             shapePositions.push({
                 x: finalX,
                 y: finalY,
@@ -4381,7 +4535,10 @@ function $4f72c5a314eddf25$export$29a844702096332e(ctx, gitHash, config = {}) {
                 }
             }
             // ── 5d. Recursive nesting ──────────────────────────────────
-            if (size > adjustedMaxSize * 0.4 && rng() < 0.15) {
+            // Focal depth: shapes near focal points get more detail
+            const focalProximity = focalDetailBoost(finalX, finalY);
+            const nestingChance = 0.15 + focalProximity * 0.15; // 15-30% near focal
+            if (size > adjustedMaxSize * 0.4 && rng() < nestingChance) {
                 const innerCount = 1 + Math.floor(rng() * 3);
                 for(let n = 0; n < innerCount; n++){
                     // Pick inner shape from palette affinities
@@ -4406,7 +4563,8 @@ function $4f72c5a314eddf25$export$29a844702096332e(ctx, gitHash, config = {}) {
                 }
             }
             // ── 5e. Shape constellations — pre-composed groups ─────────
-            if (size > adjustedMaxSize * 0.35 && rng() < 0.12) {
+            const constellationChance = 0.12 + focalProximity * 0.1; // 12-22% near focal
+            if (size > adjustedMaxSize * 0.35 && rng() < constellationChance) {
                 const constellation = $4f72c5a314eddf25$var$CONSTELLATIONS[Math.floor(rng() * $4f72c5a314eddf25$var$CONSTELLATIONS.length)];
                 const members = constellation.build(rng, size);
                 const groupRotation = rng() * Math.PI * 2;
@@ -4510,7 +4668,41 @@ function $4f72c5a314eddf25$export$29a844702096332e(ctx, gitHash, config = {}) {
             prevY = fy;
         }
     }
-    // ── 6b. Apply symmetry mirroring ─────────────────────────────────
+    // ── 6b. Motion/energy lines — short directional bursts ─────────
+    const energyArchetypes = [
+        "dense-chaotic",
+        "cosmic",
+        "neon-glow",
+        "bold-graphic"
+    ];
+    const hasEnergyLines = energyArchetypes.some((a)=>archetype.name.includes(a)) || rng() < 0.25;
+    if (hasEnergyLines && shapePositions.length > 0) {
+        const energyCount = 5 + Math.floor(rng() * 10);
+        ctx.lineCap = "round";
+        for(let e = 0; e < energyCount; e++){
+            // Pick a random shape to radiate from
+            const source = shapePositions[Math.floor(rng() * shapePositions.length)];
+            const burstCount = 2 + Math.floor(rng() * 4);
+            const baseAngle = flowAngle(source.x, source.y);
+            for(let b = 0; b < burstCount; b++){
+                const angle = baseAngle + (rng() - 0.5) * 1.2;
+                const lineLen = (source.size * 0.3 + rng() * source.size * 0.5) * scaleFactor * 0.3;
+                const startDist = source.size * 0.5;
+                const sx = source.x + Math.cos(angle) * startDist;
+                const sy = source.y + Math.sin(angle) * startDist;
+                const ex = sx + Math.cos(angle) * lineLen;
+                const ey = sy + Math.sin(angle) * lineLen;
+                ctx.globalAlpha = 0.04 + rng() * 0.06;
+                ctx.strokeStyle = (0, $d016ad53434219a1$export$f2121afcad3d553f)((0, $d016ad53434219a1$export$90ad0e6170cf6af5)((0, $d016ad53434219a1$export$b49f62f0a99da0e8)(colorHierarchy, rng), bgLum), 0.3);
+                ctx.lineWidth = (0.5 + rng() * 1.5) * scaleFactor;
+                ctx.beginPath();
+                ctx.moveTo(sx, sy);
+                ctx.lineTo(ex, ey);
+                ctx.stroke();
+            }
+        }
+    }
+    // ── 6c. Apply symmetry mirroring ─────────────────────────────────
     if (symmetryMode !== "none") {
         const canvas = ctx.canvas;
         ctx.save();
@@ -4621,6 +4813,44 @@ function $4f72c5a314eddf25$export$29a844702096332e(ctx, gitHash, config = {}) {
         ctx.restore();
         ctx.globalCompositeOperation = "source-over";
     }
+    // ── 11. Signature mark — unique geometric chop from hash prefix ──
+    {
+        const sigRng = (0, $e4b03e131ed2a289$export$eaf9227667332084)((0, $e4b03e131ed2a289$export$e9cc707de01b7042)(gitHash, 42));
+        const sigSize = Math.min(width, height) * 0.025;
+        // Bottom-right corner with padding
+        const sigX = width - sigSize * 2.5;
+        const sigY = height - sigSize * 2.5;
+        const sigSegments = 4 + Math.floor(sigRng() * 4); // 4-7 segments
+        const sigColor = (0, $d016ad53434219a1$export$f2121afcad3d553f)(colorHierarchy.accent, 0.15);
+        ctx.save();
+        ctx.globalAlpha = 0.12 + sigRng() * 0.08;
+        ctx.translate(sigX, sigY);
+        ctx.strokeStyle = sigColor;
+        ctx.fillStyle = (0, $d016ad53434219a1$export$f2121afcad3d553f)(colorHierarchy.dominant, 0.06);
+        ctx.lineWidth = Math.max(0.5, 0.8 * scaleFactor);
+        // Outer ring
+        ctx.beginPath();
+        ctx.arc(0, 0, sigSize, 0, Math.PI * 2);
+        ctx.stroke();
+        ctx.fill();
+        // Inner geometric pattern — unique per hash
+        ctx.beginPath();
+        for(let s = 0; s < sigSegments; s++){
+            const angle1 = sigRng() * Math.PI * 2;
+            const angle2 = sigRng() * Math.PI * 2;
+            const r1 = sigSize * (0.2 + sigRng() * 0.6);
+            const r2 = sigSize * (0.2 + sigRng() * 0.6);
+            ctx.moveTo(Math.cos(angle1) * r1, Math.sin(angle1) * r1);
+            ctx.lineTo(Math.cos(angle2) * r2, Math.sin(angle2) * r2);
+        }
+        ctx.stroke();
+        // Center dot
+        ctx.beginPath();
+        ctx.arc(0, 0, sigSize * 0.12, 0, Math.PI * 2);
+        ctx.fillStyle = sigColor;
+        ctx.fill();
+        ctx.restore();
+    }
     ctx.globalAlpha = 1;
 }