Tweaked network handling for sound data (and slightly for music data)

Made audioman sound event registration take and use the whole sound container, to make things cleaner
NetworkSoundData now holds one channel and sound file hash, which is less efficient (but can be made a bit better) but less messy

Author: garethyr

Managers/AudioMan.cpp

@@ -136,7 +136,7 @@ namespace RTE {
 		if (!m_AudioEnabled) {
 			return;
 		}
-		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_GLOBAL_PITCH, nullptr, nullptr, Vector(), 0, 0.0F, pitch); }
+		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_GLOBAL_PITCH, nullptr); }
 
 		m_GlobalPitch = std::clamp(pitch, 0.125F, 8.0F); 
 		if (includeMusic) { m_MusicChannelGroup->setPitch(m_GlobalPitch); }
@@ -350,7 +350,7 @@ namespace RTE {
 		if (!m_AudioEnabled || !soundContainer) {
 			return false;
 		}
-		if (m_IsInMultiplayerMode) { RegisterSoundEvent(player, SOUND_STOP, soundContainer->GetPlayingChannels()); }
+		if (m_IsInMultiplayerMode) { RegisterSoundEvent(player, SOUND_STOP, soundContainer); }
 
 		FMOD_RESULT result;
 		FMOD::Channel *soundChannel;
@@ -374,7 +374,7 @@ namespace RTE {
 		if (!m_AudioEnabled || !soundContainer || !soundContainer->IsBeingPlayed()) {
 			return;
 		}
-		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_FADE_OUT, soundContainer->GetPlayingChannels(), &soundContainer->GetSelectedSoundHashes(), Vector(), 0, 0, 0, false, 0, false, fadeOutTime); }
+		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_FADE_OUT, soundContainer, fadeOutTime); }
 
 		int sampleRate;
 		m_AudioSystem->getSoftwareFormat(&sampleRate, nullptr, nullptr);
