Changed SoundContainer::GetSounds to return a pointer to m_Sounds and GetPlayingChannels to return a pointer to m_PlayingChannels, to avoid copying stuff. Made it so Soundcontainers can have multiple hashes (one for each sound) and added methods to get vectors of selected sound hashes and selected sound objects

Added a limit to the number of playing channels a SoundContainer can have (defined in constants), for sanity and to support multiplayer
Fixed various types not being unsigned, added various safety checks, etc.

Author: garethyr

Entities/SoundContainer.cpp

@@ -9,12 +9,11 @@ namespace RTE {
 
 	void SoundContainer::Clear() {
 		m_Sounds.clear();
-		m_CurrentSound = 0;
+		m_SelectedSounds.clear();
 		m_PlayingChannels.clear();
 		m_Loops = 0;
 		m_Priority = AudioMan::PRIORITY_LOW;
 		m_AffectedByGlobalPitch = true;
-		m_Hash = 0;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -26,13 +25,11 @@ namespace RTE {
 			m_Sounds.push_back(*itr);
 		}
 
-		m_CurrentSound = reference.m_CurrentSound;
+		m_SelectedSounds = reference.m_SelectedSounds;
 		m_PlayingChannels.clear();
 		m_Loops = reference.m_Loops;
 		m_Priority = reference.m_Priority;
 		m_AffectedByGlobalPitch = reference.m_AffectedByGlobalPitch;
-		m_Hash = reference.m_Hash;
-
 
 		return 0;
 	}
@@ -43,7 +40,6 @@ namespace RTE {
 		if (propName == "AddSample" || propName == "AddSound") {
 			ContentFile newFile;
 			reader >> newFile;
-			m_Hash = newFile.GetHash();
 
 			FMOD::Sound *pNewSample = newFile.GetAsSample();
 			if (!pNewSample) {
@@ -77,6 +73,24 @@ namespace RTE {
 		}
 	}
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	
+	std::vector<std::size_t> SoundContainer::GetSelectedSoundHashes() {
+		std::vector<std::size_t> soundHashes;
+		for (std::size_t selectedSoundIndex : m_SelectedSounds) {
+			soundHashes.push_back(m_Sounds[selectedSoundIndex].first.GetHash());
+		}
+		return soundHashes;
+	}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	std::vector<FMOD::Sound *> SoundContainer::GetSelectedSoundObjects() {
+ 		std::vector<FMOD::Sound *> soundObjects;
+		for (std::size_t selectedSoundIndex : m_SelectedSounds) {
+			soundObjects.push_back(m_Sounds[selectedSoundIndex].second);
+		}
+		return soundObjects;
 	}
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Entities/SoundContainer.h

@@ -105,7 +105,7 @@ namespace RTE {
 		/// Gets the current list of sounds in the SoundContainer.
 		/// </summary>
 		/// <returns>A reference to the list.</returns>
-		std::vector<std::pair<ContentFile, FMOD::Sound *>> GetSounds() const { return m_Sounds; }
+		const std::vector<std::pair<ContentFile, FMOD::Sound *>> *GetSounds() const { return &m_Sounds; }
 
 		/// <summary>
 		/// Shows whether this SoundContainer has been initialized at all yet and loaded with any samples.
@@ -132,28 +132,34 @@ namespace RTE {
 		int GetPlayingSoundCount() { return m_PlayingChannels.size(); }
 
 		/// <summary>
-		/// Gets the index in the internal sound group of the currently playing sound in this SoundContainer.
+		/// Gets a vector of hashes of the sounds selected to be played next in this SoundContainer.
 		/// </summary>
-		/// <returns>The currently playing sound.</returns>
-		int GetCurrentSound() { return m_CurrentSound; }
+		/// <returns>The currently playing sounds hashes.</returns>
+		std::vector<std::size_t> GetSelectedSoundHashes();
+
+		/// <summary>
+		/// Gets a vector of the sounds objects selected to be played next in this SoundContainer.
+		/// </summary>
+		/// <returns>The currently playing sound objects.</returns>
+		std::vector<FMOD::Sound *> GetSelectedSoundObjects();
 
 		/// <summary>
 		/// Gets the channels playing sounds from this SoundContainer.
 		/// </summary>
 		/// <returns>The channels currently being used.</returns>
-		std::unordered_set<short int> GetPlayingChannels() { return m_PlayingChannels; }
+		std::unordered_set<unsigned short int> *GetPlayingChannels() { return &m_PlayingChannels; }
 
 		/// <summary>
 		/// Adds a channel index to the SoundContainer's collection of playing channels.
 		/// </summary>
 		/// <param name="channel">The channel index to add.</param>
-		void AddPlayingChannel(int channel) { m_PlayingChannels.insert(channel); }
+		void AddPlayingChannel(unsigned short int channel) { m_PlayingChannels.insert(channel); RTEAssert(m_PlayingChannels.size() <= c_MaxPlayingSoundsPerContainer, "Tried to play more than " + std::to_string(c_MaxPlayingSoundsPerContainer) + " sounds in SoundContainer " + GetPresetName()); }
 
 		/// <summary>
 		/// Removes a channel index from the SoundContainer's collection of playing channels.
 		/// </summary>
 		/// <param name="channel">The channel index to remove.</param>
-		void RemovePlayingChannel(int channel) { m_PlayingChannels.erase(channel); }
+		void RemovePlayingChannel(unsigned short int channel) { m_PlayingChannels.erase(channel); }
 
 		/// <summary>
 		/// Updates the distance attenuation of the SoundContainer's sounds while they're playing.
@@ -198,12 +204,6 @@ namespace RTE {
 		/// </summary>
 		/// <param name="pitched">Whether the sounds in this SoundContainer should be affected by global pitch or not.</param>
 		void SetAffectedByGlobalPitch(bool affectedByGlobalPitch) { m_AffectedByGlobalPitch = affectedByGlobalPitch; }
-
-		/// <summary>
-		/// Gets the hash for this SoundContainer, used for multiplayer data
-		/// </summary>
-		/// <returns>The hash for this SoundContainer</returns>
-		size_t GetHash() { return m_Hash; }
 #pragma endregion
 
 #pragma region Playback Controls
@@ -239,36 +239,33 @@ namespace RTE {
 		/// </summary>
 		/// <param name="player">Player to stop playback of this SoundContainer for.</param>
 		/// <returns>Whether this SoundContainer successfully stopped playing.</returns>
-		bool Stop(int player) { return HasAnySounds() ? g_AudioMan.StopSound(this, player) : false; }
+		bool Stop(int player) { return (HasAnySounds() && IsBeingPlayed()) ? g_AudioMan.StopSound(this, player) : false; }
 
 		/// <summary>
-		/// Selects, saves and returns the next sound of this SoundContainer to be played.
+		/// Selects the next sounds of this SoundContainer to be played.
 		/// </summary>
-		/// <returns>A pointer to the sound to be played. Ownership is NOT transferred.</returns>
-		FMOD::Sound * SelectNextSound();
+		bool SelectNextSounds();
 
 		/// <summary>
 		/// Fades out playback of the SoundContainer to 0 volume.
 		/// </summary>
 		/// <param name="fadeOutTime">How long the fadeout should take.</param>
-		void FadeOut(int fadeOutTime = 1000) { if (HasAnySounds()) { return g_AudioMan.FadeOutSound(this, fadeOutTime); } }
+		void FadeOut(int fadeOutTime = 1000) { if (IsBeingPlayed()) { return g_AudioMan.FadeOutSound(this, fadeOutTime); } }
 #pragma endregion
 
 	protected:
+
 		static Entity::ClassInfo m_sClass; //!< ClassInfo for this class.
 
 		std::vector<std::pair<ContentFile, FMOD::Sound *>> m_Sounds; // All the FMOD Sound objects in this SoundContainer, paired with their appropriate ContentFile. The sound objects within are owned by the ContentFile static maps
+		std::vector<size_t> m_SelectedSounds; //!< Vector of the indices of all selected sounds
 
-		//TODO change this to be a list/vector of sounds
-		int m_CurrentSound; //!< Sound group index of the current (or last played if nothing is being played) sound being played
-		std::unordered_set<short int> m_PlayingChannels; //!< The channels this SoundContainer is currently using
+		std::unordered_set<unsigned short int> m_PlayingChannels; //!< The channels this SoundContainer is currently using
 
 		int m_Loops; //!< Number of loops (repeats) the SoundContainer's sounds should play when played. 0 means it plays once, -1 means it plays until stopped 
 		int m_Priority; //!< The mixing priority of this SoundContainer's sounds. Higher values are more likely to be heard
 		bool m_AffectedByGlobalPitch; //!< Whether this SoundContainer's sounds should be able to be altered by global pitch changes
 
-		size_t m_Hash; //!< Sound file hash for network transmission.
-
 	private:
 		/// <summary>
 		/// Clears all the member variables of this SoundContainer, effectively resetting the members of this abstraction level only.

Managers/AudioMan.cpp

@@ -258,8 +258,8 @@ namespace RTE {
 		FMOD_RESULT result;
 		FMOD::Channel *soundChannel;
 
-		std::unordered_set<short int> channels = pSoundContainer->GetPlayingChannels();
-		for (std::unordered_set<short int>::iterator channelIterator = channels.begin(); channelIterator != channels.end(); ++channelIterator) {
+		std::unordered_set<unsigned short int> const *channels = pSoundContainer->GetPlayingChannels();
+		for (std::unordered_set<unsigned short int>::iterator channelIterator = channels->begin(); channelIterator != channels->end(); ++channelIterator) {
 			result = m_AudioSystem->getChannel((*channelIterator), &soundChannel);
 			if (result == FMOD_OK) {
 				soundChannel->setPitch(pitch);
@@ -471,8 +471,8 @@ namespace RTE {
 		bool anySoundsPlaying = pSoundContainer->IsBeingPlayed();
 
 		if (anySoundsPlaying) {
-			std::unordered_set<short int> channels = pSoundContainer->GetPlayingChannels();
-			for (std::unordered_set<short int>::iterator channelIterator = channels.begin(); channelIterator != channels.end(); ++channelIterator) {
+			std::unordered_set<unsigned short int> const *channels = pSoundContainer->GetPlayingChannels();
+			for (std::unordered_set<unsigned short int>::iterator channelIterator = channels->begin(); channelIterator != channels->end();) {
 				result = m_AudioSystem->getChannel((*channelIterator), &soundChannel);
 				result = result == FMOD_OK ? soundChannel->stop() : result;
 				if (result != FMOD_OK) {
@@ -509,8 +509,8 @@ namespace RTE {
 		unsigned long long parentClock;
 		float currentVolume;
 
-		std::unordered_set<short int> channels = pSoundContainer->GetPlayingChannels();
-		for (std::unordered_set<short int>::iterator channelIterator = channels.begin(); channelIterator != channels.end(); ++channelIterator) {
+		std::unordered_set<unsigned short int> const *channels = pSoundContainer->GetPlayingChannels();
+		for (std::unordered_set<unsigned short int>::iterator channelIterator = channels->begin(); channelIterator != channels->end(); ++channelIterator) {
 			result = m_AudioSystem->getChannel((*channelIterator), &soundChannel);
 			result = result == FMOD_OK ? soundChannel->getDSPClock(nullptr, &parentClock) : result;
 			result = result == FMOD_OK ? soundChannel->getVolume(&currentVolume) : result;

System/Constants.h

@@ -33,6 +33,10 @@ namespace RTE {
 	static constexpr float c_SixteenthPI = 0.1963495;
 #pragma endregion
 
+#pragma region Audio Constants
+	static constexpr unsigned short int c_NumberOfAudioChannels = 512;
+#pragma endregion
+
 #pragma region Network Constants
 	static constexpr unsigned short int c_MaxClients = 4;
 #pragma endregion