sound.h

Go to the documentation of this file.

// Luanti
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
#pragma once
 
#include "irr_v3d.h"
#include "config.h"
#include <limits>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#if !IS_CLIENT_BUILD
#error Do not include in server builds
#endif
 
struct SoundSpec;
 
class SoundFallbackPathProvider
{
public:
        virtual ~SoundFallbackPathProvider() = default;
        std::vector<std::string> getLocalFallbackPathsForSoundname(const std::string &name);
protected:
        virtual void addThePaths(const std::string &name, std::vector<std::string> &paths);
        // adds <common>.ogg, <common>.1.ogg, ..., <common>.9.ogg to paths
        void addAllAlternatives(const std::string &common, std::vector<std::string> &paths);
private:
        std::unordered_set<std::string> m_done_names;
};
 
 
using sound_handle_t = int;
 
constexpr sound_handle_t SOUND_HANDLE_T_MAX = std::numeric_limits<sound_handle_t>::max();
 
class ISoundManager
{
private:
        std::unordered_map<sound_handle_t, u32> m_occupied_ids;
        sound_handle_t m_next_id = 1;
        std::vector<sound_handle_t> m_removed_sounds;
 
protected:
        void reportRemovedSound(sound_handle_t id);
 
public:
        virtual ~ISoundManager() = default;
 
        virtual void step(f32 dtime) = 0;
        virtual void pauseAll() = 0;
        virtual void resumeAll() = 0;
 
        virtual void updateListener(const v3f &pos, const v3f &vel, const v3f &at,
                        const v3f &up) = 0;
        virtual void setListenerGain(f32 gain) = 0;
 
        virtual bool loadSoundFile(const std::string &name, const std::string &filepath) = 0;
        virtual bool loadSoundData(const std::string &name, std::string &&filedata) = 0;
        virtual void addSoundToGroup(const std::string &sound_name,
                        const std::string &group_name) = 0;
 
        virtual void playSound(sound_handle_t id, const SoundSpec &spec) = 0;
        virtual void playSoundAt(sound_handle_t id, const SoundSpec &spec, const v3f &pos,
                        const v3f &vel) = 0;
        virtual void stopSound(sound_handle_t sound) = 0;
        virtual void fadeSound(sound_handle_t sound, f32 step, f32 target_gain) = 0;
        virtual void updateSoundPosVel(sound_handle_t sound, const v3f &pos,
                        const v3f &vel) = 0;
 
        std::vector<sound_handle_t> pollRemovedSounds()
        {
                std::vector<sound_handle_t> ret;
                std::swap(m_removed_sounds, ret);
                return ret;
        }
 
        sound_handle_t allocateId(u32 num_owners);
 
        void freeId(sound_handle_t id, u32 num_owners = 1);
};
 
class DummySoundManager final : public ISoundManager
{
public:
        void step(f32 dtime) override {}
        void pauseAll() override {}
        void resumeAll() override {}
 
        void updateListener(const v3f &pos, const v3f &vel, const v3f &at, const v3f &up) override {}
        void setListenerGain(f32 gain) override {}
 
        bool loadSoundFile(const std::string &name, const std::string &filepath) override { return true; }
        bool loadSoundData(const std::string &name, std::string &&filedata) override { return true; }
        void addSoundToGroup(const std::string &sound_name, const std::string &group_name) override {};
 
        void playSound(sound_handle_t id, const SoundSpec &spec) override { reportRemovedSound(id); }
        void playSoundAt(sound_handle_t id, const SoundSpec &spec, const v3f &pos,
                        const v3f &vel) override { reportRemovedSound(id); }
        void stopSound(sound_handle_t sound) override {}
        void fadeSound(sound_handle_t sound, f32 step, f32 target_gain) override {}
        void updateSoundPosVel(sound_handle_t sound, const v3f &pos, const v3f &vel) override {}
};
 
void sound_volume_control(ISoundManager *sound_mgr, bool is_window_active);