audio.hpp

// SPDX-License-Identifier: MIT
// Author:  Giovanni Santini
// Mail:    giovanni.santini@proton.me
// Github:  @San7o
 
#pragma once
 
#include <brenta/subsystem.hpp>
 
// Backend
#include <miniaudio/miniaudio.h>
 
#include <string>
#include <unordered_map>
#include <vector>
#include <tuple>
 
namespace brenta
{
 
namespace types
{
 
typedef std::string stream_id_t;
 
typedef std::string sound_id_t;
 
typedef ma_sound sound_t;
typedef ma_sound_group stream_t;
 
} // namespace types
 
class audio : public subsystem
{  
public:
  
  static std::unordered_map<types::sound_id_t, types::sound_t> sounds;
  
  static std::unordered_map<types::stream_id_t, types::stream_t> streams;
  
  static const std::string subsystem_name;
  
  class builder;
  enum class error;
 
  // Subsystem interface
  std::expected<void, subsystem::error> initialize() override;
    
  std::expected<void, subsystem::error> terminate() override;
 
  std::string name() override;
  bool is_initialized() override;
  
  // Constructors / destructors
  
  audio() = default;
  ~audio() = default;
 
  // Member functions
  
  static audio &instance();
 
  static std::expected<void, audio::error>
  load(const types::sound_id_t &sound_id,
       const std::string &path,
       const types::stream_id_t &stream_id = "default");
 
  static std::expected<void, audio::error>
  play(const types::sound_id_t &id);
 
  //
  // Stream functions
  //
  
  static std::expected<void, audio::error>
  create_stream(const types::stream_id_t &id);
  static types::stream_t *get_stream(const types::stream_id_t &id);
  
  static std::expected<void, audio::error>
  stream_stop(const types::stream_id_t &id);
  static std::expected<void, audio::error>
  stream_start(const types::stream_id_t &id);
  static std::expected<void, audio::error>
  stream_set_volume(const types::stream_id_t &id, float volume);
 
private:
  
  static std::vector<std::pair<types::stream_id_t, float>> init_streams;
 
  static std::vector<std::tuple<types::sound_id_t,
                                std::string,
                                types::stream_id_t>> init_sounds;
 
  static bool initialized;
  
  // Backend
  static ma_engine engine;
 
};
 
class audio::builder : public subsystem::builder
{
private:
  
  std::vector<std::tuple<types::sound_id_t, std::string,
                        types::stream_id_t>> init_sounds;
  std::vector<std::pair<types::stream_id_t, float>> init_streams;
  float volume = 1.0;
  
public:
 
  builder() = default;
  ~builder() = default;
 
  builder &sound(const types::sound_id_t &sound_id,
                 const std::string &path,
                 const types::stream_id_t &stream_id = "default");
  builder &stream(const types::stream_id_t &id,
                  float volume = 1.0);
  
  brenta::subsystem &build() override;
  
};
 
enum class audio::error : int
{
  init_from_file,
  stream_not_found,
  sound_not_found,
  stream_init,
  stream_stop,
  stream_start,
};
  
} // namespace brenta