feat(audio): add AudioPlugin

core/include/cubos/core/al/audio_context.hpp

@@ -19,11 +19,12 @@ namespace cubos::core::al
  class Buffer;
  class Source;
  class Listener;
+ class AudioDevice;
  } // namespace impl
 
  /// @brief Handle to an audio buffer.
  /// @see impl::Buffer - audio buffer interface.
- /// @see AudioDevice::createBuffer()
+ /// @see AudioContext::createBuffer()
  /// @ingroup core-al
  using Buffer = std::shared_ptr<impl::Buffer>;
 
@@ -39,26 +40,11 @@ namespace cubos::core::al
  /// @ingroup core-al
  using Listener = std::shared_ptr<impl::Listener>;
 
- /// @brief Audio device interface used to wrap low-level audio rendering APIs.
- class CUBOS_CORE_API AudioDevice
- {
- public:
- virtual ~AudioDevice() = default;
-
- /// @brief Forbid copy construction.
- AudioDevice(const AudioDevice&) = delete;
-
- /// @brief Creates a new audio source.
- /// @return Handle of the new source.
- virtual Source createSource() = 0;
-
- /// @brief Creates a new audio listener.
- /// @return Handle of the new listener.
- virtual Listener listener(size_t index) = 0;
-
- protected:
- AudioDevice() = default;
- };
+ /// @brief Handle to an audio device.
+ /// @see impl::AudioDevice - audio device interface.
+ /// @see AudioContext::createDevice()
+ /// @ingroup core-al
+ using AudioDevice = std::shared_ptr<impl::AudioDevice>;
 
  /// @brief Audio context that contains audio devices;
  class CUBOS_CORE_API AudioContext
@@ -73,15 +59,17 @@ namespace cubos::core::al
 
  /// @brief Enumerates the available devices.
  /// @param[out] devices Vector to fill with the available devices.
- static void enumerateDevices(std::vector<std::string>& devices);
+ virtual void enumerateDevices(std::vector<std::string>& devices) = 0;
 
  /// @brief Creates a new audio device
  /// @param specifier The specifier of the audio device, used to identify it
+ /// @param listenerCount The number of audio listener to be created by the device's engine.
  /// @return Handle of the new device
- virtual std::shared_ptr<AudioDevice> createDevice(const std::string& specifier, unsigned int listenerCount) = 0;
+ virtual AudioDevice createDevice(unsigned int listenerCount,
+ const std::string& specifier = "MiniaudioDevice") = 0;
 
  /// @brief Creates a new audio buffer.
- /// @param data Data to be written to the buffer, cubos currently supports .wav, .mp3 and .flac files.
+ /// @param data Data to be written to the buffer, either .wav, .mp3 or .flac.
  /// @param datSize Size of the data to be written.
  /// @return Handle of the new buffer.
  virtual Buffer createBuffer(const void* data, size_t dataSize) = 0;
@@ -95,7 +83,10 @@ namespace cubos::core::al
  {
  public:
  virtual ~Buffer() = default;
- virtual size_t getLength() = 0;
+
+ /// @brief Gets the length in seconds of the audio buffer.
+ /// @return Length in seconds of the audio buffer.
+ virtual size_t length() = 0;
 
  protected:
  Buffer() = default;
@@ -162,6 +153,7 @@ namespace cubos::core::al
  Source() = default;
  };
 
+ // Abstract audio listener.
  class CUBOS_CORE_API Listener
  {
  public:
@@ -183,5 +175,26 @@ namespace cubos::core::al
  protected:
  Listener() = default;
  };
+
+ /// @brief Audio device interface used to wrap low-level audio rendering APIs.
+ class CUBOS_CORE_API AudioDevice
+ {
+ public:
+ virtual ~AudioDevice() = default;
+
+ /// @brief Forbid copy construction.
+ AudioDevice(const AudioDevice&) = delete;
+
+ /// @brief Creates a new audio source.
+ /// @return Handle of the new source.
+ virtual std::shared_ptr<impl::Source> createSource() = 0;
+
+ /// @brief Creates a new audio listener.
+ /// @return Handle of the new listener.
+ virtual std::shared_ptr<impl::Listener> listener(size_t index) = 0;
+
+ protected:
+ AudioDevice() = default;
+ };
  } // namespace impl
 } // namespace cubos::core::al

core/include/cubos/core/al/miniaudio_context.hpp

@@ -15,10 +15,10 @@ namespace cubos::core::al
  MiniaudioContext();
  ~MiniaudioContext() override;
 
- std::shared_ptr<AudioDevice> createDevice(const std::string& specifier, unsigned int listenerCount) override;
+ AudioDevice createDevice(unsigned int listenerCount, const std::string& specifier) override;
  Buffer createBuffer(const void* data, size_t dataSize) override;