@@ -413,13 +413,13 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	void AudioMan::RegisterMusicEvent(int player, NetworkMusicState state, const char *filepath, int loops, float position, float pitch) {
+	void AudioMan::RegisterMusicEvent(int player, NetworkMusicState state, const char *filepath, int loopsOrSilence, float position, float pitch) {
 		if (player == -1) {
-			for (int i = 0; i < c_MaxClients; i++) { RegisterMusicEvent(i, state, filepath, loops, position, pitch); }
+			for (int i = 0; i < c_MaxClients; i++) { RegisterMusicEvent(i, state, filepath, loopsOrSilence, position, pitch); }
 		} else {
 			NetworkMusicData musicData;
 			musicData.State = state;
-			musicData.Loops = loops;
+			musicData.LoopsOrSilence = loopsOrSilence;
 			musicData.Pitch = pitch;
 			musicData.Position = position;
 			if (filepath) {
@@ -440,43 +440,65 @@ namespace RTE {
 			return;
 		}
 		list.clear();
-		g_SoundEventsListMutex[player].lock();
 
-		for (const NetworkSoundData &soundEvent : m_SoundEvents[player]) { list.push_back(soundEvent); }
-		m_SoundEvents[player].clear();
+		g_SoundEventsListMutex[player].lock();
+		const NetworkSoundData *lastSetGlobalPitchEvent = nullptr;
+		for (const NetworkSoundData &soundEvent : m_SoundEvents[player]) {
+			if (soundEvent.State == SOUND_SET_GLOBAL_PITCH) {
+				lastSetGlobalPitchEvent = &soundEvent;
+			} else {
+				list.push_back(soundEvent);
+			}
+		}
+		if (lastSetGlobalPitchEvent) { list.push_back(*lastSetGlobalPitchEvent); }
 		g_SoundEventsListMutex[player].unlock();
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	void AudioMan::RegisterSoundEvent(int player, NetworkSoundState state, const std::unordered_set<int> *channels, const std::vector<size_t> *soundFileHashes, const Vector &position, int loops, float volume, float pitch, bool affectedByGlobalPitch, float attenuationStartDistance, bool immobile, int fadeOutTime) {
+	void AudioMan::RegisterSoundEvent(int player, NetworkSoundState state, const SoundContainer *soundContainer, int fadeoutTime) {
 		if (player == -1) {
-			for (int i = 0; i < c_MaxClients; i++) { RegisterSoundEvent(i, state, channels, soundFileHashes, position, loops, volume, pitch, affectedByGlobalPitch, attenuationStartDistance, immobile, fadeOutTime); }
+			for (int i = 0; i < c_MaxClients; i++) { RegisterSoundEvent(i, state, soundContainer, fadeoutTime); }
 		} else {
-			if (player >= 0 && player < c_MaxClients) {
+			FMOD_RESULT result = FMOD_OK;
+			std::vector<NetworkSoundData> soundDataVector;
+
+			if (state == SOUND_SET_GLOBAL_PITCH) {
 				NetworkSoundData soundData;
 				soundData.State = state;
-
-				std::fill_n(soundData.Channels, c_MaxPlayingSoundsPerContainer, c_MaxVirtualChannels + 1);
-				if (channels) { std::copy(channels->begin(), channels->end(), soundData.Channels); }
-
-				std::fill_n(soundData.SoundFileHashes, c_MaxPlayingSoundsPerContainer, 0);
-				if (soundFileHashes) { std::copy(soundFileHashes->begin(), soundFileHashes->end(), soundData.SoundFileHashes); }
-
-				soundData.Position[0] = position.m_X;
-				soundData.Position[1] = position.m_Y;
-				soundData.Loops = loops;
-				soundData.Volume = volume;
-				soundData.Pitch = pitch;
-				soundData.AffectedByGlobalPitch = affectedByGlobalPitch;
-				soundData.AttenuationStartDistance = attenuationStartDistance;
-				soundData.Immobile = immobile;
-				soundData.FadeOutTime = fadeOutTime;
-
-				g_SoundEventsListMutex[player].lock();
-				m_SoundEvents[player].push_back(soundData);
-				g_SoundEventsListMutex[player].unlock();
+				soundData.Pitch = m_GlobalPitch;
+				soundDataVector.push_back(soundData);
+			} else {
+				for (int playingChannel : *soundContainer->GetPlayingChannels()) {
+					FMOD::Channel *soundChannel;
+					result = m_AudioSystem->getChannel(playingChannel, &soundChannel);
+					FMOD::Sound *sound;
+					result = (result == FMOD_OK) ? soundChannel->getCurrentSound(&sound) : result;
+
+					if (result != FMOD_OK) {
+						continue;
+					}
+					NetworkSoundData soundData;
+					soundData.State = state;
+					soundData.SoundFileHash = soundContainer->GetSoundDataForSound(sound)->SoundFile.GetHash();
+					soundData.Channel = playingChannel;
+					soundData.Immobile = soundContainer->IsImmobile();
+					soundData.AttenuationStartDistance = soundContainer->GetAttenuationStartDistance();
+					soundData.Loops = soundContainer->GetLoopSetting();
+					soundData.Priority = soundContainer->GetPriority();
+					soundData.AffectedByGlobalPitch = soundContainer->IsAffectedByGlobalPitch();
+					soundData.Position[0] = soundContainer->GetPosition().m_X;
+					soundData.Position[1] = soundContainer->GetPosition().m_Y;
+					soundData.Volume = soundContainer->GetVolume();
+					soundData.Pitch = soundContainer->GetPitch();
+					soundData.FadeOutTime = fadeoutTime;
+					soundDataVector.push_back(soundData);
+				}
 			}
+
+			g_SoundEventsListMutex[player].lock();
+			m_SoundEvents[player].insert(m_SoundEvents[player].end(), soundDataVector.begin(), soundDataVector.end());
+			g_SoundEventsListMutex[player].unlock();
 		}
 	}
 
@@ -534,9 +556,7 @@ namespace RTE {
 			soundContainer->AddPlayingChannel(channelIndex);
 		}
 
-		if (m_IsInMultiplayerMode) {
-			RegisterSoundEvent(player, SOUND_PLAY, soundContainer->GetPlayingChannels(), &soundContainer->GetSelectedSoundHashes(), soundContainer->GetPosition(), soundContainer->GetLoopSetting(), soundContainer->GetVolume(), soundContainer->GetPitch(), soundContainer->IsAffectedByGlobalPitch(), soundContainer->GetAttenuationStartDistance(), soundContainer->IsImmobile());
-		}
+		if (m_IsInMultiplayerMode) { RegisterSoundEvent(player, SOUND_PLAY, soundContainer); }
 		return true;
 	}
 
@@ -546,7 +566,7 @@ namespace RTE {
 		if (!m_AudioEnabled || !soundContainer) {
 			return false;
 		}
-		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_POSITION, soundContainer->GetPlayingChannels(), &soundContainer->GetSelectedSoundHashes(), soundContainer->GetPosition()); }
+		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_POSITION, soundContainer); }
 
 		FMOD_RESULT result = FMOD_OK;
 		FMOD::Channel *soundChannel;
@@ -573,7 +593,7 @@ namespace RTE {
 		if (!m_AudioEnabled || !soundContainer || !soundContainer->IsBeingPlayed()) {
 			return false;
 		}
-		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_VOLUME, soundContainer->GetPlayingChannels(), &soundContainer->GetSelectedSoundHashes(), Vector(), 0, soundContainer->GetVolume()); }
+		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_VOLUME, soundContainer); }
 
 		FMOD_RESULT result = FMOD_OK;
 		FMOD::Channel *soundChannel;
@@ -605,7 +625,7 @@ namespace RTE {
 		if (!m_AudioEnabled || !soundContainer || !soundContainer->IsBeingPlayed()) {
 			return false;
 		}
-		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_PITCH, soundContainer->GetPlayingChannels(), &soundContainer->GetSelectedSoundHashes(), Vector(), 0, 0.0F, soundContainer->GetPitch()); }
+		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_PITCH, soundContainer); }
 
 		FMOD_RESULT result = FMOD_OK;
 		FMOD::Channel *soundChannel;

