95 lines
2.3 KiB
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
|
|
}
|