sfx_manager.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2008-2015 Joerg Henrichs
//
//  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.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#ifndef HEADER_SFX_MANAGER_HPP
#define HEADER_SFX_MANAGER_HPP

#include "utils/can_be_deleted.hpp"
#include "utils/leak_check.hpp"
#include "utils/no_copy.hpp"
#include "utils/synchronised.hpp"
#include "utils/vec3.hpp"

#include <condition_variable>
#include <map>
#include <string>
#include <thread>

#include <vector>

#ifdef ENABLE_SOUND
#  include <AL/al.h>
#  include <AL/alc.h>
#else
  typedef unsigned int ALuint;
#endif

class MusicInformation;
class SFXBase;
class SFXBuffer;
class XMLNode;

class SFXManager : public NoCopy, public CanBeDeleted
{
private:
    static SFXManager *m_sfx_manager;

public:

    enum SFXCommands
    {
        SFX_PLAY = 1,
        SFX_PLAY_POSITION,
        SFX_STOP,
        SFX_PAUSE,
        SFX_PAUSE_ALL,
        SFX_RESUME,
        SFX_RESUME_ALL,
        SFX_DELETE,
        SFX_SPEED,
        SFX_POSITION,
        SFX_SPEED_POSITION,
        SFX_VOLUME,
        SFX_MASTER_VOLUME,
        SFX_LOOP,
        SFX_LISTENER,
        SFX_UPDATE,
        SFX_MUSIC_START,
        SFX_MUSIC_STOP,
        SFX_MUSIC_PAUSE,
        SFX_MUSIC_RESUME,
        SFX_MUSIC_SWITCH_FAST,
        SFX_MUSIC_SET_TMP_VOLUME,
        SFX_MUSIC_WAITING,
        SFX_MUSIC_DEFAULT_VOLUME,
        SFX_EXIT,
        SFX_CREATE_SOURCE
    };   // SFXCommands

    enum CustomSFX : int
    {
        CUSTOM_HORN,    
        CUSTOM_CRASH,   
        CUSTOM_WIN,     
        CUSTOM_EXPLODE, 
        CUSTOM_GOO,     
        CUSTOM_PASS,    
        CUSTOM_ZIPPER,  
        CUSTOM_NAME,    
        CUSTOM_ATTACH,  
        CUSTOM_SHOOT,   
        NUM_CUSTOMS
    };

private:

    class SFXCommand : public NoCopy
    {
    private:
        LEAK_CHECK()
    public:
        SFXBase *m_sfx;

        SFXBuffer *m_buffer = NULL;

        MusicInformation *m_music_information;

        SFXCommands m_command;
        Vec3        m_parameter;
        // --------------------------------------------------------------------
        SFXCommand(SFXCommands command, SFXBase *base)
        {
            m_command   = command;
            m_sfx       = base;
        }   // SFXCommand()
        // --------------------------------------------------------------------
        SFXCommand(SFXCommands command, MusicInformation *mi)
        {
            m_command           = command;
            m_music_information = mi;
        }   // SFXCommnd(MusicInformation*)
        // --------------------------------------------------------------------
        SFXCommand(SFXCommands command, MusicInformation *mi, float f)
        {
            m_command = command;
            m_parameter.setX(f);
            m_music_information = mi;
        }   // SFXCommnd(MusicInformation *, float)
        // --------------------------------------------------------------------
        SFXCommand(SFXCommands command, SFXBase *base, float parameter)
        {
            m_command   = command;
            m_sfx       = base;
            m_parameter.setX(parameter);
        }   // SFXCommand(float)
        // --------------------------------------------------------------------
        SFXCommand(SFXCommands command, SFXBase *base, const Vec3 &parameter)
        {
            m_command   = command;
            m_sfx       = base;
            m_parameter = parameter;
        }   // SFXCommand(Vec3)
        // --------------------------------------------------------------------
        SFXCommand(SFXCommands command, SFXBase *base, float f,
                   const Vec3 &parameter)
        {
            m_command   = command;
            m_sfx       = base;
            m_parameter = parameter;
            m_parameter.setW(f);
        }   // SFXCommand(Vec3)
    };   // SFXCommand
    // ========================================================================

    Synchronised<Vec3>        m_listener_position;

    Vec3                      m_listener_front;

    Vec3                      m_listener_up;


    std::map<std::string, SFXBuffer*> m_all_sfx_types;

    Synchronised<std::vector<SFXBase*> > m_all_sfx;

    Synchronised< std::vector<SFXCommand*> > m_sfx_commands;

    Synchronised<std::map<std::string, SFXBase*> > m_quick_sounds;

    bool                      m_initialized;

    float                     m_master_gain;

#ifndef __SWITCH__

    std::thread               m_thread;
#endif

    uint64_t                  m_last_update_time;

    std::condition_variable   m_condition_variable;

    void                      loadSfx();
                             SFXManager();
    virtual                 ~SFXManager();

    static void mainLoop(void *obj);
    void deleteSFX(SFXBase *sfx);
    void queueCommand(SFXCommand *command);
    void reallyPositionListenerNow();

public:
    static void create();
    static void destroy();
    void queue(SFXCommands command, SFXBase *sfx=NULL);
    void queue(SFXCommands command, SFXBase *sfx, float f);
    void queue(SFXCommands command, SFXBase *sfx, const Vec3 &p);
    void queue(SFXCommands command, SFXBase *sfx, float f, const Vec3 &p);
    void queue(SFXCommands command, MusicInformation *mi);
    void queue(SFXCommands command, MusicInformation *mi, float f);
    void queue(SFXCommands command, SFXBase *sfx, const Vec3 &p, SFXBuffer* buffer);

    // ------------------------------------------------------------------------
    static SFXManager *get()
    {
        return m_sfx_manager;
    }   // get

    // ------------------------------------------------------------------------
    void                     stopThread();
    bool                     sfxAllowed();
    SFXBuffer*               loadSingleSfx(const XMLNode* node,
                                           const std::string &path=std::string(""),
                                           const bool load = true);
    SFXBuffer*               addSingleSfx(const std::string &sfx_name,
                                          const std::string &filename,
                                          bool               positional,
                                          float              rolloff,
                                          float              max_dist,
                                          float              gain,
                                          const bool         load = true);

    SFXBase*                 createSoundSource(SFXBuffer* info,
                                               const bool add_to_SFX_list=true,
                                               const bool owns_buffer=false);
    SFXBase*                 createSoundSource(const std::string &name,
                                               const bool addToSFXList=true);

    void                     deleteSFXMapping(const std::string &name);
    void                     pauseAll();
    void                     reallyPauseAllNow();
    void                     resumeAll();
    void                     reallyResumeAllNow();
    void                     update();
    void                     reallyUpdateNow(SFXCommand *current);
    bool                     soundExist(const std::string &name);
    void                     setMasterSFXVolume(float gain);
    float                    getMasterSFXVolume() const { return m_master_gain; }

    static bool              checkError(const std::string &context);
    static const std::string getErrorString(int err);

    void                     positionListener(const Vec3 &position,
                                              const Vec3 &front, const Vec3 &up);
    SFXBase*                 quickSound(const std::string &soundName);

    void                     toggleSound(const bool newValue);

    // ------------------------------------------------------------------------
    void dump();

    // ------------------------------------------------------------------------
    Vec3 getListenerPos() const { return m_listener_position.getData(); }

    // ------------------------------------------------------------------------

    SFXBuffer* getBuffer(const std::string &name);
};

#endif // HEADER_SFX_MANAGER_HPP