Music.hpp

#ifndef RAYLIB_CPP_INCLUDE_MUSIC_HPP_
#define RAYLIB_CPP_INCLUDE_MUSIC_HPP_
 
#include <span>
#include <string>
#include <string_view>
 
#include "./RaylibException.hpp"
#include "./raylib-cpp-utils.hpp"
#include "./raylib.hpp"
 
namespace raylib {
class Music : public ::Music {
public:
    Music(
        ::AudioStream stream = {nullptr, nullptr, 0, 0, 0},
        unsigned int frameCount = 0,
        bool looping = false,
        int ctxType = 0,
        void* ctxData = nullptr)
        : ::Music{stream, frameCount, looping, ctxType, ctxData} {}
 
    Music(const ::Music& music) : ::Music(music) { }
 
    Music(const std::string_view fileName) {
        Load(fileName);
    }
 
    Music(const std::string_view fileType, unsigned char* data, int dataSize) {
        Load(fileType, data, dataSize);
    }
 
    Music(const std::string_view fileType, std::span<unsigned char> data) {
        Load(fileType, data);
    }
 
    Music(const Music&) = delete;
 
    Music(Music&& other) noexcept {
        set(other);
 
        other.stream = {};
        other.frameCount = 0;
        other.looping = false;
        other.ctxType = 0;
        other.ctxData = nullptr;
    }
 
    ~Music() { Unload(); }
 
    GETTER(::AudioStream, Stream, stream)
    GETTER(unsigned int, FrameCount, frameCount)
    GETTERSETTER(bool, Looping, looping)
    GETTER(int, CtxType, ctxType)
    GETTER(void*, CtxData, ctxData)
 
    Music& operator=(const ::Music& music) {
        set(music);
        return *this;
    }
 
    Music& operator=(const Music&) = delete;
 
    Music& operator=(Music&& other) noexcept {
        if (this == &other) {
            return *this;
        }
 
        Unload();
        set(other);
 
        other.ctxType = 0;
        other.ctxData = nullptr;
        other.looping = false;
        other.frameCount = 0;
        other.stream = {};
 
        return *this;
    }
 
    void Unload() { ::UnloadMusicStream(*this); }
 
    Music& Play() {
        ::PlayMusicStream(*this);
        return *this;
    }
 
    Music& Update() {
        ::UpdateMusicStream(*this);
        return *this;
    }
 
    Music& Stop() {
        ::StopMusicStream(*this);
        return *this;
    }
 
    Music& Pause() {
        ::PauseMusicStream(*this);
        return *this;
    }
 
    Music& Resume() {
        ::ResumeMusicStream(*this);
        return *this;
    }
 
    Music& Seek(float position) {
        SeekMusicStream(*this, position);
        return *this;
    }
 
    [[nodiscard]] bool IsPlaying() const { return ::IsMusicStreamPlaying(*this); }
 
    Music& SetVolume(float volume) {
        ::SetMusicVolume(*this, volume);
        return *this;
    }
 
    Music& SetPitch(float pitch) {
        ::SetMusicPitch(*this, pitch);
        return *this;
    }
 
    Music& SetPan(float pan = 0.5f) {
        ::SetMusicPan(*this, pan);
        return *this;
    }
 
    [[nodiscard]] float GetTimeLength() const { return ::GetMusicTimeLength(*this); }
 
    [[nodiscard]] float GetTimePlayed() const { return ::GetMusicTimePlayed(*this); }
 
    void Load(const std::string_view fileName) {
        set(::LoadMusicStream(fileName.data()));
        if (!IsValid()) {
            throw RaylibException(TextFormat("Failed to load Music from file: %s", fileName.data()));
        }
    }
 
    void Load(const std::string_view fileType, unsigned char* data, int dataSize) {
        set(::LoadMusicStreamFromMemory(fileType.data(), data, dataSize));
        if (!IsValid()) {
            throw RaylibException(TextFormat("Failed to load Music from %s file dat", fileType.data()));
        }
    }
 
    void Load(const std::string_view fileType, std::span<unsigned char> data) {
        set(::LoadMusicStreamFromMemory(fileType.data(), data.data(), static_cast<int>(data.size())));
        if (!IsValid()) {
            throw RaylibException(TextFormat("Failed to load Music from %s file dat", fileType.data()));
        }
    }
 
    bool IsValid() const { return ::IsMusicValid(*this); }
protected:
    void set(const ::Music& music) {
        stream = music.stream;
        frameCount = music.frameCount;
        looping = music.looping;
        ctxType = music.ctxType;
        ctxData = music.ctxData;
    }
};
} // namespace raylib
 
using RMusic = raylib::Music;
 
#endif // RAYLIB_CPP_INCLUDE_MUSIC_HPP_