staticfx 2.0.0__py3-none-any.whl

staticfx/effects/builtin/shapes.py

@@ -0,0 +1,255 @@
+"""Wireframes and curves: a cube, a tesseract, spirographs, Lissajous figures, a DNA helix."""
+
+from __future__ import annotations
+
+import itertools
+import math
+import random
+
+from staticfx.core.color import clamp
+from staticfx.core.frame import Frame
+from staticfx.effects.base import Effect
+from staticfx.effects.builtin.geometry import (
+    CUBE_EDGES,
+    Projected,
+    Vec3,
+    cube_vertices,
+    line_points,
+    project,
+    rotate,
+)
+from staticfx.themes import Theme
+
+
+def _draw_segment(
+    effect: Effect, frame: Frame, theme: Theme, a: Projected, b: Projected, tone: float
+) -> None:
+    """Draw one edge between two projected points, shaded by depth."""
+    chars = "#" if tone > 0.66 else "+" if tone > 0.38 else "."
+    color = effect.color_at(theme, 0.2 + 0.8 * tone)
+
+    for x, y in line_points(int(a.x), int(a.y), int(b.x), int(b.y), limit=512):
+        frame.put(x, y, chars, color)
+
+
+class Cube(Effect):
+    def __init__(self, rng: random.Random, unicode: bool = False) -> None:
+        super().__init__(rng, unicode)
+        self.t = 0.0
+        self.vertices = cube_vertices(1.6)
+        self.focal = 40.0
+
+    def on_resize(self) -> None:
+        self.focal = max(8.0, min(self.height * 3.2, self.width * 1.1))
+
+    def advance(self, dt: float) -> None:
+        self.t += dt
+
+    def render(self, frame: Frame, theme: Theme) -> None:
+        t = self.t
+        rotated = [rotate(v, t * 0.7, t * 1.1, t * 0.3) for v in self.vertices]
+        points = [project(v, self.width, self.height, self.focal, 4.0) for v in rotated]
+
+        for start, end in CUBE_EDGES:
+            a, b = points[start], points[end]
+
+            if a is None or b is None:
+                continue
+
+            depth = (a.depth + b.depth) / 2
+            _draw_segment(self, frame, theme, a, b, clamp(1.6 - (depth - 2.6) / 2.4))
+
+        for point in points:
+            if point is not None:
+                frame.put(int(point.x), int(point.y), "@", theme.bright)
+
+
+def _rotate_4d(
+    point: tuple[float, ...], angle_xw: float, angle_zw: float, angle_xy: float
+) -> tuple[float, float, float, float]:
+    x, y, z, w = point
+
+    c, s = math.cos(angle_xw), math.sin(angle_xw)
+    x, w = x * c - w * s, x * s + w * c
+
+    c, s = math.cos(angle_zw), math.sin(angle_zw)
+    z, w = z * c - w * s, z * s + w * c
+
+    c, s = math.cos(angle_xy), math.sin(angle_xy)
+    x, y = x * c - y * s, x * s + y * c
+
+    return x, y, z, w
+
+
+class Tesseract(Effect):
+    def __init__(self, rng: random.Random, unicode: bool = False) -> None:
+        super().__init__(rng, unicode)
+        self.t = 0.0
+        self.focal = 40.0
+        self.vertices = [
+            tuple(0.7 * s for s in signs) for signs in itertools.product((-1, 1), repeat=4)
+        ]
+        self.edges = [
+            (i, j)
+            for i in range(16)
+            for j in range(i + 1, 16)
+            if sum(a != b for a, b in zip(self.vertices[i], self.vertices[j], strict=True)) == 1
+        ]
+
+    def on_resize(self) -> None:
+        self.focal = max(8.0, min(self.height * 3.0, self.width * 1.0))
+
+    def advance(self, dt: float) -> None:
+        self.t += dt
+
+    def render(self, frame: Frame, theme: Theme) -> None:
+        t = self.t
+        projected = []
+
+        for vertex in self.vertices:
+            x, y, z, w = _rotate_4d(vertex, t * 0.55, t * 0.8, t * 0.25)
+            scale = 1.0 / (2.2 - w)
+            point3 = Vec3(x * scale * 2.2, y * scale * 2.2, z * scale * 2.2)
+
+            point3 = rotate(point3, t * 0.3, t * 0.4, 0.0)
+            projected.append((project(point3, self.width, self.height, self.focal, 4.0), w))
+
+        for start, end in self.edges:
+            (a, wa), (b, wb) = projected[start], projected[end]
+
+            if a is None or b is None:
+                continue
+
+            tone = clamp(0.55 + 0.35 * (wa + wb))
+            _draw_segment(self, frame, theme, a, b, tone)
+
+        for point, _ in projected:
+            if point is not None:
+                frame.put(int(point.x), int(point.y), "@", theme.bright)
+
+
+class Spirograph(Effect):
+    RATIOS = ((5, 3), (7, 3), (8, 3), (7, 5), (9, 4), (11, 4), (5, 2), (13, 5))
+
+    def __init__(self, rng: random.Random, unicode: bool = False) -> None:
+        super().__init__(rng, unicode)
+        self.theta = 0.0
+        self.pick()
+
+    def pick(self) -> None:
+        big, small = self.rng.choice(self.RATIOS)
+        self.big = float(big)
+        self.small = float(small)
+        self.offset = self.small * self.rng.uniform(0.6, 1.0)
+        self.limit = (self.big - self.small) + self.offset
+        self.span = math.tau * (self.small / math.gcd(big, small))
+
+    def on_reset(self) -> None:
+        self.theta = 0.0
+        self.pick()
+
+    def advance(self, dt: float) -> None:
+        self.theta += dt * 1.8
+
+        if self.theta > self.span * 3.2:
+            self.on_reset()
+
+    def render(self, frame: Frame, theme: Theme) -> None:
+        samples = 520
+        tail = min(self.span, 14.0)
+        scale = (self.height / 2 - 1.0) / self.limit
+        cx = (self.width - 1) / 2
+        cy = (self.height - 1) / 2
+        ratio = (self.big - self.small) / self.small
+
+        for index in range(samples):
+            fraction = index / samples
+            angle = self.theta - tail * (1.0 - fraction)
+
+            if angle < 0:
+                continue
+
+            px = (self.big - self.small) * math.cos(angle) + self.offset * math.cos(ratio * angle)
+            py = (self.big - self.small) * math.sin(angle) - self.offset * math.sin(ratio * angle)
+            tone = 0.15 + 0.85 * fraction
+            char = (
+                "@" if index == samples - 1 else "*" if tone > 0.6 else "+" if tone > 0.35 else "."
+            )
+
+            frame.put(
+                int(cx + px * scale * 2.0), int(cy + py * scale), char, self.color_at(theme, tone)
+            )
+
+
+class Lissajous(Effect):
+    def __init__(self, rng: random.Random, unicode: bool = False) -> None:
+        super().__init__(rng, unicode)
+        self.t = 0.0
+        self.a = 3
+        self.b = 2
+        self.pick()
+
+    def pick(self) -> None:
+        self.a, self.b = self.rng.choice(
+            ((3, 2), (3, 4), (5, 4), (5, 6), (1, 2), (2, 3), (4, 5), (5, 3))
+        )
+
+    def on_reset(self) -> None:
+        self.t = 0.0
+        self.pick()
+
+    def advance(self, dt: float) -> None:
+        self.t += dt
+
+    def render(self, frame: Frame, theme: Theme) -> None:
+        samples = 640
+        cx = (self.width - 1) / 2
+        cy = (self.height - 1) / 2
+        ax = cx - 1.0
+        ay = cy - 0.5
+        drift = self.t * 0.35
+        head = (self.t * 1.6) % 1.0
+
+        for index in range(samples):
+            u = math.tau * index / samples
+            x = math.sin(self.a * u + drift)
+            y = math.sin(self.b * u)
+            fraction = ((index / samples) - head) % 1.0
+            tone = 0.15 + 0.85 * (1.0 - fraction)
+            char = "@" if fraction < 0.01 else "*" if tone > 0.6 else "+" if tone > 0.35 else "."
+
+            frame.put(int(cx + x * ax), int(cy + y * ay), char, self.color_at(theme, tone))
+
+
+class DNAHelix(Effect):
+    def __init__(self, rng: random.Random, unicode: bool = False) -> None:
+        super().__init__(rng, unicode)
+        self.t = 0.0
+
+    def advance(self, dt: float) -> None:
+        self.t += dt
+
+    def render(self, frame: Frame, theme: Theme) -> None:
+        cx = (self.width - 1) / 2
+        amplitude = max(3.0, min(self.width * 0.22, 14.0))
+        draw_list = []
+
+        for y in range(self.height):
+            phase = y * 0.42 + self.t * 2.2
+            sine, cosine = math.sin(phase), math.cos(phase)
+
+            if y % 3 == 0:
+                left = int(cx - amplitude * sine)
+                right = int(cx + amplitude * sine)
+                rung = self.color_at(theme, 0.3)
+
+                for x in range(min(left, right) + 1, max(left, right)):
+                    frame.put(x, y, "-", rung)
+
+            draw_list.append((cosine, int(cx + amplitude * sine), y))
+            draw_list.append((-cosine, int(cx - amplitude * sine), y))
+
+        for depth, x, y in sorted(draw_list):
+            near = 0.5 + 0.5 * depth
+            char = "@" if near > 0.8 else "O" if near > 0.5 else "o"
+            frame.put(x, y, char, self.color_at(theme, 0.25 + 0.75 * near))

