func (as *AudioSystem) Update(entity *ecs.Entity, dt float32) {
var ac *AudioComponent
var ok bool
if ac, ok = entity.ComponentFast(ac).(*AudioComponent); !ok {
return
}
if ac.player == nil {
f := Files.Sound(ac.File)
if f == nil {
return
}
var err error
ac.player, err = NewPlayer(f, 0, 0)
if err != nil {
log.Println("Error initializing AudioSystem:", err)
return
}
}
if ac.player.State() != Playing {
if ac.player.State() == Stopped {
if !ac.Repeat {
al.RewindSources(ac.player.source)
al.StopSources(ac.player.source)
entity.RemoveComponent(ac)
return
}
}
// Prepares if the track hasn't been buffered before.
if err := ac.player.prepare(ac.Background, 0, false); err != nil {
log.Println("Error initializing AudioSystem:", err)
return
}
al.PlaySources(ac.player.source)
if !ac.Background {
var space *SpaceComponent
var ok bool
if space, ok = entity.ComponentFast(space).(*SpaceComponent); !ok {
return
}
ac.player.source.SetPosition(al.Vector{
(space.Position.X + space.Width/2) / Width(),
(space.Position.Y + space.Height/2) / Height(),
0})
}
}
}
func (a *AudioSystem) Update(dt float32) {
for _, e := range a.entities {
if e.AudioComponent.player == nil {
f := Files.Sound(e.AudioComponent.File)
if f == nil {
log.Println("Audio file not loaded:", e.AudioComponent.File)
continue
}
var err error
e.AudioComponent.player, err = NewPlayer(f, 0, 0)
if err != nil {
log.Println("Error initializing AudioComponent:", err)
continue
}
}
if MasterVolume != a.cachedVolume {
e.AudioComponent.SetVolume(e.AudioComponent.RawVolume)
}
if e.AudioComponent.player.State() != Playing {
if e.AudioComponent.player.State() == Stopped {
if !e.AudioComponent.Repeat {
al.RewindSources(e.AudioComponent.player.source)
al.StopSources(e.AudioComponent.player.source)
// Remove it from this system, defer because we want to be sure it doesn't interfere with
// looping over a.entities
defer a.Remove(*e.BasicEntity)
continue
}
}
// Prepares if the track hasn't been buffered before.
if err := e.AudioComponent.player.prepare(e.AudioComponent.Background, 0, false); err != nil {
log.Println("Error initializing AudioComponent:", err)
continue
}
al.PlaySources(e.AudioComponent.player.source)
if !e.AudioComponent.Background {
e.AudioComponent.player.source.SetPosition(al.Vector{
(e.SpaceComponent.Position.X + e.SpaceComponent.Width/2) / GameWidth(), // TODO: ensure we're using correct Width/Height()
(e.SpaceComponent.Position.Y + e.SpaceComponent.Height/2) / GameHeight(),
0,
})
}
}
}
}
func (p *Player) Close() error {
if err := al.Error(); err != 0 {
return fmt.Errorf("driver: error before closing: %d", err)
}
if p.isClosed {
return nil
}
var bs []al.Buffer
al.RewindSources(p.alSource)
al.StopSources(p.alSource)
if n := p.alSource.BuffersQueued(); 0 < n {
bs = make([]al.Buffer, n)
p.alSource.UnqueueBuffers(bs...)
p.alBuffers = append(p.alBuffers, bs...)
}
p.isClosed = true
if err := al.Error(); err != 0 {
return fmt.Errorf("driver: error after closing: %d", err)
}
runtime.SetFinalizer(p, nil)
return nil
}
func (p *Player) Proceed(data []byte) error {
if err := al.Error(); err != 0 {
return fmt.Errorf("driver: before proceed: %d", err)
}
processedNum := p.alSource.BuffersProcessed()
if 0 < processedNum {
bufs := make([]al.Buffer, processedNum)
p.alSource.UnqueueBuffers(bufs...)
if err := al.Error(); err != 0 {
return fmt.Errorf("driver: Unqueue in process: %d", err)
}
p.alBuffers = append(p.alBuffers, bufs...)
}
if len(p.alBuffers) == 0 {
// This can happen (#207)
return nil
}
buf := p.alBuffers[0]
p.alBuffers = p.alBuffers[1:]
buf.BufferData(p.alFormat, data, int32(p.sampleRate))
p.alSource.QueueBuffers(buf)
if err := al.Error(); err != 0 {
return fmt.Errorf("driver: Queue in process: %d", err)
}
if p.alSource.State() == al.Stopped || p.alSource.State() == al.Initial {
al.RewindSources(p.alSource)
al.PlaySources(p.alSource)
if err := al.Error(); err != 0 {
return fmt.Errorf("driver: PlaySource in process: %d", err)
}
}
return nil
}