Add 80s retro syntwave visualizer

Author: bjarneo

ui/keys.go

@@ -282,7 +282,7 @@ func (m *Model) handleKey(msg tea.KeyMsg) tea.Cmd {
 	case "V":
 		m.fullVis = !m.fullVis
 		if m.fullVis {
-			m.vis.Rows = max(defaultVisRows, (m.height-10)*3/5)
+			m.vis.Rows = max(defaultVisRows, (m.height-10)*4/5)
 		} else {
 			m.vis.Rows = defaultVisRows
 		}

ui/model.go

@@ -642,7 +642,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.width = msg.Width
 		m.height = msg.Height
 		if m.fullVis {
-			m.vis.Rows = max(defaultVisRows, (m.height-10)*3/5)
+			m.vis.Rows = max(defaultVisRows, (m.height-10)*4/5)
 		}
 
 	case tickMsg:

ui/visualizer.go

@@ -25,6 +25,7 @@ const (
 	VisWave                   // braille waveform oscilloscope
 	VisScatter                // braille particle sparkle
 	VisFlame                  // braille rising flame tendrils
+	VisRetro                  // 80s synthwave perspective grid with wave
 	VisNone                   // hidden — no visualizer
 	visCount                  // sentinel for cycling
 )
@@ -88,6 +89,8 @@ func (v *Visualizer) ModeName() string {
 		return "Scatter"
 	case VisFlame:
 		return "Flame"
+	case VisRetro:
+		return "Retro"
 	case VisNone:
 		return "None"
 	default:
@@ -189,6 +192,8 @@ func (v *Visualizer) Render(bands [numBands]float64) string {
 		return v.renderScatter(bands)
 	case VisFlame:
 		return v.renderFlame(bands)
+	case VisRetro:
+		return v.renderRetro(bands)
 	case VisNone:
 		return ""
 	default:
@@ -523,6 +528,177 @@ func (v *Visualizer) renderFlame(bands [numBands]float64) string {
 	return strings.Join(lines, "\n")
 }
 
+// renderRetro draws a retro 80s synthwave scene: a striped setting sun above
+// the horizon, a smooth audio-reactive wave, and a perspective grid floor that
+// scrolls toward the viewer. Uses Braille characters for sub-cell resolution.
+func (v *Visualizer) renderRetro(bands [numBands]float64) string {
+	height := v.Rows
+	const charCols = 69
+	dotRows := height * 4
+	dotCols := charCols * 2
+
+	// Horizon at 40% from top — gives room for wave and sun above.
+	horizonDot := dotRows * 2 / 5
+	if horizonDot < 2 {
+		horizonDot = 2
+	}
+	floorRows := dotRows - horizonDot
+	centerX := float64(dotCols-1) / 2.0
+
+	// Dot types: 0=empty, 1=grid, 2=wave, 3=sun.
+	grid := make([][]byte, dotRows)
+	for i := range grid {
+		grid[i] = make([]byte, dotCols)
+	}
+
+	// ── SUN ── striped semicircle above horizon.
+	sunR := float64(horizonDot) * 0.85
+	for dy := range horizonDot {
+		rowDist := float64(horizonDot - dy) // dots above horizon
+		if rowDist > sunR {
+			continue
+		}
+		halfW := math.Sqrt(sunR*sunR - rowDist*rowDist)
+
+		// Bottom half of sun has horizontal stripe gaps.
+		if rowDist < sunR*0.5 {
+			sw := max(1, int(sunR*0.15))
+			if (int(rowDist)/sw)%2 == 1 {
+				continue
+			}
+		}
+
+		left := max(0, int(centerX-halfW))
+		right := min(dotCols-1, int(centerX+halfW))
+		for dx := left; dx <= right; dx++ {
+			grid[dy][dx] = 3
+		}
+	}
+
+	// ── HORIZON LINE ──
+	for dx := range dotCols {
+		grid[horizonDot][dx] = 1
+	}
+
+	// ── PERSPECTIVE GRID FLOOR ──
+
+	// Vertical lines converging to vanishing point at (centerX, horizonDot).
+	const numVLines = 18
+	for i := range numVLines + 1 {
+		bottomX := float64(i) * float64(dotCols-1) / float64(numVLines)
+		for dy := horizonDot + 1; dy < dotRows; dy++ {
+			t := float64(dy-horizonDot) / float64(max(1, floorRows-1))
+			screenX := centerX + (bottomX-centerX)*t
+			ix := int(math.Round(screenX))
+			if ix >= 0 && ix < dotCols {
+				grid[dy][ix] = 1
+			}
+		}
+	}
+
+	// Horizontal lines scrolling toward the viewer.
+	scroll := math.Mod(float64(v.frame)*0.08, 1.0)
+	const numHLines = 10
+	for i := range numHLines {
+		z := (float64(i) + scroll) / float64(numHLines)
+		if z > 1.0 {
+			z -= 1.0
+		}
+		// Quadratic perspective: dense near horizon, spread near viewer.
+		dy := horizonDot + 1 + int(z*z*float64(max(1, floorRows-2)))
+		if dy > horizonDot && dy < dotRows {
+			for dx := range dotCols {
+				grid[dy][dx] = 1
+			}
+		}
+	}
+
+	// ── AUDIO WAVE AT HORIZON ──
+	waveY := make([]int, dotCols)
+	maxWave := float64(horizonDot) * 0.85
+	for dx := range dotCols {
+		bandF := float64(dx) / float64(max(1, dotCols-1)) * float64(numBands-1)
+		bi := int(bandF)
+		frac := bandF - float64(bi)
+
+		// Cosine interpolation for a smooth curve between bands.
+		t := (1 - math.Cos(frac*math.Pi)) / 2
+
+		var level float64
+		if bi >= numBands-1 {
+			level = bands[numBands-1]
+		} else {
+			level = bands[bi]*(1-t) + bands[bi+1]*t
+		}
+
+		// Small floor so the wave never fully vanishes.
+		level = max(0.03, level)
+
+		wy := horizonDot - int(level*maxWave)
+		waveY[dx] = max(0, min(dotRows-1, wy))
+	}
+
+	// Draw wave with continuous line connections.
+	for dx := range dotCols {
+		y := waveY[dx]
+		grid[y][dx] = 2
+		if dx > 0 {
+			lo, hi := min(y, waveY[dx-1]), max(y, waveY[dx-1])
+			for fy := lo; fy <= hi; fy++ {
+				grid[fy][dx] = 2
+			}
+		}
+	}
+
+	// ── RENDER BRAILLE ──
+	lines := make([]string, height)
+	for row := range height {
+		var sb strings.Builder
+		base := row * 4
+
+		for ch := range charCols {
+			var braille rune = '\u2800'
+			colBase := ch * 2
+			hasWave, hasSun := false, false
+
+			for dr := range 4 {
+				for dc := range 2 {
+					dy := base + dr
+					dx := colBase + dc
+					if dy >= dotRows || dx >= dotCols {
+						continue
+					}
+					switch grid[dy][dx] {
+					case 1:
+						braille |= brailleBit[dr][dc]
+					case 2:
+						braille |= brailleBit[dr][dc]
+						hasWave = true
+					case 3:
+						braille |= brailleBit[dr][dc]
+						hasSun = true
+					}
+				}
+			}
+
+			// Priority: wave (red) > sun (yellow) > grid (green).
+			var style lipgloss.Style
+			switch {
+			case hasWave:
+				style = specHighStyle
+			case hasSun:
+				style = specMidStyle
+			default:
+				style = specLowStyle
+			}
+			sb.WriteString(style.Render(string(braille)))
+		}
+		lines[row] = sb.String()
+	}
+
+	return strings.Join(lines, "\n")
+}
+
 // specStyle returns the spectrum color style for a given row height (0-1).
 func specStyle(rowBottom float64) lipgloss.Style {
 	switch {