al_context.h

#pragma once
 
#include <list>
#include <map>
#include <string>
 
#include <cgv/math/fvec.h>
#include <cgv/math/fmat.h>
#include <cgv/type/info/type_id.h>
 
#include "lib_begin.h"
 
struct ALCdevice;
struct ALCcontext;
using ALuint = unsigned int;
 
namespace cgv {
namespace audio {
 
struct OALSoundFormat
{
    enum Type {
        SFT_UINT8,
        SFT_INT16
    } value_type;
    enum Channels {
        SFC_MONO = 1,
        SFC_STEREO = 2
    } nr_channels;
    int sampling_rate;
    int nr_frames;
};
 
class CGV_API OALContext
{
public:
    static std::vector<std::string> enumerate_devices();
    static std::string get_default_device_name();
    explicit OALContext(const std::string& device_name);
    OALContext(const OALContext& other) = delete;
    OALContext(OALContext&& other) = default;
    OALContext& operator=(const OALContext& other) = delete;
    OALContext& operator=(OALContext&& other) = default;
    ~OALContext();
    std::string get_device_name() const;
    void make_current();
    static bool decode_sound_file(const void* data, size_t data_length, OALSoundFormat& format, std::vector<int16_t>& memory_buffer);
    static bool load_sound_file(const std::string& filepath, OALSoundFormat& format, std::vector<int16_t>& memory_buffer);
    void create_buffer(const std::string& symbolic_name, const OALSoundFormat& format, const void* data, size_t data_length);
    void load_sample(std::string filepath, std::string symbolic_name = "");
    
    void load_sample(std::string symbolic_name, const void* data, size_t data_length);
 
    void load_samples(std::string folder, bool recursive = false);
 
    ALuint get_buffer_id(std::string sound_name) const;
    std::string get_error_string();
 
    bool is_no_error();
 
    void set_HRTF(bool active);
 
    ALCdevice* get_native_device();
 
    ALCcontext* get_native_context();
 
  private:
    ALCdevice* oal_device = nullptr;
    ALCcontext* oal_context = nullptr;
 
    std::map<std::string, ALuint> sample_buffers;
};
 
class CGV_API OALListener final
{
  public:
    OALListener() = delete;
    OALListener(const OALListener& other) = delete;
    OALListener(OALListener&& other) = delete;
    OALListener& operator=(const OALListener& other) = delete;
    OALListener& operator=(OALListener&& other) = delete;
    ~OALListener() = delete;
 
    static cgv::math::fvec<float, 3> get_position();
 
    static cgv::math::fvec<float, 3> get_velocity();
 
    static cgv::math::fmat<float, 3, 2> get_orientation();
 
    static void set_position(cgv::math::fvec<float, 3> pos);
 
    static void set_velocity(cgv::math::fvec<float, 3> vel);
 
    static void set_orientation(cgv::math::fvec<float, 3> at, cgv::math::fvec<float, 3> up);
};
 
enum OALSourceState {
    OALSS_INITIAL,
    OALSS_PLAYING,
    OALSS_PAUSED,
    OALSS_STOPPED
};
 
class CGV_API OALSource
{
  public:
    OALSource() = default;
    OALSource(const OALSource&) = delete;
    OALSource(OALSource&&) = default;
    OALSource& operator=(const OALSource&) = delete;
    OALSource& operator=(OALSource&&) = default;
    ~OALSource();
 
    bool init(OALContext& ctx, std::string sound_name = "");
    void clear();
    bool append_sound(std::string sound_name);
    void set_position(cgv::math::fvec<float, 3> pos);
 
    void set_velocity(cgv::math::fvec<float, 3> vel);
 
    void set_pitch(float pitch);
 
    void set_gain(float gain);
 
    void set_looping(bool should_loop);
 
    cgv::math::fvec<float, 3> get_position() const;
 
    cgv::math::fvec<float, 3> get_velocity() const;
 
    float get_pitch() const;
 
    float get_gain() const;
 
    bool is_looping() const;
 
    bool is_playing() const;
 
    
    OALSourceState get_state() const;
 
    void play();
 
    void pause();
 
    void play_pause(bool should_play);
 
    void stop();
 
    void rewind();
protected:
    bool append_sound_impl(std::string sound_name);
  private:
    OALContext* ctx_ptr = nullptr;
    ALuint src_id = 0;
};
 
} // namespace audio
} // namespace cgv
 
#include <cgv/config/lib_end.h>