SoundManager.h

Go to the documentation of this file.

/*
    This source file is part of Rigs of Rods
    Copyright 2005-2012 Pierre-Michel Ricordel
    Copyright 2007-2012 Thomas Fischer
    Copyright 2013-2020 Petr Ohlidal
 
    For more information, see http://www.rigsofrods.org/
 
    Rigs of Rods is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 3, as
    published by the Free Software Foundation.
 
    Rigs of Rods 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifdef USE_OPENAL
 
#pragma once
 
#include "Actor.h"
#include "Application.h"
#include "Collisions.h"
#include "GameContext.h"
#include "Sound.h"
#include "SoundScriptManager.h"
 
#include <OgreVector3.h>
#include <OgreString.h>
 
#ifdef __APPLE__
  #include <OpenAL/al.h>
  #include <OpenAL/alc.h>
  #include <OpenAL/alext.h>
  #include <OpenAL/efx-presets.h>
#else
  #include <AL/al.h>
  #include <AL/alc.h>
  #include <AL/alext.h>
  #include <AL/efx-presets.h>
#endif // __APPLE__
 
namespace RoR {
 
 
class SoundManager
{
    friend class Sound;
 
public:
    SoundManager();
    ~SoundManager();
 
    void     CleanUp();
 
    SoundPtr createSound(Ogre::String filename, Ogre::String resource_group_name = "");
 
    Ogre::Vector3 GetListenerPosition() const { return m_listener_position; }
 
    bool ListenerIsUnderwater() const { return m_listener_is_underwater; }
 
    void Update(const float dt);
 
    void UpdateGlobalDopplerFactor() const;
 
    void UpdateEfxSpecificProperties(const float dt);
 
    void UpdateSourceSpecificDopplerFactor(const int hardware_index) const;
 
    void SetListener(Ogre::Vector3 position, Ogre::Vector3 direction, Ogre::Vector3 up, Ogre::Vector3 velocity);
 
    void pauseAllSounds();
 
    void resumeAllSounds();
 
    void setMasterVolume(float v);
 
    bool isDisabled() { return audio_device == 0; }
 
    float GetSpeedOfSound() const { return alGetFloat(AL_SPEED_OF_SOUND); }
 
    void SetSpeedOfSound(const float speed_of_sound) const { alSpeedOfSound(speed_of_sound); }
 
    float GetDopplerFactor() const { return alGetFloat(AL_DOPPLER_FACTOR); }
 
    void SetDopplerFactor(const float doppler_factor) const { alDopplerFactor(doppler_factor); }
 
     void SetDopplerFactor(const ALuint hardware_source, const float doppler_factor) const;
 
    void SetAirAbsorptionFactor(const float air_absorption_factor) { m_air_absorption_factor = air_absorption_factor; }
 
    float GetAirAbsorptionFactor() const { return m_air_absorption_factor; }
 
    int getNumHardwareSources() { return hardware_sources_num; }
 
    const std::map<std::string, EFXEAXREVERBPROPERTIES>& getEfxPropertiesMap() const { return m_efx_properties_map; }
 
    const EFXEAXREVERBPROPERTIES* GetEfxProperties(const std::string& efx_preset_name) const;
 
    const EFXEAXREVERBPROPERTIES* GetReverbPresetAt(Ogre::Vector3 position) const;
 
    static const float MAX_DISTANCE;
    static const float ROLLOFF_FACTOR;
    static const float REFERENCE_DISTANCE;
    static const unsigned int MAX_HARDWARE_SOURCES = 32;
    static const unsigned int MAX_AUDIO_BUFFERS = 8192;
 
private:
    void UpdateAlListener();
 
    void UpdateListenerEnvironment();
 
    void recomputeAllSources();
 
    void recomputeSource(int source_index, int reason, float vfl, Ogre::Vector3 *vvec);
 
    ALuint getHardwareSource(int hardware_index) { return hardware_sources[hardware_index]; };
 
    void assign(int source_index, int hardware_index);
 
    void retire(int source_index);
 
    bool loadWAVFile(Ogre::String filename, ALuint buffer, Ogre::String resource_group_name = "");
 
    // active audio sources (hardware sources)
    int    hardware_sources_num = 0;                   
    int    hardware_sources_in_use_count = 0;
    int    hardware_sources_map[MAX_HARDWARE_SOURCES]; 
    ALuint hardware_sources[MAX_HARDWARE_SOURCES];     // this buffer contains valid AL handles up to m_hardware_sources_num
 
    // audio sources
    int      m_audio_sources_in_use_count = 0;
    SoundPtr audio_sources[MAX_AUDIO_BUFFERS] = { nullptr };
    // helper for calculating the most audible sources
    std::pair<int, float> audio_sources_most_audible[MAX_AUDIO_BUFFERS];
 
    // audio buffers: Array of AL buffers and filenames
    int          audio_buffers_in_use_count = 0;
    ALuint       audio_buffers[MAX_AUDIO_BUFFERS];
    Ogre::String audio_buffer_file_name[MAX_AUDIO_BUFFERS];
 
    bool          m_listener_is_underwater = false;
    Ogre::Vector3 m_listener_position = Ogre::Vector3::ZERO;
    Ogre::Vector3 m_listener_direction = Ogre::Vector3::ZERO;
    Ogre::Vector3 m_listener_up = Ogre::Vector3::ZERO;
    Ogre::Vector3 m_listener_velocity = Ogre::Vector3::ZERO;
 
    ALCdevice*    audio_device = nullptr;
    ALCcontext*   sound_context = nullptr;
 
    // OpenAL EFX stuff
    bool                                            m_efx_is_available = false;
    ALuint                                          m_listener_slot = 0;
    ALuint                                          m_efx_outdoor_obstruction_lowpass_filter_id = 0;
    ALuint                                          m_efx_occlusion_wet_path_send_id = 0;
    ALuint                                          m_efx_occlusion_wet_path_lowpass_filter_id = 0;
    float                                           m_air_absorption_factor = 1.0f;
    EfxReverbEngine                                 m_efx_reverb_engine = EfxReverbEngine::NONE;
    const EFXEAXREVERBPROPERTIES*                   m_listener_efx_reverb_properties = nullptr;
    std::map<std::string, EFXEAXREVERBPROPERTIES>   m_efx_properties_map;
    std::map<ALuint, ALuint>                        m_efx_effect_id_map;  //<! maps from auxiliary effect slot id to effect id
    LPALGENEFFECTS                                  alGenEffects = nullptr;
    LPALDELETEEFFECTS                               alDeleteEffects = nullptr;
    LPALISEFFECT                                    alIsEffect = nullptr;
    LPALEFFECTI                                     alEffecti = nullptr;
    LPALEFFECTF                                     alEffectf = nullptr;
    LPALEFFECTFV                                    alEffectfv = nullptr;
    LPALGENFILTERS                                  alGenFilters = nullptr;
    LPALDELETEFILTERS                               alDeleteFilters = nullptr;
    LPALISFILTER                                    alIsFilter = nullptr;
    LPALFILTERI                                     alFilteri = nullptr;
    LPALFILTERF                                     alFilterf = nullptr;
    LPALGENAUXILIARYEFFECTSLOTS                     alGenAuxiliaryEffectSlots = nullptr;
    LPALDELETEAUXILIARYEFFECTSLOTS                  alDeleteAuxiliaryEffectSlots = nullptr;
    LPALISAUXILIARYEFFECTSLOT                       alIsAuxiliaryEffectSlot = nullptr;
    LPALAUXILIARYEFFECTSLOTI                        alAuxiliaryEffectSloti = nullptr;
    LPALAUXILIARYEFFECTSLOTF                        alAuxiliaryEffectSlotf = nullptr;
    LPALAUXILIARYEFFECTSLOTFV                       alAuxiliaryEffectSlotfv = nullptr;
 
    ALuint  CreateAlEffect(const EFXEAXREVERBPROPERTIES* efx_properties) const;
 
    void    DeleteAlEffect(const ALuint efx_effect_id) const;
 
    void    PrepopulateEfxPropertiesMap();
 
    void    UpdateListenerEffectSlot(const float dt);
 
    void    SmoothlyUpdateAlAuxiliaryEffectSlot(const float dt, const ALuint slot_id, const EFXEAXREVERBPROPERTIES* target_efx_properties);
 
    std::tuple<Ogre::Vector3, float, float> ComputeEarlyReflectionsProperties() const;
 
    void    UpdateSourceFilters(const int hardware_index) const;
 
    bool    IsHardwareSourceObstructed(const int hardware_index) const;
 
    void    UpdateObstructionFilter(const int hardware_index, const bool enable_obstruction_filter) const;
 
    bool    UpdateOcclusionFilter(const int hardware_index, const ALuint effect_slot_id, const EFXEAXREVERBPROPERTIES* reference_efx_reverb_properties) const;
 
    void    UpdateDirectedSounds() const;
 
    void    UpdateConeProperties(
                const ALuint          source,
                const Ogre::Vector3&  cone_direction,
                const float           cone_inner_angle,
                const float           cone_outer_angle,
                const float           cone_outer_gain,
                const float           cone_outer_gain_hf
            ) const;
};
 
 
} // namespace RoR
 
#endif // USE_OPENAL