AudioEngine.h

#pragma once
 
#include "AudioConfig.h"
#include "Engine/Asset/AssetHandles.h"
#include "Engine/Audio/AudioFlow.h"
 
#include <filesystem>
#include <memory>
#include <optional>
#include <vector>
#include <unordered_map>
#include <string>
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
 
namespace Engine::Assets
{
    class Audio;
    class AudioFlowStore;
}  // namespace Engine::Assets
struct ma_engine;
struct ma_context;
struct ma_sound;
 
namespace Engine::Core {
    class AudioClipStore;
    class SteamAudioBackend;

    using AudioHandle = uint32_t;
    constexpr AudioHandle INVALID_AUDIO_HANDLE = 0;  
 
    struct AudioDeviceInfo
    {
        std::string name;
        bool        isDefault = false;
    };

    class AudioEngine {
    public:
        explicit AudioEngine(const AudioClipStore* audioClips = nullptr);

        ~AudioEngine();

        AudioEngine(const AudioEngine&) = delete;

        AudioEngine& operator=(const AudioEngine&) = delete;

        bool init();

        bool setPlaybackDevice( std::optional<uint32_t> deviceIndex );

        [[nodiscard]] std::vector<AudioDeviceInfo> getPlaybackDevices() const;

        [[nodiscard]] const std::string & getPlaybackDeviceName() const { return playbackDeviceName_; }

        void cleanup();

        void onAudioLoaded( Assets::Audio * asset, const std::filesystem::path& path);

        AudioHandle play(Assets::AudioClipHandle clip, float volume = 1.0f, bool loop = false);

        void setFlowStore( Assets::AudioFlowStore * store ) { flowStore_ = store; }

        AudioHandle playFlow( Assets::AudioFlowHandle flow, float volume = 1.0f, bool loop = false );

        void setFlowParam( AudioHandle handle, Assets::FlowSettingHandle setting, float value );

        AudioHandle playSpatialized(Assets::AudioClipHandle clip, const glm::vec3& worldPosition,
                                    float volume = 1.0f, bool loop = false);

        void updateSpatializedSource(AudioHandle handle, const glm::vec3& worldPosition);

        void setListener(const glm::vec3& worldPosition, const glm::quat& worldOrientation);

        void stop(AudioHandle handle);

        void stopAll();

        void setMasterVolume(float volume);
 
        [[nodiscard]] float getMasterVolume() const { return masterVolume_; }

        [[nodiscard]] bool isPlaying(AudioHandle handle) const;

        [[nodiscard]] bool isInitialized() const { return initialized_; }

        void renderSpatialized(float* pFramesOut, std::uint64_t frameCount);
 
    private:
        bool init( std::optional<uint32_t> deviceIndex );
        void shutdownBackend();

        AudioHandle startPlayback(
            Assets::Audio * asset, const std::string & assetPath, float volume, bool loop,
            const std::optional<glm::vec3> & worldPosition, AudioHandle handle
        );

        void drainPendingForPath( const std::filesystem::path & path, Assets::Audio * asset );

        void purgeStalePending();
 
        const AudioClipStore* audioClips_ = nullptr;
        Assets::AudioFlowStore* flowStore_ = nullptr;
        ma_context* context_ = nullptr;
        ma_engine* engine_ = nullptr;
        bool initialized_ = false;
        float masterVolume_ = 1.0f;
        std::string playbackDeviceName_;
 
        std::unique_ptr<SteamAudioBackend> steamAudio_;

        ma_sound* silenceSound_ = nullptr;
        void* silenceBuffer_ = nullptr;
 
        AudioHandle nextHandle_ = 1;

        struct PlayingSound {
            ma_sound* sound = nullptr;

            std::string assetPath;
        };
        std::unordered_map<AudioHandle, PlayingSound> playingSounds_;

        struct SpatializedSound {
            std::uint32_t source = 0;

            std::string assetPath;
        };
        std::unordered_map<AudioHandle, SpatializedSound> spatializedSounds_;

        struct PlayingFlow {
            void* dataSource = nullptr;

            ma_sound* sound = nullptr;
        };
        std::unordered_map<AudioHandle, PlayingFlow> playingFlows_;

        struct PendingPlay {
            Assets::AudioClipHandle clip;

            std::string assetPath;

            float volume = 1.0f;

            bool loop = false;

            std::optional<glm::vec3> worldPosition;
        };
        std::unordered_map<AudioHandle, PendingPlay> pendingPlays_;
 
        void cleanupFinishedSounds();
    };
 
}  // namespace EngineCore