CUSoundEngine.h

//
//  CUSoundEngine.h
//  Cornell Extensions to Cocos2D
//
//  This module provides a robust sound engine for Cocos2d applications.  It is built on top of
//  the new experimental AudioEngine, making it a lot more user friendly.  It provides all of
//  the functionality of SimpleAudioEngine except pan and pitch control.  As there is no true
//  cross platform support for either of these (they are usually ignored on non-Apple platforms)
//  this should not be a problem.
//
//  IMPORTANT: It is absolutely crucial on iOS that all sounds have exactly the same format.
//  The same file format, the same sampling rate, the same number of channels.  Any change in
//  format requires a reconfiguration of the mixer graph, and this can cause clipping and/or
//  distortion for rapid-fire sound effects.
//
//  Author: Walker White
//  Version: 12/10/15
//
#ifndef __CU_SOUND_ENGINE_H__
#define __CU_SOUND_ENGINE_H__

#include <audio/include/AudioEngine.h>

NS_CC_BEGIN

class Sound;

#define AENG experimental::AudioEngine

class CC_DLL SoundEngine {
public:
    
#pragma mark -
#pragma mark Sound Packet

    class SoundPacket {
    public:
        const std::string getKey() const    { return _key; }
        
        const Sound* getSound() const  { return _sound; }
        
        SoundPacket(const SoundPacket& data) :
        SoundPacket(data._key, data._sound, data._loop, data._volume) {}
        
        ~SoundPacket() { }
        
    protected:
        std::string _key;
        
        Sound* _sound;
        
        bool  _loop;
        
        float _volume;
        
        int _sndid;
        
        SoundPacket(const std::string& k, Sound* s, bool l, float v) :
        _sndid(-1), _sound(s), _key(k), _loop(l), _volume(v) {}
        
        SoundPacket() : _sndid(-1), _sound(nullptr), _key(""), _loop(false), _volume(0.0f) {}
        
        void set(const SoundPacket& data) {
            _sound = data._sound; _key = data._key; _loop = data._loop; _volume = data._volume;
        }
        
        friend class SoundEngine;
    };
    
    
#pragma mark -
#pragma mark Sound State
    
    enum class SoundState {
        INACTIVE,
        LOADING,
        PLAYING,
        PAUSED
    };
    
    
#pragma mark -
#pragma mark Sound Engine
protected:
    static SoundEngine* _gEngine;
    
    experimental::AudioProfile* _musicProfile;
    experimental::AudioProfile* _effectProfile;
    
    SoundPacket* _musicData;
    std::deque<SoundPacket*> _mqueue;
    
    SoundPacket** _effectData;
    std::unordered_map<std::string,int> _effectIDs;
    std::deque<std::string> _equeue;
    
    
#pragma mark Allocation

    SoundEngine() : _musicData(nullptr), _musicProfile(nullptr), _effectProfile(nullptr), _effectData(nullptr) {}
    
    ~SoundEngine() { dispose(); }
    
    bool init();
    
    void dispose();
    
    void clearQueue();
    
    
#pragma mark Audio Helpers

    void playMusic(SoundPacket* data);
    
    void playEffect(SoundPacket* data, bool force=false);
    
    static SoundState convertAudioState(AENG::AudioState state);
    
    void gcMusic(int id);
    
    void gcEffect(int id, const std::string key);
    
    
public:
#pragma mark Static Accessors

    static SoundEngine* getInstance() { return _gEngine; }
    
    static void start();
    
    static void stop();
    
    
#pragma mark -
#pragma mark Music Management

    void playMusic(Sound* sound, bool loop=false, float volume=1.0);
    
    const Sound* currentMusic() const { return (_musicData->_sndid != -1 ? _musicData->_sound : nullptr); }
    
    SoundState getMusicState() const;
    
    bool isMusicLoop() const    { return _musicData->_sndid != -1 && _musicData->_loop; }
    
    void setMusicLoop(bool loop);  // Clears the queue
    
    bool getMusicVolume() const { return (_musicData->_sndid != -1 ? _musicData->_volume : 0.0f); }
    
    void setMusicVolume(float volume);
    
    float getMusicDuration() const  {
        return _musicData->_sndid != -1 ? AENG::getDuration(_musicData->_sndid) : 0.0f;
    }
    
    float getMusicElapsed() const {
        return _musicData->_sndid != -1 ? AENG::getCurrentTime(_musicData->_sndid) : 0.0f;
    }
    
    float getMusicRemaining() const {
        return _musicData->_sndid != -1 ?
        AENG::getDuration(_musicData->_sndid)-AENG::getCurrentTime(_musicData->_sndid) :
        0.0f;
    }
    
    void setMusicElapsed(float time);
    
    void setMusicRemaining(float time);
    
    void stopMusic();
    
    void pauseMusic();
    
    void resumeMusic();
    
    void restartMusic();
    
    
#pragma mark Music Queue

    void queueMusic(Sound* sound, bool loop=false, float volume=1.0);
    
    const std::vector<const Sound*> getMusicQueue() const;
    
    size_t getMusicQueueSize() const { return _mqueue.size(); }
    
    void skipMusicQueue(unsigned int steps=0);
    
    
#pragma mark -
#pragma mark Sound Effect Management

    void playEffect(std::string key, Sound* sound, bool loop=false, float volume=1.0f, bool force=false);
    
    int getAvailableChannels() { return _effectProfile->maxInstances-(int)_effectIDs.size(); }
    
    bool isActiveEffect(std::string key) const { return _effectIDs.find(key) != _effectIDs.end(); }
    
    SoundState getEffectState(std::string key) const;
    
    bool isEffectLoop(std::string key) const;
    
    void setEffectLoop(std::string key, bool loop);
    
    float getEffectVolume(std::string key) const;
    
    void setEffectVolume(std::string key, float volume);
    
    float getEffectDuration(std::string key) const;
    
    float getEffectElapsed(std::string key) const;
    
    float getEffectRemaining(std::string key) const;
    
    void setEffectElapsed(std::string key, float time);
    
    void setEffectRemaining(std::string key, float time);
    
    void stopEffect(std::string key);
    
    void pauseEffect(std::string key);
    
    void resumeEffect(std::string key);
    
    void restartEffect(std::string key);
    
    void stopAllEffects();
    
    void pauseAllEffects();
    
    void resumeAllEffects();
    
    
#pragma mark -
#pragma mark Global Management

    void stopAll();
    
    void pauseAll();
    
    void resumeAll();
};

NS_CC_END
#endif /* defined(__CU_SOUND_ENGINE_H__) */