Penne 80s Vector (Aaron Penne — outrun perspective wireframe)

Math essence

Pinhole projection: screen_x = dim/2 + focal*x/(z + offset) * dim/8; screen_y = horizon_y + focal/(z + offset) * dim/4. Linear depth-fog alpha: alpha(z) = clip((fog_end - z)/(fog_end - fog_start), 0, 1) for z in [fog_start, fog_end]. Grid lines are (x, 0, 0)-(x, 0, grid_depth) and (-grid_extent, 0, z)-(grid_extent, 0, z). The neon sun is a half-disc at (dim/2, horizon_y) with horizontal stripes at 0.65, 0.78, 0.90 of the sun radius. Sunburst rays radiate at angles -pi + (i+1) * pi / (n_rays+1).

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/art_blocks/Penne80sVector/reference.py

"""Penne80sVector — Aaron Penne-inspired 80s perspective wireframe.

Inspired by the early-1980s synthwave/vaporwave aesthetic of
Aaron Penne's 80s-vector influences (referenced in *Apparitions* and
his broader body of work) and the iconic "outrun grid" landscape
that has been a staple of generative-art experiments since the
demoscene era.

The "80s Vector" look is built from three primitives:

    1. **A perspective-projected grid** — a flat 2D grid on the
       "ground plane" (y = 0 in 3D) is perspective-projected onto
       the canvas using a pinhole camera with the camera placed
       above the horizon, looking forward and slightly down.  Each
       grid line is drawn from (x, 0, z) in 3D to its 2D screen
       coordinate via the projection:
            screen_x = cx + (focal * world_x) / (world_z + offset)
            screen_y = horizon_y + (focal * world_y) / (world_z + offset)
       Lines closer to the camera (small z) appear larger; lines
       near the horizon compress to a single vanishing point.

    2. **Depth fog** — lines further from the camera fade toward
       the background colour via a linear alpha falloff, giving
       the characteristic 80s-synthwave atmospheric perspective.

    3. **A neon sun** — a horizontal "sun" disc (a glowing radial
       gradient circle) on the horizon.  Optionally a sunburst
       pattern of radiating lines.

The aesthetic is exactly the 80s-sci-fi computer-graphics look —
think TRON's light cycles, the outrun grid, Michael Jackson's
"Thriller" titles, or any of the 80s-synthwave album covers —
except rendered through Penne's curated palette (Zephyr-style)
rather than the canonical pink/cyan.

Reference:
- Aaron Penne on Apparitions (mentions 80s-vector aesthetic):
  https://www.artxcode.io/journal/aaron-penne-apparitions-on-art-blocks
- The canonical outrun grid pattern has been a generative-art
  staple since at least the early-2000s demoscene; Aaron Penne
  references this aesthetic in his work.
"""
from __future__ import annotations

from typing import ClassVar

import numpy as np


def _draw_filled_rect(
    canvas: np.ndarray, x0: float, y0: float, x1: float, y1: float,
    color: np.ndarray, alpha: float = 1.0,
) -> None:
    H, W, _ = canvas.shape
    xi0, xi1 = max(0, int(round(x0))), min(W, int(round(x1)) + 1)
    yi0, yi1 = max(0, int(round(y0))), min(H, int(round(y1)) + 1)
    if xi1 <= xi0 or yi1 <= yi0:
        return
    cur = canvas[yi0:yi1, xi0:xi1].astype(np.float32)
    canvas[yi0:yi1, xi0:xi1] = (cur * (1.0 - alpha) + color * alpha).astype(np.uint8)