Refractor

vkedwardli · vkedwardli · commit 6d1cf6fe3312 · 2025-12-02T00:50:20.000+08:00
diff --git a/core/emulator.cpp b/core/emulator.cpp
@@ -752,7 +752,7 @@ void Emulator::unloadGame()
 		settings.content.fileName.clear();
 		settings.content.title.clear();
 		settings.platform.system = DC_PLATFORM_DREAMCAST;
-		custom_texture.Terminate();
+		custom_texture.terminate();
 		state = Init;
 		EventManager::event(Event::Terminate);
 	}
@@ -776,7 +776,7 @@ void Emulator::term()
 			delete recompiler;
 			recompiler = nullptr;
 		}
-		custom_texture.Terminate();	// lr: avoid deadlock on exit (win32)
+		custom_texture.terminate();	// lr: avoid deadlock on exit (win32)
 		reios_term();
 		aica::term();
 		pvr::term();
@@ -852,7 +852,7 @@ void loadGameSpecificSettings()
 	loadSpecialSettings();
 
 	config::Settings::instance().setGameId(settings.content.gameId);
-	custom_texture.Init();
+	custom_texture.init();
 
 	// Reload per-game settings
 	config::Settings::instance().load(true);
@@ -885,7 +885,7 @@ void Emulator::stepRange(u32 from, u32 to)
 void Emulator::loadstate(Deserializer& deser)
 {
 	if (!custom_texture.preloaded())
-		custom_texture.Terminate();
+		custom_texture.terminate();
 #if FEAT_AREC == DYNAREC_JIT
 	aica::arm::recompiler::flush();
 #endif
@@ -1122,7 +1122,7 @@ void Emulator::diskChange()
 	cheatManager.reset(settings.content.gameId);
 	if (cheatManager.isWidescreen())
 		config::ScreenStretching.override(134);	// 4:3 -> 16:9
-	custom_texture.Terminate();
+	custom_texture.terminate();
 	EventManager::event(Event::DiskChange);
 }
 
diff --git a/core/rend/CustomTexture.cpp b/core/rend/CustomTexture.cpp
@@ -54,13 +54,12 @@ class CustomTextureSource : public BaseCustomTextureSource
 			}
 		}
 	}
-	bool customTexturesAvailable() override { return custom_textures_available; }
-	bool shouldReplace() const override { return config::CustomTextures; }
-	bool shouldPreload() const override { return config::CustomTextures && config::PreloadCustomTextures; }
-	bool LoadMap() override;
-	size_t GetTextureCount() const override { return texture_map.size(); }
+	bool shouldReplace() const override { return config::CustomTextures && custom_textures_available; }
+	bool shouldPreload() const override { return shouldReplace() && config::PreloadCustomTextures; }
+	bool loadMap() override;
+	size_t getTextureCount() const override { return texture_map.size(); }
 	void PreloadTextures(TextureCallback callback, std::atomic<bool>* stop_flag) override;
-	u8* LoadCustomTexture(u32 hash, int& width, int& height) override;
+	u8* loadCustomTexture(u32 hash, int& width, int& height) override;
 	bool isTextureReplaced(u32 hash) override final;
 	
 	
@@ -71,7 +70,7 @@ class CustomTextureSource : public BaseCustomTextureSource
 	std::map<u32, std::string> texture_map;
 };
 
