audio_manager.h

Go to the documentation of this file.

#pragma once
 
#include <atomic>
#include <mutex>
#include <thread>
#include <unordered_set>
#include <unordered_map>
#include <chrono>
#include <string>
#include <memory>
#include <vector>
#include <stdexcept>
#include <random>
#include <functional>
#include "logging.h"
#include "vec3.h"
 
#ifdef PlaySound
#undef PlaySound
#endif
 
namespace audio {
 
class AudioException : public std::runtime_error {
public:
    explicit AudioException(const std::string& message) 
        : std::runtime_error(message) {}
};
 
class InvalidHandleException : public AudioException {
public:
    explicit InvalidHandleException(const std::string& message)
        : AudioException(message) {}
};
 
class FileLoadException : public AudioException {
public:
    explicit FileLoadException(const std::string& message)
        : AudioException(message) {}
};
 
class NotInitializedException : public AudioException {
public:
    explicit NotInitializedException(const std::string& message)
        : AudioException(message) {}
};
 
} // namespace audio
 
// Forward declarations
namespace audio {
    class AudioSystem;
    class AudioTrack;
    class AudioGroup;
    class Sound;
}
 
// Place std type usage in global namespace
using ::std::atomic;
using ::std::mutex;
using ::std::thread;
using ::std::unordered_set;
using ::std::unordered_map;
using ::std::string;
using ::std::unique_ptr;
using ::std::shared_ptr;
using namespace ::std::chrono_literals;
 
namespace audio {
 
struct TrackHandle {
    uint32_t value{0};
 
    static constexpr TrackHandle Invalid() { return TrackHandle{0}; }
    constexpr bool IsValid() const { return value != 0; }
    constexpr uint32_t Value() const { return value; }
    explicit constexpr operator bool() const { return IsValid(); }
    friend constexpr bool operator==(const TrackHandle&, const TrackHandle&) = default;
};
 
struct GroupHandle {
    uint32_t value{0};
 
    static constexpr GroupHandle Invalid() { return GroupHandle{0}; }
    constexpr bool IsValid() const { return value != 0; }
    constexpr uint32_t Value() const { return value; }
    explicit constexpr operator bool() const { return IsValid(); }
    friend constexpr bool operator==(const GroupHandle&, const GroupHandle&) = default;
};
 
struct SoundHandle {
    uint32_t value{0};
 
    static constexpr SoundHandle Invalid() { return SoundHandle{0}; }
    constexpr bool IsValid() const { return value != 0; }
    constexpr uint32_t Value() const { return value; }
    explicit constexpr operator bool() const { return IsValid(); }
    friend constexpr bool operator==(const SoundHandle&, const SoundHandle&) = default;
};
 
} // namespace audio
 
namespace std {
template <>
struct hash<audio::TrackHandle> {
    size_t operator()(const audio::TrackHandle& handle) const noexcept {
        return std::hash<uint32_t>{}(handle.Value());
    }
};
 
template <>
struct hash<audio::GroupHandle> {
    size_t operator()(const audio::GroupHandle& handle) const noexcept {
        return std::hash<uint32_t>{}(handle.Value());
    }
};
 
template <>
struct hash<audio::SoundHandle> {
    size_t operator()(const audio::SoundHandle& handle) const noexcept {
        return std::hash<uint32_t>{}(handle.Value());
    }
};
} // namespace std
 
namespace audio {
 
class AudioManager {
public:
    static AudioManager& GetInstance();
 
    
    bool Initialize();
    
    void Shutdown();
 
    
    void SetMasterVolume(float volume);
    
    float GetMasterVolume() const;
    
    static void SetLogLevel(LogLevel level);
 
    static LogLevel GetLogLevel();
 
    
    TrackHandle CreateTrack();
    
    void DestroyTrack(TrackHandle track);
    
    void PlayTrack(TrackHandle track);
    
    void StopTrack(TrackHandle track);
    
    
    
    void AddLayer(TrackHandle track, const string& layerName, const string& filepath, GroupHandle group = GroupHandle::Invalid());
    
