diff options
Diffstat (limited to 'src/client')
| -rw-r--r-- | src/client/CMakeLists.txt | 17 | ||||
| -rw-r--r-- | src/client/sound.cpp | 23 | ||||
| -rw-r--r-- | src/client/sound.h | 111 | ||||
| -rw-r--r-- | src/client/sound_openal.cpp | 689 | ||||
| -rw-r--r-- | src/client/sound_openal.h | 31 |
5 files changed, 871 insertions, 0 deletions
diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt index ea8acd064..1cabe1b11 100644 --- a/src/client/CMakeLists.txt +++ b/src/client/CMakeLists.txt @@ -1,4 +1,21 @@ +set(sound_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/sound.cpp) + +if(USE_SOUND) + set(sound_SRCS ${sound_SRCS} + ${CMAKE_CURRENT_SOURCE_DIR}/sound_openal.cpp) + set(SOUND_INCLUDE_DIRS + ${OPENAL_INCLUDE_DIR} + ${VORBIS_INCLUDE_DIR} + ${OGG_INCLUDE_DIR} + PARENT_SCOPE) + set(SOUND_LIBRARIES + ${OPENAL_LIBRARY} + ${VORBIS_LIBRARIES} + PARENT_SCOPE) +endif() + set(client_SRCS + ${sound_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/meshgen/collector.cpp ${CMAKE_CURRENT_SOURCE_DIR}/render/anaglyph.cpp ${CMAKE_CURRENT_SOURCE_DIR}/render/core.cpp diff --git a/src/client/sound.cpp b/src/client/sound.cpp new file mode 100644 index 000000000..44a96dd25 --- /dev/null +++ b/src/client/sound.cpp @@ -0,0 +1,23 @@ +/* +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#include "sound.h" + +// Global DummySoundManager singleton +DummySoundManager dummySoundManager; diff --git a/src/client/sound.h b/src/client/sound.h new file mode 100644 index 000000000..c1d3c0cfa --- /dev/null +++ b/src/client/sound.h @@ -0,0 +1,111 @@ +/* +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#pragma once + +#include <set> +#include <string> +#include "irr_v3d.h" +#include "../sound.h" + +class OnDemandSoundFetcher +{ +public: + virtual void fetchSounds(const std::string &name, + std::set<std::string> &dst_paths, + std::set<std::string> &dst_datas) = 0; +}; + +class ISoundManager +{ +public: + virtual ~ISoundManager() = default; + + // Multiple sounds can be loaded per name; when played, the sound + // should be chosen randomly from alternatives + // Return value determines success/failure + virtual bool loadSoundFile( + const std::string &name, const std::string &filepath) = 0; + virtual bool loadSoundData( + const std::string &name, const std::string &filedata) = 0; + + virtual void updateListener( + const v3f &pos, const v3f &vel, const v3f &at, const v3f &up) = 0; + virtual void setListenerGain(float gain) = 0; + + // playSound functions return -1 on failure, otherwise a handle to the + // sound. If name=="", call should be ignored without error. + virtual int playSound(const std::string &name, bool loop, float volume, + float fade = 0.0f, float pitch = 1.0f) = 0; + virtual int playSoundAt(const std::string &name, bool loop, float volume, v3f pos, + float pitch = 1.0f) = 0; + virtual void stopSound(int sound) = 0; + virtual bool soundExists(int sound) = 0; + virtual void updateSoundPosition(int sound, v3f pos) = 0; + virtual bool updateSoundGain(int id, float gain) = 0; + virtual float getSoundGain(int id) = 0; + virtual void step(float dtime) = 0; + virtual void fadeSound(int sound, float step, float gain) = 0; + + int playSound(const SimpleSoundSpec &spec, bool loop) + { + return playSound(spec.name, loop, spec.gain, spec.fade, spec.pitch); + } + int playSoundAt(const SimpleSoundSpec &spec, bool loop, const v3f &pos) + { + return playSoundAt(spec.name, loop, spec.gain, pos, spec.pitch); + } +}; + +class DummySoundManager : public ISoundManager +{ +public: + virtual bool loadSoundFile(const std::string &name, const std::string &filepath) + { + return true; + } + virtual bool loadSoundData(const std::string &name, const std::string &filedata) + { + return true; + } + void updateListener(const v3f &pos, const v3f &vel, const v3f &at, const v3f &up) + { + } + void setListenerGain(float gain) {} + int playSound(const std::string &name, bool loop, float volume, float fade, + float pitch) + { + return 0; + } + int playSoundAt(const std::string &name, bool loop, float volume, v3f pos, + float pitch) + { + return 0; + } + void stopSound(int sound) {} + bool soundExists(int sound) { return false; } + void updateSoundPosition(int sound, v3f pos) {} + bool updateSoundGain(int id, float gain) { return false; } + float getSoundGain(int id) { return 0; } + void step(float dtime) {} + void fadeSound(int sound, float step, float gain) {} +}; + +// Global DummySoundManager singleton +extern DummySoundManager dummySoundManager; diff --git a/src/client/sound_openal.cpp b/src/client/sound_openal.cpp new file mode 100644 index 000000000..d66360057 --- /dev/null +++ b/src/client/sound_openal.cpp @@ -0,0 +1,689 @@ +/* +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com> +OpenAL support based on work by: +Copyright (C) 2011 Sebastian 'Bahamada' Rühl +Copyright (C) 2011 Cyriaque 'Cisoun' Skrapits <cysoun@gmail.com> +Copyright (C) 2011 Giuseppe Bilotta <giuseppe.bilotta@gmail.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; ifnot, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#include "sound_openal.h" + +#if defined(_WIN32) + #include <al.h> + #include <alc.h> + //#include <alext.h> +#elif defined(__APPLE__) + #include <OpenAL/al.h> + #include <OpenAL/alc.h> + //#include <OpenAL/alext.h> +#else + #include <AL/al.h> + #include <AL/alc.h> + #include <AL/alext.h> +#endif +#include <cmath> +#include <vorbis/vorbisfile.h> +#include <cassert> +#include "log.h" +#include "util/numeric.h" // myrand() +#include "porting.h" +#include <vector> +#include <fstream> +#include <unordered_map> +#include <unordered_set> + +#define BUFFER_SIZE 30000 + +std::shared_ptr<SoundManagerSingleton> g_sound_manager_singleton; + +typedef std::unique_ptr<ALCdevice, void (*)(ALCdevice *p)> unique_ptr_alcdevice; +typedef std::unique_ptr<ALCcontext, void(*)(ALCcontext *p)> unique_ptr_alccontext; + +static void delete_alcdevice(ALCdevice *p) +{ + if (p) + alcCloseDevice(p); +} + +static void delete_alccontext(ALCcontext *p) +{ + if (p) { + alcMakeContextCurrent(nullptr); + alcDestroyContext(p); + } +} + +static const char *alErrorString(ALenum err) +{ + switch (err) { + case AL_NO_ERROR: + return "no error"; + case AL_INVALID_NAME: + return "invalid name"; + case AL_INVALID_ENUM: + return "invalid enum"; + case AL_INVALID_VALUE: + return "invalid value"; + case AL_INVALID_OPERATION: + return "invalid operation"; + case AL_OUT_OF_MEMORY: + return "out of memory"; + default: + return "<unknown OpenAL error>"; + } +} + +static ALenum warn_if_error(ALenum err, const char *desc) +{ + if(err == AL_NO_ERROR) + return err; + warningstream<<desc<<": "<<alErrorString(err)<<std::endl; + return err; +} + +void f3_set(ALfloat *f3, v3f v) +{ + f3[0] = v.X; + f3[1] = v.Y; + f3[2] = v.Z; +} + +struct SoundBuffer +{ + ALenum format; + ALsizei freq; + ALuint buffer_id; + std::vector<char> buffer; +}; + +SoundBuffer *load_opened_ogg_file(OggVorbis_File *oggFile, + const std::string &filename_for_logging) +{ + int endian = 0; // 0 for Little-Endian, 1 for Big-Endian + int bitStream; + long bytes; + char array[BUFFER_SIZE]; // Local fixed size array + vorbis_info *pInfo; + + SoundBuffer *snd = new SoundBuffer; + + // Get some information about the OGG file + pInfo = ov_info(oggFile, -1); + + // Check the number of channels... always use 16-bit samples + if(pInfo->channels == 1) + snd->format = AL_FORMAT_MONO16; + else + snd->format = AL_FORMAT_STEREO16; + + // The frequency of the sampling rate + snd->freq = pInfo->rate; + + // Keep reading until all is read + do + { + // Read up to a buffer's worth of decoded sound data + bytes = ov_read(oggFile, array, BUFFER_SIZE, endian, 2, 1, &bitStream); + + if(bytes < 0) + { + ov_clear(oggFile); + infostream << "Audio: Error decoding " + << filename_for_logging << std::endl; + delete snd; + return nullptr; + } + + // Append to end of buffer + snd->buffer.insert(snd->buffer.end(), array, array + bytes); + } while (bytes > 0); + + alGenBuffers(1, &snd->buffer_id); + alBufferData(snd->buffer_id, snd->format, + &(snd->buffer[0]), snd->buffer.size(), + snd->freq); + + ALenum error = alGetError(); + + if(error != AL_NO_ERROR){ + infostream << "Audio: OpenAL error: " << alErrorString(error) + << "preparing sound buffer" << std::endl; + } + + infostream << "Audio file " + << filename_for_logging << " loaded" << std::endl; + + // Clean up! + ov_clear(oggFile); + + return snd; +} + +SoundBuffer *load_ogg_from_file(const std::string &path) +{ + OggVorbis_File oggFile; + + // Try opening the given file. + // This requires libvorbis >= 1.3.2, as + // previous versions expect a non-const char * + if (ov_fopen(path.c_str(), &oggFile) != 0) { + infostream << "Audio: Error opening " << path + << " for decoding" << std::endl; + return nullptr; + } + + return load_opened_ogg_file(&oggFile, path); +} + +struct BufferSource { + const char *buf; + size_t cur_offset; + size_t len; +}; + +size_t buffer_sound_read_func(void *ptr, size_t size, size_t nmemb, void *datasource) +{ + BufferSource *s = (BufferSource *)datasource; + size_t copied_size = MYMIN(s->len - s->cur_offset, size); + memcpy(ptr, s->buf + s->cur_offset, copied_size); + s->cur_offset += copied_size; + return copied_size; +} + +int buffer_sound_seek_func(void *datasource, ogg_int64_t offset, int whence) +{ + BufferSource *s = (BufferSource *)datasource; + if (whence == SEEK_SET) { + if (offset < 0 || (size_t)MYMAX(offset, 0) >= s->len) { + // offset out of bounds + return -1; + } + s->cur_offset = offset; + return 0; + } else if (whence == SEEK_CUR) { + if ((size_t)MYMIN(-offset, 0) > s->cur_offset + || s->cur_offset + offset > s->len) { + // offset out of bounds + return -1; + } + s->cur_offset += offset; + return 0; + } + // invalid whence param (SEEK_END doesn't have to be supported) + return -1; +} + +long BufferSourceell_func(void *datasource) +{ + BufferSource *s = (BufferSource *)datasource; + return s->cur_offset; +} + +static ov_callbacks g_buffer_ov_callbacks = { + &buffer_sound_read_func, + &buffer_sound_seek_func, + nullptr, + &BufferSourceell_func +}; + +SoundBuffer *load_ogg_from_buffer(const std::string &buf, const std::string &id_for_log) +{ + OggVorbis_File oggFile; + + BufferSource s; + s.buf = buf.c_str(); + s.cur_offset = 0; + s.len = buf.size(); + + if (ov_open_callbacks(&s, &oggFile, nullptr, 0, g_buffer_ov_callbacks) != 0) { + infostream << "Audio: Error opening " << id_for_log + << " for decoding" << std::endl; + return nullptr; + } + + return load_opened_ogg_file(&oggFile, id_for_log); +} + +struct PlayingSound +{ + ALuint source_id; + bool loop; +}; + +class SoundManagerSingleton +{ +public: + unique_ptr_alcdevice m_device; + unique_ptr_alccontext m_context; +public: + SoundManagerSingleton() : + m_device(nullptr, delete_alcdevice), + m_context(nullptr, delete_alccontext) + { + if (!(m_device = unique_ptr_alcdevice(alcOpenDevice(nullptr), delete_alcdevice))) + throw std::runtime_error("Audio: Global Initialization: Device Open"); + + if (!(m_context = unique_ptr_alccontext( + alcCreateContext(m_device.get(), nullptr), delete_alccontext))) { + throw std::runtime_error("Audio: Global Initialization: Context Create"); + } + + if (!alcMakeContextCurrent(m_context.get())) + throw std::runtime_error("Audio: Global Initialization: Context Current"); + + alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED); + + if (alGetError() != AL_NO_ERROR) + throw std::runtime_error("Audio: Global Initialization: OpenAL Error"); + + infostream << "Audio: Global Initialized: OpenAL " << alGetString(AL_VERSION) + << ", using " << alcGetString(m_device.get(), ALC_DEVICE_SPECIFIER) + << std::endl; + } + + ~SoundManagerSingleton() + { + infostream << "Audio: Global Deinitialized." << std::endl; + } +}; + +class OpenALSoundManager: public ISoundManager +{ +private: + OnDemandSoundFetcher *m_fetcher; + ALCdevice *m_device; + ALCcontext *m_context; + int m_next_id; + std::unordered_map<std::string, std::vector<SoundBuffer*>> m_buffers; + std::unordered_map<int, PlayingSound*> m_sounds_playing; + struct FadeState { + FadeState() = default; + + FadeState(float step, float current_gain, float target_gain): + step(step), + current_gain(current_gain), + target_gain(target_gain) {} + float step; + float current_gain; + float target_gain; + }; + + std::unordered_map<int, FadeState> m_sounds_fading; + float m_fade_delay; +public: + OpenALSoundManager(SoundManagerSingleton *smg, OnDemandSoundFetcher *fetcher): + m_fetcher(fetcher), + m_device(smg->m_device.get()), + m_context(smg->m_context.get()), + m_next_id(1), + m_fade_delay(0) + { + infostream << "Audio: Initialized: OpenAL " << std::endl; + } + + ~OpenALSoundManager() + { + infostream << "Audio: Deinitializing..." << std::endl; + + std::unordered_set<int> source_del_list; + + for (const auto &sp : m_sounds_playing) + source_del_list.insert(sp.second->source_id); + + for (const auto &id : source_del_list) + deleteSound(id); + + for (auto &buffer : m_buffers) { + for (SoundBuffer *sb : buffer.second) { + delete sb; + } + buffer.second.clear(); + } + m_buffers.clear(); + + infostream << "Audio: Deinitialized." << std::endl; + } + + void step(float dtime) + { + doFades(dtime); + } + + void addBuffer(const std::string &name, SoundBuffer *buf) + { + std::unordered_map<std::string, std::vector<SoundBuffer*>>::iterator i = + m_buffers.find(name); + if(i != m_buffers.end()){ + i->second.push_back(buf); + return; + } + std::vector<SoundBuffer*> bufs; + bufs.push_back(buf); + m_buffers[name] = bufs; + } + + SoundBuffer* getBuffer(const std::string &name) + { + std::unordered_map<std::string, std::vector<SoundBuffer*>>::iterator i = + m_buffers.find(name); + if(i == m_buffers.end()) + return nullptr; + std::vector<SoundBuffer*> &bufs = i->second; + int j = myrand() % bufs.size(); + return bufs[j]; + } + + PlayingSound* createPlayingSound(SoundBuffer *buf, bool loop, + float volume, float pitch) + { + infostream << "OpenALSoundManager: Creating playing sound" << std::endl; + assert(buf); + PlayingSound *sound = new PlayingSound; + assert(sound); + warn_if_error(alGetError(), "before createPlayingSound"); + alGenSources(1, &sound->source_id); + alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id); + alSourcei(sound->source_id, AL_SOURCE_RELATIVE, true); + alSource3f(sound->source_id, AL_POSITION, 0, 0, 0); + alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0); + alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE); + volume = std::fmax(0.0f, volume); + alSourcef(sound->source_id, AL_GAIN, volume); + alSourcef(sound->source_id, AL_PITCH, pitch); + alSourcePlay(sound->source_id); + warn_if_error(alGetError(), "createPlayingSound"); + return sound; + } + + PlayingSound* createPlayingSoundAt(SoundBuffer *buf, bool loop, + float volume, v3f pos, float pitch) + { + infostream << "OpenALSoundManager: Creating positional playing sound" + << std::endl; + assert(buf); + PlayingSound *sound = new PlayingSound; + assert(sound); + warn_if_error(alGetError(), "before createPlayingSoundAt"); + alGenSources(1, &sound->source_id); + alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id); + alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false); + alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z); + alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0); + // Use alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED) and set reference + // distance to clamp gain at <1 node distance, to avoid excessive + // volume when closer + alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 10.0f); + alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE); + // Multiply by 3 to compensate for reducing AL_REFERENCE_DISTANCE from + // the previous value of 30 to the new value of 10 + volume = std::fmax(0.0f, volume * 3.0f); + alSourcef(sound->source_id, AL_GAIN, volume); + alSourcef(sound->source_id, AL_PITCH, pitch); + alSourcePlay(sound->source_id); + warn_if_error(alGetError(), "createPlayingSoundAt"); + return sound; + } + + int playSoundRaw(SoundBuffer *buf, bool loop, float volume, float pitch) + { + assert(buf); + PlayingSound *sound = createPlayingSound(buf, loop, volume, pitch); + if(!sound) + return -1; + int id = m_next_id++; + m_sounds_playing[id] = sound; + return id; + } + + int playSoundRawAt(SoundBuffer *buf, bool loop, float volume, const v3f &pos, + float pitch) + { + assert(buf); + PlayingSound *sound = createPlayingSoundAt(buf, loop, volume, pos, pitch); + if(!sound) + return -1; + int id = m_next_id++; + m_sounds_playing[id] = sound; + return id; + } + + void deleteSound(int id) + { + std::unordered_map<int, PlayingSound*>::iterator i = m_sounds_playing.find(id); + if(i == m_sounds_playing.end()) + return; + PlayingSound *sound = i->second; + + alDeleteSources(1, &sound->source_id); + + delete sound; + m_sounds_playing.erase(id); + } + + /* If buffer does not exist, consult the fetcher */ + SoundBuffer* getFetchBuffer(const std::string &name) + { + SoundBuffer *buf = getBuffer(name); + if(buf) + return buf; + if(!m_fetcher) + return nullptr; + std::set<std::string> paths; + std::set<std::string> datas; + m_fetcher->fetchSounds(name, paths, datas); + for (const std::string &path : paths) { + loadSoundFile(name, path); + } + for (const std::string &data : datas) { + loadSoundData(name, data); + } + return getBuffer(name); + } + + // Remove stopped sounds + void maintain() + { + verbosestream<<"OpenALSoundManager::maintain(): " + <<m_sounds_playing.size()<<" playing sounds, " + <<m_buffers.size()<<" sound names loaded"<<std::endl; + std::unordered_set<int> del_list; + for (const auto &sp : m_sounds_playing) { + int id = sp.first; + PlayingSound *sound = sp.second; + // If not playing, remove it + { + ALint state; + alGetSourcei(sound->source_id, AL_SOURCE_STATE, &state); + if(state != AL_PLAYING){ + del_list.insert(id); + } + } + } + if(!del_list.empty()) + verbosestream<<"OpenALSoundManager::maintain(): deleting " + <<del_list.size()<<" playing sounds"<<std::endl; + for (int i : del_list) { + deleteSound(i); + } + } + + /* Interface */ + + bool loadSoundFile(const std::string &name, + const std::string &filepath) + { + SoundBuffer *buf = load_ogg_from_file(filepath); + if (buf) + addBuffer(name, buf); + return false; + } + + bool loadSoundData(const std::string &name, + const std::string &filedata) + { + SoundBuffer *buf = load_ogg_from_buffer(filedata, name); + if (buf) + addBuffer(name, buf); + return false; + } + + void updateListener(const v3f &pos, const v3f &vel, const v3f &at, const v3f &up) + { + alListener3f(AL_POSITION, pos.X, pos.Y, pos.Z); + alListener3f(AL_VELOCITY, vel.X, vel.Y, vel.Z); + ALfloat f[6]; + f3_set(f, at); + f3_set(f+3, -up); + alListenerfv(AL_ORIENTATION, f); + warn_if_error(alGetError(), "updateListener"); + } + + void setListenerGain(float gain) + { + alListenerf(AL_GAIN, gain); + } + + int playSound(const std::string &name, bool loop, float volume, float fade, float pitch) + { + maintain(); + if (name.empty()) + return 0; + SoundBuffer *buf = getFetchBuffer(name); + if(!buf){ + infostream << "OpenALSoundManager: \"" << name << "\" not found." + << std::endl; + return -1; + } + int handle = -1; + if (fade > 0) { + handle = playSoundRaw(buf, loop, 0.0f, pitch); + fadeSound(handle, fade, volume); + } else { + handle = playSoundRaw(buf, loop, volume, pitch); + } + return handle; + } + + int playSoundAt(const std::string &name, bool loop, float volume, v3f pos, float pitch) + { + maintain(); + if (name.empty()) + return 0; + SoundBuffer *buf = getFetchBuffer(name); + if(!buf){ + infostream << "OpenALSoundManager: \"" << name << "\" not found." + << std::endl; + return -1; + } + return playSoundRawAt(buf, loop, volume, pos, pitch); + } + + void stopSound(int sound) + { + maintain(); + deleteSound(sound); + } + + void fadeSound(int soundid, float step, float gain) + { + m_sounds_fading[soundid] = FadeState(step, getSoundGain(soundid), gain); + } + + void doFades(float dtime) + { + m_fade_delay += dtime; + + if (m_fade_delay < 0.1f) + return; + + float chkGain = 0; + for (auto i = m_sounds_fading.begin(); + i != m_sounds_fading.end();) { + if (i->second.step < 0.f) + chkGain = -(i->second.current_gain); + else + chkGain = i->second.current_gain; + + if (chkGain < i->second.target_gain) { + i->second.current_gain += (i->second.step * m_fade_delay); + i->second.current_gain = rangelim(i->second.current_gain, 0, 1); + + updateSoundGain(i->first, i->second.current_gain); + ++i; + } else { + if (i->second.target_gain <= 0.f) + stopSound(i->first); + + m_sounds_fading.erase(i++); + } + } + m_fade_delay = 0; + } + + bool soundExists(int sound) + { + maintain(); + return (m_sounds_playing.count(sound) != 0); + } + + void updateSoundPosition(int id, v3f pos) + { + auto i = m_sounds_playing.find(id); + if (i == m_sounds_playing.end()) + return; + PlayingSound *sound = i->second; + + alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false); + alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z); + alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0); + alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0); + } + + bool updateSoundGain(int id, float gain) + { + auto i = m_sounds_playing.find(id); + if (i == m_sounds_playing.end()) + return false; + + PlayingSound *sound = i->second; + alSourcef(sound->source_id, AL_GAIN, gain); + return true; + } + + float getSoundGain(int id) + { + auto i = m_sounds_playing.find(id); + if (i == m_sounds_playing.end()) + return 0; + + PlayingSound *sound = i->second; + ALfloat gain; + alGetSourcef(sound->source_id, AL_GAIN, &gain); + return gain; + } +}; + +std::shared_ptr<SoundManagerSingleton> createSoundManagerSingleton() +{ + return std::shared_ptr<SoundManagerSingleton>(new SoundManagerSingleton()); +} + +ISoundManager *createOpenALSoundManager(SoundManagerSingleton *smg, OnDemandSoundFetcher *fetcher) +{ + return new OpenALSoundManager(smg, fetcher); +}; diff --git a/src/client/sound_openal.h b/src/client/sound_openal.h new file mode 100644 index 000000000..f04ad7cac --- /dev/null +++ b/src/client/sound_openal.h @@ -0,0 +1,31 @@ +/* +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#pragma once + +#include <memory> + +#include "sound.h" + +class SoundManagerSingleton; +extern std::shared_ptr<SoundManagerSingleton> g_sound_manager_singleton; + +std::shared_ptr<SoundManagerSingleton> createSoundManagerSingleton(); +ISoundManager *createOpenALSoundManager( + SoundManagerSingleton *smg, OnDemandSoundFetcher *fetcher); |