Wave.hpp

#ifndef RAYLIB_CPP_INCLUDE_WAVE_HPP_
#define RAYLIB_CPP_INCLUDE_WAVE_HPP_
 
#include <span>
#include <string>
#include <string_view>
 
#include "./raylib.hpp"
#include "./raylib-cpp-utils.hpp"
#include "./RaylibException.hpp"
 
namespace raylib {
class Wave : public ::Wave {
 public:
    Wave(const ::Wave& wave) {
        set(wave);
    }
 
    Wave(
            unsigned int frameCount = 0,
            unsigned int sampleRate = 0,
            unsigned int sampleSize = 0,
            unsigned int channels = 0,
            void *data = nullptr) : ::Wave{frameCount, sampleRate, sampleSize, channels, data} {
        // Nothing.
    }
 
    Wave(const std::string_view fileName) {
        Load(fileName);
    }
 
    Wave(const std::string_view fileType, const unsigned char *fileData, int dataSize) {
        Load(fileType, fileData, dataSize);
    }
 
    Wave(const std::string_view fileType, std::span<const unsigned char> fileData) {
        Load(fileType, fileData);
    }
 
    Wave(const Wave& other) {
        set(other.Copy());
    }
 
    Wave(Wave&& other) {
        set(other);
 
        other.frameCount = 0;
        other.sampleRate = 0;
        other.sampleSize = 0;
        other.channels = 0;
        other.data = nullptr;
    }
 
    ~Wave() {
        Unload();
    }
 
    GETTER(unsigned int, FrameCount, frameCount)
    GETTER(unsigned int, SampleRate, sampleRate)
    GETTER(unsigned int, SampleSize, sampleSize)
    GETTER(unsigned int, Channels, channels)
    GETTER(void *, Data, data)
 
    Wave& operator=(const ::Wave& wave) {
        set(wave);
        return *this;
    }
 
    Wave& operator=(const Wave& other) {
        if (this == &other) {
            return *this;
        }
 
        Unload();
        set(other.Copy());
 
        return *this;
    }
 
    Wave& operator=(Wave&& other) noexcept {
        if (this != &other) {
            return *this;
        }
 
        Unload();
        set(other);
 
        other.frameCount = 0;
        other.sampleRate = 0;
        other.sampleSize = 0;
        other.channels = 0;
        other.data = nullptr;
 
        return *this;
    }
 
    ::Wave Copy() const {
        return ::WaveCopy(*this);
    }
 
    Wave& Crop(int initSample, int finalSample) {
        ::WaveCrop(this, initSample, finalSample);
        return *this;
    }
 
    Wave& Format(int SampleRate, int SampleSize, int Channels = 2) {
        ::WaveFormat(this, SampleRate, SampleSize, Channels);
        return *this;
    }
 
    float* LoadSamples() {
        return ::LoadWaveSamples(*this);
    }
 
    static void UnloadSamples(float *samples) {
        ::UnloadWaveSamples(samples);
    }
 
    bool Export(const std::string_view fileName) {
        // TODO(RobLoach): Throw exception on error.
        return ::ExportWave(*this, fileName.data());
    }
 
    bool ExportAsCode(const std::string_view fileName) {
        // TODO(RobLoach): Throw exception on error.
        return ::ExportWaveAsCode(*this, fileName.data());
    }
 
    void Unload() {
        // Protect against calling UnloadWave() twice.
        if (data != nullptr) {
            ::UnloadWave(*this);
            data = nullptr;
        }
    }
 
    ::Sound LoadSound() {
        return ::LoadSoundFromWave(*this);
    }
 
    operator ::Sound() {
        return LoadSound();
    }
 
    void Load(const std::string_view fileName) {
        set(::LoadWave(fileName.data()));
        if (!IsReady()) {
            throw RaylibException("Failed to load Wave from file: " + std::string(fileName));
        }
    }
 
    void Load(const std::string_view fileType, const unsigned char *fileData, int dataSize) {
        set(::LoadWaveFromMemory(fileType.data(), fileData, dataSize));
        if (!IsReady()) {
            throw RaylibException("Failed to load Wave from file data of type: " + std::string(fileType));
        }
    }
 
    void Load(const std::string_view fileType, std::span<const unsigned char> fileData) {
        set(::LoadWaveFromMemory(fileType.data(), fileData.data(), static_cast<int>(fileData.size())));
        if (!IsReady()) {
            throw RaylibException("Failed to load Wave from file data of type: " + std::string(fileType));
        }
    }
 
    bool IsReady() const {
        return ::IsWaveReady(*this);
    }
 
 protected:
    void set(const ::Wave& wave) {
        frameCount = wave.frameCount;
        sampleRate = wave.sampleRate;
        sampleSize = wave.sampleSize;
        channels = wave.channels;
        data = wave.data;
    }
};
 
}  // namespace raylib
 
using RWave = raylib::Wave;
 
#endif  // RAYLIB_CPP_INCLUDE_WAVE_HPP_