    void RemoveLayer(TrackHandle track, const string& layerName);
    
    void SetLayerVolume(TrackHandle track, const string& layerName, float volume);
    
    void FadeLayer(TrackHandle track, const string& layerName, float targetVolume, std::chrono::milliseconds duration);
    
    
    GroupHandle CreateGroup();
    
    void DestroyGroup(GroupHandle group);
    
    void SetGroupVolume(GroupHandle group, float volume);
    
    float GetGroupVolume(GroupHandle group) const;
    
    void FadeGroup(GroupHandle group, float targetVolume, std::chrono::milliseconds duration);
    
    
    SoundHandle LoadSound(const string& filepath);
    
    SoundHandle LoadSound(const string& filepath, GroupHandle group);
    
    void DestroySound(SoundHandle sound);
    
    void PlaySound(SoundHandle sound);
    
    void PlaySound(SoundHandle sound, const Vec3& position);
    
    void StopSound(SoundHandle sound);
    
    void SetSoundVolume(SoundHandle sound, float volume);
    
    void SetSoundPitch(SoundHandle sound, float pitch);
    
    void SetSoundLooping(SoundHandle sound, bool should_loop);
    
    bool IsSoundPlaying(SoundHandle sound) const;
    
    void PlayRandomSoundFromFolder(const string& folderPath, GroupHandle group = GroupHandle::Invalid());
 
    
    void SetListenerPosition(const Vec3& position, uint32_t listenerIndex = 0);
    
    Vec3 GetListenerPosition(uint32_t listenerIndex = 0) const;
    
    void SetListenerDirection(const Vec3& direction, uint32_t listenerIndex = 0);
    
    Vec3 GetListenerDirection(uint32_t listenerIndex = 0) const;
    
    void SetListenerUp(const Vec3& up, uint32_t listenerIndex = 0);
    
    Vec3 GetListenerUp(uint32_t listenerIndex = 0) const;
    
    void SetSoundPosition(SoundHandle sound, const Vec3& position);
    
    Vec3 GetSoundPosition(SoundHandle sound) const;
    
    void SetSoundMinDistance(SoundHandle sound, float minDistance);
    
    float GetSoundMinDistance(SoundHandle sound) const;
    
    void SetSoundMaxDistance(SoundHandle sound, float maxDistance);
    
    float GetSoundMaxDistance(SoundHandle sound) const;
    
    void SetSoundRolloff(SoundHandle sound, float rolloff);
    
    float GetSoundRolloff(SoundHandle sound) const;
    
    void SetSoundSpatializationEnabled(SoundHandle sound, bool enabled);
    
    bool IsSoundSpatializationEnabled(SoundHandle sound) const;
 
    bool IsInitialized() const { return running_.load(); }
 
private:
    AudioManager();
    
    ~AudioManager();
    
    // Disable copy and assignment
    AudioManager(const AudioManager&) = delete;
    AudioManager& operator=(const AudioManager&) = delete;
 
    void EnsureInitialized() const;
 
    
    TrackHandle NextTrackHandle() { return TrackHandle{next_track_handle_++}; }
    
    GroupHandle NextGroupHandle() { return GroupHandle{next_group_handle_++}; }
    
    SoundHandle NextSoundHandle() { return SoundHandle{next_sound_handle_++}; }
 
    unique_ptr<AudioSystem> audio_system_;   
    unordered_map<TrackHandle, unique_ptr<AudioTrack>> tracks_;  
    unordered_map<GroupHandle, unique_ptr<AudioGroup>> groups_;  
    unordered_map<SoundHandle, unique_ptr<Sound>> sounds_;       
    unordered_map<string, std::vector<SoundHandle>> folder_sounds_; 
 
    atomic<bool> running_{false};     
    thread update_thread_;            
    mutable mutex resource_mutex_;    
    std::mt19937 rng_{std::random_device{}()}; 
 
    atomic<uint32_t> next_track_handle_{1};    
    atomic<uint32_t> next_group_handle_{1};    
    atomic<uint32_t> next_sound_handle_{1};    
};
 
} // namespace audio