Audio.h

Go to the documentation of this file.

/* Copyright © 2010 James Legg.
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
*/

#ifndef ENGINE_AUDIO_H
#define ENGINE_AUDIO_H

#include <AL/alut.h>
#include <LinearMath/btVector3.h>
#include <LinearMath/btTransform.h>
#include <boost/shared_ptr.hpp>
#include <vector>

namespace Engine
{

class SoundSource;
class SoundListener;
class SoundInstance;
class ALSoundSource;

class Audio
{
    private:
        Audio();
    public:
        ~Audio();
        static Audio & get_instance();
        void pause();
        void resume();
        bool get_paused();
        void commit();
        void attach_listner(SoundListener * listener);
        void attach_source(SoundSource * source);
        void forget_listener(SoundListener * listener);
        void forget_source(SoundSource * source);
    private:
        std::vector<boost::shared_ptr<SoundInstance> > m_instances;
        std::vector<SoundListener *> m_listeners;
        std::vector<SoundSource *> m_sources;
        std::vector<boost::shared_ptr<ALSoundSource> > m_al_sources;
        
        ALfloat m_speed_of_sound;
        
        bool m_paused;
};

class SoundBuffer
{
    public:
        SoundBuffer(const char * filename);
        ~SoundBuffer();
        // get the openAL buffer name.
        ALuint get_al_buffer() const;
    private:
        ALuint m_buffer;
        // no copying or assignment
        SoundBuffer(const SoundBuffer & source);
        SoundBuffer & operator=(const SoundBuffer & source);
};

class SoundListener
{
    friend class Audio;
    public:
        SoundListener();
        ~SoundListener();
        void set_position(btVector3 position, btVector3 forward, btVector3 up);
        void set_velocity(btVector3 velocity);
    private:
        btVector3 m_position;
        btVector3 m_forward;
        btVector3 m_up;
        btVector3 m_velocity;
        btTransform m_inverse_transform;
        // no copying or assignment
        SoundListener(const SoundListener & source);
        SoundListener & operator=(const SoundListener & source);
};

class SoundSource
{
    friend class Audio;
    public:
        SoundSource(const SoundBuffer & buffer);
        ~SoundSource();
        void set_looping(bool loop = true);
        
        void set_position(btVector3 position);
        void set_velocity(btVector3 velocity);
        void set_gain(ALfloat gain);
        
        void set_pitch(ALfloat pitch);
        
        void play();
        
        void stop();
        
        const SoundBuffer & get_buffer() const;
    private:
        const SoundBuffer & m_buffer;
        
        bool m_looping;
        ALfloat m_gain;
        ALfloat m_pitch;
        btVector3 m_position;
        btVector3 m_velocity;
        bool m_playing;
        bool m_started;
        // no copying or assignment
        SoundSource(const SoundSource & source);
        SoundSource & operator=(const SoundSource & source);
};

class SoundInstance
{
    public:
        SoundInstance(ALuint buffer);
        ALuint get_buffer();
        bool get_assigned();
        unsigned int get_index();
        void assign(ALSoundSource & source, unsigned int index);
        void unassign();
        void set_gain(ALfloat gain);
        ALfloat get_gain();
        void set_pitch(ALfloat pitch);
        void set_position(btVector3 position);
        void set_looping(bool looping = true);
        bool get_looping();
        
        void play();
        void stop();
        bool get_playing();
        
        void update_al();
    private:
        ALSoundSource * m_source;
        unsigned int m_source_index;
        ALuint m_buffer;
        ALfloat m_gain;
        ALfloat m_pitch;
        btVector3 m_position;
        bool m_looping;
        bool m_playing;
        bool m_assigning;
};

class ALSoundSource
{
    public:
        ALSoundSource();
        ~ALSoundSource();
        ALuint get_name();
        SoundInstance * get_instance();
        void assign(SoundInstance & si);
        void unassign();
    private:
        ALuint m_name;
        SoundInstance * m_instance;
        // no copying or assignment
        ALSoundSource (const ALSoundSource & source);
        ALSoundSource & operator=(const ALSoundSource & source);
};

class AudioError
{
};

}// namespace Engine

#endif // ndef ENGINE_AUDIO_H

---

Generated at Mon Sep 6 00:41:12 2010 by Doxygen version 1.4.7 for Racer version svn335.