AudioSource.hpp

#pragma once
#if !RVE_SERVER
#include "Queryable.hpp"
#include <string>
#include "mathtypes.hpp"
#include "Ref.hpp"
#include "AudioTypes.hpp"
#include "Types.hpp"
#include "ComponentWithOwner.hpp"
#include "AudioRenderBuffer.hpp"
 
namespace RavEngine{
 
class AudioAsset{
    friend class AudioEngine;
    friend class AudioSyncSystem;
    friend class AudioSourceBase;
private:
    const float* audiodata;
    double lengthSeconds = 0;
    uint8_t nchannels = 0;
public:
    PlanarSampleBufferInlineView data;
    AudioAsset(const std::string& name, decltype(nchannels) desired_channels = 1);
    
    AudioAsset(InterleavedSampleBufferView interleavedData, decltype(nchannels) nchannels) : nchannels(nchannels){
        audiodata = interleavedData.data();
        data = PlanarSampleBufferInlineView{const_cast<float*>(audiodata),interleavedData.size(),nchannels };
        data.ImportInterleavedData(interleavedData, nchannels);
    }
    
    ~AudioAsset();
    
    inline double GetLength() const {return lengthSeconds;}
    inline decltype(nchannels) GetNChanels() const {
        return nchannels;
    }
    
    inline auto GetData() const{
        return audiodata;
    }
    
    inline auto GetNumSamples() const{
        return data.sizeOneChannel();
    }
};
 
 
 
struct AudioDataProvider{
    virtual void ProvideBufferData(PlanarSampleBufferInlineView& out_buffer, PlanarSampleBufferInlineView& effectScratchBuffer) = 0;
    
    AudioDataProvider(uint16_t nsamples, uint8_t nchannels) : renderData(nsamples, nchannels){}
    
    SingleAudioRenderBuffer renderData;
    float volume = 1;
    bool loops : 1 = false;
    bool isPlaying : 1 = false;
    
    virtual void Play(){
        isPlaying = true;
    }
    
    virtual void Pause(){
        isPlaying = false;
    }
    
    virtual void Restart() = 0;
    
    
    inline float GetVolume() const { return volume; }
    
    inline void SetVolume(float vol){volume = vol;}
    
    inline void SetLoop(bool loop) {this->loops = loop;}
    
    inline bool IsPlaying() const { return isPlaying; }
};
 
 
class AudioListener : public Queryable<AudioListener>, public AudioGraphComposed, public AutoCTTI{};
 
struct SampledAudioDataProvider : public AudioGraphComposed, public AudioDataProvider{
    Ref<AudioAsset> asset;
    
    uint64_t lastPlayTime = 0;
    
    SampledAudioDataProvider(decltype(asset) a, uint8_t nchannels = 1);
    
    inline void SetAudio(decltype(SampledAudioDataProvider::asset) a) {
        asset = a;
    }
    
    void Restart() final;
    
    void Pause() final;
    
    void Play() final;
    
    void ProvideBufferData(PlanarSampleBufferInlineView& buffer, PlanarSampleBufferInlineView& scratchSpace) final;
};
 
struct AudioSourceBase {
   
protected:
    friend class AudioEngine;
    friend class AudioSyncSystem;
    Ref<AudioDataProvider> player;
    
public:
    
    AudioSourceBase(decltype(player) a) : player(a){}
 
    inline void SetPlayer(decltype(player) p ){
        player = p;
    }
    
    inline decltype(player) GetPlayer() const{
        return player;
    }
 
};
 
struct AudioSourceComponent : public AudioSourceBase, public ComponentWithOwner, public Queryable<AudioSourceComponent>{
    AudioSourceComponent(Entity owner, Ref<AudioDataProvider> a);
};
 
struct AmbientAudioSourceComponent : public AudioSourceBase, public Queryable< AmbientAudioSourceComponent>, public AutoCTTI {
    AmbientAudioSourceComponent(Ref<AudioDataProvider> a);
};
 
struct InstantaneousAudioSource : public AudioSourceBase{
    vector3 source_position;
    
    InstantaneousAudioSource(Ref<AudioAsset> a, const vector3& position, float vol = 1);
};
 
struct InstantaneousAudioSourceToPlay {
    InstantaneousAudioSource source;
    Entity fakeOwner{{INVALID_ENTITY}, nullptr};
    InstantaneousAudioSourceToPlay(const InstantaneousAudioSource& source, entity_t fakeOwner) :
        source(source), fakeOwner(fakeOwner,nullptr) {}
};
 
 
struct InstantaneousAmbientAudioSource : public AudioSourceBase {
    InstantaneousAmbientAudioSource(Ref<AudioAsset> a, float vol = 1);
};
 
}
#endif