NLSOUND::CBackgroundSoundManager Class Reference

#include <background_sound_manager.h>

Inheritance diagram for NLSOUND::CBackgroundSoundManager:

---

Detailed Description

This manager handle the background sound :

• primitive positioned sound (point, path and patatoid supported)
• primitive positioned effect (patatoid only)
• primitive positioned sample bank (patatoid only)
• A set of 32 application definable flag that can be used in background sound to filter the sub sounds of a background sound. Each filter can be assigned at run time a fade in and fade out delay that is used when sound are muted/unmuted according to filter status.

Sounds can be put in three separate layer (named a, b and c). In each layer, sounds patatoid are concurent and the smaller in surface muffle the other sounds.

Effets are managed according to the EAX capacity of the driver.

Sample bank patatoid are used to dynamicaly load/unload the sample banks will the player walk the univers.

Author:

Boris Boucher

Nevrax France

Date:

2002

Definition at line 79 of file background_sound_manager.h.

Public Member Functions
const UAudioMixer::TBackgroundFilterFades &	getBackgroundFilterFades ()
const UAudioMixer::TBackgroundFlags &	getBackgroundFlags ()
	Get the background flags.
const float *	getFilterValues ()
const std::vector< NLMISC::CVector > &	getZone (uint32 zone, bool *isPath=0)
	Return a patatoid. If isPath is not null, set it.
NLMISC::CVector	getZoneSourcePos (uint32 zone)
	Return the position of the 3d source for a zone.
void	load (const std::string &continent, NLLIGO::CLigoConfig &config)
void	loadAudioFromPrimitives (const NLLIGO::IPrimitive &audioRoot)
void	loadEffecsFromRegion (const NLLIGO::CPrimRegion &region)
void	loadSamplesFromRegion (const NLLIGO::CPrimRegion &region)
void	loadSoundsFromRegion (const NLLIGO::CPrimRegion &region)
void	play ()
	Start to play the background sound.
void	setBackgroundFilterFades (const UAudioMixer::TBackgroundFilterFades &backgroundFilterFades)
void	setBackgroundFlags (const UAudioMixer::TBackgroundFlags &backgroundFlags)
	Set the background flags.
void	setListenerPosition (const NLMISC::CVector &listenerPosition)
	Call this method when the listener position change.
void	stop ()
	Stop the background sound.
void	unload ()
void	updateBackgroundStatus ()
	Call this method to update the background sound (sub method of setListenerPosition).
Private Member Functions
void	addFxZone (const std::string &fxName, const std::vector< NLLIGO::CPrimVector > &points)
	add a fx zone
void	addSampleBank (const std::vector< std::string > &bankNames, const std::vector< NLLIGO::CPrimVector > &points)
	add a sample bank zone
void	addSound (const std::string &rawSoundName, const std::vector< NLLIGO::CPrimVector > &points, bool isPath)
	deprecated, Internal use only for loading.
void	addSound (const std::string &soundName, uint layerId, const std::vector< NLLIGO::CPrimVector > &points, bool isPath)
	CBackgroundSoundManager ()
	Constructor.
void	loadEffectsFromPrimitives (const NLLIGO::IPrimitive &fxRoot)
void	loadSamplesFromPrimitives (const NLLIGO::IPrimitive &sampleRoot)
void	loadSoundsFromPrimitives (const NLLIGO::IPrimitive &soundRoot)
void	onUpdate ()
template<class CharType> std::vector< std::basic_string< CharType > >	split (const std::basic_string< CharType > &str, CharType splitTag)
	TODO : Utility... should be in NLMISC ?
virtual	~CBackgroundSoundManager ()
	Destructor.
Private Attributes
UAudioMixer::TBackgroundFilterFades	_BackgroundFilterFades
	Background filters fades.
UAudioMixer::TBackgroundFlags	_BackgroundFlags
	Background flags.
bool	_DoFade
	Is some fade in/out running?
NLMISC::TTime	_FilterFadesStart [UAudioMixer::TBackgroundFlags::NB_BACKGROUND_FLAGS]
	The date of last fade in or out started for each filter.
float	_FilterFadeValues [UAudioMixer::TBackgroundFlags::NB_BACKGROUND_FLAGS]
	The filter fade values.
std::vector< TFxZone >	_FxZones
	Container for the fx primitive.
NLMISC::TStringId	_LastEnv
	Last setted env fx. Used when clustered sound is not active.
NLMISC::CVector	_LastPosition
	The last position of the listener.
bool	_Playing
	Flag for playing background sounds.
std::vector< TBanksData >	_Banks
	Container for the banks primitive.
std::set< std::string >	_LoadedBanks
	Container for the list of currently loaded banks.
std::vector< TSoundData >	_Layers [BACKGROUND_LAYER]
	Array of vector of sound data.
Friends
class	CAudioMixerUser

---

Constructor & Destructor Documentation

NLSOUND::CBackgroundSoundManager::CBackgroundSoundManager (   )  [private]

Constructor. Definition at line 60 of file background_sound_manager.cpp. References _BackgroundFlags, _FilterFadesStart, _FilterFadeValues, NLSOUND::UAudioMixer::TBackgroundFlags::Flags, and uint. : _LastPosition(0,0,0), _Playing(false), _DoFade(false) { for (uint i=0; i<UAudioMixer::TBackgroundFlags::NB_BACKGROUND_FLAGS; ++i) { _BackgroundFlags.Flags[i] = false; _FilterFadesStart[i] = 0; _FilterFadeValues[i] = 1.0f; } }

NLSOUND::CBackgroundSoundManager::~CBackgroundSoundManager (   )  [private, virtual]

Destructor. Definition at line 71 of file background_sound_manager.cpp. References unload(). { unload(); }

---

Member Function Documentation

void NLSOUND::CBackgroundSoundManager::addFxZone (  const std::string &  fxName, const std::vector< NLLIGO::CPrimVector > &  points )  [private]