+ void enumerateDevices(std::vector<std::string>& devices) override;
 
- static void enumerateDevices(std::vector<std::string>& devices);
  static std::string getDefaultDevice();
 
  private:

core/src/al/audio_context.cpp

@@ -6,8 +6,3 @@ std::shared_ptr<AudioContext> AudioContext::create()
 {
  return std::make_shared<MiniaudioContext>();
 }
-
-void AudioContext::enumerateDevices(std::vector<std::string>& devices)
-{
- MiniaudioContext::enumerateDevices(devices);
-}

core/src/al/miniaudio_context.cpp

@@ -3,31 +3,32 @@
 #include <cubos/core/log.hpp>
 #include <cubos/core/reflection/external/string.hpp>
 
-// TODO: settings.getInteger("audio ")
-
 using namespace cubos::core::al;
 
 class MiniaudioBuffer : public impl::Buffer
 {
 public:
- ma_decoder mDecoder;
+ ma_decoder decoder;
+
  MiniaudioBuffer(const void* data, size_t dataSize)
  {
- if (ma_decoder_init_memory(data, dataSize, nullptr, &mDecoder) != MA_SUCCESS)
+ if (ma_decoder_init_memory(data, dataSize, nullptr, &decoder) != MA_SUCCESS)
  {
  CUBOS_ERROR("Failed to initialize Decoder from data");
  }
+
+ mValid = true;
  }
 
  ~MiniaudioBuffer() override
  {
- ma_decoder_uninit(&mDecoder);
+ ma_decoder_uninit(&decoder);
  }
 
- size_t getLength() override
+ size_t length() override
  {
  ma_uint64 lengthInPCMFrames;
- ma_result result = ma_decoder_get_length_in_pcm_frames(&mDecoder, &lengthInPCMFrames);
+ ma_result result = ma_decoder_get_length_in_pcm_frames(&decoder, &lengthInPCMFrames);
 
  if (result != MA_SUCCESS)
  {
@@ -36,8 +37,16 @@ class MiniaudioBuffer : public impl::Buffer
  }
 
  // Calculate the length in seconds: Length in PCM frames divided by the sample rate.
- return static_cast<size_t>(lengthInPCMFrames) / mDecoder.outputSampleRate;
+ return static_cast<size_t>(lengthInPCMFrames) / decoder.outputSampleRate;
+ }
+
+ bool isValid() const
+ {
+ return mValid;
  }
+
+private:
+ bool mValid = false;
 };
 
 class MiniaudioSource : public impl::Source
@@ -64,7 +73,7 @@ class MiniaudioSource : public impl::Source
  return;
  }
 
- if (ma_sound_init_from_data_source(&mEngine, &miniaudioBuffer->mDecoder, 0, nullptr, &mSound) != MA_SUCCESS)
+ if (ma_sound_init_from_data_source(&mEngine, &miniaudioBuffer->decoder, 0, nullptr, &mSound) != MA_SUCCESS)
  {
  CUBOS_ERROR("Failed to initialize sound from buffer.");
  return;
@@ -133,7 +142,7 @@ class MiniaudioSource : public impl::Source
 
 private:
  ma_sound mSound;
- ma_engine mEngine;
+ ma_engine& mEngine;
 };
 
 class MiniaudioListener : public impl::Listener
@@ -170,7 +179,7 @@ class MiniaudioListener : public impl::Listener
  unsigned int mIndex;
 };
 
-class MiniaudioDevice : public cubos::core::al::AudioDevice
+class MiniaudioDevice : public impl::AudioDevice
 {
 public:
  MiniaudioDevice(ma_context& context, const std::string& deviceName, ma_uint32 listenerCount)
@@ -221,6 +230,8 @@ class MiniaudioDevice : public cubos::core::al::AudioDevice
  return;
  }
 
+ mValid = true;
+
  mListeners.reserve(listenerCount);
  for (ma_uint32 i = 0; i < listenerCount; ++i)
  {
@@ -248,11 +259,17 @@ class MiniaudioDevice : public cubos::core::al::AudioDevice
  return mListeners[index];
  }
 
+ bool isValid() const
+ {
+ return mValid;
+ }
+
 private:
  ma_context mContext;
  ma_device mDevice;
  ma_engine mEngine;
  std::vector<std::shared_ptr<MiniaudioListener>> mListeners;
+ bool mValid = false;
 };
 
 MiniaudioContext::MiniaudioContext()
