Merge pull request #100 from cortex-command-community/CF94-FMOD-Phase-2

Cf94 fmod phase 2

Author: garethyr

Entities/Actor.h

@@ -1319,7 +1319,7 @@ ENTITYALLOCATION(Actor)
 			m_DeathSound.Reset();
 		} else {
             SoundContainer newDeathSound;
-			newDeathSound.Create(samplePath, false);
+			newDeathSound.Create(samplePath);
 			m_DeathSound = newDeathSound;
 		}
 	}

Entities/SoundContainer.cpp

@@ -5,13 +5,21 @@ namespace RTE {
 
 	CONCRETECLASSINFO(SoundContainer, Entity, 0);
 
+	const std::unordered_map<std::string, SoundContainer::SoundCycleMode> SoundContainer::c_CycleModeMap = {
+		{"Random", SoundContainer::SoundCycleMode::MODE_RANDOM},
+		{"Forwards", SoundContainer::SoundCycleMode::MODE_FORWARDS}
+	};
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	void SoundContainer::Clear() {
-		m_Sounds.clear();
-		m_SelectedSounds.clear();
+		m_SoundSets.clear();
+		m_SelectedSoundSet = 0;
+		m_SoundSelectionCycleMode = MODE_RANDOM;
+
 		m_PlayingChannels.clear();
-		m_AttenuationStartDistance = 1;
+
+		m_AttenuationStartDistance = c_DefaultAttenuationStartDistance;
 		m_Loops = 0;
 		m_Priority = AudioMan::PRIORITY_NORMAL;
 		m_AffectedByGlobalPitch = true;
@@ -25,10 +33,16 @@ namespace RTE {
 	int SoundContainer::Create(const SoundContainer &reference) {
 		Entity::Create(reference);
 
-		for (std::vector<std::pair<ContentFile, FMOD::Sound *>>::const_iterator itr = reference.m_Sounds.begin(); itr != reference.m_Sounds.end(); ++itr) {
-			m_Sounds.push_back(*itr);
+		for (const std::vector<SoundData> &referenceSoundSet : reference.m_SoundSets) {
+			std::vector<SoundData> soundSet;
+			for (const SoundData &referenceData : referenceSoundSet) {
+				soundSet.push_back(SoundData {referenceData.SoundFile, referenceData.SoundObject, referenceData.Offset, referenceData.MinimumAudibleDistance, referenceData.AttenuationStartDistance});
+			}
+			m_SoundSets.push_back(soundSet);
 		}
-		m_SelectedSounds = reference.m_SelectedSounds;
+		m_SelectedSoundSet = reference.m_SelectedSoundSet;
+		m_SoundSelectionCycleMode = reference.m_SoundSelectionCycleMode;
+
 		m_PlayingChannels.clear();
 
 		m_AttenuationStartDistance = reference.m_AttenuationStartDistance;
@@ -43,12 +57,15 @@ namespace RTE {
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	int SoundContainer::ReadProperty(std::string propName, Reader &reader) {
-		if (propName == "AddSound") {
-			ContentFile newFile;
-			reader >> newFile;
-			FMOD::Sound *pNewSample = newFile.GetAsSample();
-			if (!pNewSample) { reader.ReportError(std::string("Failed to load the sample from the file")); }
-			m_Sounds.push_back(std::pair<ContentFile, FMOD::Sound *>(newFile, pNewSample));
+		if (propName == "AddSound" || propName == "AddSoundSet") {
+			return ReadSoundOrSoundSet(propName, reader);
+		} else if (propName == "CycleMode") {
+			std::string cycleModeString = reader.ReadPropValue();
+			if (c_CycleModeMap.find(cycleModeString) != c_CycleModeMap.end()) {
+				m_SoundSelectionCycleMode = c_CycleModeMap.find(cycleModeString)->second;
+			} else {
+				reader.ReportError("Cycle mode " + cycleModeString + " is invalid.");
+			}
 		} else if (propName == "AttenuationStartDistance") {
 			reader >> m_AttenuationStartDistance;
 		} else if (propName == "LoopSetting") {
@@ -68,66 +85,147 @@ namespace RTE {
 		return 0;
 	}
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	
+	int SoundContainer::ReadSoundOrSoundSet(const std::string &propName, Reader &reader) {
+		vector<SoundData> soundSet;
+		if (propName == "AddSound") {
+			soundSet.push_back(ReadSound(reader));
+		} else if (propName == "AddSoundSet") {
+			reader.ReadPropValue();
+			while (reader.NextProperty()) {
+				std::string soundSetSubPropertyName = reader.ReadPropName();
+				if (soundSetSubPropertyName == "AddSound") {
+					soundSet.push_back(ReadSound(reader));
+				} else {
+					reader.ReportError(soundSetSubPropertyName + " is not a valid property of SoundSets.");
+				}
+			}
+		}
+
+		m_SoundSets.push_back(soundSet);
+		return 0;
+	}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	SoundContainer::SoundData SoundContainer::ReadSound(Reader &reader) {
+		std::string propValue = reader.ReadPropValue();
+		SoundData soundData;
+
+		/// <summary>
+		/// Internal lambda function to load an audio file by path in as a ContentFile, which in turn loads it into FMOD, then returns SoundData for it in the outParam outSoundData.
+		/// </summary>
+		/// <param name="soundPath">The path to the sound file.</param>
+		auto readSound = [&soundData, &reader](const std::string &soundPath) {
+			ContentFile soundFile(soundPath.c_str());
+			FMOD::Sound *soundObject = soundFile.GetAsSample();
+			if (g_AudioMan.IsAudioEnabled() && !soundObject) { reader.ReportError(std::string("Failed to load the sound from the file")); }
+
+			soundData.SoundFile = soundFile;
+			soundData.SoundObject = soundObject;
+		};
+
+		if (propValue != "Sound" && propValue != "ContentFile") {
+			readSound(propValue);
+			return soundData;
+		}
+
+		while (reader.NextProperty()) {
+			std::string soundSubPropertyName = reader.ReadPropName();
+			if (soundSubPropertyName == "FilePath" || soundSubPropertyName == "Path") {
+				readSound(reader.ReadPropValue());
+			} else if (soundSubPropertyName == "Offset") {
+				reader >> soundData.Offset;
+			} else if (soundSubPropertyName == "MinimumAudibleDistance") {
+				reader >> soundData.MinimumAudibleDistance;
+			} else if (soundSubPropertyName == "AttenuationStartDistance") {
+				reader >> soundData.AttenuationStartDistance;
+			}
+		}
+
+		return soundData;
+	}
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	void SoundContainer::AddSound(std::string const soundPath, bool abortGameForInvalidSound) {
-		ContentFile newFile(soundPath.c_str());
+	void SoundContainer::AddSound(const std::string &soundFilePath, unsigned int soundSetIndex, const Vector &offset, float minimumAudibleDistance, float attenuationStartDistance, bool abortGameForInvalidSound) {
+		std::vector<SoundData> soundSet;
+		if (soundSetIndex < m_SoundSets.size()) { soundSet = m_SoundSets[soundSetIndex]; }
 
-		FMOD::Sound *newSample = newFile.GetAsSample(abortGameForInvalidSound);
-		if (newSample) {
-			FMOD_RESULT result = newSample->setMode((m_Loops == 0) ? FMOD_LOOP_OFF : FMOD_LOOP_NORMAL);
-			result = (result == FMOD_OK) ? newSample->setLoopCount(m_Loops) : result;
-			m_Sounds.push_back(std::pair<ContentFile, FMOD::Sound *>(newFile, newSample));
+		ContentFile soundFile(soundFilePath.c_str());
+		FMOD::Sound *soundObject = soundFile.GetAsSample(abortGameForInvalidSound);
+		if (!soundObject) {
+			return;
 		}
+
+		attenuationStartDistance = (attenuationStartDistance < 0) ? c_DefaultAttenuationStartDistance : attenuationStartDistance;
+		soundSet.push_back({soundFile, soundObject, offset, minimumAudibleDistance, attenuationStartDistance});
+		if (soundSetIndex >= m_SoundSets.size()) { m_SoundSets.push_back(soundSet); }
+
+		m_AllSoundPropertiesUpToDate = false;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	std::vector<size_t> SoundContainer::GetSelectedSoundHashes() {
+	std::vector<size_t> SoundContainer::GetSelectedSoundHashes() const {
 		std::vector<size_t> soundHashes;
-		for (size_t selectedSoundIndex : m_SelectedSounds) {
-			soundHashes.push_back(m_Sounds[selectedSoundIndex].first.GetHash());
+		for (const SoundData &selectedSoundData : m_SoundSets[m_SelectedSoundSet]) {
+			soundHashes.push_back(selectedSoundData.SoundFile.GetHash());
 		}
 		return soundHashes;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-	std::vector<FMOD::Sound *> SoundContainer::GetSelectedSoundObjects() {
- 		std::vector<FMOD::Sound *> soundObjects;
-		for (size_t selectedSoundIndex : m_SelectedSounds) {
-			soundObjects.push_back(m_Sounds[selectedSoundIndex].second);
+	
+	const SoundContainer::SoundData *SoundContainer::GetSoundDataForSound(const FMOD::Sound *sound) const {
+		for (const std::vector<SoundData> &soundSet : m_SoundSets) {
+			for (const SoundData &soundData : soundSet) {
+				if (sound == soundData.SoundObject) {
+					return &soundData;
+				}
+			}
 		}
-		return soundObjects;
+		return NULL;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	bool SoundContainer::SelectNextSounds() {
-		int soundCount = GetSoundCount();
-		if (soundCount == 0) {
-			return false;
-		}
-		size_t previouslySelectedSound = (m_SelectedSounds.size() > 0) ? m_SelectedSounds[0] : 0;
+	bool SoundContainer::SelectNextSoundSet() {
+		int soundSetCount = m_SoundSets.size();
+		switch (soundSetCount) {
+			case 0:
+				return false;
+			case 1:
+				return true;
+			case 2:
+				m_SelectedSoundSet = (m_SelectedSoundSet + 1) % 2;
+				break;
+			default:
+				/// <summary>
+				/// Internal lambda function to pick a random sound that's not the previously played sound. Done to avoid scoping issues inside the switch below.
+				/// </summary>
+				auto selectRandomSound = [&soundSetCount, this]() {
+					size_t soundToSelect = std::floorf(static_cast<float>(soundSetCount) * PosRand());
+					while (soundToSelect == m_SelectedSoundSet) {
+						soundToSelect = std::floorf(static_cast<float>(soundSetCount) * PosRand());
+					}
+					m_SelectedSoundSet = soundToSelect;
+				};
 
-		if (m_SelectedSounds.empty() || soundCount == 1) {
-			m_SelectedSounds.clear();
-			m_SelectedSounds.push_back(previouslySelectedSound);
-		} else {
-			m_SelectedSounds.clear();
-			if (soundCount == 2) {
-				m_SelectedSounds.push_back((previouslySelectedSound + 1) % soundCount);
-			} else if (soundCount > 2) {
-				size_t soundToSelect = floorf(static_cast<float>(soundCount) * PosRand());
-				// Mix it up again if we got the same sound twice
-				while (soundToSelect == previouslySelectedSound) {
-					soundToSelect = floorf(static_cast<float>(soundCount) * PosRand());
+				switch (m_SoundSelectionCycleMode) {
+					case MODE_RANDOM:
+						selectRandomSound();
+						break;
+					case MODE_FORWARDS:
+						m_SelectedSoundSet = (m_SelectedSoundSet + 1) % soundSetCount;
+						break;
+					default:
+						RTEAbort("Invalid sound cycle mode " + m_SoundSelectionCycleMode);
+						break;
 				}
-				m_SelectedSounds.push_back(soundToSelect);
-			}
+				RTEAssert(m_SelectedSoundSet >= 0 && m_SelectedSoundSet < soundSetCount, "Failed to select next sound, either none was selected or the selected sound was invalid.");
 		}
-		RTEAssert(m_SelectedSounds.size() > 0 && m_SelectedSounds[0] >= 0 && m_SelectedSounds[0] < soundCount, "Failed to select next sound, either none was selected or the selected sound was invalid.");
-	
 		return true;
 	}
 
@@ -136,16 +234,57 @@ namespace RTE {
 	FMOD_RESULT SoundContainer::UpdateSoundProperties() {
 		FMOD_RESULT result = FMOD_OK;
 
-		for (std::vector<std::pair<ContentFile, FMOD::Sound * >>::const_iterator itr = m_Sounds.begin(); itr != m_Sounds.end() && result == FMOD_OK; ++itr) {
-			FMOD_MODE soundMode = (m_Loops == 0) ? FMOD_LOOP_OFF : FMOD_LOOP_NORMAL;
-			soundMode |= m_Immobile ? FMOD_3D_HEADRELATIVE : FMOD_3D_WORLDRELATIVE;
+		for (std::vector<SoundData> &soundSet : m_SoundSets) {
+			for (SoundData &soundData : soundSet) {
+				FMOD_MODE soundMode = (m_Loops == 0) ? FMOD_LOOP_OFF : FMOD_LOOP_NORMAL;
+				if (m_Immobile) {
+					soundMode |= FMOD_3D_HEADRELATIVE;
+					m_AttenuationStartDistance = c_SoundMaxAudibleDistance;
+				} else {
+					soundMode |= FMOD_3D_CUSTOMROLLOFF;
+				}
+
+				result = (result == FMOD_OK) ? soundData.SoundObject->setMode(soundMode) : result;
+				result = (result == FMOD_OK) ? soundData.SoundObject->setLoopCount(m_Loops) : result;
+				if (m_Immobile) {
+					result = (result == FMOD_OK) ? soundData.SoundObject->set3DMinMaxDistance(m_AttenuationStartDistance, c_SoundMaxAudibleDistance) : result;
+				} else {
+					//FMOD_VECTOR customRolloffPoints[10];
+					//CalculateCustomRolloffPoints(soundData, customRolloffPoints, 10);
 
-			result = (result == FMOD_OK) ? itr->second->setMode(soundMode) : result;
-			result = (result == FMOD_OK) ? itr->second->setLoopCount(m_Loops) : result;
-			result = (result == FMOD_OK) ? itr->second->set3DMinMaxDistance(m_AttenuationStartDistance, 100000) : result;
+					//TODO Consider replacing this with normal min and max distance (but keep custom rolloff mode) so we can save some pointing issues. Might need to store min audible distance in audioman if fmod is strict about min and max distance sizes wrt each other.
+					soundData.CustomRolloffPoints[0] = FMOD_VECTOR{soundData.MinimumAudibleDistance, 0, 0};
+					soundData.CustomRolloffPoints[1] = FMOD_VECTOR{(soundData.AttenuationStartDistance < 0) ? m_AttenuationStartDistance : soundData.AttenuationStartDistance, 1, 0};
+					result = (result == FMOD_OK) ? soundData.SoundObject->set3DCustomRolloff(soundData.CustomRolloffPoints, 2) : result;
+				}
+			}
 		}
 		m_AllSoundPropertiesUpToDate = result == FMOD_OK;
 
 		return result;
 	}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	//TODO this needs to be used or be deleted
+	void SoundContainer::CalculateCustomRolloffPoints(const SoundData &soundDataToCalculateFor, FMOD_VECTOR *rolloffPoints, int numRolloffPoints) {
+		int attenuationStartDistance = (soundDataToCalculateFor.AttenuationStartDistance < 0) ? m_AttenuationStartDistance : soundDataToCalculateFor.AttenuationStartDistance;
+		float currentDistance = attenuationStartDistance;
+		float currentVolumeLevel = 1;
+
+		int i = 0;
+		if (soundDataToCalculateFor.MinimumAudibleDistance > 0) {
+			i = 2;
+			currentDistance += soundDataToCalculateFor.MinimumAudibleDistance;
+			rolloffPoints[0] = FMOD_VECTOR{0, 0, 0};
+			rolloffPoints[1] = FMOD_VECTOR{soundDataToCalculateFor.MinimumAudibleDistance - 0.1F, 0, 0};
+		}
+
+		for (i = ((soundDataToCalculateFor.MinimumAudibleDistance > 0) ? 2 : 0); i < numRolloffPoints - 1; i++) {
+			rolloffPoints[i] = FMOD_VECTOR{currentDistance, currentVolumeLevel, 0};
+			currentDistance += attenuationStartDistance;
+			currentVolumeLevel = (currentDistance < c_SoundMaxAudibleDistance) ? currentVolumeLevel * 0.5F : 0;
+		}
+		rolloffPoints[numRolloffPoints - 1] = FMOD_VECTOR{currentDistance, 0, 0};
+	}
 }