AudioStream.hpp

#ifndef RAYLIB_CPP_INCLUDE_AUDIOSTREAM_HPP_
#define RAYLIB_CPP_INCLUDE_AUDIOSTREAM_HPP_
 
#include "./RaylibException.hpp"
#include <span>
 
namespace raylib {
class AudioStream : public ::AudioStream {
public:
    AudioStream(const ::AudioStream& music)
        : ::AudioStream(music) {
        // Nothing.
    }
 
    AudioStream(
        rAudioBuffer* buffer = nullptr,
        rAudioProcessor* processor = nullptr,
        unsigned int sampleRate = 0,
        unsigned int sampleSize = 0,
        unsigned int channels = 0)
        : ::AudioStream{buffer, processor, sampleRate, sampleSize, channels} {
        // Nothing.
    }
 
    AudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels = 2) {
        Load(sampleRate, sampleSize, channels);
    }
 
    AudioStream(const AudioStream&) = delete;
 
    AudioStream(AudioStream&& other) noexcept {
        set(other);
 
        other.buffer = nullptr;
        other.processor = nullptr;
        other.sampleRate = 0;
        other.sampleSize = 0;
        other.channels = 0;
    }
 
    ~AudioStream() { Unload(); }
 
    GETTER(rAudioBuffer*, Buffer, buffer)
    GETTER(rAudioProcessor*, Processor, processor)
    GETTER(unsigned int, SampleRate, sampleRate)
    GETTER(unsigned int, SampleSize, sampleSize)
    GETTER(unsigned int, Channels, channels)
 
    AudioStream& operator=(const ::AudioStream& stream) {
        set(stream);
        return *this;
    }
 
    AudioStream& operator=(const AudioStream&) = delete;
 
    AudioStream& operator=(AudioStream&& other) noexcept {
        if (this == &other) {
            return *this;
        }
 
        Unload();
        set(other);
 
        other.buffer = nullptr;
        other.processor = nullptr;
        other.sampleRate = 0;
        other.sampleSize = 0;
        other.channels = 0;
 
        return *this;
    }
 
    AudioStream& Update(const void* data, int samplesCount) {
        ::UpdateAudioStream(*this, data, samplesCount);
        return *this;
    }
 
    AudioStream& Update(std::span<std::byte> data) {
        ::UpdateAudioStream(*this, data.data(), static_cast<int>(data.size()));
        return *this;
    }
 
    void Unload() {
        if (IsValid()) {
            ::UnloadAudioStream(*this);
        }
    }
 
    [[nodiscard]] bool IsProcessed() const { return ::IsAudioStreamProcessed(*this); }
 
    AudioStream& Play() {
        ::PlayAudioStream(*this);
        return *this;
    }
 
    AudioStream& Pause() {
        ::PauseAudioStream(*this);
        return *this;
    }
 
    AudioStream& Resume() {
        ::ResumeAudioStream(*this);
        return *this;
    }
 
    [[nodiscard]] bool IsPlaying() const { return ::IsAudioStreamPlaying(*this); }
 
    AudioStream& Stop() {
        ::StopAudioStream(*this);
        return *this;
    }
 
    AudioStream& SetVolume(float volume = 1.0f) {
        ::SetAudioStreamVolume(*this, volume);
        return *this;
    }
 
    AudioStream& SetPitch(float pitch) {
        ::SetAudioStreamPitch(*this, pitch);
        return *this;
    }
 
    AudioStream& SetPan(float pan = 0.5f) {
        ::SetAudioStreamPan(*this, pan);
        return *this;
    }
 
    static void SetBufferSizeDefault(int size) { ::SetAudioStreamBufferSizeDefault(size); }
 
    void SetCallback(::AudioCallback callback) { ::SetAudioStreamCallback(*this, callback); }
 
    void AttachProcessor(::AudioCallback processor) { ::AttachAudioStreamProcessor(*this, processor); }
 
    void DetachProcessor(::AudioCallback processor) { ::DetachAudioStreamProcessor(*this, processor); }
 
    [[nodiscard]] bool IsValid() const { return ::IsAudioStreamValid(*this); }
 
    void Load(unsigned int SampleRate, unsigned int SampleSize, unsigned int Channels = 2) {
        Unload();
        set(::LoadAudioStream(SampleRate, SampleSize, Channels));
        if (!IsValid()) {
            throw RaylibException("Failed to load audio stream");
        }
    }
protected:
    void set(const ::AudioStream& stream) {
        buffer = stream.buffer;
        processor = stream.processor;
        sampleRate = stream.sampleRate;
        sampleSize = stream.sampleSize;
        channels = stream.channels;
    }
};
} // namespace raylib
 
using RAudioStream = raylib::AudioStream;
 
#endif // RAYLIB_CPP_INCLUDE_AUDIOSTREAM_HPP_