@@ -306,25 +323,16 @@ void MiniaudioContext::enumerateDevices(std::vector<std::string>& devices)
 {
  devices.clear();
 
- // Create a temporary context
- ma_context context;
-
- if (ma_context_init(nullptr, 0, nullptr, &context) != MA_SUCCESS)
- {
- CUBOS_ERROR("Failed to initialize audio context for enumeration");
- return;
- }
-
  ma_device_info* pPlaybackDeviceInfos;
  ma_uint32 playbackDeviceCount;
 
- if (ma_context_get_devices(&context, &pPlaybackDeviceInfos, &playbackDeviceCount, nullptr, nullptr) != MA_SUCCESS)
+ if (ma_context_get_devices(&mContext, &pPlaybackDeviceInfos, &playbackDeviceCount, nullptr, nullptr) != MA_SUCCESS)
  {
  CUBOS_ERROR("Failed to enumerate audio devices.");
  return;
  }
 
- ma_context_uninit(&context);
+ ma_context_uninit(&mContext);
 
  devices.reserve(playbackDeviceCount);
 
@@ -341,10 +349,24 @@ void MiniaudioContext::enumerateDevices(std::vector<std::string>& devices)
 
 Buffer MiniaudioContext::createBuffer(const void* data, size_t dataSize)
 {
- return std::make_shared<MiniaudioBuffer>(data, dataSize);
+ auto buffer = std::make_shared<MiniaudioBuffer>(data, dataSize);
+ if (!buffer->isValid())
+ {
+ CUBOS_ERROR("Failed to create MiniaudioBuffer.");
+ return nullptr;
+ }
+
+ return buffer;
 }
 
-std::shared_ptr<AudioDevice> MiniaudioContext::createDevice(const std::string& specifier, ma_uint32 listenerCount)
+AudioDevice MiniaudioContext::createDevice(ma_uint32 listenerCount, const std::string& specifier)
 {
- return std::make_shared<MiniaudioDevice>(mContext, specifier, listenerCount);
+ auto device = std::make_shared<MiniaudioDevice>(mContext, specifier, listenerCount);
+ if (!device->isValid())
+ {
+ CUBOS_ERROR("Failed to create MiniaudioDevice.");
+ return nullptr;
+ }
+
+ return device;
 }

engine/CMakeLists.txt

@@ -36,6 +36,9 @@ set(CUBOS_ENGINE_SOURCE
  "src/utils/free_camera/plugin.cpp"
  "src/utils/free_camera/controller.cpp"
 
+ "src/audio/plugin.cpp"
+ "src/audio/source.cpp"
+ "src/audio/listener.cpp"
  "src/audio/audio.cpp"
  "src/audio/bridge.cpp"
 

engine/include/cubos/engine/audio/audio.hpp

@@ -17,10 +17,11 @@ namespace cubos::engine
  struct CUBOS_ENGINE_API Audio
  {
  CUBOS_REFLECT;
- std::shared_ptr<cubos::core::al::impl::Buffer> mData; // Raw data of the audio
- size_t mLength; // Audio length in seconds TODO: add getter in audio
 
- explicit Audio(std::shared_ptr<cubos::core::al::MiniaudioContext>, core::memory::Stream& stream);
+ /// @brief Audio buffer.
+ cubos::core::al::Buffer buffer;
+
+ explicit Audio(std::shared_ptr<cubos::core::al::AudioContext>, core::memory::Stream& stream);
  Audio(Audio&& other) noexcept;
  ~Audio();
  };

engine/include/cubos/engine/audio/bridge.hpp

@@ -17,10 +17,10 @@ namespace cubos::engine
  class AudioBridge : public FileBridge
  {
  public:
- std::shared_ptr<cubos::core::al::MiniaudioContext> mContext;
+ std::shared_ptr<cubos::core::al::AudioContext> mContext;
 
  /// @brief Constructs a bridge.
- AudioBridge(std::shared_ptr<cubos::core::al::MiniaudioContext> context)
+ AudioBridge(std::shared_ptr<cubos::core::al::AudioContext> context)
  : FileBridge(core::reflection::reflect<Audio>())
  , mContext(context)
  {

engine/include/cubos/engine/audio/listener.hpp

@@ -0,0 +1,25 @@
+/// @file
+/// @brief Component @ref cubos::engine::AudioListener.
+/// @ingroup audio-plugin
+
+#pragma once
+
+#include <cubos/core/al/audio_context.hpp>
+#include <cubos/core/reflection/reflect.hpp>
+
+#include <cubos/engine/api.hpp>
+
+namespace cubos::engine
+{
+ /// @brief Component which adds an AudioListener to the entitiy
+ /// @ingroup audio-plugin
+ struct CUBOS_ENGINE_API AudioListener
+ {
+ CUBOS_REFLECT;
+
+ bool active = false; //< Is the listener active?
+
+ private:
+ cubos::core::al::Listener listener;
+ };
+} // namespace cubos::engine