Files
beatglow/app/shader/shader.go

95 lines
2.3 KiB
Go

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])
}
// Normalize channels
for c := range s.buffer {
audio.Normalize(s.buffer[c])
}
}
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
}