njin_audio.h

#pragma once
#include "_types.h"
#include <entt/entity/fwd.hpp>
 
namespace njin {
// Opaque, see njin_ctx.h.
struct context;


enum audio_bus {
  bus_master, 
  bus_music,  
  bus_sfx,    
  bus_ui,     
  bus_voice,  
  audio_bus_count 
};

void audio_set_bus_volume(context &ctx, audio_bus bus, f32 volume);

f32 audio_bus_volume(const context &ctx, audio_bus bus);

void audio_set_bus_muted(context &ctx, audio_bus bus, bool muted);

bool audio_bus_muted(const context &ctx, audio_bus bus);

void sound_set_bus(context &ctx, sound_handle handle, audio_bus bus);

sound_handle sound_load(context &ctx, const char *path);

sound_handle sound_load_samples(context &ctx, const f32 *samples, i32 count,
                                i32 sample_rate);

void sound_unload(context &ctx, sound_handle handle);

void sound_set_volume(context &ctx, sound_handle handle, f32 volume);

void sound_set_muted(context &ctx, sound_handle handle, bool muted);

void sound_play_once(context &ctx, sound_handle handle);

void sound_play_once_at(context &ctx, sound_handle handle, f32 pitch, f32 gain);

void sound_play_restart(context &ctx, sound_handle handle);

void sound_play_loop(context &ctx, sound_handle handle);

void sound_play_at(context &ctx, sound_handle handle, vec2 world_pos);

void audio_set_range(context &ctx, f32 full_until, f32 silent_from);

void sound_stop(context &ctx, sound_handle handle);


music_handle music_load(context &ctx, const char *path);

void music_unload(context &ctx, music_handle handle);

void music_set_volume(context &ctx, music_handle handle, f32 volume);

void music_set_muted(context &ctx, music_handle handle, bool muted);

void music_set_looping(context &ctx, music_handle handle, bool looping);

void music_play(context &ctx, music_handle handle);

void music_stop(context &ctx, music_handle handle);

void music_pause(context &ctx, music_handle handle);

void music_resume(context &ctx, music_handle handle);

bool music_playing(context &ctx, music_handle handle);

void music_fade_in(context &ctx, music_handle handle, f32 seconds);

void music_fade_out(context &ctx, music_handle handle, f32 seconds);

void music_crossfade(context &ctx, music_handle handle, f32 seconds);


struct audio_listener3d {
  vec3 position{0.0f, 0.0f, 0.0f}; 
  vec3 forward{0.0f, 0.0f, -1.0f}; 
  vec3 up{0.0f, 1.0f, 0.0f};       
  vec3 velocity{0.0f, 0.0f, 0.0f}; 
};

void audio_set_listener3d(context &ctx, const audio_listener3d &listener);

void audio_listener3d_follow_camera(context &ctx, bool follow = true);

audio_listener3d audio_listener3d_get(const context &ctx);

void audio_set_speed_of_sound(context &ctx, f32 units_per_second);

enum audio_rolloff {
  rolloff_inverse,
  rolloff_linear,
  rolloff_exponential,
};

struct sound3d_desc {
  f32 volume = 1.0f; 
  f32 pitch = 1.0f;  
  f32 min_distance = 1.0f;  
  f32 max_distance = 40.0f; 
  audio_rolloff rolloff = rolloff_inverse; 
  f32 rolloff_factor = 1.0f;
  f32 spread = 1.0f;
  f32 doppler = 1.0f;
  vec3 cone_direction{0.0f, 0.0f, 0.0f};
  f32 cone_inner = 360.0f; 
  f32 cone_outer = 360.0f; 
  f32 cone_outer_volume = 0.0f; 
  bool occlusion = false;
  f32 occlusion_volume = 0.35f; 
  f32 occlusion_margin = 0.5f;
};

voice3d_handle sound_play3d(context &ctx, sound_handle handle, vec3 position, const sound3d_desc &desc = {});

voice3d_handle sound_play3d(context &ctx, sound_handle handle, entt::entity entity, const sound3d_desc &desc = {});

voice3d_handle sound_loop3d(context &ctx, sound_handle handle, vec3 position, const sound3d_desc &desc = {});

voice3d_handle sound_loop3d(context &ctx, sound_handle handle, entt::entity entity, const sound3d_desc &desc = {});

void voice3d_set_position(context &ctx, voice3d_handle voice, vec3 position);

void voice3d_attach(context &ctx, voice3d_handle voice, entt::entity entity, vec3 offset = {});

void voice3d_set_velocity(context &ctx, voice3d_handle voice, vec3 velocity);

void voice3d_set_desc(context &ctx, voice3d_handle voice, const sound3d_desc &desc);

sound3d_desc voice3d_desc(const context &ctx, voice3d_handle voice);

void voice3d_stop(context &ctx, voice3d_handle voice);

bool voice3d_playing(const context &ctx, voice3d_handle voice);

struct voice3d_mix {
  f32 volume = 0.0f;   
  f32 pan = 0.0f;      
  f32 pitch = 1.0f;    
  f32 distance = 0.0f; 
  bool occluded = false; 
};

voice3d_mix voice3d_state(const context &ctx, voice3d_handle voice);
} // namespace njin