staticfx/effects/builtin/signals.py

@@ -0,0 +1,298 @@
+"""Broken signals: TV static, a failing test card, scope traces, lightning, a spectrum."""
+
+from __future__ import annotations
+
+import math
+import random
+
+from staticfx.core.color import clamp
+from staticfx.core.frame import Frame
+from staticfx.core.glyphs import tech_glyphs
+from staticfx.effects.base import Effect
+from staticfx.themes import Theme
+
+NOISE_SHADE = " .:-=+*#%@"
+
+
+class StaticNoise(Effect):
+    def __init__(self, rng: random.Random, unicode: bool = False) -> None:
+        super().__init__(rng, unicode)
+        self.t = 0.0
+
+    def advance(self, dt: float) -> None:
+        self.t += dt
+
+    def render(self, frame: Frame, theme: Theme) -> None:
+        palette = self.palette(theme)
+        top = len(palette) - 1
+        random = self.rng.random
+        band = (self.t * 0.22) % 1.4 * self.height - self.height * 0.2
+
+        for y in range(self.height):
+            # A slow dark roll-bar drifts down the screen.
+            dim = 0.45 if abs(y - band) < max(1.5, self.height * 0.06) else 1.0
+
+            for x in range(self.width):
+                v = random() ** 0.8 * dim
+                index = int(v * 9)
+
+                if index:
+                    frame.put(x, y, NOISE_SHADE[index], palette[int(v * top)])
+
+
+class TVGlitch(Effect):
+    def __init__(self, rng: random.Random, unicode: bool = False) -> None:
+        super().__init__(rng, unicode)
+        self.t = 0.0
+        self.roll = 0.0
+        self.roll_speed = 0.0
+        self.tears: list[list[float]] = []
+        self.cooldown = 0.0
+
+    def on_resize(self) -> None:
+        self.tears = []
+
+    def advance(self, dt: float) -> None:
+        rng = self.rng
+        self.t += dt
+        self.cooldown -= dt
+        self.roll += self.roll_speed * dt
+        self.roll_speed *= max(0.0, 1.0 - 3.0 * dt)
+
+        for tear in self.tears:
+            tear[3] -= dt
+
+        self.tears = [tear for tear in self.tears if tear[3] > 0.0]
+
+        if self.cooldown <= 0.0:
+            self.cooldown = rng.uniform(0.08, 0.5)
+
+            for _ in range(rng.randint(1, 3)):
+                self.tears.append(
+                    [
+                        rng.randrange(self.height),
+                        rng.randint(1, max(1, self.height // 7)),
+                        rng.randint(-self.width // 4, max(1, self.width // 4)),
+                        rng.uniform(0.06, 0.3),
+                    ]
+                )
+
+            if rng.random() < 0.12:
+                self.roll_speed = rng.uniform(15.0, 40.0)
+
+    def render(self, frame: Frame, theme: Theme) -> None:
+        rng = self.rng
+        palette = self.palette(theme)
+        top = len(palette) - 1
+        roll = int(self.roll)
+        shifts = {}
+
+        for start, size, shift, _ in self.tears:
+            for row in range(int(start), int(start + size)):
+                shifts[row % self.height] = int(shift)
+
+        for y in range(self.height):
+            row_shift = shifts.get(y)
+            noisy = row_shift is not None and rng.random() < 0.55
+
+            for x in range(self.width):
+                if noisy:
+                    v = rng.random()
+                    char = NOISE_SHADE[int(v * 9)]
+                else:
+                    sx = x - (row_shift or 0)
+                    checker = ((sx // 6) + ((y + roll) // 3)) & 1
+                    v = 0.5 if checker else 0.14
+
+                    if rng.random() < 0.04:
+                        v = rng.random()
+
+                    char = NOISE_SHADE[int(v * 9)]
+
+                if char != " ":
+                    frame.put(x, y, char, palette[int(v * top)])
+
+
+class SignalScramble(Effect):
+    def __init__(self, rng: random.Random, unicode: bool = False) -> None:
+        super().__init__(rng, unicode)
+        self.t = 0.0
+        self.pool = tech_glyphs(unicode)
+        self.bursts: list[list[float]] = []
+        self.cooldown = 0.0
+
+    def on_resize(self) -> None:
+        self.bursts = []
+
+    def advance(self, dt: float) -> None:
+        rng = self.rng
+        self.t += dt
+        self.cooldown -= dt
+
+        for burst in self.bursts:
+            burst[2] -= dt
+
+        self.bursts = [burst for burst in self.bursts if burst[2] > 0.0]
+
+        if self.cooldown <= 0.0:
+            self.cooldown = rng.uniform(0.15, 0.7)
+            start = rng.randrange(self.width)
+            self.bursts.append(
+                [start, start + rng.randint(4, max(5, self.width // 3)), rng.uniform(0.1, 0.4)]
+            )
+
+    def _wave(self, x: float, which: int) -> float:
+        t = self.t
+        cy = (self.height - 1) / 2
+        amp = self.height * (0.32 - 0.07 * which)
+
+        return cy + amp * (
+            math.sin(x * (0.11 + 0.04 * which) + t * (2.0 + which))
+            * (0.6 + 0.4 * math.sin(x * 0.03 - t * 0.8))
+            + 0.25 * math.sin(x * 0.37 + t * 5.0)
+        )
+
+    def render(self, frame: Frame, theme: Theme) -> None:
+        rng = self.rng
+        tones = (0.95, 0.65, 0.4)
+
+        for which, tone in enumerate(tones):
+            color = self.color_at(theme, tone)
+
+            for x in range(self.width):
+                y = self._wave(x, which)
+                slope = self._wave(x + 1, which) - y
+                char = "\\" if slope > 0.7 else "/" if slope < -0.7 else "-"
+                frame.put(x, round(y), char, color)
+
+        bright = theme.bright
+
+        for start, end, _ in self.bursts:
+            for x in range(int(start), min(self.width, int(end))):
+                jitter = rng.randint(-3, 3)
+                y = round(self._wave(x, 0)) + jitter
+                frame.put(x, y, rng.choice(self.pool), bright)
+                frame.put(
+                    x, y + rng.choice((-1, 1)), rng.choice(self.pool), self.color_at(theme, 0.5)
+                )
+
+
+class WaveBars(Effect):
+    def __init__(self, rng: random.Random, unicode: bool = False) -> None:
+        super().__init__(rng, unicode)
+        self.levels: list[float] = []
+        self.targets: list[float] = []
+        self.peaks: list[float] = []
+        self.t = 0.0
+
+    def on_resize(self) -> None:
+        count = max(1, self.width // 3)
+        self.levels = [0.0] * count
+        self.targets = [0.0] * count
+        self.peaks = [0.0] * count
+
+    def advance(self, dt: float) -> None:
+        rng = self.rng
+        count = len(self.levels)
+        self.t += dt
+
+        for i in range(count):
+            if rng.random() < 5.0 * dt:
+                shape = 0.3 + 0.7 * math.sin(math.pi * (i + 0.5) / count)
+                self.targets[i] = shape * rng.random() ** 0.6
+
+            gain = 14.0 if self.targets[i] > self.levels[i] else 4.0
+            self.levels[i] += (self.targets[i] - self.levels[i]) * min(1.0, gain * dt)
+            self.peaks[i] = max(self.levels[i], self.peaks[i] - 0.35 * dt)
+
+    def render(self, frame: Frame, theme: Theme) -> None:
+        block = "█" if self.unicode else "#"
+        height = self.height
+
+        for i, level in enumerate(self.levels):
+            filled = int(level * (height - 1) + 0.5)
+            peak = int(self.peaks[i] * (height - 1) + 0.5)
+
+            for row in range(filled):
+                y = height - 1 - row
+                color = self.color_at(theme, 0.25 + 0.75 * (row / max(1, height - 1)))
+
+                for dx in (0, 1):
+                    frame.put(i * 3 + dx, y, block, color)
+
+            if peak > 0:
+                for dx in (0, 1):
+                    frame.put(i * 3 + dx, height - 1 - peak, "=", theme.bright)
+
+
+class ElectricStorm(Effect):
+    def __init__(self, rng: random.Random, unicode: bool = False) -> None:
+        super().__init__(rng, unicode)
+        self.bolts: list[dict] = []
+        self.flash = 0.0
+        self.cooldown = 0.3
+
+    def on_resize(self) -> None:
+        self.bolts = []
+
+    def _make_bolt(self) -> dict:
+        rng = self.rng
+        x = rng.randrange(self.width)
+        cells: list[tuple[int, int, str]] = []
+        stack = [(x, 0, 1.0)]
+
+        while stack:
+            bx, by, vigor = stack.pop()
+
+            while by < self.height and 0 <= bx < self.width:
+                step = rng.choice((-1, 0, 0, 1))
+                char = "/" if step < 0 else "\\" if step > 0 else "|"
+                cells.append((bx, by, char))
+                bx += step
+                by += 1
+
+                if vigor > 0.5 and rng.random() < 0.07:
+                    stack.append((bx, by, vigor * 0.5))
+
+                if vigor < 0.5 and rng.random() < 0.12:
+                    break
+
+        life = rng.uniform(0.25, 0.5)
+        return {"cells": cells, "life": life, "max": life}
+
+    def advance(self, dt: float) -> None:
+        rng = self.rng
+        self.cooldown -= dt
+        self.flash = max(0.0, self.flash - dt * 4.0)
+
+        if self.cooldown <= 0.0:
+            self.cooldown = rng.uniform(0.35, 1.6)
+
+            for _ in range(rng.choice((1, 1, 2))):
+                self.bolts.append(self._make_bolt())
+
+            self.flash = 1.0
+
+        for bolt in self.bolts:
+            bolt["life"] -= dt
+
+        self.bolts = [bolt for bolt in self.bolts if bolt["life"] > 0.0]
+
+    def render(self, frame: Frame, theme: Theme) -> None:
+        rng = self.rng
+
+        # Ambient crackle, brighter right after a strike.
+        density = 0.004 + 0.05 * self.flash
+        color = self.color_at(theme, 0.2 + 0.4 * self.flash)
+
+        for _ in range(int(self.width * self.height * density)):
+            frame.put(
+                rng.randrange(self.width), rng.randrange(self.height), rng.choice(".:'`"), color
+            )
+
+        for bolt in self.bolts:
+            fade = clamp(bolt["life"] / bolt["max"])
+            bolt_color = theme.bright if fade > 0.5 else self.color_at(theme, 0.4 + fade)
+
+            for x, y, char in bolt["cells"]:
+                frame.put(x, y, char, bolt_color)