Changed volume setting back to account for 3DLevel < 1 making automatic attenuation not work. Also made it mute when set to 0 so it won't screw things up

Changed soundcontainer playing in audioman.cpp to do panning and positioning properly, fixed audioman 3d effects handling to deal with volume setting when needed
Cleaned up some stuff in audioman

Author: garethyr

Entities/SoundContainer.cpp

@@ -278,7 +278,7 @@ namespace RTE {
 				}
 			}
 		}
-		return nullptr;
+		return NULL;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Entities/SoundContainer.h

@@ -323,7 +323,7 @@ namespace RTE {
 		/// Sets the volume sounds in this SoundContainer should be played at. Note that this does not factor volume changes due to the SoundContainer's position. Does not affect currently playing sounds.
 		/// </summary>
 		/// <param name="newVolume">The new volume sounds in this SoundContainer should be played at. Limited between 0 and 10.</param>
-		void SetVolume(float newVolume) { m_Volume = std::clamp(newVolume, 0.0F, 10.0F); if (IsBeingPlayed()) { g_AudioMan.ChangeSoundContainerPlayingChannelsVolume(this); } }
+		void SetVolume(float newVolume) { newVolume = std::clamp(newVolume, 0.0F, 10.0F); if (IsBeingPlayed()) { g_AudioMan.ChangeSoundContainerPlayingChannelsVolume(this, newVolume); m_Volume = newVolume; } }
 
 		/// <summary>
 		/// Gets the pitch the sounds in this SoundContainer are played at. Note that this does not factor in global pitch.

Managers/AudioMan.cpp

@@ -508,14 +508,17 @@ namespace RTE {
 
 			result = (result == FMOD_OK) ? channel->setUserData(soundContainer) : result;
 			result = (result == FMOD_OK) ? channel->setCallback(SoundChannelEndedCallback) : result;
-			result = (result == FMOD_OK) ? channel->set3DAttributes(&GetAsFMODVector(soundContainer->GetPosition() + soundData.Offset), nullptr) : result;
-			result = (result == FMOD_OK) ? channel->set3DLevel(g_SettingsMan.SoundPanningEffectStrength()) : result;
+			if (!soundContainer->IsImmobile()) {
+				m_SoundChannelMinimumAudibleDistances.insert({channelIndex, soundData.MinimumAudibleDistance});
+				UpdatePositionalEffectsForSoundChannel(channel, &GetAsFMODVector(soundContainer->GetPosition() + soundData.Offset));
+				result = (result == FMOD_OK) ? channel->set3DLevel(g_SettingsMan.SoundPanningEffectStrength()) : result;
+			} else {
+				result = (result == FMOD_OK) ? channel->set3DLevel(0.0F) : result;
+			}
 			result = (result == FMOD_OK) ? channel->setPriority(soundContainer->GetPriority()) : result;
 			result = (result == FMOD_OK) ? channel->setVolume(soundContainer->GetVolume()) : result;
 			result = (result == FMOD_OK) ? channel->setPitch(soundContainer->GetPitch()) : result;
 
-			m_SoundChannelMinimumAudibleDistances.insert({channelIndex, soundData.MinimumAudibleDistance});
-			if (!soundContainer->IsImmobile()) { UpdatePositionalEffectsForSoundChannel(channel); }
 
 			if (result != FMOD_OK) {
 				g_ConsoleMan.PrintString("ERROR: Could not play sounds from SoundContainer " + soundContainer->GetPresetName() + ": " + std::string(FMOD_ErrorString(result)));
@@ -566,19 +569,29 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	bool AudioMan::ChangeSoundContainerPlayingChannelsVolume(SoundContainer *soundContainer) {
+	bool AudioMan::ChangeSoundContainerPlayingChannelsVolume(SoundContainer *soundContainer, float newVolume) {
 		if (!m_AudioEnabled || !soundContainer || !soundContainer->IsBeingPlayed()) {
 			return false;
 		}
 		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_VOLUME, soundContainer->GetPlayingChannels(), &soundContainer->GetSelectedSoundHashes(), Vector(), 0, soundContainer->GetVolume()); }
 
 		FMOD_RESULT result = FMOD_OK;
 		FMOD::Channel *soundChannel;
+		float soundContainerOldVolume = soundContainer->GetVolume() == 0 ? 1.0F : soundContainer->GetVolume();
+		float soundChannelCurrentVolume;
 
 		const std::unordered_set<int> *playingChannels = soundContainer->GetPlayingChannels();
 		for (int channelIndex : *playingChannels) {
 			result = m_AudioSystem->getChannel(channelIndex, &soundChannel);
-			result = result == FMOD_OK ? soundChannel->setVolume(soundContainer->GetVolume()) : result;
+			result = result == FMOD_OK ? soundChannel->getVolume(&soundChannelCurrentVolume) : result;
+
+			if (newVolume == 0.0F) {
+				result = result == FMOD_OK ? soundChannel->setMute(true) : result;
+				result = result == FMOD_OK ? soundChannel->setVolume(soundChannelCurrentVolume / soundContainerOldVolume) : result;
+			} else {
+				result = result == FMOD_OK ? soundChannel->setMute(false) : result;
+				result = result == FMOD_OK ? soundChannel->setVolume(newVolume / soundContainerOldVolume * soundChannelCurrentVolume) : result;
+			}
 			if (result != FMOD_OK) {
 				g_ConsoleMan.PrintString("ERROR: Could not update sound volume for the sound being played on channel " + std::to_string(channelIndex) + " for SoundContainer " + soundContainer->GetPresetName() + ": " + std::string(FMOD_ErrorString(result)));
 			}
@@ -669,24 +682,48 @@ namespace RTE {
 			wrappedChannelPositions = {channelPosition};
 		} else {
 			wrappedChannelPositions = (channelPosition.x <= halfSceneWidth) ?
-				wrappedChannelPositions = {channelPosition, GetAsFMODVector({channelPosition.x + g_SceneMan.GetSceneWidth(), channelPosition.y})} :
-				wrappedChannelPositions = {GetAsFMODVector({channelPosition.x - g_SceneMan.GetSceneWidth(), channelPosition.y}), channelPosition};
+				wrappedChannelPositions = {channelPosition, {channelPosition.x + g_SceneMan.GetSceneWidth(), channelPosition.y}} :
+				wrappedChannelPositions = {FMOD_VECTOR({channelPosition.x - g_SceneMan.GetSceneWidth(), channelPosition.y}), channelPosition};
 		}
 
-		float shortestDistance = -1;
+		float shortestDistance = c_SoundMaxAudibleDistance;
+		float longestDistance = 0;
 		for (const Vector *humanPlayerPosition : m_CurrentActivityHumanPlayerPositions) {
 			for (const FMOD_VECTOR &wrappedChannelPosition : wrappedChannelPositions) {
 				float distanceToChannelPosition = (*humanPlayerPosition - GetAsVector(wrappedChannelPosition)).GetMagnitude();
-				if (shortestDistance == -1 || distanceToChannelPosition < shortestDistance) {
+				if (distanceToChannelPosition < shortestDistance) {
 					shortestDistance = distanceToChannelPosition;
 					channelPosition = wrappedChannelPosition;
 				}
+				if (distanceToChannelPosition > longestDistance) { longestDistance = distanceToChannelPosition; }
 			}
 		}
 
 		int soundChannelIndex;
 		result = result == FMOD_OK ? soundChannel->getIndex(&soundChannelIndex) : result;
-		result = result == FMOD_OK ? soundChannel->setMute(shortestDistance < m_SoundChannelMinimumAudibleDistances.at(soundChannelIndex)) : result;
+
+		float attenuationStartDistance;
+		float soundMaxDistance;
+		result = result == FMOD_OK ? soundChannel->get3DMinMaxDistance(&attenuationStartDistance, &soundMaxDistance) : result;
+		
+		float attenuatedVolume = shortestDistance <= attenuationStartDistance ? 1.0F : attenuationStartDistance / shortestDistance;
+		if (shortestDistance > soundMaxDistance) {
+			attenuatedVolume = 0.0F;
+		} else if (m_SoundChannelMinimumAudibleDistances.empty() || m_SoundChannelMinimumAudibleDistances.find(soundChannelIndex) == m_SoundChannelMinimumAudibleDistances.end()) {
+			g_ConsoleMan.PrintString("ERROR: An error occurred when checking to see if the sound at channel " + std::to_string(soundChannelIndex) + " was less than its minimum audible distance away from the farthest listener.");
+		} else if (longestDistance < m_SoundChannelMinimumAudibleDistances.at(soundChannelIndex)) {
+			attenuatedVolume = 0.0F;
+		}
+
+		void *userData;
+		result = result == FMOD_OK ? soundChannel->getUserData(&userData) : result;
+		float panLevel;
+		result = result == FMOD_OK ? soundChannel->get3DLevel(&panLevel) : result;
+		if (result == FMOD_OK && panLevel < 1.0F) {
+			SoundContainer *channelSoundContainer = static_cast<SoundContainer *>(userData);
+			result = soundChannel->setVolume(attenuatedVolume * channelSoundContainer->GetVolume());
+		}
+
 		result = (result == FMOD_OK && (sceneWraps || positionOverride)) ? soundChannel->set3DAttributes(&channelPosition, nullptr) : result;
 
 		return result;

Managers/AudioMan.h

@@ -433,23 +433,21 @@ namespace RTE {
 		/// Sets/updates the position of a SoundContainer's playing sounds.
 		/// </summary>
 		/// <param name="soundContainer">A pointer to a SoundContainer object. Ownership IS NOT transferred!</param>
-		/// <param name="position">The position at which to play the SoundContainer's sounds.</param>
 		/// <returns>Whether the position was successfully set.</returns>
 		bool ChangeSoundContainerPlayingChannelsPosition(SoundContainer *soundContainer);
 
 		/// <summary>
 		/// Changes the volume of a SoundContainer's playing sounds.
 		/// </summary>
 		/// <param name="soundContainer">A pointer to a SoundContainer object. Ownership IS NOT transferred!</param>
-		/// <param name="volume">The new volume to play sounds at, between 0 and 1.</param>
+		/// <param name="newVolume">The new volume to play sounds at, between 0 and 1.</param>
 		/// <returns>Whether the volume was successfully updated.</returns>
-		bool ChangeSoundContainerPlayingChannelsVolume(SoundContainer *soundContainer);
+		bool ChangeSoundContainerPlayingChannelsVolume(SoundContainer *soundContainer, float newVolume);
 
 		/// <summary>
 		/// Changes the frequency/pitch of a SoundContainer's playing sounds.
 		/// </summary>
 		/// <param name="soundContainer">A pointer to a SoundContainer object. Ownership IS NOT transferred!</param>
-		/// <param name="pitch">New pitch to play sounds at, limited to 8 octaves up or down (i.e. 0.125 - 8).</param>
 		/// <returns>Whether the pitch was successfully updated.</returns>
 		bool ChangeSoundContainerPlayingChannelsPitch(SoundContainer *soundContainer);
 #pragma endregion