refactor renderer

src/common/emulatorConfig.cpp

@@ -93,4 +93,8 @@ bool NggRectlistDrawEnabled() {
 	return g_config->ngg_rectlist_draw_enabled;
 }
 
+bool ReadbackLinearImagesEnabled() {
+	return g_config->readback_linear_images;
+}
+
 } // namespace Config

src/common/emulatorConfig.h

@@ -36,6 +36,7 @@ struct ConfigOptions {
 	bool                   spirv_debug_printf_enabled  = false;
 	bool                   renderdoc_enabled           = false;
 	bool                   ngg_rectlist_draw_enabled   = true;
+	bool                   readback_linear_images      = false;
 };
 
 void Load(const ConfigOptions& cfg);
@@ -64,6 +65,7 @@ bool SpirvDebugPrintfEnabled();
 
 bool RenderDocEnabled();
 bool NggRectlistDrawEnabled();
+bool ReadbackLinearImagesEnabled();
 
 } // namespace Config
 

src/common/lruCache.h

@@ -0,0 +1,119 @@
+#ifndef EMULATOR_SRC_COMMON_LRUCACHE_H_
+#define EMULATOR_SRC_COMMON_LRUCACHE_H_
+
+#include <cstddef>
+#include <deque>
+#include <type_traits>
+#include <utility>
+
+namespace Common {
+
+template <typename Object, typename Tick>
+class LeastRecentlyUsedCache {
+	struct Item {
+		Object object {};
+		Tick   tick {};
+		Item*  next = nullptr;
+		Item*  prev = nullptr;
+	};
+
+public:
+	[[nodiscard]] size_t Insert(Object object, Tick tick) {
+		const auto id = Build();
+		auto&      item = m_items[id];
+		item.object = std::move(object);
+		item.tick   = tick;
+		Attach(item);
+		return id;
+	}
+
+	void Touch(size_t id, Tick tick) {
+		auto& item = m_items[id];
+		if (item.tick >= tick) {
+			return;
+		}
+		item.tick = tick;
+		if (&item != m_last) {
+			Detach(item);
+			Attach(item);
+		}
+	}
+
+	void Free(size_t id) {
+		auto& item = m_items[id];
+		Detach(item);
+		item.next = nullptr;
+		item.prev = nullptr;
+		m_free.push_back(id);
+	}
+
+	template <typename Function>
+	void ForEachItemBelow(Tick tick, Function&& function) {
+		constexpr bool ReturnsBool =
+		    std::is_same_v<std::invoke_result_t<Function, Object>, bool>;
+		for (auto* item = m_first; item != nullptr;) {
+			if (item->tick > tick) {
+				return;
+			}
+			auto* next = item->next;
+			if constexpr (ReturnsBool) {
+				if (function(item->object)) {
+					return;
+				}
+			} else {
+				function(item->object);
+			}
+			item = next;
+		}
+	}
+
+private:
+	[[nodiscard]] size_t Build() {
+		if (m_free.empty()) {
+			const auto id = m_items.size();
+			m_items.emplace_back();
+			return id;
+		}
+		const auto id = m_free.front();
+		m_free.pop_front();
+		return id;
+	}
+
+	void Attach(Item& item) {
+		if (m_first == nullptr) {
+			m_first = &item;
+		}
+		if (m_last == nullptr) {
+			m_last = &item;
+			return;
+		}
+		item.prev   = m_last;
+		m_last->next = &item;
+		item.next   = nullptr;
+		m_last      = &item;
+	}
+
+	void Detach(Item& item) {
+		if (item.prev != nullptr) {
+			item.prev->next = item.next;
+		}
+		if (item.next != nullptr) {
+			item.next->prev = item.prev;
+		}
+		if (m_first == &item) {
+			m_first = item.next;
+		}
+		if (m_last == &item) {
+			m_last = item.prev;
+		}
+	}
+
+	std::deque<Item>   m_items;
+	std::deque<size_t> m_free;
+	Item*              m_first = nullptr;
+	Item*              m_last  = nullptr;
+};
+
+} // namespace Common
+
+#endif // EMULATOR_SRC_COMMON_LRUCACHE_H_

src/common/uniqueFunction.h

@@ -0,0 +1,56 @@
+#ifndef KYTY_COMMON_UNIQUEFUNCTION_H_
+#define KYTY_COMMON_UNIQUEFUNCTION_H_
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace Common {
+
+template <typename Result, typename... Args>
+class UniqueFunction {
+	class CallableBase {
+	public:
+		virtual ~CallableBase() = default;
+		virtual Result Invoke(Args&&... args) = 0;
+	};
+
+	template <typename Function>
+	class Callable final: public CallableBase {
+	public:
+		explicit Callable(Function function): m_function(std::move(function)) {}
+
+		Result Invoke(Args&&... args) override {
+			return m_function(std::forward<Args>(args)...);
+		}
+
+	private:
+		Function m_function;
+	};
+
+public:
+	UniqueFunction() = default;
+
+	template <typename Function>
+	UniqueFunction(Function&& function)
+	    : m_callable(std::make_unique<Callable<std::decay_t<Function>>>(
+	          std::forward<Function>(function))) {}
+
+	UniqueFunction(UniqueFunction&&) noexcept            = default;
+	UniqueFunction& operator=(UniqueFunction&&) noexcept = default;
+	UniqueFunction(const UniqueFunction&)                = delete;
+	UniqueFunction& operator=(const UniqueFunction&)     = delete;
+
+	Result operator()(Args... args) const {
+		return m_callable->Invoke(std::forward<Args>(args)...);
+	}
+
+	explicit operator bool() const noexcept { return m_callable != nullptr; }
+
+private:
+	std::unique_ptr<CallableBase> m_callable;
+};
+
+} // namespace Common
+
+#endif // KYTY_COMMON_UNIQUEFUNCTION_H_