copy/move schedule, Run* support CommandBufferView

include/UECS/CommandBuffer.hpp

@@ -17,6 +17,12 @@ namespace Ubpa::UECS {
 
 		auto& GetCommands() noexcept { return commands; }
 		const auto& GetCommands() const noexcept { return commands; }
+
+		void Run() {
+			for (const auto& cmd : commands)
+				cmd();
+			commands.clear();
+		}
 	private:
 		std::vector<std::function<void()>> commands;
 	};

include/UECS/Schedule.hpp

@@ -18,6 +18,8 @@ namespace Ubpa::UECS {
 	class SystemMngr;
 	class SysFuncGraph;
 
+	static constexpr int SpecialLayer = -std::numeric_limits<int>::max();
+
 	// [description]
 	// system infomation record
 	// - SystemFunc
@@ -117,12 +119,17 @@ namespace Ubpa::UECS {
 		Schedule& Disable(std::string_view sys, int layer = 0);
 
 		// clear every frame
-		std::pmr::monotonic_buffer_resource* GetFrameMonotonicResource() { return &frame_rsrc; }
+		std::pmr::monotonic_buffer_resource* GetFrameMonotonicResource() { return frame_rsrc.get(); }
 		template<typename T, typename... Args>
 		T* CreateFrameObject(Args&&... args) const;
+		std::string_view RegisterFrameString(std::string_view str);
 
-		~Schedule();
 	private:
+		Schedule();
+		Schedule(const Schedule&);
+		Schedule(Schedule&&) noexcept = default;
+		~Schedule();
+
 		template<typename... Args>
 		const SystemFunc* Request(int layer, Args&&...);
 
@@ -163,8 +170,7 @@ namespace Ubpa::UECS {
 
 		std::map<int, LayerInfo> layerInfos;
 
-		mutable std::pmr::monotonic_buffer_resource frame_rsrc; // release in every frame
-		std::string_view RegisterFrameString(std::string_view str);
+		std::unique_ptr<std::pmr::monotonic_buffer_resource> frame_rsrc; // release in every frame
 
 		friend class World;
 	};

include/UECS/SystemFunc.hpp

@@ -13,6 +13,8 @@
 #include <functional>
 
 namespace Ubpa::UECS {
+	class Schedule;
+
 	// [- description]
 	// system function registered by Schedule in <System>::OnUpdate(Schedule&)
 	// name + query(archetype filter + component locator) + singleton locator + function<...>
@@ -72,6 +74,8 @@ namespace Ubpa::UECS {
 
 		bool operator==(const SystemFunc& sysFunc) const noexcept { return name == sysFunc.name; }
 	private:
+		friend class Schedule;
+		SystemFunc(const SystemFunc&) = default;
 		Mode mode;
 		std::string_view name;
 		std::size_t hashCode; // after name

include/UECS/World.hpp

@@ -16,10 +16,7 @@ namespace Ubpa::UECS {
 	// SystemMngr + EntityMngr
 	class World {
 	public:
-		World() :
-			jobRsrc{ std::make_unique<std::pmr::unsynchronized_pool_resource>() },
-			systemMngr { this } {}
-		// not copy/move schedule, so you can't use DumpUpdateJobGraph() and GenUpdateFrameGraph() before Update()
+		World();
 		World(const World&);
 		World(World&&) noexcept;
 		~World();
@@ -57,7 +54,7 @@ namespace Ubpa::UECS {
 		// <tagged-components>: [const] <Cmpt>*...
 		// CmptsView
 		template<typename Func>
-		void RunEntityJob(
+		CommandBuffer RunEntityJob(
 			Func&&,
 			bool isParallel = true,
 			ArchetypeFilter = {},
@@ -91,7 +88,7 @@ namespace Ubpa::UECS {
 		// std::size_t entityBeginIndexInQuery
 		// ChunkView (necessary)
 		template<typename Func>
-		void RunChunkJob(
+		CommandBuffer RunChunkJob(
 			Func&&,
 			ArchetypeFilter = {},
 			bool isParallel = true,
@@ -136,7 +133,7 @@ namespace Ubpa::UECS {
 		std::mutex commandBufferMutex;
 		void RunCommands(int layer);
 
-		void Run(SystemFunc*);
+		CommandBuffer Run(SystemFunc*);
 
 		std::pmr::synchronized_pool_resource frame_sync_rsrc;
 	};

include/UECS/details/Schedule.inl

@@ -3,7 +3,7 @@
 namespace Ubpa::UECS {
 	template<typename T, typename... Args>
 	T* Schedule::CreateFrameObject(Args&&... args) const {
-		void* buffer = frame_rsrc.allocate(sizeof(T), alignof(T));
+		void* buffer = frame_rsrc->allocate(sizeof(T), alignof(T));
 		return new(buffer)T(std::forward<Args>(args)...);
 	}
 
@@ -111,7 +111,8 @@ namespace Ubpa::UECS {
 
 	template<typename... Args>
 	const SystemFunc* Schedule::Request(int layer, Args&&... args) {
-		SystemFunc* sysFunc = (SystemFunc*)frame_rsrc.allocate(sizeof(SystemFunc), alignof(SystemFunc));
+		assert(layer != SpecialLayer);
+		SystemFunc* sysFunc = (SystemFunc*)frame_rsrc->allocate(sizeof(SystemFunc), alignof(SystemFunc));
 		new(sysFunc)SystemFunc(std::forward<Args>(args)...);
 		layerInfos[layer].sysFuncs.emplace(sysFunc->GetValue(), sysFunc);
 		return sysFunc;

include/UECS/details/World.inl

@@ -2,7 +2,7 @@
 
 namespace Ubpa::UECS {
 	template<typename Func>
-	void World::RunEntityJob(
+	CommandBuffer World::RunEntityJob(
 		Func&& func,
 		bool isParallel,
 		ArchetypeFilter filter,
@@ -19,7 +19,7 @@ namespace Ubpa::UECS {
 			{},
 			isParallel
 		};
-		Run(&sys);
+		return Run(&sys);
 	}
 
 	template<typename Func>
@@ -35,6 +35,8 @@ namespace Ubpa::UECS {
 			"const RunEntityJob should use const World*");
 		static_assert(Length_v<Filter_t<ArgList, IsWrite>> == 0,
 			"const RunEntityJob can't write cmpt");
+		static_assert(!Contain_v<ArgList, CommandBufferView>,
+			"const RunEntityJob shouldn't use CommandBufferView");
 		assert("const RunEntityJob can't write cmpt"
 			&& !cmptLocator.HasWriteTypeID());
 
@@ -48,7 +50,7 @@ namespace Ubpa::UECS {
 	}
 
 	template<typename Func>
-	void World::RunChunkJob(
+	CommandBuffer World::RunChunkJob(
 		Func&& func,
 		ArchetypeFilter filter,
 		bool isParallel,
@@ -63,7 +65,7 @@ namespace Ubpa::UECS {
 			{},
 			isParallel
 		};
-		Run(&sys);
+		return Run(&sys);
 	}
 
 	template<typename Func>
@@ -74,8 +76,10 @@ namespace Ubpa::UECS {
 		SingletonLocator singletonLocator
 	) const {
 		using ArgList = FuncTraits_ArgList<Func>;
-		static_assert(Contain_v<ArgList, World*> == 0,
+		static_assert(!Contain_v<ArgList, World*>,
 			"const RunChunkJob should use const World*");
+		static_assert(!Contain_v<ArgList, CommandBufferView>,
+			"const RunChunkJob shouldn't use CommandBufferView");
 		assert("const RunChunkJob can't write cmpt"
 			&& !filter.HaveWriteTypeID());
 

src/core/Schedule.cpp

@@ -6,36 +6,51 @@ using namespace Ubpa;
 using namespace Ubpa::UECS;
 using namespace std;
 
-Schedule::~Schedule() {
-	Clear();
+Schedule::Schedule() : frame_rsrc{ std::make_unique<std::pmr::monotonic_buffer_resource>() } {}
+
+Schedule::~Schedule() { Clear(); }
+
+Schedule::Schedule(const Schedule& other) :
+	frame_rsrc{ std::make_unique<std::pmr::monotonic_buffer_resource>() },
+	layerInfos{ other.layerInfos }
+{
+	for (auto& [layer, info] : layerInfos) {
+		for (auto& [id, sys] : info.sysFuncs) {
+			sys = CreateFrameObject<SystemFunc>(*sys);
+			sys->name = RegisterFrameString(sys->Name());
+		}
+	}
 }
 
 std::string_view Schedule::RegisterFrameString(std::string_view str) {
-	auto* buffer = (char*)frame_rsrc.allocate((str.size() + 1) * sizeof(char), alignof(char));
+	auto* buffer = (char*)frame_rsrc->allocate((str.size() + 1) * sizeof(char), alignof(char));
 	std::memcpy(buffer, str.data(), str.size() * sizeof(char));
 	buffer[str.size()] = 0;
 	return str;
 }
 
 Schedule& Schedule::Order(string_view x, string_view y, int layer) {
+	assert(layer != SpecialLayer);
 	layerInfos[layer].sysFuncOrder.emplace(SystemFunc::GetValue(x), SystemFunc::GetValue(y));
 	return *this;
 }
 
 Schedule& Schedule::AddNone(string_view sys, TypeID type, int layer) {
+	assert(layer != SpecialLayer);
 	std::size_t hashcode = SystemFunc::GetValue(sys);
 	layerInfos[layer].sysNones[hashcode].push_back(type);
 	return *this;
 }
 
 Schedule& Schedule::Disable(std::string_view sys, int layer) {
+	assert(layer != SpecialLayer);
 	layerInfos[layer].disabledSysFuncs.insert(SystemFunc::GetValue(sys));
 	return *this;
 }
 
 void Schedule::Clear() {
 	for (auto& [layer, layerinfo] : layerInfos) {
-		//auto alloc = std::pmr::polymorphic_allocator<SystemFunc>{ &frame_rsrc };
+		//auto alloc = std::pmr::polymorphic_allocator<SystemFunc>{ frame_rsrc.get() };
 		for (const auto& [hash, sysFunc] : layerinfo.sysFuncs) {
 			sysFunc->~SystemFunc();
 			// no need to deallocate
@@ -47,21 +62,22 @@ void Schedule::Clear() {
 		layerinfo.sysNones.clear();
 	}
 	layerInfos.clear();
-	frame_rsrc.release();
+	frame_rsrc->release();
 }
 
 Schedule::CmptSysFuncsMap* Schedule::GenCmptSysFuncsMap(int layer) const {
+	assert(layer != SpecialLayer);
 	const auto& layerinfo = layerInfos.at(layer);
 	const auto& sysFuncs = layerinfo.sysFuncs;
 	const auto& disabledSysFuncs = layerinfo.disabledSysFuncs;
 
-	CmptSysFuncsMap* rst = CreateFrameObject<CmptSysFuncsMap>(CmptSysFuncsMap::allocator_type{ &frame_rsrc });
+	CmptSysFuncsMap* rst = CreateFrameObject<CmptSysFuncsMap>(CmptSysFuncsMap::allocator_type{ frame_rsrc.get() });
 	for (const auto& [hashcode, sysFunc] : sysFuncs) {
 		if (disabledSysFuncs.contains(hashcode))
 			continue;
 
 		for (const auto& type : sysFunc->entityQuery.locator.AccessTypeIDs()) {
-			auto& cmptSysFuncs = rst->try_emplace(type, &frame_rsrc).first->second;
+			auto& cmptSysFuncs = rst->try_emplace(type, frame_rsrc.get()).first->second;
 			switch (type.GetAccessMode())
 			{
 			case AccessMode::LAST_FRAME:
@@ -79,7 +95,7 @@ Schedule::CmptSysFuncsMap* Schedule::GenCmptSysFuncsMap(int layer) const {
 			}
 		}
 		for (const auto& type : sysFunc->singletonLocator.SingletonTypes()) {
-			auto& cmptSysFuncs = rst->try_emplace(type, &frame_rsrc).first->second;
+			auto& cmptSysFuncs = rst->try_emplace(type, frame_rsrc.get()).first->second;
 			switch (type.GetAccessMode())
 			{
 			case AccessMode::LAST_FRAME:
@@ -97,7 +113,7 @@ Schedule::CmptSysFuncsMap* Schedule::GenCmptSysFuncsMap(int layer) const {
 			}
 		}
 		for (const auto& type : sysFunc->randomAccessor.types) {
-			auto& cmptSysFuncs = rst->try_emplace(type, &frame_rsrc).first->second;
+			auto& cmptSysFuncs = rst->try_emplace(type, frame_rsrc.get()).first->second;
 			switch (type.GetAccessMode())
 			{
 			case AccessMode::LAST_FRAME:
@@ -118,7 +134,7 @@ Schedule::CmptSysFuncsMap* Schedule::GenCmptSysFuncsMap(int layer) const {
 		if (sysFunc->GetMode() == SystemFunc::Mode::Chunk) {
 			const auto& filter = sysFunc->entityQuery.filter;
 			for (const auto& type : filter.all) {
-				auto& cmptSysFuncs = rst->try_emplace(type, &frame_rsrc).first->second;
+				auto& cmptSysFuncs = rst->try_emplace(type, frame_rsrc.get()).first->second;
 				switch (type.GetAccessMode())
 				{
 				case AccessMode::LAST_FRAME:
@@ -137,7 +153,7 @@ Schedule::CmptSysFuncsMap* Schedule::GenCmptSysFuncsMap(int layer) const {
 			}
 
 			for (const auto& type : filter.any) {
-				auto& cmptSysFuncs = rst->try_emplace(type, &frame_rsrc).first->second;
+				auto& cmptSysFuncs = rst->try_emplace(type, frame_rsrc.get()).first->second;
 				switch (type.GetAccessMode())
 				{
 				case AccessMode::LAST_FRAME:
@@ -160,6 +176,7 @@ Schedule::CmptSysFuncsMap* Schedule::GenCmptSysFuncsMap(int layer) const {
 }
 
 SysFuncGraph* Schedule::GenSysFuncGraph(int layer) const {
+	assert(layer != SpecialLayer);
 	const auto& layerinfo = layerInfos.at(layer);
 	const auto& sysNones = layerinfo.sysNones;
 	const auto& sysFuncs = layerinfo.sysFuncs;
@@ -182,7 +199,7 @@ SysFuncGraph* Schedule::GenSysFuncGraph(int layer) const {
 	CmptSysFuncsMap* cmptSysFuncsMap = GenCmptSysFuncsMap(layer); // use frame rsrc, no need to release
 
 	// [gen graph]
-	SysFuncGraph* graph = CreateFrameObject<SysFuncGraph>(&frame_rsrc);
+	SysFuncGraph* graph = CreateFrameObject<SysFuncGraph>(frame_rsrc.get());
 
 	// [gen graph] - vertex
 	for (const auto& [hashcode, sysFunc] : sysFuncs) {
@@ -228,7 +245,7 @@ SysFuncGraph* Schedule::GenSysFuncGraph(int layer) const {
 		if (cmptSysFuncs.writeSysFuncs.empty())
 			continue;
 
-		SysFuncGraph* subgraph = CreateFrameObject<SysFuncGraph>(&frame_rsrc);
+		SysFuncGraph* subgraph = CreateFrameObject<SysFuncGraph>(frame_rsrc.get());
 		graph->SubGraph(*subgraph, std::span{ cmptSysFuncs.writeSysFuncs.data(), cmptSysFuncs.writeSysFuncs.size() });
 		auto [success, sorted_wirtes] = subgraph->Toposort();
 		assert(success);