sound.h

Go to the documentation of this file.

 
#ifndef SOUND_H_
#define SOUND_H_
 
//incomplete types from SDL
struct musicrw;
struct _Mix_Music;
typedef struct _Mix_Music Mix_Music;
struct Mix_Chunk;

class SoundEngine
{
    public:
        SoundEngine();

        void clear_sound();

        void preloadsound(int n);

        void preloadmapsounds();

        int playsound(int n, const vec *loc = nullptr, extentity *ent = nullptr, int flags = 0, int loops = 0, int fade = 0, int chanid = -1, int radius = 0, int expire = -1);

        bool stopsound(int n, int chanid, int fade);

        void stopsounds();

        void updatesounds();

        int playsoundname(const char *s, const vec *loc, int vol, int flags, int loops, int fade, int chanid, int radius, int expire);

        void initsound();

        void startmusic(char *name, char *cmd);

        void resetsound();

        void setstereo(const int * const on);

        int getstereo();

        void setmaxradius(const int * const dist);

        int getmaxradius();

        void setsoundchans(const int * const val);

        int getsoundchans();

        void setsoundvol(const int * vol);

        int getsoundvol();

        void setmusicvol(const int * musicvol);

        int getmusicvol();

        void setaudiodriver(char * f);

        void setsound(const int * on);

        int getsound();

        void registersound(char *name, int *vol);

        void mapsound(char *name, int *vol, int *maxuses);

        void altsound(char *name, int *vol);

        void altmapsound(char *name, int *vol);

        void numsounds();

        void nummapsounds();

        void soundreset();

        void mapsoundreset();
 
    private:
        void stopmapsound(extentity *e);
 
        bool stereo = true;
 
        int maxsoundradius = 340;
 
        //free channels that are not playing sounds
        void reclaimchannels();
        void syncchannels();
        bool minimizedsounds = false;
        int getminimizedsounds();
        void setminimizedsounds(int minimize);
 
        void stopmapsounds();
        //check map entities to see what sounds need to be played because of them
        void checkmapsounds();
 
        //number of sounds before the game will refuse to play another sound (with `playsound()`);
        //set to 0 to disable checking (0 does not set no sounds to be playable)
        int maxsoundsatonce = 7;
        int getmaxsoundsatonce();
        void setmaxsoundsatonce(const int *num);
        int debugsound = 0;
 
        bool nosound = true;
 
        struct SoundSample
        {
            SoundEngine * const parent;
            std::string name;
            Mix_Chunk *chunk;
 
            SoundSample(SoundEngine& p);
            ~SoundSample();
 
            void cleanup();
 
            bool load(const char *dir);
        };
 
        struct soundslot
        {
            SoundSample *sample;
            int volume;
        };
 
        struct SoundConfig
        {
            int slots, numslots;
            int maxuses;
 
            bool hasslot(const soundslot *p, const std::vector<soundslot> &v) const;
 
            int chooseslot(int flags) const;
        };
 
        //sound channel object that is allocated to every sound emitter in use
        //(entities, players, weapons, etc.)
        //defined in world coordinates, and position mixing is done for the player dynamically
        class SoundChannel
        {
            public:
                bool inuse;
                const soundslot *slot;
                extentity *ent;
                int volume;
 
                SoundChannel(int id, SoundEngine& p);
 
                bool updatechannel();
                void syncchannel();
                void setupchannel(int n, const soundslot *slot, const vec *loc, extentity *ent, int flags, int radius);
 
                void setloc(const vec& newloc);
 
                bool hasloc() const;
 
                void clearloc();
                void reset();
            private:
                SoundEngine * const parent;
                int id;
                int radius, pan, flags;
                bool dirty;
                vec loc;
        };
 
        std::vector<SoundChannel> channels;
        int maxchannels = 0;
 
        int soundvol = 255;
 
        int musicvol = 60;
 
        bool shouldinitaudio = true;
 
    #ifdef WIN32
        #define AUDIODRIVER "directsound winmm"
    #else
        #define AUDIODRIVER "pulseaudio alsa arts esd jack pipewire dsp"
    #endif
 
        std::string audiodriver = AUDIODRIVER;
        bool sound;
 
        //# of sound channels (not physical output channels, but individual sound samples in use, such as weaps and light ents)
        int soundchans = 32;
        //max sound frequency (44.1KHz = CD)
        int soundfreq = 44100;
        //length of sound buffer in milliseconds
        int soundbufferlen = 1024;
 
        bool initaudio();
 
        struct SoundType
        {
            SoundEngine * const parent;
            std::map<std::string, SoundSample> samples;
            std::vector<soundslot> slots;
            std::vector<SoundConfig> configs;
            const char *dir;
            SoundType(const char *dir, SoundEngine& p);
            int findsound(const char *name, int vol);
            int addslot(const char *name, int vol);
            int addsound(const char *name, int vol, int maxuses = 0);
            void addalt(const char *name, int vol);
            void clear();
            void reset();
            void cleanupsamples();
            void cleanup();
            void preloadsound(int n);
            bool playing(const SoundChannel &chan, const SoundConfig &config) const;
        };
        SoundType gamesounds;
        SoundType mapsounds;
 
        //free all channels
        void resetchannels();
 
        void musicdone();
        Mix_Music *loadmusic(const char *name);
        Mix_Chunk *loadwav(const char *name);
 
        //creates a new SoundChannel object with passed properties
        SoundChannel &newchannel(int n, const soundslot *slot, const vec *loc = nullptr, extentity *ent = nullptr, int flags = 0, int radius = 0);
 
        //sets a channel as not being in use
        void freechannel(int n);
 
        void stopchannels();
 
        void setmusicvol(int musicvol);
 
        char *musicfile    = nullptr,
             *musicdonecmd = nullptr;
 
        Mix_Music *music    = nullptr;
        SDL_RWops *musicrw  = nullptr;
        stream *musicstream = nullptr;
 
        void stopmusic();
};
#endif