Sound.hpp

#ifndef RAYLIB_CPP_INCLUDE_SOUND_HPP_
#define RAYLIB_CPP_INCLUDE_SOUND_HPP_
 
#include <span>
#include <string>
#include <string_view>
 
#include "./raylib.hpp"
#include "./raylib-cpp-utils.hpp"
#include "./RaylibException.hpp"
 
namespace raylib {
class Sound : public ::Sound {
 public:
    Sound(const Sound&) = delete;
    Sound& operator=(const Sound&) = delete;
 
    Sound() {
        stream = { nullptr, nullptr, 0, 0, 0 };
        frameCount = 0;
    }
 
    Sound(::AudioStream stream, unsigned int frameCount) : ::Sound{stream, frameCount} {
        // Nothing.
    }
 
    Sound(Sound&& other) {
        set(other);
 
        other.stream = { nullptr, nullptr, 0, 0, 0 };
        other.frameCount = 0;
    }
 
    Sound(const std::string_view fileName) {
        Load(fileName);
    }
 
    Sound(const ::Wave& wave) {
        Load(wave);
    }
 
    ~Sound() {
        Unload();
    }
 
    GETTER(unsigned int, FrameCount, frameCount)
    GETTER(::AudioStream, Stream, stream)
 
    Sound& operator=(Sound&& other) noexcept {
        if (this == &other) {
            return *this;
        }
 
        Unload();
        set(other);
        other.frameCount = 0;
        other.stream = { nullptr, nullptr, 0, 0, 0 };
 
        return *this;
    }
 
    Sound& Update(const void *data, int samplesCount) {
        ::UpdateSound(*this, data, samplesCount);
        return *this;
    }
 
    Sound& Update(const std::span<std::byte> data) {
        ::UpdateSound(*this, data.data(), static_cast<int>(data.size()));
        return *this;
    }
 
    Sound& Update(const void *data) {
        ::UpdateSound(*this, data, static_cast<int>(frameCount));
        return *this;
    }
 
    void Unload() {
        // Protect against calling UnloadSound() twice.
        if (frameCount != 0) {
            ::UnloadSound(*this);
            frameCount = 0;
        }
    }
 
    Sound& Play() {
        ::PlaySound(*this);
        return *this;
    }
 
    Sound& Stop() {
        ::StopSound(*this);
        return *this;
    }
 
    Sound& Pause() {
        ::PauseSound(*this);
        return *this;
    }
 
    Sound& Resume() {
        ::ResumeSound(*this);
        return *this;
    }
 
    bool IsPlaying() const {
        return ::IsSoundPlaying(*this);
    }
 
    Sound& SetVolume(float volume) {
        ::SetSoundVolume(*this, volume);
        return *this;
    }
 
    Sound& SetPitch(float pitch) {
        ::SetSoundPitch(*this, pitch);
        return *this;
    }
 
    Sound& SetPan(float pan = 0.5f) {
        ::SetSoundPan(*this, pan);
        return *this;
    }
 
    void Load(const std::string_view fileName) {
        set(::LoadSound(fileName.data()));
        if (!IsReady()) {
            throw RaylibException("Failed to load Sound from file");
        }
    }
 
    void Load(const ::Wave& wave) {
        set(::LoadSoundFromWave(wave));
        if (!IsReady()) {
            throw RaylibException("Failed to load Wave");
        }
    }
 
    bool IsReady() const {
        return ::IsSoundReady(*this);
    }
 
 protected:
    void set(const ::Sound& sound) {
        frameCount = sound.frameCount;
        stream = sound.stream;
    }
};
}  // namespace raylib
 
using RSound = raylib::Sound;
 
#endif  // RAYLIB_CPP_INCLUDE_SOUND_HPP_