Index: ps/trunk/source/graphics/TerrainTextureEntry.cpp
===================================================================
--- ps/trunk/source/graphics/TerrainTextureEntry.cpp	(revision 28013)
+++ ps/trunk/source/graphics/TerrainTextureEntry.cpp	(revision 28014)
@@ -1,186 +1,186 @@
-/* Copyright (C) 2022 Wildfire Games.
+/* Copyright (C) 2024 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "TerrainTextureEntry.h"
 
 #include "graphics/MaterialManager.h"
 #include "graphics/Terrain.h"
 #include "graphics/TerrainProperties.h"
 #include "graphics/TerrainTextureManager.h"
 #include "graphics/TextureManager.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/CStrInternStatic.h"
 #include "ps/Filesystem.h"
 #include "ps/XML/Xeromyces.h"
 #include "renderer/Renderer.h"
 #include "renderer/SceneRenderer.h"
 
 #include <map>
 
 CTerrainTextureEntry::CTerrainTextureEntry(CTerrainPropertiesPtr properties, const VfsPath& path):
 	m_pProperties(properties),
 	m_BaseColor(0),
 	m_BaseColorValid(false)
 {
 	ENSURE(properties);
 
 	CXeromyces XeroFile;
 	if (XeroFile.Load(g_VFS, path, "terrain_texture") != PSRETURN_OK)
 	{
 		LOGERROR("Terrain xml not found (%s)", path.string8());
 		return;
 	}
 
 	#define EL(x) int el_##x = XeroFile.GetElementID(#x)
 	#define AT(x) int at_##x = XeroFile.GetAttributeID(#x)
 	EL(tag);
 	EL(terrain);
 	EL(texture);
 	EL(textures);
 	EL(material);
 	EL(props);
 	EL(alphamap);
 	AT(file);
 	AT(name);
 	#undef AT
 	#undef EL
 
 	XMBElement root = XeroFile.GetRoot();
 
 	if (root.GetNodeName() != el_terrain)
 	{
 		LOGERROR("Invalid terrain format (unrecognised root element '%s')", XeroFile.GetElementString(root.GetNodeName()));
 		return;
 	}
 
 	std::vector<std::pair<CStr, VfsPath> > samplers;
 	VfsPath alphamap("standard");
 	m_Tag = utf8_from_wstring(path.Basename().string());
 
 	XERO_ITER_EL(root, child)
 	{
 		int child_name = child.GetNodeName();
 
 		if (child_name == el_textures)
 		{
 			XERO_ITER_EL(child, textures_element)
 			{
 				ENSURE(textures_element.GetNodeName() == el_texture);
 
 				CStr name;
 				VfsPath terrainTexturePath;
 				XERO_ITER_ATTR(textures_element, relativePath)
 				{
 					if (relativePath.Name == at_file)
 						terrainTexturePath = VfsPath("art/textures/terrain") / relativePath.Value.FromUTF8();
 					else if (relativePath.Name == at_name)
 						name = relativePath.Value;
 				}
 				samplers.emplace_back(name, terrainTexturePath);
 				if (name == str_baseTex.string())
 					m_DiffuseTexturePath = terrainTexturePath;
 			}
 
 		}
 		else if (child_name == el_material)
 		{
 			VfsPath mat = VfsPath("art/materials") / child.GetText().FromUTF8();
 			if (CRenderer::IsInitialised())
 				m_Material = g_Renderer.GetSceneRenderer().GetMaterialManager().LoadMaterial(mat);
 		}
 		else if (child_name == el_alphamap)
 		{
 			alphamap = child.GetText().FromUTF8();
 		}
 		else if (child_name == el_props)
 		{
 			CTerrainPropertiesPtr ret (new CTerrainProperties(properties));
 			ret->LoadXml(child, &XeroFile, path);
-			if (ret) m_pProperties = ret;
+			m_pProperties = ret;
 		}
 		else if (child_name == el_tag)
 		{
 			m_Tag = child.GetText();
 		}
 	}
 
 	for (size_t i = 0; i < samplers.size(); ++i)
 	{
 		CTextureProperties texture(samplers[i].second);
 		texture.SetAddressMode(Renderer::Backend::Sampler::AddressMode::REPEAT);
 		texture.SetAnisotropicFilter(true);
 
 		if (CRenderer::IsInitialised())
 		{
 			CTexturePtr texptr = g_Renderer.GetTextureManager().CreateTexture(texture);
 			m_Material.AddSampler(CMaterial::TextureSampler(samplers[i].first, texptr));
 		}
 	}
 
 	if (CRenderer::IsInitialised())
 		m_TerrainAlpha = g_TexMan.LoadAlphaMap(alphamap);
 
 	float texAngle = 0.f;
 	float texSize = 1.f;
 
 	if (m_pProperties)
 	{
 		m_Groups = m_pProperties->GetGroups();
 		texAngle = m_pProperties->GetTextureAngle();
 		texSize = m_pProperties->GetTextureSize();
 	}
 
 	m_TextureMatrix.SetZero();
 	m_TextureMatrix._11 = cosf(texAngle) / texSize;
 	m_TextureMatrix._13 = -sinf(texAngle) / texSize;
 	m_TextureMatrix._21 = -sinf(texAngle) / texSize;
 	m_TextureMatrix._23 = -cosf(texAngle) / texSize;
 	m_TextureMatrix._44 = 1.f;
 
 	GroupVector::iterator it=m_Groups.begin();
 	for (;it!=m_Groups.end();++it)
 		(*it)->AddTerrain(this);
 }
 
 CTerrainTextureEntry::~CTerrainTextureEntry()
 {
 	for (GroupVector::iterator it=m_Groups.begin();it!=m_Groups.end();++it)
 		(*it)->RemoveTerrain(this);
 }
 
 // BuildBaseColor: calculate the root color of the texture, used for coloring minimap, and store
 // in m_BaseColor member
 void CTerrainTextureEntry::BuildBaseColor()
 {
 	// Use the explicit properties value if possible
 	if (m_pProperties && m_pProperties->HasBaseColor())
 	{
 		m_BaseColor=m_pProperties->GetBaseColor();
 		m_BaseColorValid = true;
 		return;
 	}
 
 	// Use the texture color if available
 	if (GetTexture()->TryLoad())
 	{
 		m_BaseColor = GetTexture()->GetBaseColor();
 		m_BaseColorValid = true;
 	}
 }
Index: ps/trunk/source/soundmanager/SoundManager.cpp
===================================================================
--- ps/trunk/source/soundmanager/SoundManager.cpp	(revision 28013)
+++ ps/trunk/source/soundmanager/SoundManager.cpp	(revision 28014)
@@ -1,876 +1,876 @@
-/* Copyright (C) 2021 Wildfire Games.
+/* Copyright (C) 2024 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "ISoundManager.h"
 #include "SoundManager.h"
 #include "data/SoundData.h"
 #include "items/CBufferItem.h"
 #include "items/CSoundItem.h"
 #include "items/CStreamItem.h"
 
 #include "lib/external_libraries/libsdl.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
 #include "ps/ConfigDB.h"
 #include "ps/Filesystem.h"
 #include "ps/Profiler2.h"
 #include "ps/Threading.h"
 #include "ps/XML/Xeromyces.h"
 
 #include <thread>
 
 ISoundManager* g_SoundManager = NULL;
 
 #define SOURCE_NUM 64
 
 #if CONFIG2_AUDIO
 
 class CSoundManagerWorker
 {
 	NONCOPYABLE(CSoundManagerWorker);
 
 public:
 	CSoundManagerWorker()
 	{
 		m_Items = new ItemsList;
 		m_DeadItems = new ItemsList;
 		m_Shutdown = false;
 
 		m_WorkerThread = std::thread(Threading::HandleExceptions<RunThread>::Wrapper, this);
 	}
 
 	~CSoundManagerWorker()
 	{
 		delete m_Items;
 		CleanupItems();
 		delete m_DeadItems;
 	}
 
 	bool Shutdown()
 	{
 		{
 			std::lock_guard<std::mutex> lock(m_WorkerMutex);
 
 			m_Shutdown = true;
 
 			ItemsList::iterator lstr = m_Items->begin();
 			while (lstr != m_Items->end())
 			{
 				delete *lstr;
 				++lstr;
 			}
 
 		}
 
 		m_WorkerThread.join();
 
 		return true;
 	}
 
 	void addItem(ISoundItem* anItem)
 	{
 		std::lock_guard<std::mutex> lock(m_WorkerMutex);
 		m_Items->push_back(anItem);
 	}
 
 	void CleanupItems()
 	{
 		std::lock_guard<std::mutex> lock(m_DeadItemsMutex);
 		AL_CHECK;
 		ItemsList::iterator deadItems = m_DeadItems->begin();
 		while (deadItems != m_DeadItems->end())
 		{
 			delete *deadItems;
 			++deadItems;
 
 			AL_CHECK;
 		}
 		m_DeadItems->clear();
 	}
 
 private:
 	static void RunThread(CSoundManagerWorker* data)
 	{
 		debug_SetThreadName("CSoundManagerWorker");
 		g_Profiler2.RegisterCurrentThread("soundmanager");
 
 		data->Run();
 	}
 
 	void Run()
 	{
 		while (true)
 		{
 			// Handle shutdown requests as soon as possible
 			if (GetShutdown())
 				return;
 
 			int pauseTime = 500;
 			if (g_SoundManager->InDistress())
 				pauseTime = 50;
 
 			{
 				std::lock_guard<std::mutex> workerLock(m_WorkerMutex);
 
 				ItemsList::iterator lstr = m_Items->begin();
 				ItemsList* nextItemList = new ItemsList;
 
 				while (lstr != m_Items->end())
 				{
 					AL_CHECK;
 					if ((*lstr)->IdleTask())
 					{
 						if ((pauseTime == 500) && (*lstr)->IsFading())
 							pauseTime = 100;
 
 						nextItemList->push_back(*lstr);
 					}
 					else
 					{
 						std::lock_guard<std::mutex> deadItemsLock(m_DeadItemsMutex);
 						m_DeadItems->push_back(*lstr);
 					}
 					++lstr;
 
 					AL_CHECK;
 				}
 
 				delete m_Items;
 				m_Items = nextItemList;
 
 				AL_CHECK;
 			}
 			SDL_Delay(pauseTime);
 		}
 	}
 
 	bool GetShutdown()
 	{
 		std::lock_guard<std::mutex> lock(m_WorkerMutex);
 		return m_Shutdown;
 	}
 
 private:
 	// Thread-related members:
 	std::thread m_WorkerThread;
 	std::mutex m_WorkerMutex;
 	std::mutex m_DeadItemsMutex;
 
 	// Shared by main thread and worker thread:
 	// These variables are all protected by a mutexes
 	ItemsList* m_Items;
 	ItemsList* m_DeadItems;
 
 	bool m_Shutdown;
 
 	CSoundManagerWorker(ISoundManager* UNUSED(other)){};
 };
 
 void ISoundManager::CreateSoundManager()
 {
 	if (g_SoundManager)
 		return;
 
 	ALCdevice* device = alcOpenDevice(nullptr);
 	if (!device)
 	{
 		LOGWARNING("No audio device was found.");
 		return;
 	}
 
 	g_SoundManager = new CSoundManager(device);
 	g_SoundManager->StartWorker();
 }
 
 void ISoundManager::SetEnabled(bool doEnable)
 {
 	if (g_SoundManager && !doEnable)
 		SAFE_DELETE(g_SoundManager);
 	else if (!g_SoundManager && doEnable)
 		ISoundManager::CreateSoundManager();
 }
 void ISoundManager::CloseGame()
 {
 	if (CSoundManager* aSndMgr = (CSoundManager*)g_SoundManager)
 		aSndMgr->SetAmbientItem(NULL);
 }
 
 void CSoundManager::al_ReportError(ALenum err, const char* caller, int line)
 {
 	LOGERROR("OpenAL error: %s; called from %s (line %d)\n", alGetString(err), caller, line);
 }
 
 void CSoundManager::al_check(const char* caller, int line)
 {
 	ALenum err = alGetError();
 	if (err != AL_NO_ERROR)
 		al_ReportError(err, caller, line);
 }
 
 Status CSoundManager::ReloadChangedFiles(const VfsPath& UNUSED(path))
 {
 	// TODO implement sound file hotloading
 	return INFO::OK;
 }
 
 /*static*/ Status CSoundManager::ReloadChangedFileCB(void* param, const VfsPath& path)
 {
 	return static_cast<CSoundManager*>(param)->ReloadChangedFiles(path);
 }
 
 CSoundManager::CSoundManager(ALCdevice* device)
 	: m_Context(nullptr), m_Device(device), m_ALSourceBuffer(nullptr),
 	m_CurrentTune(nullptr), m_CurrentEnvirons(nullptr),
 	m_Worker(nullptr), m_DistressMutex(), m_PlayListItems(nullptr), m_SoundGroups(),
 	m_Gain(.5f), m_MusicGain(.5f), m_AmbientGain(.5f), m_ActionGain(.5f), m_UIGain(.5f),
 	m_Enabled(false), m_BufferSize(98304), m_BufferCount(50),
 	m_SoundEnabled(true), m_MusicEnabled(true), m_MusicPaused(false),
 	m_AmbientPaused(false), m_ActionPaused(false),
 	m_RunningPlaylist(false), m_PlayingPlaylist(false), m_LoopingPlaylist(false),
 	m_PlaylistGap(0), m_DistressErrCount(0), m_DistressTime(0)
 {
 	CFG_GET_VAL("sound.mastergain", m_Gain);
 	CFG_GET_VAL("sound.musicgain", m_MusicGain);
 	CFG_GET_VAL("sound.ambientgain", m_AmbientGain);
 	CFG_GET_VAL("sound.actiongain", m_ActionGain);
 	CFG_GET_VAL("sound.uigain", m_UIGain);
 
 	AlcInit();
 
 	if (m_Enabled)
 	{
 		SetMasterGain(m_Gain);
 		InitListener();
 
 		m_PlayListItems = new PlayList;
 	}
 
 	if (!CXeromyces::AddValidator(g_VFS, "sound_group", "audio/sound_group.rng"))
 		LOGERROR("CSoundManager: failed to load grammar file 'audio/sound_group.rng'");
 
 	RegisterFileReloadFunc(ReloadChangedFileCB, this);
 
 	RunHardwareDetection();
 }
 
 CSoundManager::~CSoundManager()
 {
 	UnregisterFileReloadFunc(ReloadChangedFileCB, this);
 
 	if (m_Worker)
 	{
 		AL_CHECK;
 		m_Worker->Shutdown();
 		AL_CHECK;
 		m_Worker->CleanupItems();
 		AL_CHECK;
 
 		delete m_Worker;
 	}
 	AL_CHECK;
 
 	for (const std::pair<const std::wstring, CSoundGroup*>& p : m_SoundGroups)
 		delete p.second;
 	m_SoundGroups.clear();
 
 	if (m_PlayListItems)
 		delete m_PlayListItems;
 
 	if (m_ALSourceBuffer != NULL)
 		delete[] m_ALSourceBuffer;
 
 	if (m_Context)
 		alcDestroyContext(m_Context);
 
 	if (m_Device)
 		alcCloseDevice(m_Device);
 }
 
 void CSoundManager::StartWorker()
 {
 	if (m_Enabled)
 		m_Worker = new CSoundManagerWorker();
 }
 
 Status CSoundManager::AlcInit()
 {
 	Status ret = INFO::OK;
 
 	if(!m_Device)
 		m_Device = alcOpenDevice(nullptr);
 
 	if (m_Device)
 	{
 		ALCint attribs[] = {ALC_STEREO_SOURCES, 16, 0};
 		m_Context = alcCreateContext(m_Device, &attribs[0]);
 
 		if (m_Context)
 		{
 			alcMakeContextCurrent(m_Context);
 			m_ALSourceBuffer = new ALSourceHolder[SOURCE_NUM];
 			ALuint* sourceList = new ALuint[SOURCE_NUM];
 
 			alGenSources(SOURCE_NUM, sourceList);
 			ALCenum err = alcGetError(m_Device);
 
 			if (err == ALC_NO_ERROR)
 			{
 				for (int x = 0; x < SOURCE_NUM; x++)
 				{
 					m_ALSourceBuffer[x].ALSource = sourceList[x];
 					m_ALSourceBuffer[x].SourceItem = NULL;
 				}
 				m_Enabled = true;
 			}
 			else
 			{
 				LOGERROR("error in gensource = %d", err);
 			}
 			delete[] sourceList;
 		}
 	}
 
 	// check if init succeeded.
 	// some OpenAL implementations don't indicate failure here correctly;
 	// we need to check if the device and context pointers are actually valid.
 	ALCenum err = alcGetError(m_Device);
 	const char* dev_name = (const char*)alcGetString(m_Device, ALC_DEVICE_SPECIFIER);
 
 	if (err == ALC_NO_ERROR && m_Device && m_Context)
 		debug_printf("Sound: AlcInit success, using %s\n", dev_name);
 	else
 	{
 		LOGERROR("Sound: AlcInit failed, m_Device=%p m_Context=%p dev_name=%s err=%x\n", (void *)m_Device, (void *)m_Context, dev_name, err);
 
 // FIXME Hack to get around exclusive access to the sound device
 #if OS_UNIX
 		ret = INFO::OK;
 #else
 		ret = ERR::FAIL;
 #endif // !OS_UNIX
 	}
 
 	return ret;
 }
 
 bool CSoundManager::InDistress()
 {
 	std::lock_guard<std::mutex> lock(m_DistressMutex);
 
 	if (m_DistressTime == 0)
 		return false;
 	else if ((timer_Time() - m_DistressTime) > 10)
 	{
 		m_DistressTime = 0;
 // Coming out of distress mode
 		m_DistressErrCount = 0;
 		return false;
 	}
 
 	return true;
 }
 
 void CSoundManager::SetDistressThroughShortage()
 {
 	std::lock_guard<std::mutex> lock(m_DistressMutex);
 
 // Going into distress for normal reasons
 
 	m_DistressTime = timer_Time();
 }
 
 void CSoundManager::SetDistressThroughError()
 {
 	std::lock_guard<std::mutex> lock(m_DistressMutex);
 
 // Going into distress due to unknown error
 
 	m_DistressTime = timer_Time();
 	m_DistressErrCount++;
 }
 
 
 
 ALuint CSoundManager::GetALSource(ISoundItem* anItem)
 {
 	for (int x = 0; x < SOURCE_NUM; x++)
 	{
 		if (!m_ALSourceBuffer[x].SourceItem)
 		{
 			m_ALSourceBuffer[x].SourceItem = anItem;
 			return m_ALSourceBuffer[x].ALSource;
 		}
 	}
 	SetDistressThroughShortage();
 	return 0;
 }
 
 void CSoundManager::ReleaseALSource(ALuint theSource)
 {
 	for (int x = 0; x < SOURCE_NUM; x++)
 	{
 		if (m_ALSourceBuffer[x].ALSource == theSource)
 		{
 			m_ALSourceBuffer[x].SourceItem = NULL;
 			return;
 		}
 	}
 }
 
 long CSoundManager::GetBufferCount()
 {
 	return m_BufferCount;
 }
 long CSoundManager::GetBufferSize()
 {
 	return m_BufferSize;
 }
 
 void CSoundManager::AddPlayListItem(const VfsPath& itemPath)
 {
 	if (m_Enabled)
 		m_PlayListItems->push_back(itemPath);
 }
 
 void CSoundManager::ClearPlayListItems()
 {
 	if (m_Enabled)
 	{
 		if (m_PlayingPlaylist)
 			SetMusicItem(NULL);
 
 		m_PlayingPlaylist = false;
 		m_LoopingPlaylist = false;
 		m_RunningPlaylist = false;
 
 		m_PlayListItems->clear();
 	}
 }
 
 void CSoundManager::StartPlayList(bool doLoop)
 {
 	if (m_Enabled && m_MusicEnabled)
 	{
 		if (m_PlayListItems->size() > 0)
 		{
 			m_PlayingPlaylist = true;
 			m_LoopingPlaylist = doLoop;
 			m_RunningPlaylist = false;
 
 			ISoundItem* aSnd = LoadItem((m_PlayListItems->at(0)));
 			if (aSnd)
 				SetMusicItem(aSnd);
 			else
 				SetMusicItem(NULL);
 		}
 	}
 }
 
 void CSoundManager::SetMasterGain(float gain)
 {
 	if (m_Enabled)
 	{
 		m_Gain = gain;
 		alListenerf(AL_GAIN, m_Gain);
 		AL_CHECK;
 	}
 }
 
 void CSoundManager::SetMusicGain(float gain)
 {
 	m_MusicGain = gain;
 
 	if (m_CurrentTune)
 		m_CurrentTune->SetGain(m_MusicGain);
 }
 void CSoundManager::SetAmbientGain(float gain)
 {
 	m_AmbientGain = gain;
 }
 void CSoundManager::SetActionGain(float gain)
 {
 	m_ActionGain = gain;
 }
 void CSoundManager::SetUIGain(float gain)
 {
 	m_UIGain = gain;
 }
 
 
 ISoundItem* CSoundManager::LoadItem(const VfsPath& itemPath)
 {
 	AL_CHECK;
 
 	if (m_Enabled)
 	{
 		CSoundData* itemData = CSoundData::SoundDataFromFile(itemPath);
 
 		AL_CHECK;
 		if (itemData)
 			return CSoundManager::ItemForData(itemData);
 	}
 
 	return NULL;
 }
 
 ISoundItem* CSoundManager::ItemForData(CSoundData* itemData)
 {
 	AL_CHECK;
 	ISoundItem* answer = NULL;
 
 	AL_CHECK;
 
 	if (m_Enabled && (itemData != NULL))
 	{
 		if (itemData->IsOneShot())
 		{
 			if (itemData->GetBufferCount() == 1)
 				answer = new CSoundItem(itemData);
 			else
 				answer = new CBufferItem(itemData);
 		}
 		else
 		{
 			answer = new CStreamItem(itemData);
 		}
 
-		if (answer && m_Worker)
+		if (m_Worker)
 			m_Worker->addItem(answer);
 	}
 
 	return answer;
 }
 
 void CSoundManager::IdleTask()
 {
 	if (m_Enabled)
 	{
 		if (m_CurrentTune)
 		{
 			m_CurrentTune->EnsurePlay();
 			if (m_PlayingPlaylist && m_RunningPlaylist)
 			{
 				if (m_CurrentTune->Finished())
 				{
 					if (m_PlaylistGap == 0)
 					{
 						m_PlaylistGap = timer_Time() + 15;
 					}
 					else if (m_PlaylistGap < timer_Time())
 					{
 						m_PlaylistGap = 0;
 						PlayList::iterator it = find(m_PlayListItems->begin(), m_PlayListItems->end(), m_CurrentTune->GetName());
 						if (it != m_PlayListItems->end())
 						{
 							++it;
 
 							Path nextPath;
 							if (it == m_PlayListItems->end())
 								nextPath = m_PlayListItems->at(0);
 							else
 								nextPath = *it;
 
 							ISoundItem* aSnd = LoadItem(nextPath);
 							if (aSnd)
 								SetMusicItem(aSnd);
 						}
 					}
 				}
 			}
 		}
 
 		if (m_CurrentEnvirons)
 			m_CurrentEnvirons->EnsurePlay();
 
 		if (m_Worker)
 			m_Worker->CleanupItems();
 	}
 }
 
 ISoundItem*	CSoundManager::ItemForEntity(entity_id_t UNUSED(source), CSoundData* sndData)
 {
 	ISoundItem* currentItem = NULL;
 
 	if (m_Enabled)
 		currentItem = ItemForData(sndData);
 
 	return currentItem;
 }
 
 
 void CSoundManager::InitListener()
 {
 	ALfloat listenerPos[] = {0.0, 0.0, 0.0};
 	ALfloat listenerVel[] = {0.0, 0.0, 0.0};
 	ALfloat	listenerOri[] = {0.0, 0.0, -1.0, 0.0, 1.0, 0.0};
 
 	alListenerfv(AL_POSITION, listenerPos);
 	alListenerfv(AL_VELOCITY, listenerVel);
 	alListenerfv(AL_ORIENTATION, listenerOri);
 
 	alDistanceModel(AL_LINEAR_DISTANCE);
 }
 
 void CSoundManager::PlayGroupItem(ISoundItem* anItem, ALfloat groupGain)
 {
 	if (anItem)
 	{
 		if (m_Enabled && (m_ActionGain > 0))
 		{
 			anItem->SetGain(m_ActionGain * groupGain);
 			anItem->PlayAndDelete();
 			AL_CHECK;
 		}
 	}
 }
 
 void CSoundManager::SetMusicEnabled(bool isEnabled)
 {
 	if (m_CurrentTune && !isEnabled)
 	{
 		m_CurrentTune->FadeAndDelete(1.00);
 		m_CurrentTune = NULL;
 	}
 	m_MusicEnabled = isEnabled;
 }
 
 void CSoundManager::PlayAsGroup(const VfsPath& groupPath, const CVector3D& sourcePos, entity_id_t source, bool ownedSound)
 {
 	// Make sure the sound group is loaded
 	CSoundGroup* group;
 	if (m_SoundGroups.find(groupPath.string()) == m_SoundGroups.end())
 	{
 		group = new CSoundGroup();
 		if (!group->LoadSoundGroup(L"audio/" + groupPath.string()))
 		{
 			LOGERROR("Failed to load sound group '%s'", groupPath.string8());
 			delete group;
 			group = NULL;
 		}
 		// Cache the sound group (or the null, if it failed)
 		m_SoundGroups[groupPath.string()] = group;
 	}
 	else
 	{
 		group = m_SoundGroups[groupPath.string()];
 	}
 
 	// Failed to load group -> do nothing
 	if (group && (ownedSound || !group->TestFlag(eOwnerOnly)))
 		group->PlayNext(sourcePos, source);
 }
 
 void CSoundManager::PlayAsMusic(const VfsPath& itemPath, bool looping)
 {
 	if (m_Enabled)
 	{
 		UNUSED2(looping);
 
 		ISoundItem* aSnd = LoadItem(itemPath);
 		if (aSnd != NULL)
 			SetMusicItem(aSnd);
 	}
 }
 
 void CSoundManager::PlayAsAmbient(const VfsPath& itemPath, bool looping)
 {
 	if (m_Enabled)
 	{
 		UNUSED2(looping);
 		ISoundItem* aSnd = LoadItem(itemPath);
 		if (aSnd != NULL)
 			SetAmbientItem(aSnd);
 	}
 }
 
 
 void CSoundManager::PlayAsUI(const VfsPath& itemPath, bool looping)
 {
 	if (m_Enabled)
 	{
 		IdleTask();
 
 		if (ISoundItem* anItem = LoadItem(itemPath))
 		{
 			if (m_UIGain > 0)
 			{
 				anItem->SetGain(m_UIGain);
 				anItem->SetLooping(looping);
 				anItem->PlayAndDelete();
 			}
 		}
 		AL_CHECK;
 	}
 }
 
 void CSoundManager::Pause(bool pauseIt)
 {
 	PauseMusic(pauseIt);
 	PauseAmbient(pauseIt);
 	PauseAction(pauseIt);
 }
 
 void CSoundManager::PauseMusic(bool pauseIt)
 {
 	if (m_CurrentTune && pauseIt && !m_MusicPaused)
 	{
 		m_CurrentTune->FadeAndPause(1.0);
 	}
 	else if (m_CurrentTune && m_MusicPaused && !pauseIt && m_MusicEnabled)
 	{
 		m_CurrentTune->SetGain(0);
 		m_CurrentTune->Resume();
 		m_CurrentTune->FadeToIn(m_MusicGain, 1.0);
 	}
 	m_MusicPaused = pauseIt;
 }
 
 void CSoundManager::PauseAmbient(bool pauseIt)
 {
 	if (m_CurrentEnvirons && pauseIt)
 		m_CurrentEnvirons->Pause();
 	else if (m_CurrentEnvirons)
 		m_CurrentEnvirons->Resume();
 
 	m_AmbientPaused = pauseIt;
 }
 
 void CSoundManager::PauseAction(bool pauseIt)
 {
 	m_ActionPaused = pauseIt;
 }
 
 void CSoundManager::SetMusicItem(ISoundItem* anItem)
 {
 	if (m_Enabled)
 	{
 		AL_CHECK;
 		if (m_CurrentTune)
 		{
 			m_CurrentTune->FadeAndDelete(2.00);
 			m_CurrentTune = NULL;
 		}
 
 		IdleTask();
 
 		if (anItem)
 		{
 			if (m_MusicEnabled)
 			{
 				m_CurrentTune = anItem;
 				m_CurrentTune->SetGain(0);
 
 				if (m_PlayingPlaylist)
 				{
 					m_RunningPlaylist = true;
 					m_CurrentTune->Play();
 				}
 				else
 					m_CurrentTune->PlayLoop();
 
 				m_MusicPaused = false;
 				m_CurrentTune->FadeToIn(m_MusicGain, 1.00);
 			}
 			else
 			{
 				anItem->StopAndDelete();
 			}
 		}
 		AL_CHECK;
 	}
 }
 
 void CSoundManager::SetAmbientItem(ISoundItem* anItem)
 {
 	if (m_Enabled)
 	{
 		if (m_CurrentEnvirons)
 		{
 			m_CurrentEnvirons->FadeAndDelete(3.00);
 			m_CurrentEnvirons = NULL;
 		}
 		IdleTask();
 
 		if (anItem)
 		{
 			if (m_AmbientGain > 0)
 			{
 				m_CurrentEnvirons = anItem;
 				m_CurrentEnvirons->SetGain(0);
 				m_CurrentEnvirons->PlayLoop();
 				m_CurrentEnvirons->FadeToIn(m_AmbientGain, 2.00);
 			}
 		}
 		AL_CHECK;
 	}
 }
 
 void CSoundManager::RunHardwareDetection()
 {
 	// OpenAL alGetString might not return anything interesting on certain platforms
 	// (see https://stackoverflow.com/questions/28960638 for an example).
 	// However our previous code supported only Windows, and alGetString does work on
 	// Windows, so this is an improvement.
 
 	// Sound cards
 
 	const ALCchar* devices = nullptr;
 	if (alcIsExtensionPresent(nullptr, "ALC_enumeration_EXT") == AL_TRUE)
 	{
 		if (alcIsExtensionPresent(nullptr, "ALC_enumerate_all_EXT") == AL_TRUE)
 			devices = alcGetString(nullptr, ALC_ALL_DEVICES_SPECIFIER);
 		else
 			devices = alcGetString(nullptr, ALC_DEVICE_SPECIFIER);
 	}
 	WARN_IF_FALSE(devices);
 
 	m_SoundCardNames.clear();
 	do
 	{
 		m_SoundCardNames += devices;
 		devices += strlen(devices) + 1;
 		m_SoundCardNames += "; ";
 	} while (*devices);
 
 	// Driver version
 	const ALCchar* al_version = alGetString(AL_VERSION);
 	if (al_version)
 		m_OpenALVersion = al_version;
 }
 
 CStr8 CSoundManager::GetOpenALVersion() const
 {
 	return m_OpenALVersion;
 }
 
 CStr8 CSoundManager::GetSoundCardNames() const
 {
 	return m_SoundCardNames;
 }
 
 #else // CONFIG2_AUDIO
 
 void ISoundManager::CreateSoundManager(){}
 void ISoundManager::SetEnabled(bool UNUSED(doEnable)){}
 void ISoundManager::CloseGame(){}
 void ISoundManager::RunHardwareDetection() {}
 CStr8 ISoundManager::GetSoundCardNames() const { return CStr8(); };
 CStr8 ISoundManager::GetOpenALVersion() const { return CStr8(); };
 #endif // CONFIG2_AUDIO