initial import, >900commits predate this

framework/screen_director/src/mm/services/screen_director.cpp

@@ -0,0 +1,107 @@
+#include "./screen_director.hpp"
+
+#include <tracy/Tracy.hpp>
+
+#include <mm/logger.hpp>
+
+namespace MM::Services {
+
+bool ScreenDirector::enable(MM::Engine& engine) {
+	if (!_update_handle.expired())
+		return false;
+
+	{
+		_update_handle = engine.addFixedUpdate([this](Engine& e) { this->update(e); });
+		auto tmp_lock = _update_handle.lock();
+		tmp_lock->priority = -100; // post everything ?
+		tmp_lock->name = "ScreenDirector::update";
+	}
+
+
+	// start initial screen
+	if (!queued_screen_id.empty()) {
+		auto next_screen_id = queued_screen_id;
+		auto& next_screen = screens[next_screen_id];
+
+		startScreen(engine, next_screen);
+
+		curr_screen_id = next_screen_id;
+	}
+
+	return true;
+}
+
+void ScreenDirector::disable(MM::Engine& engine) {
+	engine.removeFixedUpdate(_update_handle);
+	_update_handle.reset();
+}
+
+void ScreenDirector::update(MM::Engine& engine) {
+	if (curr_screen_id != queued_screen_id) {
+		engine.addFixedDefer([this](MM::Engine& engine) {
+			changeScreenTo(engine, queued_screen_id);
+		});
+	}
+}
+
+void ScreenDirector::startScreen(MM::Engine& engine, Screen& screen) {
+	ZoneScoped;
+	for (auto service_id : screen.start_disable) {
+		engine.disableService(service_id);
+	}
+
+	for (auto service_id : screen.start_enable) {
+		engine.enableService(service_id); // TODO: check return value
+	}
+
+	for (auto [i_id, t_id] : screen.start_provide) {
+		bool r = engine.provide(i_id, t_id); // TODO: check return value
+		assert(r);
+	}
+
+	screen.start_fn(engine);
+}
+
+void ScreenDirector::endScreen(MM::Engine& engine, Screen& screen) {
+	ZoneScoped;
+	screen.end_fn(engine);
+
+	for (auto service_id : screen.end_disable) {
+		engine.disableService(service_id);
+	}
+
+	for (auto service_id : screen.end_enable) {
+		engine.enableService(service_id); // TODO: check return value
+	}
+}
+
+void ScreenDirector::changeScreenTo(MM::Engine& engine, const std::string id) {
+	ZoneScoped;
+
+	if (screens.count(id) == 0) {
+		SPDLOG_ERROR("tried to change to not defined screen '{}'", id);
+		return;
+	}
+
+	ZoneText(id.c_str(), id.size());
+
+	auto& curr_screen = screens[curr_screen_id];
+	auto& next_screen = screens[id];
+
+	endScreen(engine, curr_screen);
+
+	startScreen(engine, next_screen);
+
+	curr_screen_id = id;
+}
+
+void ScreenDirector::queueChangeScreenTo(const std::string& id) {
+	ZoneScoped;
+	ZoneText(id.c_str(), id.size());
+
+	// TODO: do some checks
+	queued_screen_id = id;
+}
+
+} // MM::Services
+

framework/screen_director/src/mm/services/screen_director.hpp

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <mm/engine.hpp>
+
+//#include <vector> // in engine.hpp
+#include <map>
+
+namespace MM::Services {
+
+class ScreenDirector : public Service {
+	public:
+		const char* name(void) override { return "ScreenDirector"; }
+
+		// enable switches to queued_screen_index
+		bool enable(MM::Engine&) override;
+		void disable(MM::Engine&) override;
+
+	public:
+		struct Screen {
+			// lists of services relevant for this screen, disable and enable are called when its changed to
+			std::vector<Engine::service_family_type> start_disable;
+			std::vector<Engine::service_family_type> start_enable;
+
+			// register provider, when its changed to
+			std::vector<
+				std::pair<
+					Engine::service_family_type,	// I
+					Engine::service_family_type		// T
+				>
+			> start_provide;
+
+			// lists of services relevant for this screen, disable and enable are called when its changed from
+			std::vector<Engine::service_family_type> end_disable;
+			std::vector<Engine::service_family_type> end_enable;
+
+			// called when its changed to, after services disable and enable
+			std::function<void(MM::Engine&)> start_fn = [](MM::Engine&){};
+
+			// called when the screen changed from
+			std::function<void(MM::Engine&)> end_fn = [](MM::Engine&){};
+		};
+
+		std::map<std::string, Screen> screens;
+
+		// TODO: private?
+		std::string curr_screen_id = "";
+		std::string queued_screen_id = "";
+
+	private:
+		MM::Engine::FunctionDataHandle _update_handle;
+		void update(MM::Engine& engine);
+
+	private:
+		// INTERNAL helper, to reduce redundant code
+		void startScreen(MM::Engine& engine, Screen& screen);
+		void endScreen(MM::Engine& engine, Screen& screen);
+
+	public:
+		void changeScreenTo(MM::Engine& engine, const std::string id);
+		void queueChangeScreenTo(const std::string& id);
+};
+
+} // MM::Services
+