add a fx zone Definition at line 473 of file background_sound_manager.cpp. References _FxZones, NLSOUND::CBackgroundSoundManager::TFxZone::FxName, NLSOUND::CBackgroundSoundManager::TFxZone::MaxBox, min, NLSOUND::CBackgroundSoundManager::TFxZone::MinBox, NLSOUND::CBackgroundSoundManager::TFxZone::Points, uint, NLMISC::CVector::x, and NLMISC::CVector::y. Referenced by loadEffectsFromPrimitives(). { TFxZone fxZone; fxZone.FxName = CStringMapper::map(fxName); fxZone.Points.resize (points.size()); for (uint j=0; j<points.size(); j++) { fxZone.Points[j] = points[j]; } // compute bouding box. CVector vmin(FLT_MAX, FLT_MAX, 0), vmax(-FLT_MAX, -FLT_MAX, 0); vector<CVector>::iterator first(fxZone.Points.begin()), last(fxZone.Points.end()); for (; first != last; ++first) { vmin.x = min(first->x, vmin.x); vmin.y = min(first->y, vmin.y); vmax.x = max(first->x, vmax.x); vmax.y = max(first->y, vmax.y); } fxZone.MaxBox = vmax; fxZone.MinBox = vmin; _FxZones.push_back(fxZone); }

void NLSOUND::CBackgroundSoundManager::addSampleBank (  const std::vector< std::string > &  bankNames, const std::vector< NLLIGO::CPrimVector > &  points )  [private]

add a sample bank zone Definition at line 502 of file background_sound_manager.cpp. References NLSOUND::CBackgroundSoundManager::TBanksData::Banks, NLSOUND::CBackgroundSoundManager::TBanksData::MaxBox, min, NLSOUND::CBackgroundSoundManager::TBanksData::MinBox, NLSOUND::CBackgroundSoundManager::TBanksData::Points, uint, NLMISC::CVector::x, and NLMISC::CVector::y. Referenced by loadSamplesFromPrimitives(), and loadSamplesFromRegion(). { TBanksData bd; // uint pointCount = points.size (); bd.Points.resize (points.size()); for (uint j=0; j<points.size(); j++) { bd.Points[j] = points[j]; } // compute bouding box. CVector vmin(FLT_MAX, FLT_MAX, 0), vmax(-FLT_MAX, -FLT_MAX, 0); vector<CVector>::iterator first(bd.Points.begin()), last(bd.Points.end()); for (; first != last; ++first) { vmin.x = min(first->x, vmin.x); vmin.y = min(first->y, vmin.y); vmax.x = max(first->x, vmax.x); vmax.y = max(first->y, vmax.y); } bd.MaxBox = vmax; bd.MinBox = vmin; for(uint i=0; i<bankNames.size(); ++i) { if (!bankNames[i].empty()) bd.Banks.push_back(bankNames[i]); } // ok, store it in the container. _Banks.push_back(bd); }

void NLSOUND::CBackgroundSoundManager::addSound (  const std::string &  rawSoundName, const std::vector< NLLIGO::CPrimVector > &  points, bool  isPath )  [private]

deprecated, Internal use only for loading. Definition at line 149 of file background_sound_manager.cpp. References addSound(), NLSOUND::BACKGROUND_LAYER, NLMISC::clamp(), count, nlwarning, uint, and uint32. { uint layerId = 0; uint n = 0; string name; // count the number of '-' in the string. n = std::count(rawSoundName.begin(), rawSoundName.end(), '-'); if (n == 2) { // no layer spec, default to layer A uint32 pos1 = rawSoundName.find ("-"); if(pos1 == string::npos) { nlwarning ("zone have the malformated name '%s' missing -name-", rawSoundName.c_str()); return; } pos1++; uint32 pos2 = rawSoundName.find ("-", pos1); if(pos2 == string::npos) { nlwarning ("zone have the malformated name '%s' missing -name-", rawSoundName.c_str()); return; } name = rawSoundName.substr(pos1, pos2-pos1); } else if (n == 3) { // layer spec ! uint32 pos1 = rawSoundName.find ("-"); uint32 pos2 = rawSoundName.find ("-", pos1+1); if(pos1 == string::npos || pos2 == string::npos) { nlwarning ("zone have the malformated name '%s' missing -layerId- or -name-", rawSoundName.c_str()); return; } pos1++; uint32 pos3 = rawSoundName.find ("-", pos2+1); if(pos3 == string::npos) { nlwarning ("zone have the malformated name '%s' missing -name-", rawSoundName.c_str()); return; } char id = rawSoundName[pos1]; // check caps if (id < 'a') id = id + ('a' - 'A'); layerId = id - 'a'; NLMISC::clamp(layerId, 0u, BACKGROUND_LAYER-1); pos2++; name = rawSoundName.substr(pos2, pos3-pos2); } else { nlwarning ("zone have the malformated name '%s", rawSoundName.c_str()); return; } addSound(name, layerId, points, isPath); /* TSoundData sd; sd.SoundName = name; sd.Sound = mixer->getSoundId(sd.SoundName); sd.Source = 0; // Copy the points sd.Points.resize (points.size ()); for (uint i=0; i<points.size (); i++) sd.Points[i] = points[i]; sd.Selected = false; sd.IsPath = isPath; if (sd.Sound != 0) { // the sound is available ! // compute bouding box/ CVector vmin(FLT_MAX, FLT_MAX, 0), vmax(-FLT_MAX, -FLT_MAX, 0); vector<CVector>::iterator first(sd.Points.begin()), last(sd.Points.end()); for (; first != last; ++first) { vmin.x = min(first->x, vmin.x); vmin.y = min(first->y, vmin.y); vmax.x = max(first->x, vmax.x); vmax.y = max(first->y, vmax.y); } sd.MaxBox = vmax; sd.MinBox = vmin; // compute the surface without the sound distance sd.Surface = (vmax.x - vmin.x) * (vmax.y - vmin.y); // add the eard distance of the sound. float dist = sd.Sound->getMaxDistance(); sd.MaxBox.x += dist; sd.MaxBox.y += dist; sd.MinBox.x -= dist; sd.MinBox.y -= dist; sd.MaxDist = dist; // store the sound. // TODO : handle the three layer. _Layers[layerId].push_back(sd); } else { nlwarning ("The sound '%s' can't be loaded", sd.SoundName.c_str()); } */ }

void NLSOUND::CBackgroundSoundManager::addSound (  const std::string &  soundName, uint  layerId, const std::vector< NLLIGO::CPrimVector > &  points, bool  isPath )  [private]

Definition at line 93 of file background_sound_manager.cpp. References _Layers, NLSOUND::CSound::getMaxDistance(), NLSOUND::CAudioMixerUser::getSoundId(), NLSOUND::CBackgroundSoundManager::TSoundData::IsPath, NLSOUND::CBackgroundSoundManager::TSoundData::MaxBox, NLSOUND::CBackgroundSoundManager::TSoundData::MaxDist, min, NLSOUND::CBackgroundSoundManager::TSoundData::MinBox, nlwarning, NLSOUND::CBackgroundSoundManager::TSoundData::Points, NLSOUND::CBackgroundSoundManager::TSoundData::Selected, NLSOUND::CBackgroundSoundManager::TSoundData::Sound, NLSOUND::CBackgroundSoundManager::TSoundData::SoundName, NLSOUND::CBackgroundSoundManager::TSoundData::Source, NLSOUND::CBackgroundSoundManager::TSoundData::Surface, uint, NLMISC::CVector::x, and NLMISC::CVector::y. Referenced by addSound(), loadSoundsFromPrimitives(), and loadSoundsFromRegion(). { CAudioMixerUser *mixer = CAudioMixerUser::instance(); TSoundData sd; sd.SoundName = CStringMapper::map(soundName); sd.Sound = mixer->getSoundId(sd.SoundName); sd.Source = 0; // Copy the points sd.Points.resize (points.size ()); for (uint i=0; i<points.size (); i++) sd.Points[i] = points[i]; sd.Selected = false; sd.IsPath = isPath; if (sd.Sound != 0) { // the sound is available ! // compute bouding box/ CVector vmin(FLT_MAX, FLT_MAX, 0), vmax(-FLT_MAX, -FLT_MAX, 0); vector<CVector>::iterator first(sd.Points.begin()), last(sd.Points.end()); for (; first != last; ++first) { vmin.x = min(first->x, vmin.x); vmin.y = min(first->y, vmin.y); vmax.x = max(first->x, vmax.x); vmax.y = max(first->y, vmax.y); } sd.MaxBox = vmax; sd.MinBox = vmin; // compute the surface without the sound distance sd.Surface = (vmax.x - vmin.x) * (vmax.y - vmin.y); // add the eard distance of the sound. float dist = sd.Sound->getMaxDistance(); sd.MaxBox.x += dist; sd.MaxBox.y += dist; sd.MinBox.x -= dist; sd.MinBox.y -= dist; sd.MaxDist = dist; // store the sound. // TODO : handle the three layer. _Layers[layerId].push_back(sd); } else { nlwarning ("The sound '%s' can't be loaded", CStringMapper::unmap(sd.SoundName).c_str()); } }

const UAudioMixer::TBackgroundFilterFades & NLSOUND::CBackgroundSoundManager::getBackgroundFilterFades (   )

Definition at line 87 of file background_sound_manager.cpp. References _BackgroundFilterFades. Referenced by NLSOUND::CAudioMixerUser::getBackgroundFilterFades(). { return _BackgroundFilterFades; }

const UAudioMixer::TBackgroundFlags & NLSOUND::CBackgroundSoundManager::getBackgroundFlags (   )

Get the background flags. Definition at line 76 of file background_sound_manager.cpp. References _BackgroundFlags. Referenced by NLSOUND::CAudioMixerUser::getBackgroundFlags(). { return _BackgroundFlags; }

const float* NLSOUND::CBackgroundSoundManager::getFilterValues (   )  [inline]

Definition at line 139 of file background_sound_manager.h. References _FilterFadeValues. Referenced by NLSOUND::CBackgroundSource::play(). { return _FilterFadeValues;}

const std::vector<NLMISC::CVector>& NLSOUND::CBackgroundSoundManager::getZone (  uint32  zone, bool *  isPath = 0 )

Return a patatoid. If isPath is not null, set it.

CVector NLSOUND::CBackgroundSoundManager::getZoneSourcePos (  uint32  zone  )

Return the position of the 3d source for a zone. Definition at line 1369 of file background_sound_manager.cpp. References uint32. { /* nlassert (zone< BackgroundSounds.size()); CVector pos; if (BackgroundSounds[zone].SourceDay != NULL) BackgroundSounds[zone].SourceDay->getPos(pos); return pos; */ return CVector(); }

void NLSOUND::CBackgroundSoundManager::load (  const std::string &  continent, NLLIGO::CLigoConfig &  config )

Load background sound for a continent. It'll automatically unload the old continent before loading the new one. This method load the 'audio' regions (specifying the sounds), the 'effect' regions and the 'sample' regions. Continent is for example "matis" or "fyros". It'll add .prim to the continent name and lookup() to find zones. So, don't forget to add sound .prim in the CPath system for the lookup With the new primitive file, this method will try to load the .primitive file before attempting to load any .prim file. If the .primitive is found, then no .prim are loaded. Definition at line 618 of file background_sound_manager.cpp. References _FxZones, _Layers, NLSOUND::BACKGROUND_LAYER, file, NLSOUND::CAudioMixerUser::getPackedSheetPath(), NLSOUND::CAudioMixerUser::getPackedSheetUpdate(), H_AUTO, loadAudioFromPrimitives(), loadEffecsFromRegion(), loadSamplesFromRegion(), loadSoundsFromRegion(), nlinfo, NLLIGO::CPrimitives::read(), NLLIGO::CPrimitives::RootNode, NLLIGO::CPrimRegion::serial(), NLMISC::IStream::serial(), NLMISC::IStream::serialCont(), uint, uint32, and NLLIGO::CPrimRegion::VZones. Referenced by NLSOUND::CAudioMixerUser::loadBackgroundSound(). { NL_ALLOC_CONTEXT(NLSOUND_CBackgroundSoundManager); uint32 PACKED_VERSION = 1; // First, try to load from a .primitive file (contain everythink) { CIFile file; // CPrimRegion region; CPrimitives primitives; primitives.RootNode = new CPrimNode; string fn = continent+"_audio.primitive"; string path = CPath::lookup(fn, false); if(!path.empty() && file.open (path)) { // first, try to load the binary version (if up to date) { uint32 version; string filename = continent+".background_primitive"; string binPath = CPath::lookup(filename, false, false, false); if (!binPath.empty() && (CFile::getFileModificationDate(binPath) > CFile::getFileModificationDate(path))) { CIFile binFile(binPath); binFile.serial(version); if (version == PACKED_VERSION) { nlinfo ("loading '%s'", filename.c_str()); _Banks.clear(); binFile.serialCont(_Banks); for (uint i=0; i<BACKGROUND_LAYER; ++i) { _Layers[i].clear(); binFile.serialCont(_Layers[i]); } _FxZones.clear(); binFile.serialCont(_FxZones); // jobs done ! return; } } } nlinfo ("loading '%s'", fn.c_str()); CIXml xml; { H_AUTO(BackgroundSoundMangerLoad_xml_init); xml.init (file); } { H_AUTO(BackgroundSoundMangerLoad_primitive_read); primitives.read(xml.getRootNode(), fn.c_str(), config); } // region.serial(xml); file.close (); { H_AUTO(BackgroundSoundMangerLoad_loadAudioFromPrimitive); loadAudioFromPrimitives(*primitives.RootNode); } // store the binary version of the audio primitive for later use CAudioMixerUser *mixer = CAudioMixerUser::instance(); if (mixer->getPackedSheetUpdate()) { // need to update packed sheet, so write the binary primitive version string filename = mixer->getPackedSheetPath()+"/"+continent+".background_primitive"; COFile file(filename); file.serial(PACKED_VERSION); file.serialCont(_Banks); for (uint i=0; i<BACKGROUND_LAYER; ++i) file.serialCont(_Layers[i]); file.serialCont(_FxZones); } // Jobs done ! return; } } // We reach this only if the new .primitive file format is not found // then, we try to load separate .prim file for sound, samples and fx // load the sound. { CIFile file; CPrimRegion region; string fn = continent+"_audio.prim"; nlinfo ("loading '%s'", fn.c_str()); string path = CPath::lookup(fn, false); if(!path.empty() && file.open (path)) { CIXml xml; xml.init (file); region.serial(xml); file.close (); nlinfo ("Region '%s' contains %d zones for the background sounds", continent.c_str(), region.VZones.size()); loadSoundsFromRegion(region); } } // load the effect. { CIFile file; CPrimRegion region; string fn = continent+"_effects.prim"; nlinfo ("loading '%s'", fn.c_str()); string path = CPath::lookup(fn, false); if(!path.empty() && file.open (path)) { CIXml xml; xml.init (file); region.serial(xml); file.close (); nlinfo ("Region '%s' contains %d zones for the background effetcs", continent.c_str(), region.VZones.size()); loadEffecsFromRegion(region); } } // load the samples banks. { CIFile file; CPrimRegion region; string fn = continent+"_samples.prim"; nlinfo ("loading '%s'", fn.c_str()); string path = CPath::lookup(fn, false); if(!path.empty() && file.open (path)) { CIXml xml; xml.init (file); region.serial(xml); file.close (); nlinfo ("Region '%s' contains %d zones for the background samples banks", continent.c_str(), region.VZones.size()); loadSamplesFromRegion(region); } } }

void NLSOUND::CBackgroundSoundManager::loadAudioFromPrimitives (  const NLLIGO::IPrimitive &  audioRoot  )

Load the sounds, effects and sample banks from a region class. Definition at line 272 of file background_sound_manager.cpp. References _Playing, NLLIGO::IPrimitive::getChild(), NLLIGO::IPrimitive::getNumChildren(), NLLIGO::IPrimitive::getPropertyByName(), loadEffectsFromPrimitives(), loadSamplesFromPrimitives(), loadSoundsFromPrimitives(), play(), uint, and unload(). Referenced by load(), and NLSOUND::CAudioMixerUser::loadBackgroundAudioFromPrimitives(). { std::string className; if(audioRoot.getPropertyByName("class", className)) { if (className == "audio") { // ok, it a root of the audio primitives // remember playing state bool oldState = _Playing; unload(); for (uint i=0; i<audioRoot.getNumChildren(); ++i) { const NLLIGO::IPrimitive *child; audioRoot.getChild(child, i); if (child->getPropertyByName("class", className)) { if (className == "sounds") { loadSoundsFromPrimitives(*child); } else if (className == "sample_banks") { loadSamplesFromPrimitives(*child); } else if (className == "env_fx") { loadEffectsFromPrimitives(*child); } } } if (oldState) play(); } } else { // try to look in the first child level for (uint i=0; i<audioRoot.getNumChildren(); ++i) { const NLLIGO::IPrimitive *child; audioRoot.getChild(child, i); if (child->getPropertyByName("class", className)) { if (className == "audio") { // recurse in this node loadAudioFromPrimitives(*child); // don't look any other primitives break; } } } } }

void NLSOUND::CBackgroundSoundManager::loadEffecsFromRegion (  const NLLIGO::CPrimRegion &  region  )

Load the effects from a CPrimRegion class. deprecated Definition at line 570 of file background_sound_manager.cpp. Referenced by load(), and NLSOUND::CAudioMixerUser::loadBackgroundEffectsFromRegion(). { }

void NLSOUND::CBackgroundSoundManager::loadEffectsFromPrimitives (  const NLLIGO::IPrimitive &  fxRoot  )  [private]

Load the sounds from primitive Definition at line 441 of file background_sound_manager.cpp. References _FxZones, addFxZone(), NLLIGO::IPrimitive::getChild(), NLLIGO::IPrimitive::getNumChildren(), NLLIGO::IPrimitive::getPropertyByName(), and uint. Referenced by loadAudioFromPrimitives(). { std::string className; _FxZones.clear(); if (fxRoot.getPropertyByName("class", className)) { if (className == "env_fx") { for (uint i=0; i<fxRoot.getNumChildren(); ++i) { const NLLIGO::IPrimitive *child; std::string primName; fxRoot.getChild(child, i); if (child->getPropertyByName("class", className)) { child->getPropertyByName("name", primName); if (className == "env_fx_zone") { std::string fxName; if (child->getPropertyByName("fx_name", fxName)) { addFxZone(fxName, static_cast<const CPrimZone*>(child)->VPoints); } } } } } } }

void NLSOUND::CBackgroundSoundManager::loadSamplesFromPrimitives (  const NLLIGO::IPrimitive &  sampleRoot  )  [private]

Load the sample banks from primitive Definition at line 410 of file background_sound_manager.cpp. References addSampleBank(), NLLIGO::IPrimitive::getChild(), NLLIGO::IPrimitive::getNumChildren(), NLLIGO::IPrimitive::getPropertyByName(), and uint. Referenced by loadAudioFromPrimitives(). { std::string className; _Banks.clear(); if (sampleRoot.getPropertyByName("class", className)) { if (className == "sample_banks") { for (uint i=0; i<sampleRoot.getNumChildren(); ++i) { const NLLIGO::IPrimitive *child; std::string primName; sampleRoot.getChild(child, i); if (child->getPropertyByName("class", className)) { child->getPropertyByName("name", primName); if (className == "sample_bank_zone") { const std::vector<std::string> *names; if (child->getPropertyByName("bank_names", names)) { addSampleBank(*names, static_cast<const CPrimZone*>(child)->VPoints); } } } } } } }

void NLSOUND::CBackgroundSoundManager::loadSamplesFromRegion (  const NLLIGO::CPrimRegion &  region  )

Load the samples banks from a CPrimRegion class. deprecated Definition at line 537 of file background_sound_manager.cpp. References addSampleBank(), nlwarning, split(), uint, and NLLIGO::CPrimRegion::VZones. Referenced by load(), and NLSOUND::CAudioMixerUser::loadBackgroundSamplesFromRegion(). { _Banks.clear(); for (uint i=0; i< region.VZones.size(); ++i) { if (region.VZones[i].VPoints.size() > 2) { // parse the zone name to find the samples name. std::vector<std::string> splitted = split(region.VZones[i].Name, '-'); std::vector<std::string> bankNames; if (splitted.size() > 2) { for (uint j=1; j<splitted.size()-1; ++j) { bankNames.push_back(splitted[j]); } addSampleBank(bankNames, region.VZones[i].VPoints); } else { nlwarning ("A sample bank patatoid name did'nt contains banks name '%s'", region.VZones[i].Name.c_str()); } } else { nlwarning ("A sample bank patatoid have less than 3 points '%s'", region.VZones[i].Name.c_str()); } } }

void NLSOUND::CBackgroundSoundManager::loadSoundsFromPrimitives (  const NLLIGO::IPrimitive &  soundRoot  )  [private]

Load the sounds from primitive Definition at line 334 of file background_sound_manager.cpp. References addSound(), NLSOUND::BACKGROUND_LAYER, NLMISC::clamp(), NLLIGO::IPrimitive::getChild(), NLLIGO::IPrimitive::getNumChildren(), NLLIGO::IPrimitive::getNumVector(), NLLIGO::IPrimitive::getPropertyByName(), nlwarning, and uint. Referenced by loadAudioFromPrimitives(). { std::string className; if (soundRoot.getPropertyByName("class", className)) { if (className == "sounds" || className == "sound_folder") { // ok, it sounds or a sounds foilder for (uint i=0; i<soundRoot.getNumChildren(); ++i) { const NLLIGO::IPrimitive *child; std::string primName; soundRoot.getChild(child, i); if (child->getPropertyByName("class", className)) { uint layerId = 0; std::string layerString; std::string soundName; if (child->getPropertyByName("layer", layerString)) { // extract layer number. if (!layerString.empty()) { // TODO : handle special case for weather layer layerId = layerString[layerString.size()-1] - '0'; } clamp(layerId, 0u, BACKGROUND_LAYER-1); } child->getPropertyByName("name", primName); child->getPropertyByName("sound", soundName); // compatibility with older primitive if (soundName.empty()) soundName = primName; if (className == "sound_zone") { if(child->getNumVector()>2) { addSound(soundName, layerId, static_cast<const CPrimZone*>(child)->VPoints, false); } else { nlwarning ("A background sound patatoid have less than 3 points '%s'", primName.c_str()); } } else if (className == "sound_path") { if(child->getNumVector() > 1) { addSound(soundName, layerId, static_cast<const CPrimPath*>(child)->VPoints, true); } else { nlwarning ("A background sound path have less than 2 points '%s'", primName.c_str()); } } else if (className == "sound_point") { std::vector<NLLIGO::CPrimVector> points; points.push_back(static_cast<const CPrimPoint*>(child)->Point); addSound(soundName, layerId, points, false); } else if (className == "sound_folder") { loadSoundsFromPrimitives(*child); } } } } } }

void NLSOUND::CBackgroundSoundManager::loadSoundsFromRegion (  const NLLIGO::CPrimRegion &  region  )

Load the background sounds from a CPrimRegion class. deprecated Definition at line 574 of file background_sound_manager.cpp. References _Playing, addSound(), nlwarning, play(), uint, unload(), NLLIGO::CPrimRegion::VPaths, NLLIGO::CPrimRegion::VPoints, and NLLIGO::CPrimRegion::VZones. Referenced by load(), and NLSOUND::CAudioMixerUser::loadBackgroundSoundFromRegion(). { uint i; // remember playing state bool oldState = _Playing; unload(); for (i = 0; i < region.VZones.size(); i++) { if(region.VZones[i].VPoints.size()>2) { addSound(region.VZones[i].Name, region.VZones[i].VPoints, false); } else { nlwarning ("A background sound patatoid have less than 3 points '%s'", region.VZones[i].Name.c_str()); } } for (i = 0; i < region.VPaths.size(); i++) { if(region.VPaths[i].VPoints.size() > 1) { addSound(region.VPaths[i].Name, region.VPaths[i].VPoints, true); } else { nlwarning ("A background sound path have less than 2 points '%s'", region.VPaths[i].Name.c_str()); } } for (i = 0; i < region.VPoints.size(); i++) { std::vector<CPrimVector> points; points.push_back(region.VPoints[i].Point); addSound(region.VPoints[i].Name, points, false); } // restart playing ? if (oldState) play(); }

void NLSOUND::CBackgroundSoundManager::onUpdate (   )  [private, virtual]

Implements NLSOUND::CAudioMixerUser::IMixerUpdate. Definition at line 1341 of file background_sound_manager.cpp. References updateBackgroundStatus(). { updateBackgroundStatus(); }

void NLSOUND::CBackgroundSoundManager::play (   )

Start to play the background sound. Definition at line 778 of file background_sound_manager.cpp. References _BackgroundFlags, _DoFade, _FilterFadesStart, _FilterFadeValues, _Playing, NLSOUND::UAudioMixer::TBackgroundFlags::Flags, uint, and updateBackgroundStatus(). Referenced by loadAudioFromPrimitives(), loadSoundsFromRegion(), and NLSOUND::CAudioMixerUser::playBackgroundSound(). { if (_Playing) return; _Playing = true; CAudioMixerUser::instance()->registerUpdate(this); // init the filter value and filter start time for (uint i =0; i<UAudioMixer::TBackgroundFlags::NB_BACKGROUND_FLAGS; ++i) { _FilterFadesStart[i] = 0; _FilterFadeValues[i] = 1.0f * !_BackgroundFlags.Flags[i]; } // force an initial filtering _DoFade = true; updateBackgroundStatus(); }

void NLSOUND::CBackgroundSoundManager::setBackgroundFilterFades (  const UAudioMixer::TBackgroundFilterFades &  backgroundFilterFades  )

Definition at line 82 of file background_sound_manager.cpp. References _BackgroundFilterFades. Referenced by NLSOUND::CAudioMixerUser::setBackgroundFilterFades(). { _BackgroundFilterFades = backgroundFilterFades; }

void NLSOUND::CBackgroundSoundManager::setBackgroundFlags (  const UAudioMixer::TBackgroundFlags &  backgroundFlags  )

Set the background flags. Definition at line 1312 of file background_sound_manager.cpp. References _BackgroundFilterFades, _BackgroundFlags, _DoFade, _FilterFadesStart, _FilterFadeValues, NLSOUND::UAudioMixer::TBackgroundFilterFades::FadeIns, NLSOUND::UAudioMixer::TBackgroundFilterFades::FadeOuts, NLSOUND::UAudioMixer::TBackgroundFlags::Flags, uint, and uint64. Referenced by NLSOUND::CAudioMixerUser::setBackgroundFlags(). { for (uint i=0; i<UAudioMixer::TBackgroundFlags::NB_BACKGROUND_FLAGS; ++i) { if (_BackgroundFlags.Flags[i] != backgroundFlags.Flags[i]) { // the filter flags has changed ! if (backgroundFlags.Flags[i]) { // the filter is activated, to a fade out _FilterFadesStart[i] = uint64(NLMISC::CTime::getLocalTime() - (1-_FilterFadeValues[i]) * _BackgroundFilterFades.FadeOuts[i]); _DoFade = true; } else { // the filter is cleared, do a fade in _FilterFadesStart[i] = uint64(NLMISC::CTime::getLocalTime() - (_FilterFadeValues[i]) * _BackgroundFilterFades.FadeIns[i]); _DoFade = true; } } _BackgroundFlags.Flags[i] = backgroundFlags.Flags[i]; } if (_DoFade) CAudioMixerUser::instance()->registerUpdate(this); }

void NLSOUND::CBackgroundSoundManager::setListenerPosition (  const NLMISC::CVector &  listenerPosition  )

Call this method when the listener position change. Definition at line 850 of file background_sound_manager.cpp. References _LastPosition, and updateBackgroundStatus(). Referenced by NLSOUND::CAudioMixerUser::setListenerPos(). { if (_LastPosition == listenerPosition) { return; } _LastPosition = listenerPosition; updateBackgroundStatus(); }

template<class CharType> std::vector<std::basic_string<CharType> > NLSOUND::CBackgroundSoundManager::split (  const std::basic_string< CharType > &  str, CharType  splitTag )  [inline, private]

TODO : Utility... should be in NLMISC ? Definition at line 171 of file background_sound_manager.h. References size. Referenced by loadSamplesFromRegion(). { std::vector<std::basic_string<CharType> > splitted; std::basic_string<CharType>::size_type pos = 0, nextPos = 0, size = 0; while ((nextPos = str.find(splitTag, nextPos)) != std::basic_string<CharType>::npos) { size = nextPos - pos; if (size > 0) splitted.push_back(std::basic_string<CharType>(str, pos, nextPos - pos)); // skip the tag nextPos += 1; pos = nextPos; } // is there a last part ? size = nextPos - pos; if (pos != str.size()) splitted.push_back(std::basic_string<CharType>(str, pos, str.size() - pos)); return splitted; }

void NLSOUND::CBackgroundSoundManager::stop (   )

Stop the background sound. Definition at line 801 of file background_sound_manager.cpp. References _Layers, _Playing, NLSOUND::BACKGROUND_LAYER, uint, and NLSOUND::CAudioMixerUser::unregisterUpdate(). Referenced by NLSOUND::CAudioMixerUser::stopBackgroundSound(), and unload(). { if(!_Playing) return; CAudioMixerUser *mixer = CAudioMixerUser::instance(); for (uint i=0; i<BACKGROUND_LAYER; ++i) { // stop all playing source std::vector<TSoundData>::iterator first(_Layers[i].begin()), last(_Layers[i].end()); for (; first != last; ++first) { if (first->Source != 0 && first->Source->isPlaying()) first->Source->stop(); } } CAudioMixerUser::instance()->unregisterUpdate(this); _Playing = false; }

void NLSOUND::CBackgroundSoundManager::unload (   )

Remove all data about the current continents Definition at line 823 of file background_sound_manager.cpp. References _Layers, NLSOUND::BACKGROUND_LAYER, stop(), and uint. Referenced by loadAudioFromPrimitives(), loadSoundsFromRegion(), and ~CBackgroundSoundManager(). { stop(); CAudioMixerUser *mixer = CAudioMixerUser::instance(); for (uint i=0; i<BACKGROUND_LAYER; ++i) { // delete all created source std::vector<TSoundData>::iterator first(_Layers[i].begin()), last(_Layers[i].end()); for (; first != last; ++first) { if (first->Source) // mixer->removeSource(first->Source); delete first->Source; } // and free the layer. _Layers[i].clear(); } // erase the sample banks zone _Banks.clear(); // TODO : erase the fx zones }

void NLSOUND::CBackgroundSoundManager::updateBackgroundStatus (   )

Call this method to update the background sound (sub method of setListenerPosition). Status of all selected sound ordered by surface. Definition at line 861 of file background_sound_manager.cpp. References _BackgroundFilterFades, _BackgroundFlags, _DoFade, _FilterFadesStart, _FilterFadeValues, _FxZones, _LastEnv, _LastPosition, _Layers, _LoadedBanks, _Playing, NLSOUND::BACKGROUND_LAYER, NLSOUND::BACKGROUND_SOUND_ALTITUDE, NLSOUND::CSourceCommon::checkup(), NLMISC::clamp(), count, NLSOUND::CAudioMixerUser::createSource(), NLSOUND::UAudioMixer::TBackgroundFilterFades::FadeIns, NLSOUND::UAudioMixer::TBackgroundFilterFades::FadeOuts, NLSOUND::UAudioMixer::TBackgroundFlags::Flags, NLSOUND::CBackgroundSoundManager::TSoundStatus::Gain, NLSOUND::CAudioMixerUser::getClusteredSound(), NLSOUND::CClusteredSound::getClusterSoundStatus(), NLSOUND::CAudioMixerUser::getListener(), NLMISC::CTime::getLocalTime(), NLSOUND::CClusteredSound::getRootCluster(), NLSOUND::CSourceCommon::getType(), H_AFTER, H_AUTO, H_BEFORE, NLSOUND::CBackgroundSoundManager::TSoundStatus::Inside, NLSOUND::INSIDE_FALLOF, NLSOUND::CBackgroundSoundManager::TSoundData::IsPath, NLSOUND::CSourceCommon::isPlaying(), NLSOUND::CAudioMixerUser::loadSampleBank(), NLSOUND::CBackgroundSoundManager::TSoundData::MaxDist, NLSOUND::CSourceCommon::play(), NLSOUND::CBackgroundSoundManager::TSoundData::Points, NLSOUND::CBackgroundSoundManager::TSoundStatus::Position, NLSOUND::CClusteredSound::CClusterSoundStatus::Position, NLSOUND::CBackgroundSoundManager::TSoundData::Selected, NLSOUND::IListener::setEnvironment(), NL3D::CCluster::setEnvironmentFx(), NLSOUND::CSourceCommon::setPos(), NLSOUND::CSourceCommon::setRelativeGain(), NLSOUND::CBackgroundSoundManager::TSoundData::Sound, NLSOUND::CBackgroundSoundManager::TSoundStatus::SoundData, NLSOUND::CBackgroundSoundManager::TSoundData::Source, NLSOUND::CSourceCommon::stop(), NLSOUND::CBackgroundSoundManager::TSoundData::Surface, uint, NLSOUND::CAudioMixerUser::unloadSampleBank(), NLSOUND::CAudioMixerUser::unregisterUpdate(), NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. Referenced by NLSOUND::CAudioMixerUser::applyListenerMove(), onUpdate(), play(), setListenerPosition(), and NLSOUND::CAudioMixerUser::update(). { H_AUTO(NLSOUND_UpdateBackgroundSound) if (!_Playing) return; CAudioMixerUser *mixer = CAudioMixerUser::instance(); // it s on 2d so we don't have z CVector listener = _LastPosition; listener.z = 0.0f; // special case for clustered sound management. If the listener is not // in the global cluster, it's background listening place could be different CClusteredSound *clusteredSound = mixer->getClusteredSound(); if (clusteredSound != 0) { const CClusteredSound::CClusterSoundStatus *css = clusteredSound->getClusterSoundStatus(clusteredSound->getRootCluster()); if (css != 0) { listener = css->Position; listener.z = 0.0f; } } // evalutate the current env fx { H_AUTO(NLSOUND_EvaluateEnvFx) NL3D::CCluster *rootCluster = 0; if (mixer->getClusteredSound()) rootCluster = mixer->getClusteredSound()->getRootCluster(); std::vector<TFxZone>::iterator first(_FxZones.begin()), last(_FxZones.end()); for (; first != last; ++first) { if (listener.x >= first->MinBox.x && listener.x <= first->MaxBox.x && listener.y >= first->MinBox.y && listener.y <= first->MaxBox.y ) { // bounding box ok, if (CPrimZone::contains(listener, first->Points)) { // stop at the first zone ! if (rootCluster) { // use the cluster system rootCluster->setEnvironmentFx(first->FxName); } else { // no cluster system, set the env 'manualy' IListener *drvListener = static_cast<CListenerUser*>(mixer->getListener())->getListener(); if (_LastEnv != first->FxName) { _LastEnv = first->FxName; uint envNum; if (first->FxName == CStringMapper::map("GENERIC")) envNum = 0; else if (first->FxName == CStringMapper::map("PADDEDCELL")) envNum = 1; else if (first->FxName == CStringMapper::map("ROOM")) envNum = 2; else if (first->FxName == CStringMapper::map("BATHROOM")) envNum = 3; else if (first->FxName == CStringMapper::map("LIVINGROOM")) envNum = 4; else if (first->FxName == CStringMapper::map("STONEROOM")) envNum = 5; else if (first->FxName == CStringMapper::map("AUDITORIUM")) envNum = 6; else if (first->FxName == CStringMapper::map("CONCERTHALL")) envNum = 7; else if (first->FxName == CStringMapper::map("CAVE")) envNum = 8; else if (first->FxName == CStringMapper::map("ARENA")) envNum = 9; else if (first->FxName == CStringMapper::map("HANGAR")) envNum = 10; else if (first->FxName == CStringMapper::map("CARPETEDHALLWAY")) envNum = 11; else if (first->FxName == CStringMapper::map("HALLWAY")) envNum = 12; else if (first->FxName == CStringMapper::map("STONECORRIDOR")) envNum = 13; else if (first->FxName == CStringMapper::map("ALLEY")) envNum = 14; else if (first->FxName == CStringMapper::map("FOREST")) envNum = 15; else if (first->FxName == CStringMapper::map("CITY")) envNum = 16; else if (first->FxName == CStringMapper::map("MOUNTAINS")) envNum = 16; else if (first->FxName == CStringMapper::map("QUARRY")) envNum = 17; else if (first->FxName == CStringMapper::map("PLAIN")) envNum = 18; else if (first->FxName == CStringMapper::map("PARKINGLOT")) envNum = 19; else if (first->FxName == CStringMapper::map("SEWERPIPE")) envNum = 20; else if (first->FxName == CStringMapper::map("UNDERWATER")) envNum = 21; else if (first->FxName == CStringMapper::map("DRUGGED")) envNum = 22; else if (first->FxName == CStringMapper::map("DIZZY")) envNum = 23; else if (first->FxName == CStringMapper::map("PSYCHOTIC")) envNum = 24; else envNum = 18; drvListener->setEnvironment(envNum, 10); } } break; } } } } // compute the list of load/unload banks. { H_AUTO(NLSOUND_LoadUnloadSampleBank) // set of bank that must be in ram. std::set<std::string> newBanks; std::vector<TBanksData>::iterator first(_Banks.begin()), last(_Banks.end()); for (; first != last; ++first) { if (listener.x >= first->MinBox.x && listener.x <= first->MaxBox.x && listener.y >= first->MinBox.y && listener.y <= first->MaxBox.y ) { // bounding box ok, if (CPrimZone::contains(listener, first->Points)) { // add the banks of this zone in the n newBanks.insert(first->Banks.begin(), first->Banks.end()); } } } /* { nldebug("-----------------------------"); nldebug("Loaded sample banks (%u elements):", _LoadedBanks.size()); set<string>::iterator first(_LoadedBanks.begin()), last(_LoadedBanks.end()); for (; first != last; ++first) { const string &str = *first; nldebug(" %s", first->c_str()); } } { nldebug("New Sample bank list (%u elements):", newBanks.size()); set<string>::iterator first(newBanks.begin()), last(newBanks.end()); for (; first != last; ++first) { const string &str = *first; nldebug(" %s", first->c_str()); } } */ // ok, now compute to set : the set of bank to load, and the set of banks to unload. std::set<std::string> noChange; std::set_intersection(_LoadedBanks.begin(), _LoadedBanks.end(), newBanks.begin(), newBanks.end(), std::inserter(noChange, noChange.end())); std::set<std::string> loadList; std::set_difference(newBanks.begin(), newBanks.end(), noChange.begin(), noChange.end(), std::inserter(loadList, loadList.end())); std::set<std::string> unloadList; std::set_difference(_LoadedBanks.begin(), _LoadedBanks.end(), newBanks.begin(), newBanks.end(), std::inserter(unloadList, unloadList.end())); // and now, load and unload.... { std::set<std::string>::iterator first(loadList.begin()), last(loadList.end()); for (; first != last; ++first) { // nldebug("Trying to load sample bank %s", first->c_str()); mixer->loadSampleBank(true, *first); } _LoadedBanks.insert(loadList.begin(), loadList.end()); } { std::set<std::string>::iterator first(unloadList.begin()), last(unloadList.end()); for (; first != last; ++first) { // nldebug("Trying to unload sample bank %s", first->c_str()); if (mixer->unloadSampleBank(*first)) { // ok, the bank is unloaded _LoadedBanks.erase(*first); } else if (CSampleBank::findSampleBank(CStringMapper::map(*first)) == 0) { // ok, the bank is unavailable ! _LoadedBanks.erase(*first); } } } } H_BEFORE(NLSOUND_UpdateSoundLayer) // retreive the root cluster... NL3D::CCluster *rootCluster = 0; if (mixer->getClusteredSound() != 0) rootCluster = mixer->getClusteredSound()->getRootCluster(); // Apply the same algo for each sound layer. for (uint i=0; i<BACKGROUND_LAYER; ++i) { vector<TSoundData> &layer = _Layers[i]; vector<uint> selectedIndex; vector<uint> leaveIndex; selectedIndex.reserve(layer.size()); leaveIndex.reserve(layer.size()); // extract the list of selected/unselected box vector<TSoundData>::iterator first(layer.begin()), last(layer.end()); for (uint count = 0; first != last; ++first, ++count) { if (listener.x >= first->MinBox.x && listener.x <= first->MaxBox.x && listener.y >= first->MinBox.y && listener.y <= first->MaxBox.y // && listener.z >= first->MinBox.z && listener.z <= first->MaxBox.z ) { // nldebug("patat %u is selected by box (%s)", count, first->SoundName.c_str()); selectedIndex.push_back(count); } else { // nldebug("patat %u is rejected by box (%s)", count, first->SoundName.c_str()); // listener out of this box. if (first->Selected && first->Source != 0) { // we leave this box. leaveIndex.push_back(count); } } } // stop all the sound that are leaved. { vector<uint>::iterator first(leaveIndex.begin()), last(leaveIndex.end()); for (; first != last; ++first) { TSoundData &sd = layer[*first]; sd.Selected = false; if (sd.Source->isPlaying()) sd.Source->stop(); } } // Compute new source mixing in this layer { multimap<float, TSoundStatus> status; // first loop to compute selected sound gain and position and order the result by surface.. { vector<uint>::iterator first(selectedIndex.begin()), last(selectedIndex.end()); for (; first != last; ++first) { TSoundData &sd = layer[*first]; CVector pos; float gain = 1.0f; float distance; bool inside = false; // inside the patat ? if(CPrimZone::contains(listener, sd.Points, distance, pos, sd.IsPath)) { inside = true; pos = _LastPosition; // use the real listener position, not the 0 z centered gain = 1.0f; // nlinfo ("inside patate %d name '%s' ", *first, sd.SoundName.c_str()); } else { if (distance < sd.MaxDist) { // compute the gain. // gain = (sd.MaxDist - distance) / sd.MaxDist; } else { // too far gain = 0; } //nlinfo ("near patate %d name '%s' from %f ", *first, sd.SoundName.c_str(), distance); } // store the status. status.insert(make_pair(sd.Surface, TSoundStatus(sd, pos, gain, distance, inside))); } } // second loop thrue the surface ordered selected sound. { // Sound mixing strategie : // The smallest zone sound mask bigger one float maskFactor = 1.0f; multimap<float, TSoundStatus>::iterator first(status.begin()), last(status.end()); for (; first != last; ++first) { TSoundStatus &ss = first->second; if (maskFactor > 0.0f && ss.Gain > 0) { float gain; if (!ss.SoundData.IsPath && ss.SoundData.Points.size() > 1) gain = maskFactor * ss.Gain; else gain = ss.Gain; // maskFactor -= ss.Gain; ss.SoundData.Selected = true; // if (ss.Gain == 1) // if (ss.Distance == 0) if (ss.Inside) { // inside a pattate, then decrease the mask factor will we are more inside the patate maskFactor -= first->second.Distance / INSIDE_FALLOF; clamp(maskFactor, 0.0f, 1.0f); } // start the soond (if needed) and update the volume. if (ss.SoundData.Source == 0) { // try to create the source. ss.SoundData.Source = static_cast<CSourceCommon*>(mixer->createSource(ss.SoundData.Sound, false, 0, 0, rootCluster)); } if (ss.SoundData.Source != 0) { // set the volume ss.SoundData.Source->setRelativeGain(gain); // and the position ss.Position.z = _LastPosition.z + BACKGROUND_SOUND_ALTITUDE; ss.SoundData.Source->setPos(ss.Position); // nldebug("Setting source %s at %f", ss.SoundData.SoundName.c_str(), gain); if (!ss.SoundData.Source->isPlaying()) { // start the sound is needed. ss.SoundData.Source->play(); } else if (ss.SoundData.Source->getType() != CSourceCommon::SOURCE_SIMPLE) ss.SoundData.Source->checkup(); } } else if (ss.SoundData.Source != 0 && ss.SoundData.Source->isPlaying()) { // stop this too far source. ss.SoundData.Source->stop(); } } } } // compute source mixing } // for each layer H_AFTER(NLSOUND_UpdateSoundLayer) H_BEFORE(NLSOUND_DoFadeInOut) // update the fade in / out if (_DoFade) { TTime now = NLMISC::CTime::getLocalTime(); _DoFade = false; uint i; //for each filter for (i=0; i< UAudioMixer::TBackgroundFlags::NB_BACKGROUND_FLAGS; ++i) { if (_FilterFadesStart[i] != 0) { // this filter is fading if (_BackgroundFlags.Flags[i]) { // fading out TTime delta = now - _FilterFadesStart[i]; if (delta > _BackgroundFilterFades.FadeOuts[i]) { // the fade is terminated _FilterFadeValues[i] = 0; // stop the fade for this filter _FilterFadesStart[i] = 0; } else { _FilterFadeValues[i] = 1 - (float(delta) / _BackgroundFilterFades.FadeOuts[i]); // continue to fade (at least for this filter. _DoFade |= true; } } else { // fading in TTime delta = now - _FilterFadesStart[i]; if (delta > _BackgroundFilterFades.FadeIns[i]) { // the fade is terminated _FilterFadeValues[i] = 1; // stop the fade for this filter _FilterFadesStart[i] = 0; } else { _FilterFadeValues[i] = float(delta) / _BackgroundFilterFades.FadeIns[i]; // continue to fade (at least for this filter. _DoFade |= true; } } } } // update all playing background source that filter value has changed // for each layer for (i=0; i<BACKGROUND_LAYER; ++i) { // for each patat std::vector<TSoundData>::iterator first(_Layers[i].begin()), last(_Layers[i].end()); for (; first != last; ++first) { if (first->Selected) { // update this playing sound if (first->Source != 0 && first->Source->getType() == CSourceCommon::SOURCE_BACKGROUND) static_cast<CBackgroundSource*>(first->Source)->updateFilterValues(_FilterFadeValues); } } } if (!_DoFade) { // we can remove the update. mixer->unregisterUpdate(this); } } H_AFTER(NLSOUND_DoFadeInOut) }

---

Friends And Related Function Documentation

friend class CAudioMixerUser [friend]

Definition at line 147 of file background_sound_manager.h.

---

Field Documentation

UAudioMixer::TBackgroundFilterFades NLSOUND::CBackgroundSoundManager::_BackgroundFilterFades [private]

Background filters fades. Definition at line 200 of file background_sound_manager.h. Referenced by getBackgroundFilterFades(), setBackgroundFilterFades(), setBackgroundFlags(), and updateBackgroundStatus().

UAudioMixer::TBackgroundFlags NLSOUND::CBackgroundSoundManager::_BackgroundFlags [private]

Background flags. Definition at line 198 of file background_sound_manager.h. Referenced by CBackgroundSoundManager(), getBackgroundFlags(), play(), setBackgroundFlags(), and updateBackgroundStatus().

std::vector<TBanksData> NLSOUND::CBackgroundSoundManager::_Banks [private]

Container for the banks primitive. Definition at line 229 of file background_sound_manager.h.

bool NLSOUND::CBackgroundSoundManager::_DoFade [private]

Is some fade in/out running? Definition at line 206 of file background_sound_manager.h. Referenced by play(), setBackgroundFlags(), and updateBackgroundStatus().

NLMISC::TTime NLSOUND::CBackgroundSoundManager::_FilterFadesStart[UAudioMixer::TBackgroundFlags::NB_BACKGROUND_FLAGS] [private]

The date of last fade in or out started for each filter. Definition at line 202 of file background_sound_manager.h. Referenced by CBackgroundSoundManager(), play(), setBackgroundFlags(), and updateBackgroundStatus().

float NLSOUND::CBackgroundSoundManager::_FilterFadeValues[UAudioMixer::TBackgroundFlags::NB_BACKGROUND_FLAGS] [private]

The filter fade values. Definition at line 204 of file background_sound_manager.h. Referenced by CBackgroundSoundManager(), getFilterValues(), play(), setBackgroundFlags(), and updateBackgroundStatus().

std::vector<TFxZone> NLSOUND::CBackgroundSoundManager::_FxZones [private]

Container for the fx primitive. Definition at line 305 of file background_sound_manager.h. Referenced by addFxZone(), load(), loadEffectsFromPrimitives(), and updateBackgroundStatus().

NLMISC::TStringId NLSOUND::CBackgroundSoundManager::_LastEnv [private]

Last setted env fx. Used when clustered sound is not active. Definition at line 307 of file background_sound_manager.h. Referenced by updateBackgroundStatus().

NLMISC::CVector NLSOUND::CBackgroundSoundManager::_LastPosition [private]

The last position of the listener. Definition at line 209 of file background_sound_manager.h. Referenced by setListenerPosition(), and updateBackgroundStatus().

std::vector<TSoundData> NLSOUND::CBackgroundSoundManager::_Layers[BACKGROUND_LAYER] [private]

Array of vector of sound data. Definition at line 265 of file background_sound_manager.h. Referenced by addSound(), load(), stop(), unload(), and updateBackgroundStatus().

std::set<std::string> NLSOUND::CBackgroundSoundManager::_LoadedBanks [private]

Container for the list of currently loaded banks. Definition at line 231 of file background_sound_manager.h. Referenced by updateBackgroundStatus().

bool NLSOUND::CBackgroundSoundManager::_Playing [private]

Flag for playing background sounds. Definition at line 195 of file background_sound_manager.h. Referenced by loadAudioFromPrimitives(), loadSoundsFromRegion(), play(), stop(), and updateBackgroundStatus().

---

The documentation for this class was generated from the following files:

• background_sound_manager.h
• background_sound_manager.cpp

---