Wrote more tests separated storages correctly

Author: Kelwan

ecsact/entt/detail/apply_pending.hh

@@ -26,7 +26,7 @@ template<typename C>
 auto apply_pending_remove(::entt::registry& registry) -> void {
 	registry.view<pending_remove<C>>().each([&](auto entity) {
 		if constexpr(!std::is_empty_v<C>) {
-			registry.erase<beforechange_storage<C>>(entity);
+			registry.erase<exec_beforechange_storage<C>>(entity);
 		}
 		registry.erase<C>(entity);
 	});

ecsact/entt/detail/internal_markers.hh

@@ -37,12 +37,15 @@ struct beforeremove_storage<C> {
 
 template<typename C>
 	requires(!std::is_empty_v<C>)
-struct beforechange_storage {
+struct exec_beforechange_storage {
 	C value;
 };
 
 template<typename C>
-struct component_changed {};
+	requires(!std::is_empty_v<C>)
+struct exec_itr_beforechange_storage {
+	C value;
+};
 
 template<typename C>
 struct pending_add;
@@ -110,7 +113,7 @@ auto remove_system_markers_if_needed( //
 }
 
 template<typename C>
-auto add_sys_changestorage_if_needed( //
+auto add_exec_itr_beforechange_if_needed( //
 	::entt::registry&,
 	ecsact::entt::entity_id
 ) -> void {

ecsact/entt/wrapper/core.hh

@@ -61,14 +61,15 @@ inline auto add_component( //
 		if constexpr(std::is_empty_v<C>) {
 			reg.emplace<C>(entity);
 		} else {
-			reg.emplace<detail::beforechange_storage<C>>(
+			reg.emplace<detail::exec_beforechange_storage<C>>(
 				entity,
 				*static_cast<const C*>(component_data)
 			);
 			reg.emplace<C>(entity, *static_cast<const C*>(component_data));
 		}
 
 		ecsact::entt::detail::add_system_markers_if_needed<C>(reg, entity);
+		ecsact::entt::detail::add_exec_itr_beforechange_if_needed<C>(reg, entity);
 	}
 
 	return err;
@@ -97,14 +98,15 @@ inline auto add_component_exec_options( //
 		if constexpr(std::is_empty_v<C>) {
 			reg.emplace<C>(entity);
 		} else {
-			reg.emplace<detail::beforechange_storage<C>>(
+			reg.emplace<detail::exec_beforechange_storage<C>>(
 				entity,
 				*static_cast<const C*>(component_data)
 			);
 			reg.emplace<C>(entity, *static_cast<const C*>(component_data));
 		}
 		reg.template emplace_or_replace<component_added<C>>(entity);
 		ecsact::entt::detail::add_system_markers_if_needed<C>(reg, entity);
+		ecsact::entt::detail::add_exec_itr_beforechange_if_needed<C>(reg, entity);
 	}
 
 	return err;
@@ -173,7 +175,7 @@ auto remove_component(
 
 	reg.remove<C>(entity);
 	if constexpr(!std::is_empty_v<C>) {
-		reg.remove<detail::beforechange_storage<C>>(entity);
+		reg.remove<detail::exec_beforechange_storage<C>>(entity);
 	}
 	reg.template remove<component_added<C>>(entity);
 	reg.template remove<component_updated<C>>(entity);
@@ -206,7 +208,7 @@ auto remove_component_exec_options(
 	reg.template emplace_or_replace<component_removed<C>>(entity);
 
 	if constexpr(!std::is_empty_v<C>) {
-		reg.template remove<detail::beforechange_storage<C>>(entity);
+		reg.template remove<detail::exec_beforechange_storage<C>>(entity);
 	}
 
 	ecsact::entt::detail::remove_system_markers_if_needed<C>(reg, entity);
@@ -295,7 +297,7 @@ auto _trigger_update_component_event(
 	ecsact::entt::detail::execution_events_collector& events_collector
 ) -> void {
 	using ecsact::entt::component_updated;
-	using ecsact::entt::detail::beforechange_storage;
+	using ecsact::entt::detail::exec_beforechange_storage;
 
 	if(!events_collector.has_update_callback()) {
 		return;
@@ -305,12 +307,13 @@ auto _trigger_update_component_event(
 	if constexpr(!C::transient && !std::is_empty_v<C>) {
 		::entt::basic_view changed_view{
 			reg.template storage<C>(),
-			reg.template storage<beforechange_storage<C>>(),
+			reg.template storage<exec_beforechange_storage<C>>(),
 			reg.template storage<component_updated<C>>(),
 		};
 
 		for(ecsact::entt::entity_id entity : changed_view) {
-			auto& before = changed_view.template get<beforechange_storage<C>>(entity);
+			auto& before =
+				changed_view.template get<exec_beforechange_storage<C>>(entity);
 			auto& current = changed_view.template get<C>(entity);
 
 			if(before.value != current) {
@@ -403,33 +406,31 @@ inline auto prepare_component(ecsact_registry_id registry_id) -> void {
 	reg.template storage<component_removed<C>>();
 
 	if constexpr(!std::is_empty_v<C>) {
-		reg.storage<detail::beforechange_storage<C>>();
+		reg.storage<detail::exec_beforechange_storage<C>>();
 		reg.template storage<component_updated<C>>();
 	}
 }
 
-template<typename C>
-auto has_component_changed(entt::entity_id entity, ::entt::registry& reg)
-	-> bool {
-	using detail::beforechange_storage;
-	using detail::component_changed;
+template<typename C, typename V>
+auto has_component_changed(entt::entity_id entity, V& view) -> bool {
+	using detail::exec_itr_beforechange_storage;
 
-	auto current_comp = reg.get<C>(entity);
-	auto before_comp = reg.get<beforechange_storage<C>>(entity);
+	const auto& current_comp = view.template get<C>(entity);
+	const auto& before_comp =
+		view.template get<exec_itr_beforechange_storage<C>>(entity);
 
 	if(before_comp.value != current_comp) {
-		std::cout << "Component has changed!" << std::endl;
 		return true;
 	}
-	std::cout << "Component has not changed!" << std::endl;
 	return false;
 }
 
 template<typename C>
-auto update_beforechange_storage(entt::entity_id entity, ::entt::registry& reg)
+auto update_exec_itr_beforechange(entt::entity_id entity, ::entt::registry& reg)
 	-> void {
 	auto  comp = reg.get<C>(entity);
-	auto& beforechange_comp = reg.get<detail::beforechange_storage<C>>(entity);
+	auto& beforechange_comp =
+		reg.get<detail::exec_itr_beforechange_storage<C>>(entity);
 
 	beforechange_comp.value = comp;
 }

ecsact/entt/wrapper/dynamic.hh

@@ -20,8 +20,8 @@ auto context_add(
 ) -> void {
 	using ecsact::entt::component_added;
 	using ecsact::entt::component_removed;
-	using ecsact::entt::detail::beforechange_storage;
 	using ecsact::entt::detail::beforeremove_storage;
+	using ecsact::entt::detail::exec_beforechange_storage;
 	using ecsact::entt::detail::pending_add;
 
 	assert(ecsact_id_cast<ecsact_component_like_id>(C::id) == component_id);
@@ -36,7 +36,8 @@ auto context_add(
 		registry.template emplace_or_replace<pending_add<C>>(entity, *component);
 
 		auto& before_change =
-			registry.template emplace_or_replace<beforechange_storage<C>>(entity);
+			registry.template emplace_or_replace<exec_beforechange_storage<C>>(entity
+			);
 
 		before_change.value = *component;
 

rt_entt_codegen/core/execute_systems.cc

@@ -68,6 +68,7 @@ auto ecsact::rt_entt_codegen::core::print_execute_systems( //
 	}
 
 	ctx.write("\nupdate_all_beforechange_storage(registry_id);\n");
+	ctx.write("cleanup_system_notifies(registry_id);\n");
 
 	ctx.indentation -= 1;
 	ctx.write("\n}\n\n");
@@ -90,9 +91,9 @@ auto ecsact::rt_entt_codegen::core::print_execute_systems( //
 				"trigger_component_events_all(registry_id, events_collector);\n\n"
 			);
 		});
-		ctx.write("cleanup_component_events(registry_id);\n");
-		ctx.write("cleanup_system_notifies(registry_id);\n");
 	});
 
+	ctx.write("cleanup_component_events(registry_id);\n");
+
 	ctx.write("return ECSACT_EXEC_SYS_OK;");
 }

rt_entt_codegen/core/system_markers.cc

@@ -102,37 +102,43 @@ auto ecsact::rt_entt_codegen::core::print_add_sys_beforestorage_fn(
 	using cc_lang_support::cpp_identifier;
 	using ecsact::meta::decl_full_name;
 
-	// for(auto comp_id : details.all_components) {
-	// 	auto comp_name = cpp_identifier(decl_full_name(comp_id));
-
-	// 	ctx.write("template<>\n");
-	// 	auto printer =
-	// 		method_printer{
-	// 			ctx,
-	// 			std::format(
-	// 				"ecsact::entt::detail::add_sys_changestorage_if_needed< {}>",
-	// 				comp_name
-	// 			)
-	// 		}
-	// 			.parameter("::entt::registry&", "reg")
-	// 			.parameter("ecsact::entt::entity_id", "entity")
-	// 			.return_type("void");
-
-	// 	for(auto system_id : details.all_systems) {
-	// 		auto count = ecsact::meta::system_notify_settings_count(system_id);
-	// 		auto notify_settings = ecsact::meta::system_notify_settings(system_id);
-
-	// 		for(auto const [comp_id_to_compare, notify_setting] : notify_settings) {
-	// 			if(comp_id == static_cast<ecsact_component_id>(comp_id_to_compare)) {
-	// 				if(notify_setting == ECSACT_SYS_NOTIFY_ONCHANGE) {
-	// 					ctx.write(std::format( //
-	// 						"reg.emplace<beforechange_storage<{}>>(entity);\n",
-	// 						comp_name
-	// 					));
-	// 					break;
-	// 				}
-	// 			}
-	// 		}
-	// 	}
-	// }
+	auto already_printed_ = std::set<ecsact_component_id>{};
+
+	for(auto comp_id : details.all_components) {
+		auto comp_name = cpp_identifier(decl_full_name(comp_id));
+
+		ctx.write("template<>\n");
+		auto printer =
+			method_printer{
+				ctx,
+				std::format(
+					"ecsact::entt::detail::add_exec_itr_beforechange_if_needed< {}>",
+					comp_name
+				)
+			}
+				.parameter("::entt::registry&", "reg")
+				.parameter("ecsact::entt::entity_id", "entity")
+				.return_type("void");
+
+		for(auto system_id : details.all_systems) {
+			auto count = ecsact::meta::system_notify_settings_count(system_id);
+			auto notify_settings = ecsact::meta::system_notify_settings(system_id);
+
+			for(auto const [comp_id_to_compare, notify_setting] : notify_settings) {
+				if(comp_id == static_cast<ecsact_component_id>(comp_id_to_compare)) {
+					if(notify_setting == ECSACT_SYS_NOTIFY_ONCHANGE) {
+						if(already_printed_.contains(comp_id)) {
+							break;
+						}
+						already_printed_.insert(comp_id);
+						ctx.write(std::format( //
+							"reg.emplace<exec_itr_beforechange_storage<{}>>(entity);\n",
+							comp_name
+						));
+						break;
+					}
+				}
+			}
+		}
+	}
 }

rt_entt_codegen/core/update_beforechange.cc

@@ -30,7 +30,7 @@ auto ecsact::rt_entt_codegen::core::print_update_all_beforechange_storage(
 		auto comp_name = c_identifier(decl_full_name((comp_id)));
 		auto cpp_comp_name = cpp_identifier(decl_full_name(comp_id));
 		auto comp_change_name = std::format( //
-			"ecsact::entt::detail::beforechange_storage<{}>",
+			"ecsact::entt::detail::exec_itr_beforechange_storage<{}>",
 			cpp_comp_name
 		);
 
@@ -43,7 +43,7 @@ auto ecsact::rt_entt_codegen::core::print_update_all_beforechange_storage(
 
 		block(ctx, std::format("for(auto entity: {})", view_name), [&]() {
 			ctx.write(std::format(
-				"ecsact::entt::wrapper::core::update_beforechange_storage<{}>(entity, "
+				"ecsact::entt::wrapper::core::update_exec_itr_beforechange<{}>(entity, "
 				"reg);\n",
 				cpp_comp_name
 			));

rt_entt_codegen/shared/system_util.cc

@@ -120,18 +120,8 @@ auto ecsact::rt_entt_codegen::system_util::detail::print_system_notify_views(
 		}
 
 		if(notify_setting == ECSACT_SYS_NOTIFY_ONCHANGE) {
-			// TODO: Implement a component to be checked and added in another PR
-			// Added when component fields have changed during execution
-			auto component_changed_str =
-				std::format("ecsact::entt::component_updated<{}>", cpp_comp_name);
-
-			auto sys_onchange_str = std::format(
-				"ecsact::entt::detail::beforechange_storage<{}>",
-				cpp_comp_name
-			);
-
-			auto sys_beforechanged_str = std::format(
-				"ecsact::entt::detail::component_changed<{}>",
+			auto exec_itr_onchange_str = std::format(
+				"ecsact::entt::detail::exec_itr_beforechange_storage<{}>",
 				cpp_comp_name
 			);
 
@@ -142,7 +132,7 @@ auto ecsact::rt_entt_codegen::system_util::detail::print_system_notify_views(
 				view_name,
 				registry_name,
 				details,
-				std::vector{component_changed_str},
+				std::vector{exec_itr_onchange_str},
 				std::vector{run_system_comp}
 			);