bubbletea/examples/splash/main.go
2025-11-04 15:04:06 -05:00

178 lines
3.8 KiB
Go

package main
import (
"fmt"
"image/color"
"math"
"strings"
"time"
tea "charm.land/bubbletea/v2"
"charm.land/lipgloss/v2"
)
// This example was ported from the awesome Textualize project by @willmcgugan.
// Check it out here:
// https://github.com/Textualize/textual/blob/main/examples/splash.py
// Color gradient
var colors = []color.Color{
lipgloss.Color("#881177"),
lipgloss.Color("#aa3355"),
lipgloss.Color("#cc6666"),
lipgloss.Color("#ee9944"),
lipgloss.Color("#eedd00"),
lipgloss.Color("#99dd55"),
lipgloss.Color("#44dd88"),
lipgloss.Color("#22ccbb"),
lipgloss.Color("#00bbcc"),
lipgloss.Color("#0099cc"),
lipgloss.Color("#3366bb"),
lipgloss.Color("#663399"),
}
type model struct {
width int
height int
rate int64
}
func (m model) Init() tea.Cmd {
return tick
}
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
switch msg := msg.(type) {
case tea.KeyPressMsg:
return m, tea.Quit
case tea.WindowSizeMsg:
m.width = msg.Width
m.height = msg.Height
case tickMsg:
return m, tick
}
return m, nil
}
func (m model) View() tea.View {
var v tea.View
v.AltScreen = true
if m.width == 0 {
v.SetContent("Initializing...")
return v
}
v.SetContent(m.gradient())
return v
}
func (m model) gradient() string {
// Time-based angle for animation
t := float64(time.Now().UnixNano()*m.rate) / float64(time.Second)
angleRadians := -t * math.Pi / 180.0
sinAngle := math.Sin(angleRadians)
cosAngle := math.Cos(angleRadians)
centerX := float64(m.width) / 2
centerY := float64(m.height)
var output strings.Builder
for lineY := range m.height {
pointY := float64(lineY)*2 - centerY
pointX := 0.0 - centerX
x1 := (centerX + (pointX*cosAngle - pointY*sinAngle)) / float64(m.width)
x2 := (centerX + (pointX*cosAngle - (pointY+1.0)*sinAngle)) / float64(m.width)
pointX = float64(m.width) - centerX
endX1 := (centerX + (pointX*cosAngle - pointY*sinAngle)) / float64(m.width)
deltaX := (endX1 - x1) / float64(m.width)
if math.Abs(deltaX) < 0.0001 {
// Special case for verticals
color1 := getGradientColor(x1)
color2 := getGradientColor(x2)
style := lipgloss.NewStyle().
Foreground(color1).
Background(color2)
output.WriteString(style.Render(strings.Repeat("▀", m.width)))
} else {
// Render each column in the row
for x := range m.width {
pos1 := x1 + float64(x)*deltaX
pos2 := x2 + float64(x)*deltaX
color1 := getGradientColor(pos1)
color2 := getGradientColor(pos2)
style := lipgloss.NewStyle().
Foreground(color1).
Background(color2)
output.WriteString(style.Render("▀"))
}
}
if lineY < m.height-1 {
output.WriteString("\n")
}
}
return output.String()
}
func getGradientColor(position float64) color.Color {
// Normalize position to [0,1]
if position <= 0 {
position = 0
}
if position >= 1 {
position = 1
}
// Calculate the color index
idx := position * float64(len(colors)-1)
i1 := int(math.Floor(idx))
i2 := int(math.Ceil(idx))
// Ensure indices are within bounds
i1 = i1 % len(colors)
i2 = i2 % len(colors)
if i1 < 0 {
i1 += len(colors)
}
if i2 < 0 {
i2 += len(colors)
}
// Interpolate between colors
t := idx - float64(i1)
return interpolateColors(colors[i1], colors[i2], t)
}
func interpolateColors(color1, color2 color.Color, t float64) color.Color {
// Parse hex colors
r1, g1, b1, _ := color1.RGBA()
r1, g1, b1 = r1>>8, g1>>8, b1>>8
r2, g2, b2, _ := color2.RGBA()
r2, g2, b2 = r2>>8, g2>>8, b2>>8
// Interpolate
r := int(float64(r1)*(1-t) + float64(r2)*t)
g := int(float64(g1)*(1-t) + float64(g2)*t)
b := int(float64(b1)*(1-t) + float64(b2)*t)
return color.RGBA{uint8(r), uint8(g), uint8(b), 255}
}
type tickMsg time.Time
func tick() tea.Msg {
return tickMsg(time.Now())
}
func main() {
p := tea.NewProgram(
model{rate: 90},
)
if _, err := p.Run(); err != nil {
fmt.Printf("Error running program: %v", err)
}
}