AudioManager.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears 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.
 */
 
#pragma once
 
#include <OgreSingleton.h>
#include <boost/thread.hpp>
#include <vorbis/vorbisfile.h>
#include "Manager.h"
 
// Include OpenAL
#if defined(__WIN32__) || defined(_WIN32)
    #include <al.h>
    #include <alc.h>
#else
    #include <AL/al.h>
    #include <AL/alc.h>
#endif
 
class AudioManager : public Manager, public Ogre::Singleton<AudioManager>{
 
    public:
 
        struct Music{
 
            Ogre::String name;
 
            Ogre::String file;
 
            float loop;
        };
 
        struct Sound{
 
            Ogre::String name;
 
            Ogre::String file;
        };
 
        AudioManager();
 
        virtual ~AudioManager();
 
        void operator()();
 
        void Input(const VGears::Event& event) override;
 
        void UpdateDebug() override;
 
        void OnResize() override;
 
        void ClearField() override;
 
        void ClearBattle() override;
 
        void ClearWorld() override;
 
        void MusicPause();
 
        void MusicResume();
 
        void ScriptPlayMusic(const char* name);
 
        void MusicPlay(const Ogre::String& name);
 
        void ScriptPlaySound(const char* name);
 
        void ScriptPlaySound(const char* name, const int channel);
 
        void ScriptPlaySounds(
          const char* name1, const char* name2, const char* name3, const char* name4
        );
 
        void SoundPlay(const Ogre::String& name);
 
        void MusicStop();
 
        void AddMusic(const AudioManager::Music& music);
 
        AudioManager::Music* GetMusic(const Ogre::String& name);
 
        void AddSound(const AudioManager::Sound& sound);
 
        AudioManager::Sound* GetSound(const Ogre::String& name);
 
        void AddTrack(const int id, const int track_id);
 
        int ScriptGetTrack(int id);
 
        int ScriptGetBattleTrack();
 
        void ScriptSetBattleTrack(int id);
 
    private:
 
        class Player{
 
            public:
                Player(boost::recursive_mutex* mutex);
 
                ~Player();
 
                void Pause();
 
                void Play(const Ogre::String& file);
 
                void Resume();
 
                void Stop();
 
                void SetLoop(const float loop);
 
                void Update();
 
                float GetPosition();
 
            private:
 
                boost::recursive_mutex* update_mutex_;
 
                float loop_;
 
                Ogre::String file_;
 
                OggVorbis_File vorbis_file_;
 
                vorbis_info* vorbis_info_;
 
                int vorbis_section_;
 
                bool stream_finished_;
 
                char* buffer_;
 
                ALuint source_;
 
                ALsizei FillBuffer();
        };
 
        const bool Init();
 
        const char* ALError();
 
        const char* ALCError( const ALCdevice* device );
 
        void UpdateField() override;
 
        void UpdateBattle() override;
 
        void UpdateWorld() override;
 
        bool initialized_;
 
        ALCdevice* al_device_;
 
        ALCcontext* al_context_;
 
        char* buffer_;
 
        boost::recursive_mutex update_mutex_;
 
        boost::thread* update_thread_;
 
        bool thread_continue_;
 
        AudioManager::Player music_;
 
        AudioManager::Player battle_music_;
 
        AudioManager::Player fx_;
 
        std::list<AudioManager::Music> music_list_;
 
        std::unordered_map<unsigned int, unsigned int> tracks_;
 
        int battle_track_;
 
        std::list<AudioManager::Sound> sound_list_;
 
        static ALsizei channel_buffer_size_;
 
        static int channel_buffer_number_;
};