Managers/AudioMan.h

@@ -49,7 +49,7 @@ namespace RTE {
 		struct NetworkMusicData {
 			unsigned char State;
 			char Path[256];
-			int Loops;
+			int LoopsOrSilence;
 			float Position;
 			float Pitch;
 		};
@@ -58,12 +58,12 @@ namespace RTE {
 		/// Sound event states for sending sound data from the server to clients during multiplayer games.
 		/// </summary>
 		enum NetworkSoundState {
-			SOUND_PLAY = 0,
+			SOUND_SET_GLOBAL_PITCH = 0,
+			SOUND_PLAY,
 			SOUND_STOP,
 			SOUND_SET_POSITION,
 			SOUND_SET_VOLUME,
 			SOUND_SET_PITCH,
-			SOUND_SET_GLOBAL_PITCH,
 			SOUND_FADE_OUT
 		};
 
@@ -72,15 +72,16 @@ namespace RTE {
 		/// </summary>
 		struct NetworkSoundData {
 			unsigned char State;
-			int Channels[c_MaxPlayingSoundsPerContainer];
-			size_t SoundFileHashes[c_MaxPlayingSoundsPerContainer];
-			float Position[2];
+			std::size_t SoundFileHash;
+			int Channel;
+			bool Immobile;
+			float AttenuationStartDistance;
 			int Loops;
+			int Priority;
+			bool AffectedByGlobalPitch;
+			float Position[2];
 			float Volume;
 			float Pitch;
-			bool AffectedByGlobalPitch;
-			float AttenuationStartDistance;
-			bool Immobile;
 			int FadeOutTime;
 		};
 
@@ -348,34 +349,26 @@ namespace RTE {
 		/// <param name="player">Player(s) for which the event happened.</param>
 		/// <param name="state">NetworkMusicState for the event.</param>
 		/// <param name="filepath">Music file path to transmit to client.</param>
-		/// <param name="loops">Loops counter.</param>
+		/// <param name="loops">LoopsOrSilence counter or, if state is silence, the length of the silence.</param>
 		/// <param name="position">Music playback position.</param>
 		/// <param name="pitch">Pitch value.</param>
-		void RegisterMusicEvent(int player, NetworkMusicState state, const char *filepath, int loops = 0, float position = 0, float pitch = 1);
+		void RegisterMusicEvent(int player, NetworkMusicState state, const char *filepath, int loopsOrSilence = 0, float position = 0, float pitch = 1);
 
 		/// <summary>
 		/// Fills the list with sound events happened for the specified network player.
 		/// </summary>
 		/// <param name="player">Player to get events for.</param>
 		/// <param name="list">List with events for this player.</param>
-		void GetSoundEvents(int player, std::list<NetworkSoundData> & list);
+		void GetSoundEvents(int player, std::list<NetworkSoundData> &list);
 
 		/// <summary>
-		/// Adds the sound event to internal list of sound events for the specified player.
+		/// Adds the sound event to the internal list of sound events for the specified player.
 		/// </summary>
 		/// <param name="player">Player(s) for which the event happened.</param>
-		/// <param name="state">NetworkSoundState for the event .</param>
-		/// <param name="channels">Pointer to an unordered_set of channels this sound event applies to on the server.</param>
-		/// <param name="soundFileHashes">Pointer to a vector of hashes describing sound file locations to transmit to client.</param>
-		/// <param name="position">Sound position.</param>
-		/// <param name="loops">Loops counter.</param>
-		/// <param name="volume">Volume value.</param>
-		/// <param name="pitch">Pitch value.</param>
-		/// <param name="attenuationStartDistance">The distance at which the sound will start attenuating away.</param>
-		/// <param name="affectedByGlobalPitch">Whether the sound is affected by pitch.</param>
-		/// <param name="immobile">Whether the sound is immobile or not.</param>
-		/// <param name="fadeOutTime">The amount of time, in ms, to fade out over.</param>
-		void RegisterSoundEvent(int player, NetworkSoundState state, const std::unordered_set<int> *channels = nullptr, const std::vector<size_t> *soundFileHashes = nullptr, const Vector &position = Vector(), int loops = 0, float volume = 1.0F, float pitch = 1.0F, bool affectedByGlobalPitch = false, float attenuationStartDistance = 0, bool immobile = false, int fadeOutTime = 0);
+		/// <param name="state">NetworkSoundState for the event.</param>
+		/// <param name="soundContainer">A pointer to the SoundContainer this event is happening to, or a null pointer for global events.</param>
+		/// <param name="fadeOutTime">THe amount of time, in MS, to fade out over. This data isn't contained in SoundContainer, so it needs to be passed in separately.</param>
+		void RegisterSoundEvent(int player, NetworkSoundState state, const SoundContainer *soundContainer, int fadeOutTime = 0);
 #pragma endregion
 
 #pragma region Class Info