audio_internal.h

#pragma once
 
#include "pixelbullet/audio/audio_backend.h"
#include "pixelbullet/audio/audio_playback_handle.h"
#include "pixelbullet/audio/audio_playback_settings.h"
#include "pixelbullet/audio/audio_spatial_settings.h"
#include "pixelbullet/audio/command_queue.h"
#include "pixelbullet/filesystem/virtual_path.h"
 
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <thread>
 
#include <glm/glm.hpp>
 
namespace pixelbullet
{
class Filesystem;
 
namespace audio_internal
{
struct AudioPlaySoundRequest
{
    AudioPlaybackHandle handle;
    std::string resolved_path;
    AudioPlaybackSettings settings;
};
 
struct AudioState
{
    std::thread audio_thread;
    CommandQueue command_queue;
    std::unique_ptr<AudioBackend> backend;
    std::atomic<AudioPlaybackHandle::ValueType> next_handle_value{ 1 };
    bool initialized = false;
};
 
using BackendFactory = std::function<std::unique_ptr<AudioBackend>()>;
 
enum class WorkerStepResult
{
    Command,
    Timeout,
    Closed,
};
 
inline constexpr auto k_worker_poll_timeout = std::chrono::milliseconds(50);
 
struct AudioListenerTransform
{
    glm::vec3 position = glm::vec3(0.0f);
    glm::vec3 forward = glm::vec3(0.0f, 0.0f, -1.0f);
    glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f);
};
 
[[nodiscard]] std::unique_ptr<AudioBackend> create_backend();
[[nodiscard]] bool initialize_backend(AudioState& state);
[[nodiscard]] bool initialize_backend(AudioState& state, BackendFactory backend_factory);
void shutdown_backend(AudioState& state);
void close_worker_thread(AudioState& state);
void start_worker_thread(AudioState& state);
 
[[nodiscard]] AudioPlaybackHandle allocate_playback_handle(AudioState& state) noexcept;
[[nodiscard]] AudioLoadMode resolve_load_mode(AudioPlaybackSettings settings) noexcept;
[[nodiscard]] float sanitize_volume(float volume) noexcept;
[[nodiscard]] AudioSpatialSettings sanitize_spatial_settings(AudioSpatialSettings settings) noexcept;
[[nodiscard]] bool is_valid_playback_position(glm::vec3 position) noexcept;
[[nodiscard]] std::optional<AudioPlaybackSettings> sanitize_playback_settings(AudioPlaybackSettings settings) noexcept;
[[nodiscard]] std::optional<AudioListenerTransform> sanitize_listener_transform(glm::vec3 position, glm::vec3 forward,
                                                                                glm::vec3 up) noexcept;
[[nodiscard]] bool submit_command_if_initialized(AudioState& state, std::function<void()> command);
[[nodiscard]] std::optional<AudioPlaySoundRequest> build_play_sound_request(Filesystem& filesystem, AudioState& state,
                                                                            const VirtualPath& file_path, AudioPlaybackSettings settings);
 
[[nodiscard]] WorkerStepResult process_worker_step(AudioState& state, std::chrono::milliseconds timeout = k_worker_poll_timeout);
void run_worker_loop(AudioState& state);
} // namespace audio_internal
} // namespace pixelbullet