Checkpoint
This commit is contained in:
223 files changed
+14770
-18352
No files matched your search
@@ -0,0 +1,468 @@
|
||||
package shader
|
||||
|
||||
import "math"
|
||||
|
||||
// Effect defines the interface for shader effects.
|
||||
type Effect interface {
|
||||
Apply(x, y, width, height int, samples []float64) (r, g, b float64)
|
||||
}
|
||||
|
||||
type AudioIntensityBarsEffect struct{}
|
||||
|
||||
func (e *AudioIntensityBarsEffect) Apply(x, y, width, height int, sample []float64) (r, g, b float64) {
|
||||
// Calculate the average amplitude across all channels
|
||||
amplitude := 0.0
|
||||
for _, sample := range sample {
|
||||
amplitude += math.Abs(sample)
|
||||
}
|
||||
amplitude /= float64(len(sample))
|
||||
|
||||
// Map the amplitude to bar height
|
||||
barHeight := int(amplitude * float64(height))
|
||||
|
||||
// If the current y is within the bar height, light up the pixel
|
||||
if y < barHeight {
|
||||
intensity := 1.0 - (float64(y) / float64(barHeight))
|
||||
r = intensity
|
||||
g = intensity
|
||||
b = intensity
|
||||
}
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type StereoColorGradientEffect struct{}
|
||||
|
||||
func (e *StereoColorGradientEffect) Apply(x, y, _, _ int, sample []float64) (r, g, b float64) {
|
||||
left := math.Abs(sample[0])
|
||||
right := math.Abs(sample[1])
|
||||
|
||||
r = left
|
||||
g = right
|
||||
b = (left + right) / 2.0
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type StereoRippleEffect struct{}
|
||||
|
||||
func (e *StereoRippleEffect) Apply(x, y, width, height int, sample []float64) (r, g, b float64) {
|
||||
centerX := width / 2
|
||||
centerY := height / 2
|
||||
|
||||
dx := float64(x - centerX)
|
||||
dy := float64(y - centerY)
|
||||
distance := math.Sqrt(dx*dx + dy*dy)
|
||||
|
||||
// Use the difference between left and right channels for ripple intensity
|
||||
ripple := math.Sin(distance*0.1 - (sample[0]-sample[1])*10.0)
|
||||
ripple = (ripple + 1.0) / 2.0 // Normalize to [0, 1]
|
||||
|
||||
r = ripple
|
||||
g = ripple * 0.5
|
||||
b = ripple * 0.2
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type StereoSpectrumBarsEffect struct{}
|
||||
|
||||
func (e *StereoSpectrumBarsEffect) Apply(x, y, width, height int, sample []float64) (r, g, b float64) {
|
||||
barWidth := 10
|
||||
barIndex := x / barWidth
|
||||
|
||||
// Use left channel for even bars, right channel for odd bars
|
||||
var amplitude float64
|
||||
if barIndex%2 == 0 {
|
||||
amplitude = math.Abs(sample[0])
|
||||
} else {
|
||||
amplitude = math.Abs(sample[1])
|
||||
}
|
||||
|
||||
barHeight := int(amplitude * float64(barWidth))
|
||||
|
||||
if y < barHeight {
|
||||
r = 1.0
|
||||
g = 0.5
|
||||
b = 0.0
|
||||
}
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type ChannelSeparationEffect struct {
|
||||
}
|
||||
|
||||
func (e *ChannelSeparationEffect) Apply(x, y, width, _ int, sample []float64) (r, g, b float64) {
|
||||
// Split the screen vertically for stereo separation
|
||||
if len(sample) > 1 {
|
||||
if x < width/2 {
|
||||
// Left channel controls the left side
|
||||
r = math.Abs(sample[0])
|
||||
g = 0.0
|
||||
b = 0.0
|
||||
} else {
|
||||
// Right channel controls the right side
|
||||
r = 0.0
|
||||
g = math.Abs(sample[1])
|
||||
b = 0.0
|
||||
}
|
||||
} else {
|
||||
// Mono audio: use the same value for both sides
|
||||
r = math.Abs(sample[0])
|
||||
g = math.Abs(sample[0])
|
||||
b = math.Abs(sample[0])
|
||||
}
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type StereoWaveformEffect struct{}
|
||||
|
||||
func (e *StereoWaveformEffect) Apply(x, y, _, _ int, sample []float64) (r, g, b float64) {
|
||||
// Map the audio sample to the y-axis for each channel
|
||||
if len(sample) > 1 {
|
||||
leftY := int((sample[0] + 1.0) / 2.0 * float64(64))
|
||||
rightY := int((sample[1] + 1.0) / 2.0 * float64(64))
|
||||
|
||||
// Left channel (red)
|
||||
if math.Abs(float64(y)-float64(leftY)) < 2 {
|
||||
r = 1.0
|
||||
}
|
||||
// Right channel (green)
|
||||
if math.Abs(float64(y)-float64(rightY)) < 2 {
|
||||
g = 1.0
|
||||
}
|
||||
} else {
|
||||
// Mono audio: single waveform
|
||||
waveY := int((sample[0] + 1.0) / 2.0 * float64(64))
|
||||
if math.Abs(float64(y)-float64(waveY)) < 2 {
|
||||
r = 1.0
|
||||
g = 1.0
|
||||
b = 1.0
|
||||
}
|
||||
}
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type StereoSpectrumEffect struct {
|
||||
BarHeight int
|
||||
}
|
||||
|
||||
func (e *StereoSpectrumEffect) Apply(x, y, _, _ int, sample []float64) (r, g, b float64) {
|
||||
// Divide the screen into horizontal bars for each channel
|
||||
barHeight := e.BarHeight
|
||||
if barHeight < 1 {
|
||||
barHeight = 8
|
||||
}
|
||||
barIndex := y / barHeight
|
||||
|
||||
if len(sample) > 1 {
|
||||
if barIndex%2 == 0 {
|
||||
// Left channel (red)
|
||||
r = math.Abs(sample[0])
|
||||
} else {
|
||||
// Right channel (green)
|
||||
g = math.Abs(sample[1])
|
||||
}
|
||||
} else {
|
||||
// Mono audio: use the same value for all bars
|
||||
r = math.Abs(sample[0])
|
||||
g = math.Abs(sample[0])
|
||||
b = math.Abs(sample[0])
|
||||
}
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type StereoRadialEffect struct {
|
||||
}
|
||||
|
||||
func (e *StereoRadialEffect) Apply(x, y, width, height int, sample []float64) (r, g, b float64) {
|
||||
// Center of the screen
|
||||
centerX := width / 2
|
||||
centerY := height / 2
|
||||
|
||||
// Distance and angle from the center
|
||||
dx := float64(x - centerX)
|
||||
dy := float64(y - centerY)
|
||||
distance := math.Sqrt(dx*dx + dy*dy)
|
||||
angle := math.Atan2(dy, dx)
|
||||
|
||||
if len(sample) > 1 {
|
||||
// Left channel controls the top half, right channel controls the bottom half
|
||||
if angle > 0 {
|
||||
r = math.Abs(sample[0]) * (1.0 - distance/128.0)
|
||||
} else {
|
||||
g = math.Abs(sample[1]) * (1.0 - distance/128.0)
|
||||
}
|
||||
} else {
|
||||
// Mono audio: uniform radial effect
|
||||
r = math.Abs(sample[0]) * (1.0 - distance/128.0)
|
||||
g = math.Abs(sample[0]) * (1.0 - distance/128.0)
|
||||
b = math.Abs(sample[0]) * (1.0 - distance/128.0)
|
||||
}
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type StereoPulseEffect struct{}
|
||||
|
||||
func (e *StereoPulseEffect) Apply(x, y, _, _ int, sample []float64) (r, g, b float64) {
|
||||
if len(sample) > 1 {
|
||||
// Left channel controls horizontal pulsation
|
||||
r = 0.5 + 0.5*math.Sin(float64(x)*0.1+sample[0]*10.0)
|
||||
// Right channel controls vertical pulsation
|
||||
g = 0.5 + 0.5*math.Sin(float64(y)*0.1+sample[1]*10.0)
|
||||
} else {
|
||||
// Mono audio: uniform pulsation
|
||||
pulse := 0.5 + 0.5*math.Sin(float64(x+y)*0.1+sample[0]*10.0)
|
||||
r = pulse
|
||||
g = pulse
|
||||
b = pulse
|
||||
}
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type StereoSwirlEffect struct {
|
||||
}
|
||||
|
||||
func (e *StereoSwirlEffect) Apply(x, y, width, height int, sample []float64) (r, g, b float64) {
|
||||
// Center of the screen
|
||||
centerX := width / 2
|
||||
centerY := height / 2
|
||||
|
||||
// Distance and angle from the center
|
||||
dx := float64(x - centerX)
|
||||
dy := float64(y - centerY)
|
||||
angle := math.Atan2(dy, dx)
|
||||
|
||||
if len(sample) > 1 {
|
||||
// Left channel controls clockwise swirl, right channel controls counterclockwise swirl
|
||||
swirl := math.Sin(angle+sample[0]*10.0) + math.Cos(angle-sample[1]*10.0)
|
||||
r = (swirl + 1.0) / 2.0
|
||||
g = (1.0 - swirl) / 2.0
|
||||
b = 0.5
|
||||
} else {
|
||||
// Mono audio: uniform swirl
|
||||
swirl := math.Sin(angle + sample[0]*10.0)
|
||||
r = (swirl + 1.0) / 2.0
|
||||
g = (1.0 - swirl) / 2.0
|
||||
b = 0.5
|
||||
}
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type StereoMirrorEffect struct {
|
||||
Width int
|
||||
}
|
||||
|
||||
func (e *StereoMirrorEffect) Apply(x, y, _, _ int, sample []float64) (r, g, b float64) {
|
||||
if len(sample) > 1 {
|
||||
if x < e.Width/2 {
|
||||
// Left channel controls the left side
|
||||
r = math.Abs(sample[0])
|
||||
} else {
|
||||
// Right channel controls the mirrored right side
|
||||
r = math.Abs(sample[1])
|
||||
}
|
||||
} else {
|
||||
// Mono audio: uniform mirror
|
||||
r = math.Abs(sample[0])
|
||||
}
|
||||
g = r
|
||||
b = r
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type PulsatingCirclesEffect struct {
|
||||
}
|
||||
|
||||
func (e *PulsatingCirclesEffect) Apply(x, y, width, height int, sample []float64) (r, g, b float64) {
|
||||
// Center of the screen
|
||||
centerX := width / 2
|
||||
centerY := height / 2
|
||||
|
||||
// Distance from the center
|
||||
dx := float64(x - centerX)
|
||||
dy := float64(y - centerY)
|
||||
distance := math.Sqrt(dx*dx + dy*dy)
|
||||
|
||||
// Calculate the average amplitude across all channels
|
||||
amplitude := 0.0
|
||||
for _, sample := range sample {
|
||||
amplitude += math.Abs(sample)
|
||||
}
|
||||
amplitude /= float64(len(sample))
|
||||
|
||||
// Map the amplitude to the circle radius
|
||||
radius := amplitude * 64.0
|
||||
|
||||
// Light up pixels near the circle boundary
|
||||
if math.Abs(distance-radius) < 2 {
|
||||
intensity := 1.0
|
||||
r = intensity
|
||||
g = intensity
|
||||
b = intensity
|
||||
}
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type AudioNoiseEffect struct{}
|
||||
|
||||
func (e *AudioNoiseEffect) Apply(x, y, _, _ int, sample []float64) (r, g, b float64) {
|
||||
// Calculate the average amplitude across all channels
|
||||
amplitude := 0.0
|
||||
for _, sample := range sample {
|
||||
amplitude += math.Abs(sample)
|
||||
}
|
||||
amplitude /= float64(len(sample))
|
||||
|
||||
// Generate noise based on the amplitude
|
||||
noise := math.Sin(float64(x*y)) * amplitude
|
||||
intensity := (noise + 1.0) / 2.0
|
||||
r = intensity
|
||||
g = intensity
|
||||
b = intensity
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type AudioRipplesEffect struct{}
|
||||
|
||||
func (e *AudioRipplesEffect) Apply(x, y, width, height int, sample []float64) (r, g, b float64) {
|
||||
// Center of the screen
|
||||
centerX := width / 2
|
||||
centerY := height / 2
|
||||
|
||||
// Distance from the center
|
||||
dx := float64(x - centerX)
|
||||
dy := float64(y - centerY)
|
||||
distance := math.Sqrt(dx*dx + dy*dy)
|
||||
|
||||
// Calculate the average amplitude across all channels
|
||||
amplitude := 0.0
|
||||
for _, sample := range sample {
|
||||
amplitude += math.Abs(sample)
|
||||
}
|
||||
amplitude /= float64(len(sample))
|
||||
|
||||
// Create ripples based on the amplitude
|
||||
ripple := math.Sin(distance*0.1 - amplitude*10.0)
|
||||
intensity := (ripple + 1.0) / 2.0
|
||||
r = intensity
|
||||
g = intensity
|
||||
b = intensity
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type AudioScanlinesEffect struct{}
|
||||
|
||||
func (e *AudioScanlinesEffect) Apply(x, y, _, _ int, sample []float64) (r, g, b float64) {
|
||||
// Calculate the average amplitude across all channels
|
||||
amplitude := 0.0
|
||||
for _, sample := range sample {
|
||||
amplitude += math.Abs(sample)
|
||||
}
|
||||
amplitude /= float64(len(sample))
|
||||
|
||||
// Alternate scanlines based on the amplitude
|
||||
if y%2 == 0 {
|
||||
intensity := amplitude
|
||||
r = intensity
|
||||
g = intensity
|
||||
b = intensity
|
||||
} else {
|
||||
intensity := 1.0 - amplitude
|
||||
r = intensity
|
||||
g = intensity
|
||||
b = intensity
|
||||
}
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type MoireRotatingZoomerEffect struct {
|
||||
Time float64 // Time counter for animation
|
||||
}
|
||||
|
||||
func (e *MoireRotatingZoomerEffect) Apply(x, y, width, height int, sample []float64) (r, g, b float64) {
|
||||
// Center of the screen
|
||||
centerX := float64(width) / 2.0
|
||||
centerY := float64(height) / 2.0
|
||||
|
||||
// Normalized coordinates relative to the center
|
||||
dx := float64(x) - centerX
|
||||
dy := float64(y) - centerY
|
||||
|
||||
// Calculate the average amplitude across all channels
|
||||
amplitude := 0.0
|
||||
for _, sample := range sample {
|
||||
amplitude += math.Abs(sample)
|
||||
}
|
||||
amplitude /= float64(len(sample))
|
||||
|
||||
// Use amplitude to modulate rotation speed and zoom level
|
||||
rotationSpeed := 0.5 + amplitude*2.0 // Speed increases with amplitude
|
||||
zoomLevel := 1.0 + amplitude*2.0 // Zoom increases with amplitude
|
||||
|
||||
// Update time for animation
|
||||
e.Time += 0.01 * rotationSpeed
|
||||
|
||||
// Rotate and zoom the coordinates
|
||||
angle := e.Time
|
||||
cosA := math.Cos(angle)
|
||||
sinA := math.Sin(angle)
|
||||
rotatedX := dx*cosA - dy*sinA
|
||||
rotatedY := dx*sinA + dy*cosA
|
||||
|
||||
// Apply zoom
|
||||
rotatedX /= zoomLevel
|
||||
rotatedY /= zoomLevel
|
||||
|
||||
// Create a Moiré pattern using sine waves
|
||||
moire := math.Sin(rotatedX*0.1) * math.Sin(rotatedY*0.1)
|
||||
|
||||
// Map the Moiré pattern to gray scale intensity
|
||||
intensity := (moire + 1.0) / 2.0 // Normalize to [0, 1]
|
||||
r = intensity
|
||||
g = intensity
|
||||
b = intensity
|
||||
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
type RadialAudioIntensityEffect struct{}
|
||||
|
||||
func (e *RadialAudioIntensityEffect) Apply(x, y, width, height int, audioSample []float64) (r, g, b float64) {
|
||||
// Center of the screen
|
||||
centerX := float64(width) / 2.0
|
||||
centerY := float64(height) / 2.0
|
||||
|
||||
// Distance from the center
|
||||
dx := float64(x) - centerX
|
||||
dy := float64(y) - centerY
|
||||
distance := math.Sqrt(dx*dx + dy*dy)
|
||||
|
||||
// Calculate the average amplitude across all channels
|
||||
amplitude := 0.0
|
||||
for _, sample := range audioSample {
|
||||
amplitude += math.Abs(sample)
|
||||
}
|
||||
amplitude /= float64(len(audioSample))
|
||||
|
||||
// Map the amplitude to the radial intensity
|
||||
intensity := amplitude * (1.0 - distance/float64(width/2))
|
||||
r = intensity
|
||||
g = intensity
|
||||
b = intensity
|
||||
return r, g, b
|
||||
}
|
||||
|
||||
var (
|
||||
_ Effect = (*AudioIntensityBarsEffect)(nil)
|
||||
_ Effect = (*AudioNoiseEffect)(nil)
|
||||
_ Effect = (*AudioRipplesEffect)(nil)
|
||||
_ Effect = (*AudioScanlinesEffect)(nil)
|
||||
_ Effect = (*MoireRotatingZoomerEffect)(nil)
|
||||
_ Effect = (*PulsatingCirclesEffect)(nil)
|
||||
_ Effect = (*RadialAudioIntensityEffect)(nil)
|
||||
_ Effect = (*StereoColorGradientEffect)(nil)
|
||||
_ Effect = (*StereoMirrorEffect)(nil)
|
||||
_ Effect = (*StereoPulseEffect)(nil)
|
||||
_ Effect = (*StereoRadialEffect)(nil)
|
||||
_ Effect = (*StereoSpectrumBarsEffect)(nil)
|
||||
_ Effect = (*StereoSwirlEffect)(nil)
|
||||
_ Effect = (*StereoWaveformEffect)(nil)
|
||||
)
|
||||
@@ -0,0 +1,89 @@
|
||||
package shader
|
||||
|
||||
import (
|
||||
"image"
|
||||
"image/color"
|
||||
"image/draw"
|
||||
"math"
|
||||
|
||||
"github.com/BeatGlow/audio"
|
||||
|
||||
"github.com/BeatGlow/display/pixel"
|
||||
)
|
||||
|
||||
// Shader represents a shader that can render effects based on an audio stream.
|
||||
type Shader struct {
|
||||
Effects []Effect // List of effects to apply
|
||||
|
||||
canvas draw.Image
|
||||
buffer audio.Buffer[float64]
|
||||
}
|
||||
|
||||
func New(model color.Model, size image.Point) *Shader {
|
||||
switch model {
|
||||
case pixel.MonoModel:
|
||||
return &Shader{canvas: pixel.NewMonoImage(size.X, size.Y)}
|
||||
case pixel.Gray2Model:
|
||||
return &Shader{canvas: pixel.NewGray2Image(size.X, size.Y)}
|
||||
case pixel.Gray4Model:
|
||||
return &Shader{canvas: pixel.NewGray4Image(size.X, size.Y)}
|
||||
default:
|
||||
return &Shader{canvas: image.NewRGBA(image.Rectangle{Max: size})}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Shader) ProcessBuffer(buffer audio.Buffer[float64]) {
|
||||
if s.buffer == nil {
|
||||
s.buffer = make(audio.Buffer[float64], len(buffer))
|
||||
for channel, channels := 0, len(s.buffer); channel < channels; channel++ {
|
||||
s.buffer[channel] = make([]float64, len(buffer[0]))
|
||||
}
|
||||
}
|
||||
|
||||
for channel, channels := 0, len(s.buffer); channel < channels; channel++ {
|
||||
copy(s.buffer[channel], buffer[channel])
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Shader) Render() image.Image {
|
||||
size := s.canvas.Bounds().Size()
|
||||
for y := 0; y < size.Y; y++ {
|
||||
for x := 0; x < size.X; x++ {
|
||||
// Calculate the index in the audio data based on the x position
|
||||
audioIndex := int(float64(x) / float64(size.X) * float64(len(s.buffer[0])))
|
||||
if audioIndex >= len(s.buffer[0]) {
|
||||
audioIndex = len(s.buffer[0]) - 1
|
||||
}
|
||||
|
||||
// Get the audio sample for all channels
|
||||
audioSample := make([]float64, len(s.buffer))
|
||||
for channel := range s.buffer {
|
||||
audioSample[channel] = s.buffer[channel][audioIndex]
|
||||
}
|
||||
|
||||
// Apply all effects
|
||||
r, g, b := 0.0, 0.0, 0.0
|
||||
for _, fx := range s.Effects {
|
||||
er, eg, eb := fx.Apply(x, y, size.X, size.Y, audioSample)
|
||||
r += er
|
||||
g += eg
|
||||
b += eb
|
||||
}
|
||||
|
||||
// Normalize the color values to the range [0, 1]
|
||||
r = math.Min(math.Max(r, 0.0), 1.0)
|
||||
g = math.Min(math.Max(g, 0.0), 1.0)
|
||||
b = math.Min(math.Max(b, 0.0), 1.0)
|
||||
|
||||
// Set the pixel color
|
||||
s.canvas.Set(x, y, color.RGBA{
|
||||
R: uint8(r * 255),
|
||||
G: uint8(g * 255),
|
||||
B: uint8(b * 255),
|
||||
A: 255,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
return s.canvas
|
||||
}
|
||||
Reference in new issue
Block a user