-bool CustomTextureSource::LoadMap()
+bool CustomTextureSource::loadMap()
 {
 	texture_map.clear();
 	hostfs::DirectoryTree tree(textures_path);
@@ -98,10 +97,10 @@ void CustomTextureSource::PreloadTextures(TextureCallback callback, std::atomic<
 {
 	for (auto const& [hash, path] : texture_map)
 	{
-		if (stop_flag != nullptr && stop_flag->load(std::memory_order_relaxed))
+		if (stop_flag != nullptr && *stop_flag)
 			return;
 		int w, h;
-		u8* data = LoadCustomTexture(hash, w, h);
+		u8* data = loadCustomTexture(hash, w, h);
 		if (data != nullptr)
 		{
 			size_t size = (size_t)w * h * 4;
@@ -116,7 +115,7 @@ void CustomTextureSource::PreloadTextures(TextureCallback callback, std::atomic<
 	}
 }
 
-u8* CustomTextureSource::LoadCustomTexture(u32 hash, int& width, int& height)
+u8* CustomTextureSource::loadCustomTexture(u32 hash, int& width, int& height)
 {
 	auto it = texture_map.find(hash);
 	if (it == texture_map.end())
@@ -173,60 +172,60 @@ std::string CustomTexture::getGameId()
    return game_id;
 }
 
-bool CustomTexture::Init()
+bool CustomTexture::init()
 {
 	if (!initialized)
 	{
-		stop_preload.store(false, std::memory_order_relaxed);
+		stop_preload = false;
 		resetPreloadProgress();
-		pending_preloads.store(0, std::memory_order_relaxed);
+		pending_preloads = 0;
 		initialized = true;
 
 		std::string game_id = getGameId();
 		if (game_id.length() > 0)
 		{
-			AddSource(std::make_unique<CustomTextureSource>(game_id));
+			addSource(std::make_unique<CustomTextureSource>(game_id));
 		}
 	}
 
 	return loaderThread != nullptr;
 }
 
 bool CustomTexture::enabled() {
-	return Init();
+	return loaderThread != nullptr;
 }
 
 bool CustomTexture::preloaded() {
-	return preload_total.load(std::memory_order_relaxed) > 0;
+	return preload_total > 0;
 }
 
 bool CustomTexture::isPreloading() {
-	if (pending_preloads.load(std::memory_order_relaxed) > 0)
+	if (pending_preloads > 0)
 		return true;
 
 	int texLoaded = 0;
 	int texTotal = 0;
 	size_t loaded_size_b = 0;
-	GetPreloadProgress(texLoaded, texTotal, loaded_size_b);
+	getPreloadProgress(texLoaded, texTotal, loaded_size_b);
 	
 	return (texTotal > 0 && texLoaded < texTotal);
 }
 
-void CustomTexture::AddSource(std::unique_ptr<BaseCustomTextureSource> source)
+void CustomTexture::addSource(std::unique_ptr<BaseCustomTextureSource> source)
 {
 	BaseCustomTextureSource* ptr = source.get();
 	sources.emplace_back(std::move(source));
 	
 	if (initialized)
 	{
-		if (!loaderThread && ptr->customTexturesAvailable())
+		if (!loaderThread && ptr->shouldReplace())
 		{
 			loaderThread = std::make_unique<WorkerThread>("CustomTexLoader");
 		}
 		if (loaderThread)
 		{
 			if (ptr->shouldPreload())
-				pending_preloads.fetch_add(1, std::memory_order_relaxed);
+				pending_preloads++;
 			loaderThread->run([this, ptr]() {
 				prepareSource(ptr);
 			});
@@ -235,29 +234,19 @@ void CustomTexture::AddSource(std::unique_ptr<BaseCustomTextureSource> source)
 }
 
 CustomTexture::~CustomTexture() {
-	Terminate();
+	terminate();
 }
 
-void CustomTexture::Terminate()
+void CustomTexture::terminate()
 {
-	stop_preload.store(true, std::memory_order_relaxed);
+	stop_preload = true;
 	if (loaderThread)
 		loaderThread->stop();
 	loaderThread.reset();
 	for (auto& source : sources)
-		source->Terminate();
+		source->terminate();
 	sources.clear();
-	if (!preloaded_textures.empty())
-	{
-#ifndef LIBRETRO
-		auto textures_to_free = std::make_shared<std::map<u32, TextureData>>(std::move(preloaded_textures));
-		std::thread([textures_to_free]() {
-			textures_to_free->clear();
-		}).detach();
-#else
-		preloaded_textures.clear();
-#endif
-	}
+	preloaded_textures.clear();
 	resetPreloadProgress();
 	initialized = false;
 }
@@ -282,7 +271,7 @@ u8* CustomTexture::loadTexture(u32 hash, int& width, int& height)
 		auto& source = *it;
 		if (source->shouldReplace())
 		{
-			u8* data = source->LoadCustomTexture(hash, width, height);
+			u8* data = source->loadCustomTexture(hash, width, height);
 			if (data != nullptr)
 				return data;
 		}
@@ -315,9 +304,9 @@ bool CustomTexture::isTextureReplaced(BaseTextureCacheData* texture)
 	return false;
 }
 
-void CustomTexture::LoadCustomTextureAsync(BaseTextureCacheData *texture_data)
+void CustomTexture::loadCustomTextureAsync(BaseTextureCacheData *texture_data)
 {
-	if (!Init())
+	if (!init())
 		return;
 
 	texture_data->custom_load_in_progress++;
@@ -326,7 +315,7 @@ void CustomTexture::LoadCustomTextureAsync(BaseTextureCacheData *texture_data)
 	});
 }
 
-void CustomTexture::DumpTexture(BaseTextureCacheData* texture, int w, int h, void *src_buffer)
+void CustomTexture::dumpTexture(BaseTextureCacheData* texture, int w, int h, void *src_buffer)
 {
 	if (!config::DumpReplacedTextures.get() && isTextureReplaced(texture))
 		return;
@@ -463,47 +452,43 @@ void CustomTexture::DumpTexture(BaseTextureCacheData* texture, int w, int h, voi
 
 void CustomTexture::prepareSource(BaseCustomTextureSource* source)
 {
-	struct PreloadGuard {
-		std::atomic<int>& counter;
-		bool shouldPreload;
-		~PreloadGuard() { if (shouldPreload) counter.fetch_sub(1, std::memory_order_relaxed); }
-	} guard{ pending_preloads, source->shouldPreload() };
+	bool should_preload = source->shouldPreload();
 
-	if (stop_preload.load(std::memory_order_relaxed))
-		return;
-
-	if (source->LoadMap())
+	if (!stop_preload && source->loadMap())
 	{
-		if (guard.shouldPreload)
+		if (should_preload)
 		{
-			int count = static_cast<int>(source->GetTextureCount());
+			int count = static_cast<int>(source->getTextureCount());
 			if (count > 0)
 			{
-				preload_total.fetch_add(count, std::memory_order_relaxed);
+				preload_total += count;
 				auto callback = [this](u32 hash, TextureData&& data) {
 					size_t size = data.data.size();
 					preloaded_textures[hash] = std::move(data);
-					preload_loaded.fetch_add(1, std::memory_order_relaxed);
-					preload_loaded_size.fetch_add(size, std::memory_order_relaxed);
+					preload_loaded++;
+					preload_loaded_size += size;
 				};
 				source->PreloadTextures(callback, &stop_preload);
 			}
 		}
 	}
+
+	if (should_preload)
+		pending_preloads--;
 }
 
-void CustomTexture::GetPreloadProgress(int& completed, int& total, size_t& loaded_size) const
+void CustomTexture::getPreloadProgress(int& completed, int& total, size_t& loaded_size) const
 {
-	total = preload_total.load(std::memory_order_relaxed);
-	if (total == 0 && pending_preloads.load(std::memory_order_relaxed) > 0)
+	total = preload_total;
+	if (total == 0 && pending_preloads > 0)
 		total = -1; // Prints Preparing... in UI
-	completed = preload_loaded.load(std::memory_order_relaxed);
-	loaded_size = preload_loaded_size.load(std::memory_order_relaxed);
+	completed = preload_loaded;
+	loaded_size = preload_loaded_size;
 }
 
 void CustomTexture::resetPreloadProgress()
 {
-	preload_total.store(0, std::memory_order_relaxed);
-	preload_loaded.store(0, std::memory_order_relaxed);
-	preload_loaded_size.store(0, std::memory_order_relaxed);
+	preload_total = 0;
+	preload_loaded = 0;
+	preload_loaded_size = 0;
 }
diff --git a/core/rend/CustomTexture.h b/core/rend/CustomTexture.h
@@ -40,13 +40,12 @@ class BaseCustomTextureSource
 	using TextureCallback = std::function<void(u32 hash, TextureData&& data)>;
 
 	virtual ~BaseCustomTextureSource() { }
-	virtual bool customTexturesAvailable() { return true; }
 	virtual bool shouldReplace() const { return false; }
 	virtual bool shouldPreload() const { return false; }
-	virtual bool LoadMap() = 0;
-	virtual size_t GetTextureCount() const { return 0; }
-	virtual void Terminate() { }
-	virtual u8* LoadCustomTexture(u32 hash, int& width, int& height) = 0;
+	virtual bool loadMap() = 0;
+	virtual size_t getTextureCount() const { return 0; }
+	virtual void terminate() { }
+	virtual u8* loadCustomTexture(u32 hash, int& width, int& height) = 0;
 	virtual bool isTextureReplaced(u32 hash) = 0;
 	virtual void PreloadTextures(TextureCallback callback, std::atomic<bool>* stop_flag) { }
 };
@@ -55,15 +54,15 @@ class CustomTexture
 {
 public:
 	~CustomTexture();
-	bool Init();
+	bool init();
 	bool enabled();
 	bool preloaded();
 	bool isPreloading();
-	void AddSource(std::unique_ptr<BaseCustomTextureSource> source);
-	void LoadCustomTextureAsync(BaseTextureCacheData *texture_data);
-	void DumpTexture(BaseTextureCacheData* texture, int w, int h, void *src_buffer);
-	void Terminate();
-	void GetPreloadProgress(int& completed, int& total, size_t& loaded_size) const;
+	void addSource(std::unique_ptr<BaseCustomTextureSource> source);
+	void loadCustomTextureAsync(BaseTextureCacheData *texture_data);
+	void dumpTexture(BaseTextureCacheData* texture, int w, int h, void *src_buffer);
+	void terminate();
+	void getPreloadProgress(int& completed, int& total, size_t& loaded_size) const;
 
 private:
 	u8* loadTexture(u32 hash, int& width, int& height);
diff --git a/core/rend/TexCache.cpp b/core/rend/TexCache.cpp
@@ -516,7 +516,7 @@ bool BaseTextureCacheData::Update()
 			size = originalSize;
 			return true;
 		}
-		custom_texture.LoadCustomTextureAsync(this);
+		custom_texture.loadCustomTextureAsync(this);
 	}
 
 	void *temp_tex_buffer = NULL;
@@ -676,7 +676,7 @@ bool BaseTextureCacheData::Update()
 	if (config::DumpTextures)
 	{
 		ComputeHash();
-		custom_texture.DumpTexture(this, upscaled_w, upscaled_h, temp_tex_buffer);
+		custom_texture.dumpTexture(this, upscaled_w, upscaled_h, temp_tex_buffer);
 		NOTICE_LOG(RENDERER, "Dumped texture %x.png. Old hash %x", texture_hash, old_texture_hash);
 	}
 	PrintTextureName();
diff --git a/core/rend/TexCache.h b/core/rend/TexCache.h
@@ -263,7 +263,7 @@ class BaseTextureCache
 	void Clear()
 	{
 		if (!custom_texture.preloaded())
-			custom_texture.Terminate();
+			custom_texture.terminate();
 		for (auto& [id, texture] : cache)
 			texture.Delete();
 
diff --git a/core/ui/gui.cpp b/core/ui/gui.cpp
@@ -1388,7 +1388,7 @@ static void gui_display_loadscreen()
 				int texLoaded = 0;
 				int texTotal = 0;
 				size_t loaded_size_b = 0;
-				custom_texture.GetPreloadProgress(texLoaded, texTotal, loaded_size_b);
+				custom_texture.getPreloadProgress(texLoaded, texTotal, loaded_size_b);
 				
 				ImGui::Text("%s", label);
 				float progress = 0;
diff --git a/core/ui/settings_video.cpp b/core/ui/settings_video.cpp
@@ -213,15 +213,18 @@ void gui_settings_video()
     	OptionCheckbox("Full Framebuffer Emulation", config::EmulateFramebuffer,
     			"Fully accurate VRAM framebuffer emulation. Helps games that directly access the framebuffer for special effects. "
     			"Very slow and incompatible with upscaling and wide screen.");
-    	OptionCheckbox("Load Custom Textures", config::CustomTextures,
-    			"Load custom/high-res textures from data/textures/<game id>");
-		ImGui::Indent();
 		{
-			DisabledScope scope(!config::CustomTextures.get() || game_started);
-			OptionCheckbox("Preload Custom Textures", config::PreloadCustomTextures,
-					"Preload custom textures at game start. May improve performance but increase memory usage");
+			DisabledScope scope(game_started);
+			OptionCheckbox("Load Custom Textures", config::CustomTextures,
+						   "Load custom/high-res textures from data/textures/<game id>");
+			ImGui::Indent();
+			{
+				DisabledScope scope(!config::CustomTextures.get());
+				OptionCheckbox("Preload Custom Textures", config::PreloadCustomTextures,
+							   "Preload custom textures at game start. May improve performance but increases memory usage");
+			}
+			ImGui::Unindent();
 		}
-		ImGui::Unindent();
     }
 	ImGui::Spacing();
     header("Aspect Ratio");
diff --git a/shell/libretro/libretro.cpp b/shell/libretro/libretro.cpp
diff --git a/shell/libretro/libretro_core_options.h b/shell/libretro/libretro_core_options.h

Original file line number	Diff line number	Diff line change
`@@ -54,13 +54,12 @@ class CustomTextureSource : public BaseCustomTextureSource`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`}`
`57`		`- bool customTexturesAvailable() override { return custom_textures_available; }`
`58`		`- bool shouldReplace() const override { return config::CustomTextures; }`
`59`		`- bool shouldPreload() const override { return config::CustomTextures && config::PreloadCustomTextures; }`
`60`		`- bool LoadMap() override;`
`61`		`- size_t GetTextureCount() const override { return texture_map.size(); }`
	`57`	`+ bool shouldReplace() const override { return config::CustomTextures && custom_textures_available; }`
	`58`	`+ bool shouldPreload() const override { return shouldReplace() && config::PreloadCustomTextures; }`
	`59`	`+ bool loadMap() override;`
	`60`	`+ size_t getTextureCount() const override { return texture_map.size(); }`
`62`	`61`	`void PreloadTextures(TextureCallback callback, std::atomic<bool>* stop_flag) override;`
`63`		`- u8* LoadCustomTexture(u32 hash, int& width, int& height) override;`
	`62`	`+ u8* loadCustomTexture(u32 hash, int& width, int& height) override;`
`64`	`63`	`bool isTextureReplaced(u32 hash) override final;`
`65`	`64`
`66`	`65`
`@@ -71,7 +70,7 @@ class CustomTextureSource : public BaseCustomTextureSource`
`71`	`70`	`std::map<u32, std::string> texture_map;`
`72`	`71`	`};`
`73`	`72`
`74`		`-bool CustomTextureSource::LoadMap()`
	`73`	`+bool CustomTextureSource::loadMap()`
`75`	`74`	`{`
`76`	`75`	`texture_map.clear();`
`77`	`76`	`hostfs::DirectoryTree tree(textures_path);`
`@@ -98,10 +97,10 @@ void CustomTextureSource::PreloadTextures(TextureCallback callback, std::atomic<`
`98`	`97`	`{`
`99`	`98`	`for (auto const& [hash, path] : texture_map)`
`100`	`99`	`{`
`101`		`- if (stop_flag != nullptr && stop_flag->load(std::memory_order_relaxed))`
	`100`	`+ if (stop_flag != nullptr && *stop_flag)`
`102`	`101`	`return;`
`103`	`102`	`int w, h;`
`104`		`- u8* data = LoadCustomTexture(hash, w, h);`
	`103`	`+ u8* data = loadCustomTexture(hash, w, h);`
`105`	`104`	`if (data != nullptr)`
`106`	`105`	`{`
`107`	`106`	`size_t size = (size_t)w * h * 4;`
`@@ -116,7 +115,7 @@ void CustomTextureSource::PreloadTextures(TextureCallback callback, std::atomic<`
`116`	`115`	`}`
`117`	`116`	`}`
`118`	`117`
`119`		`-u8* CustomTextureSource::LoadCustomTexture(u32 hash, int& width, int& height)`
	`118`	`+u8* CustomTextureSource::loadCustomTexture(u32 hash, int& width, int& height)`
`120`	`119`	`{`
`121`	`120`	`auto it = texture_map.find(hash);`
`122`	`121`	`if (it == texture_map.end())`
`@@ -173,60 +172,60 @@ std::string CustomTexture::getGameId()`
`173`	`172`	`return game_id;`
`174`	`173`	`}`
`175`	`174`
`176`		`-bool CustomTexture::Init()`
	`175`	`+bool CustomTexture::init()`
`177`	`176`	`{`
`178`	`177`	`if (!initialized)`
`179`	`178`	`{`
`180`		`- stop_preload.store(false, std::memory_order_relaxed);`
	`179`	`+ stop_preload = false;`
`181`	`180`	`resetPreloadProgress();`
`182`		`- pending_preloads.store(0, std::memory_order_relaxed);`
	`181`	`+ pending_preloads = 0;`
`183`	`182`	`initialized = true;`
`184`	`183`
`185`	`184`	`std::string game_id = getGameId();`
`186`	`185`	`if (game_id.length() > 0)`
`187`	`186`	`{`
`188`		`- AddSource(std::make_unique<CustomTextureSource>(game_id));`
	`187`	`+ addSource(std::make_unique<CustomTextureSource>(game_id));`
`189`	`188`	`}`
`190`	`189`	`}`
`191`	`190`
`192`	`191`	`return loaderThread != nullptr;`
`193`	`192`	`}`
`194`	`193`
`195`	`194`	`bool CustomTexture::enabled() {`
`196`		`- return Init();`
	`195`	`+ return loaderThread != nullptr;`
`197`	`196`	`}`
`198`	`197`
`199`	`198`	`bool CustomTexture::preloaded() {`
`200`		`- return preload_total.load(std::memory_order_relaxed) > 0;`
	`199`	`+ return preload_total > 0;`
`201`	`200`	`}`
`202`	`201`
`203`	`202`	`bool CustomTexture::isPreloading() {`
`204`		`- if (pending_preloads.load(std::memory_order_relaxed) > 0)`
	`203`	`+ if (pending_preloads > 0)`
`205`	`204`	`return true;`
`206`	`205`
`207`	`206`	`int texLoaded = 0;`
`208`	`207`	`int texTotal = 0;`
`209`	`208`	`size_t loaded_size_b = 0;`
`210`		`- GetPreloadProgress(texLoaded, texTotal, loaded_size_b);`
	`209`	`+ getPreloadProgress(texLoaded, texTotal, loaded_size_b);`
`211`	`210`
`212`	`211`	`return (texTotal > 0 && texLoaded < texTotal);`
`213`	`212`	`}`
`214`	`213`
`215`		`-void CustomTexture::AddSource(std::unique_ptr<BaseCustomTextureSource> source)`
	`214`	`+void CustomTexture::addSource(std::unique_ptr<BaseCustomTextureSource> source)`
`216`	`215`	`{`
`217`	`216`	`BaseCustomTextureSource* ptr = source.get();`
`218`	`217`	`sources.emplace_back(std::move(source));`
`219`	`218`
`220`	`219`	`if (initialized)`
`221`	`220`	`{`
`222`		`- if (!loaderThread && ptr->customTexturesAvailable())`
	`221`	`+ if (!loaderThread && ptr->shouldReplace())`
`223`	`222`	`{`
`224`	`223`	`loaderThread = std::make_unique<WorkerThread>("CustomTexLoader");`
`225`	`224`	`}`
`226`	`225`	`if (loaderThread)`
`227`	`226`	`{`
`228`	`227`	`if (ptr->shouldPreload())`
`229`		`- pending_preloads.fetch_add(1, std::memory_order_relaxed);`
	`228`	`+ pending_preloads++;`
`230`	`229`	`loaderThread->run([this, ptr]() {`
`231`	`230`	`prepareSource(ptr);`
`232`	`231`	`});`
`@@ -235,29 +234,19 @@ void CustomTexture::AddSource(std::unique_ptr<BaseCustomTextureSource> source)`
`235`	`234`	`}`
`236`	`235`
`237`	`236`	`CustomTexture::~CustomTexture() {`
`238`		`- Terminate();`
	`237`	`+ terminate();`
`239`	`238`	`}`
`240`	`239`
`241`		`-void CustomTexture::Terminate()`
	`240`	`+void CustomTexture::terminate()`
`242`	`241`	`{`
`243`		`- stop_preload.store(true, std::memory_order_relaxed);`
	`242`	`+ stop_preload = true;`
`244`	`243`	`if (loaderThread)`
`245`	`244`	`loaderThread->stop();`
`246`	`245`	`loaderThread.reset();`
`247`	`246`	`for (auto& source : sources)`
`248`		`- source->Terminate();`
	`247`	`+ source->terminate();`
`249`	`248`	`sources.clear();`
`250`		`- if (!preloaded_textures.empty())`
`251`		`- {`
`252`		`-#ifndef LIBRETRO`
`253`		`- auto textures_to_free = std::make_shared<std::map<u32, TextureData>>(std::move(preloaded_textures));`
`254`		`- std::thread([textures_to_free]() {`
`255`		`- textures_to_free->clear();`
`256`		`- }).detach();`
`257`		`-#else`
`258`		`- preloaded_textures.clear();`
`259`		`-#endif`
`260`		`- }`
	`249`	`+ preloaded_textures.clear();`
`261`	`250`	`resetPreloadProgress();`
`262`	`251`	`initialized = false;`
`263`	`252`	`}`
`@@ -282,7 +271,7 @@ u8* CustomTexture::loadTexture(u32 hash, int& width, int& height)`
`282`	`271`	`auto& source = *it;`
`283`	`272`	`if (source->shouldReplace())`
`284`	`273`	`{`
`285`		`- u8* data = source->LoadCustomTexture(hash, width, height);`
	`274`	`+ u8* data = source->loadCustomTexture(hash, width, height);`
`286`	`275`	`if (data != nullptr)`
`287`	`276`	`return data;`
`288`	`277`	`}`
`@@ -315,9 +304,9 @@ bool CustomTexture::isTextureReplaced(BaseTextureCacheData* texture)`
`315`	`304`	`return false;`
`316`	`305`	`}`
`317`	`306`
`318`		`-void CustomTexture::LoadCustomTextureAsync(BaseTextureCacheData *texture_data)`
	`307`	`+void CustomTexture::loadCustomTextureAsync(BaseTextureCacheData *texture_data)`
`319`	`308`	`{`
`320`		`- if (!Init())`
	`309`	`+ if (!init())`
`321`	`310`	`return;`
`322`	`311`
`323`	`312`	`texture_data->custom_load_in_progress++;`
`@@ -326,7 +315,7 @@ void CustomTexture::LoadCustomTextureAsync(BaseTextureCacheData *texture_data)`
`326`	`315`	`});`
`327`	`316`	`}`
`328`	`317`
`329`		`-void CustomTexture::DumpTexture(BaseTextureCacheData* texture, int w, int h, void *src_buffer)`
	`318`	`+void CustomTexture::dumpTexture(BaseTextureCacheData* texture, int w, int h, void *src_buffer)`
`330`	`319`	`{`
`331`	`320`	`if (!config::DumpReplacedTextures.get() && isTextureReplaced(texture))`
`332`	`321`	`return;`
`@@ -463,47 +452,43 @@ void CustomTexture::DumpTexture(BaseTextureCacheData* texture, int w, int h, voi`
`463`	`452`
`464`	`453`	`void CustomTexture::prepareSource(BaseCustomTextureSource* source)`
`465`	`454`	`{`
`466`		`- struct PreloadGuard {`
`467`		`- std::atomic<int>& counter;`
`468`		`- bool shouldPreload;`
`469`		`- ~PreloadGuard() { if (shouldPreload) counter.fetch_sub(1, std::memory_order_relaxed); }`
`470`		`- } guard{ pending_preloads, source->shouldPreload() };`
	`455`	`+ bool should_preload = source->shouldPreload();`
`471`	`456`
`472`		`- if (stop_preload.load(std::memory_order_relaxed))`
`473`		`- return;`
`474`		`-`
`475`		`- if (source->LoadMap())`
	`457`	`+ if (!stop_preload && source->loadMap())`
`476`	`458`	`{`
`477`		`- if (guard.shouldPreload)`
	`459`	`+ if (should_preload)`
`478`	`460`	`{`
`479`		`- int count = static_cast<int>(source->GetTextureCount());`
	`461`	`+ int count = static_cast<int>(source->getTextureCount());`
`480`	`462`	`if (count > 0)`
`481`	`463`	`{`
`482`		`- preload_total.fetch_add(count, std::memory_order_relaxed);`
	`464`	`+ preload_total += count;`
`483`	`465`	`auto callback = [this](u32 hash, TextureData&& data) {`
`484`	`466`	`size_t size = data.data.size();`
`485`	`467`	`preloaded_textures[hash] = std::move(data);`
`486`		`- preload_loaded.fetch_add(1, std::memory_order_relaxed);`
`487`		`- preload_loaded_size.fetch_add(size, std::memory_order_relaxed);`
	`468`	`+ preload_loaded++;`
	`469`	`+ preload_loaded_size += size;`
`488`	`470`	`};`
`489`	`471`	`source->PreloadTextures(callback, &stop_preload);`
`490`	`472`	`}`
`491`	`473`	`}`
`492`	`474`	`}`
	`475`	`+`
	`476`	`+ if (should_preload)`
	`477`	`+ pending_preloads--;`
`493`	`478`	`}`
`494`	`479`
`495`		`-void CustomTexture::GetPreloadProgress(int& completed, int& total, size_t& loaded_size) const`
	`480`	`+void CustomTexture::getPreloadProgress(int& completed, int& total, size_t& loaded_size) const`
`496`	`481`	`{`
`497`		`- total = preload_total.load(std::memory_order_relaxed);`
`498`		`- if (total == 0 && pending_preloads.load(std::memory_order_relaxed) > 0)`
	`482`	`+ total = preload_total;`
	`483`	`+ if (total == 0 && pending_preloads > 0)`
`499`	`484`	`total = -1; // Prints Preparing... in UI`
`500`		`- completed = preload_loaded.load(std::memory_order_relaxed);`
`501`		`- loaded_size = preload_loaded_size.load(std::memory_order_relaxed);`
	`485`	`+ completed = preload_loaded;`
	`486`	`+ loaded_size = preload_loaded_size;`
`502`	`487`	`}`
`503`	`488`
`504`	`489`	`void CustomTexture::resetPreloadProgress()`
`505`	`490`	`{`
`506`		`- preload_total.store(0, std::memory_order_relaxed);`
`507`		`- preload_loaded.store(0, std::memory_order_relaxed);`
`508`		`- preload_loaded_size.store(0, std::memory_order_relaxed);`
	`491`	`+ preload_total = 0;`
	`492`	`+ preload_loaded = 0;`
	`493`	`+ preload_loaded_size = 0;`
`509`	`494`	`}`
Original file line number	Diff line number	Diff line change
`@@ -516,7 +516,7 @@ bool BaseTextureCacheData::Update()`
`516`	`516`	`size = originalSize;`
`517`	`517`	`return true;`
`518`	`518`	`}`
`519`		`- custom_texture.LoadCustomTextureAsync(this);`
	`519`	`+ custom_texture.loadCustomTextureAsync(this);`
`520`	`520`	`}`
`521`	`521`
`522`	`522`	`void *temp_tex_buffer = NULL;`
`@@ -676,7 +676,7 @@ bool BaseTextureCacheData::Update()`
`676`	`676`	`if (config::DumpTextures)`
`677`	`677`	`{`
`678`	`678`	`ComputeHash();`
`679`		`- custom_texture.DumpTexture(this, upscaled_w, upscaled_h, temp_tex_buffer);`
	`679`	`+ custom_texture.dumpTexture(this, upscaled_w, upscaled_h, temp_tex_buffer);`
`680`	`680`	`NOTICE_LOG(RENDERER, "Dumped texture %x.png. Old hash %x", texture_hash, old_texture_hash);`
`681`	`681`	`}`
`682`	`682`	`PrintTextureName();`
Original file line number	Diff line number	Diff line change
`@@ -263,7 +263,7 @@ class BaseTextureCache`
`263`	`263`	`void Clear()`
`264`	`264`	`{`
`265`	`265`	`if (!custom_texture.preloaded())`
`266`		`- custom_texture.Terminate();`
	`266`	`+ custom_texture.terminate();`
`267`	`267`	`for (auto& [id, texture] : cache)`
`268`	`268`	`texture.Delete();`
`269`	`269`