feat(audio): Add Sound asset (#230)

core/include/cubos/core/al/audio_device.hpp

@@ -8,7 +8,6 @@
 #include <string>
 #include <vector>
 
-#include <glm/glm.hpp>
 #include <miniaudio.h>
 
 #include <cubos/core/api.hpp>

core/src/al/miniaudio_device.cpp

@@ -221,6 +221,22 @@ Buffer MiniaudioDevice::createBuffer(const void* data, size_t dataSize)
     return std::make_shared<MiniaudioBuffer>(data, dataSize);
 }
 
+size_t MiniaudioBuffer::getLength()
+{
+    ma_uint64 lengthInPCMFrames;
+    ma_result result = ma_decoder_get_length_in_pcm_frames(&mDecoder, &lengthInPCMFrames);
+
+    if (result != MA_SUCCESS)
+    {
+        CUBOS_ERROR("Failed to get the length of audio in PCM frames.");
+        return 0;
+    }
+
+    // Calculate the length in seconds: Length in PCM frames divided by the sample rate.
+    float lengthInSeconds = static_cast<float>(lengthInPCMFrames) / static_cast<float>(mDecoder.outputSampleRate);
+    return static_cast<size_t>(lengthInSeconds);
+}
+
 Source MiniaudioDevice::createSource()
 {
     return std::make_shared<MiniaudioSource>();

core/src/al/miniaudio_device.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstddef>
 #include <cubos/core/al/audio_device.hpp>
 
 namespace cubos::core::al

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/audio.cpp"
+    "src/audio/bridge.cpp"
+
 	"src/assets/plugin.cpp"
 	"src/assets/assets.cpp"
 	"src/assets/bridge.cpp"

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

@@ -0,0 +1,28 @@
+/// @file
+/// @brief Class @ref cubos::engine::Audio.
+/// @ingroup audio-plugin
+#pragma once
+
+#include <cubos/core/ecs/blueprint.hpp>
+#include <cubos/core/memory/stream.hpp>
+#include <cubos/core/reflection/reflect.hpp>
+#include <cubos/core/al/miniaudio_device.hpp>
+
+#include <cubos/engine/assets/asset.hpp>
+
+namespace cubos::engine
+{
+    /// @brief Asset containing raw Audio data.
+    ///
+    /// @ingroup audio-plugin
+    struct CUBOS_ENGINE_API Audio
+    {
+        CUBOS_REFLECT;
+        Buffer data;  // Raw data of the audio
+        size_t length;  // Audio length in seconds TODO: add getter in audio
+
+        explicit Audio(core::memory::Stream& stream);
+        Audio(Audio&& other) noexcept;
+        ~Audio();
+    };
+} // namespace cubos::engine

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

@@ -0,0 +1,28 @@
+/// @file
+/// @brief Class @ref cubos::engine::AudioBridge.
+/// @ingroup audio-plugin
+
+#pragma once
+
+#include <cubos/engine/assets/bridges/file.hpp>
+#include <cubos/engine/audio/audio.hpp>
+
+namespace cubos::engine
+{
+    /// @brief Bridge which loads and saves @ref Sound assets.
+    ///
+    /// Uses the format specified in @ref Audio::loadFrom and @ref Audio::writeTo
+    ///
+    /// @ingroup audio-plugin
+    class AudioBridge : public FileBridge
+    {
+    public:
+        /// @brief Constructs a bridge.
+        AudioBridge()
+        : FileBridge(core::reflection::reflect<Audio>)
+
+    protected:
+        bool loadFromFile(Assets& assets, const AnyAsset& handle, core::memory::Stream& stream) override;
+        bool saveToFile(const Assets& assets, const AnyAsset& handle, core::memory::Stream& stream) override;
+    };
+} // namespace cubos::engine

engine/src/audio/audio.cpp

@@ -0,0 +1,48 @@
+#include <cubos/core/log.hpp>
+#include <cubos/core/reflection/external/cstring.hpp>
+#include <cubos/core/reflection/type.hpp>
+
+#include <cubos/engine/audio/audio.hpp>
+
+CUBOS_REFLECT_IMPL(cubos::engine::Audio)
+{
+    return core::reflection::Type::create("cubos::engine::Audio");
+}
+
+cubos::engine::Audio::Audio(core::memory::Stream& stream)
+{
+    stream.seek(0, cubos::core::memory::SeekOrigin::End);
+    size_t streamSize = stream.tell();
+    void* contents = operator new(sizeof(char) * streamSize);
+    stream.seek(0, cubos::core::memory::SeekOrigin::Begin);
+    if (stream.read((char*)contents, streamSize) < streamSize)
+    {
+        CUBOS_ERROR("Couldn't load audio: Read less than stream lenght", stbi_failure_reason());
+        // TODO: add audio buffer here
+        data = nullptr;
+        operator delete(contents);
+        return;
+    };
+    // NOTE: load audio buffer from memory
+    data = cubos::core::al::createBuffer(contents, (size_t) streamSize);
+    if (data == nullptr)
+    {
+        CUBOS_ERROR("Couldn't load buffer: {}", stbi_failure_reason());
+    }
+    operator delete(contents);
+}
+
+cubos::engine::Audio::~Audio()
+{
+    if (data != nullptr)
+    {
+        // NOTE: not sure about this
+        ma_decoder_uninit(data);
+    }
+}
+
+cubos::engine::Audio::Audio(Audio&& other) noexcept
+    : data(other.data)
+{
+    other.data = nullptr;
+}

engine/src/audio/bridge.cpp

@@ -0,0 +1,25 @@
+#include <cubos/core/log.hpp>
+#include <cubos/engine/assets/assets.hpp>
+#include <cubos/engine/audio/bridge.hpp>
+#include <cubos/engine/audio/audio.hpp>
+
+using namespace cubos::engine;
+
+bool AudioBridge::loadFromFile(Assets& assets, const AnyAsset& handle, core::memory::Stream& stream)
+{
+    Audio audio{stream};
+    if (audio.data == nullptr)
+    {
+        return false;
+    }
+    assets.store(handle, std::move(audio));
+    return true;
+}
+bool AudioBridge::saveToFile(const Assets& assets, const AnyAsset& handle, core::memory::Stream& stream)
+{
+    (void)assets;
+    (void)handle;
+    (void)stream;
+    CUBOS_ERROR("Saving audios is currently unsupported");
+    return false;
+}