Merge pull request #225 from Silverlan/develop

Author: Silverlan

cmake/fetch_modules.cmake

@@ -28,7 +28,7 @@ endif()
 
 if(PRAGMA_WITH_COMMON_MODULES)
     pr_fetch_module("pr_bullet"                    "https://github.com/Silverlan/pr_bullet.git"           "a1097f685ba2d18cb4397c48d17f3e7615b376db")
-    pr_fetch_module("pr_audio_soloud"              "https://github.com/Silverlan/pr_soloud.git"           "6e2b627232abc0410d92c614f767ca4759c0104a")
+    pr_fetch_module("pr_audio_soloud"              "https://github.com/Silverlan/pr_soloud.git"           "9bb3405fb73033402ae12b5bde09c5deb8de295c")
     pr_fetch_module("pr_audio_dummy"               "https://github.com/Silverlan/pr_audio_dummy.git"      "c54a035cf61f4c47f88bd6274e43e54054e6cb21")
     pr_fetch_module("pr_prosper_opengl"            "https://github.com/Silverlan/pr_prosper_opengl.git"   "54a9860dba94a73610e069c3d7dad627ded6c5e3")
 endif()

core/client/src/implementation/engine/engine.cpp

@@ -1117,13 +1117,8 @@ bool pragma::CEngine::Initialize(int argc, char *argv[])
 		m_gpuProfilingStageManager->InitializeProfilingStageManager(gpuProfiler);
 	});
 
-	try {
-		InitializeSoundEngine();
-	}
-	catch(const std::runtime_error &err) {
-		criticalFailure(std::format("Failed to initialize audio engine: {}. {} will now exit.", err.what(), engine_info::get_name()));
+	if(!InitializeSoundEngine())
 		return false;
-	}
 
 	OpenClientState();
 	register_game_shaders(); // Preload game shaders

core/client/src/implementation/engine/sound.cpp

@@ -9,54 +9,73 @@ import :audio;
 const pragma::audio::ISoundSystem *pragma::CEngine::GetSoundSystem() const { return const_cast<CEngine *>(this)->GetSoundSystem(); }
 pragma::audio::ISoundSystem *pragma::CEngine::GetSoundSystem() { return m_soundSystem.get(); }
 
-pragma::audio::ISoundSystem *pragma::CEngine::InitializeSoundEngine()
+static std::pair<std::string, std::string> get_audio_api_path(std::string_view audioAPI)
 {
-	spdlog::info("Initializing sound engine...");
+	auto location = pragma::audio::get_audio_api_module_location(std::string {audioAPI});
+	auto modulePath = pragma::util::get_normalized_module_path(location);
+	return {std::move(location), std::move(modulePath)};
+}
 
