X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fgame%2Fsystem.h;h=e3d71171c1e19aa8e31da854aa007737885774ce;hb=ffbfe95f51058c4de3c898b1a02e2fadba2b8134;hp=88ba291fb50bcb05e9881014f5e6096f34939daa;hpb=248d62f7240d342982ade65a510be912b867fe49;p=libs%2Fgame.git

diff --git a/source/game/system.h b/source/game/system.h
index 88ba291..e3d7117 100644
--- a/source/game/system.h
+++ b/source/game/system.h
@@ -1,26 +1,113 @@
 #ifndef MSP_GAME_SYSTEM_H_
 #define MSP_GAME_SYSTEM_H_
 
+#include <functional>
 #include <msp/time/timedelta.h>
+#include "accessguard.h"
+#include "component.h"
+#include "reflection.h"
+#include "stage.h"
 
 namespace Msp::Game {
 
-class Stage;
-
 class System
 {
+public:
+	enum DependencyFlags
+	{
+		NO_DEPENDENCY = 0,
+		READ_OLD = 1,
+		READ_FRESH = 3,
+		WRITE = 4,
+		UPDATE = READ_OLD | WRITE,
+		CHAINED_UPDATE = READ_FRESH | WRITE
+	};
+
+	struct Dependency
+	{
+		DependencyFlags flags = NO_DEPENDENCY;
+		const Reflection::ClassBase &type;
+		void (*prepare)(Stage &) = nullptr;
+		void (*commit)(Stage &) = nullptr;
+		void (*unblock)(DependencyFlags) = nullptr;
+		void (*block)(DependencyFlags) = nullptr;
+
+		Dependency(const Reflection::ClassBase &t): type(t) { }
+	};
+
+	class Activator: public NonCopyable
+	{
+	private:
+		System &system;
+
+	public:
+		Activator(System &s): system(s) { system.begin_tick(); }
+		~Activator() { system.end_tick(); }
+	};
+
 protected:
 	Stage &stage;
+	std::vector<std::function<void()>> deferred_queue;
+	std::vector<Dependency> dependencies;
+
+	static thread_local System *active;
 
 	System(Stage &s): stage(s) { }
 public:
 	virtual ~System() = default;
 
-	virtual void pre_tick() = 0;
+	Stage &get_stage() const { return stage; }
+
+protected:
+	template<typename T>
+	void declare_dependency(DependencyFlags);
+
+public:
+	void begin_tick();
 	virtual void tick(Time::TimeDelta) = 0;
-	virtual void post_tick() = 0;
+	void end_tick();
+	virtual void deferred_tick();
+
+protected:
+	template<typename F>
+	void defer(F &&f) { deferred_queue.emplace_back(std::forward<F>(f)); }
 };
 
+
+template<typename T>
+inline void System::declare_dependency(DependencyFlags flags)
+{
+	if(!std::is_base_of_v<Component, T>)
+		throw std::invalid_argument("System::declare_dependency");
+
+	const Reflection::ClassBase &type = stage.get_reflector().get_or_create_class<T>();
+	auto i = find_if(dependencies, [&type](const Dependency &d){ return &d.type==&type; });
+
+	if(i!=dependencies.end())
+		flags = static_cast<DependencyFlags>(flags|i->flags);
+
+	Dependency &dep = (i!=dependencies.end() ? *i : dependencies.emplace_back(type));
+	dep.flags = flags;
+	if constexpr(requires(T &c) { typename T::Data; c.prepare_tick(); c.commit_tick(); })
+	{
+#ifdef DEBUG
+		dep.unblock = +[](DependencyFlags f){
+			if(f&READ_OLD) AccessGuard::get_instance().unblock<AccessGuard::Read<typename T::Data>>();
+			if(f&WRITE) AccessGuard::get_instance().unblock<AccessGuard::Write<typename T::Data>>();
+		};
+		dep.block = +[](DependencyFlags f){
+			if(f&READ_OLD) AccessGuard::get_instance().block<AccessGuard::Read<typename T::Data>>();
+			if(f&WRITE) AccessGuard::get_instance().block<AccessGuard::Write<typename T::Data>>();
+		};
+#endif
+		if(flags&WRITE)
+		{
+			dep.prepare = +[](Stage &s){ s.iterate_objects<T>([](T &c){ c.prepare_tick(); }); };
+			dep.commit = +[](Stage &s){ s.iterate_objects<T>([](T &c){ c.commit_tick(); }); };
+		}
+	}
+}
+
 } // namespace Msp::Game
 
 #endif