-	auto &audioAPI = GetAudioAPI();
-	auto getAudioApiPath = [](const std::string &audioAPI, std::string &outLocation, std::string &outModulePath) {
-		outLocation = audio::get_audio_api_module_location(audioAPI);
-		outModulePath = util::get_normalized_module_path(outLocation);
-	};
-	auto loadAudioApiModule = [this, &getAudioApiPath](const std::string &audioAPI, std::string &outErr) -> bool {
-		std::string location;
-		std::string modulePath;
-		getAudioApiPath(audioAPI, location, modulePath);
-		m_audioAPILib = util::load_library_module(modulePath, util::get_default_additional_library_search_directories(modulePath), {}, &outErr);
-		return (m_audioAPILib != nullptr);
-	};
+static std::expected<std::shared_ptr<pragma::util::Library>, std::string> load_audio_library_module(std::string_view audioAPI, std::string_view modulePath)
+{
 	std::string err;
-	std::vector<std::string> fallbackApis {audioAPI, "soloud", "dummy"};
-	for(auto &apiName : fallbackApis) {
-		m_audioAPI = apiName;
-		if(loadAudioApiModule(apiName, err))
-			break;
-		spdlog::warn("Failed to load audio API '{}': {}", audioAPI, err);
-	}
+	auto lib = pragma::util::load_library_module(std::string {modulePath}, pragma::util::get_default_additional_library_search_directories(std::string {modulePath}), {}, &err);
+	if(!lib)
+		return std::unexpected {err};
+	return lib;
+}
+
+struct SoundSystemInfo {
+	std::shared_ptr<pragma::audio::ISoundSystem> soundSystem;
+	std::shared_ptr<pragma::util::Library> library;
+};
+static std::expected<SoundSystemInfo, std::string> load_audio_library(std::string_view audioAPI)
+{
+	auto [location, modulePath] = get_audio_api_path(audioAPI);
+	auto lib = load_audio_library_module(audioAPI, modulePath);
+	if(!lib)
+		return std::unexpected {std::format("Failed to load audio library '{}': {}", modulePath, lib.error())};
+
+	auto fInitAudioAPI = (*lib)->FindSymbolAddress<bool (*)(float, std::shared_ptr<pragma::audio::ISoundSystem> &, std::string &)>("initialize_audio_api");
+	if(!fInitAudioAPI)
+		return std::unexpected {std::format("Symbol 'initialize_audio_api' not found in audio library '{}'!", modulePath)};
 
-	if(!m_audioAPILib)
-		Con::CRIT << "No valid audio module found!" << Con::endl;
-	auto lib = m_audioAPILib;
-	std::string location;
-	std::string modulePath;
-	getAudioApiPath(audioAPI, location, modulePath);
+	std::string errMsg;
+	std::shared_ptr<pragma::audio::ISoundSystem> soundSystem;
+	auto success = fInitAudioAPI(pragma::units_to_metres(1.f), soundSystem, errMsg);
+	if(!success || !soundSystem)
+		return std::unexpected {std::format("Failed to initialize audio library '{}': {}!", modulePath, errMsg)};
+	return SoundSystemInfo {soundSystem, lib.value()};
+}
+
+pragma::audio::ISoundSystem *pragma::CEngine::InitializeSoundEngine()
+{
+	spdlog::info("Initializing sound engine...");
 
-	if(lib != nullptr) {
-		spdlog::info("Loading audio module '{}'...", location);
-		auto fInitAudioAPI = lib->FindSymbolAddress<bool (*)(float, std::shared_ptr<audio::ISoundSystem> &, std::string &)>("initialize_audio_api");
-		if(fInitAudioAPI == nullptr)
-			err = "Symbol 'initialize_audio_api' not found in library '" + location + "'!";
-		else {
-			std::string errMsg;
-			auto success = fInitAudioAPI(units_to_metres(1.f), m_soundSystem, errMsg);
-			if(success == false)
-				err = errMsg;
+	auto &baseAudioAPI = GetAudioAPI();
+	std::vector<std::string> fallbackApis {};
+	if(baseAudioAPI != "soloud")
+		fallbackApis.push_back("soloud");
+	if(baseAudioAPI != "dummy")
+		fallbackApis.push_back("dummy");
+	for(auto &audioAPI : fallbackApis) {
+		spdlog::info("Loading audio library '{}'...", audioAPI);
+		auto res = load_audio_library(audioAPI);
+		if(!res) {
+			spdlog::warn("Failed to load audio library '{}': {}", audioAPI, res.error());
+			continue;
 		}
+		auto &info = res.value();
+		m_audioAPI = audioAPI;
+		m_soundSystem = info.soundSystem;
+		m_audioAPILib = info.library;
 	}
-	else
-		err = "Module '" + modulePath + "' not found!";
-	if(m_soundSystem == nullptr)
-		throw std::runtime_error {"Unable to load audio implementation library: " + err + "!"};
+
+	if(!m_soundSystem) {
+		CriticalFailure("Failed to initialize sound system: No audio library could be loaded. See log messages for more information.");
+		return nullptr;
+	}
+
 	m_soundSystem->SetSoundSourceFactory([](const audio::PSoundChannel &channel) -> audio::PSoundSource { return audio::CALSound::Create(get_cengine()->GetClientState(), channel); });
 	audio::set_world_scale(units_to_metres(1.0));
 	return m_soundSystem.get();

core/shared/src/implementation/engine/engine.cpp

@@ -584,7 +584,7 @@ void pragma::Engine::Tick()
 void pragma::Engine::CriticalFailure(std::string_view message, bool shouldExit)
 {
 	spdlog::error(message);
-	debug::show_message_prompt(std::string {message}, debug::MessageBoxButtons::Ok, "Critial Failure");
+	debug::show_message_prompt(std::string {message}, debug::MessageBoxButtons::Ok, "Critical Failure");
 	Close();
 	Release();
 	util::sleep_for_seconds(5);