chore: wip

Author: zaucy

ecsact/entt/detail/apply_pending.hh

@@ -11,16 +11,16 @@ auto apply_pending_add(ecsact::entt::registry_t& registry) -> void {
 	if constexpr(std::is_empty_v<C>) {
 		registry.view<pending_add<C>>().each([&](auto entity) {
 			C& comp = registry.emplace<C>(entity);
-			lifecycle_on_add<C>(registry, entity, comp);
+			// lifecycle_on_add<C>(registry, entity, comp);
 		});
 	} else {
 		registry.view<pending_add<C>>().each( //
 			[&](auto entity, const pending_add<C>& comp) {
-				C& comp = registry.emplace<C>(entity, comp.value);
+				registry.emplace<C>(entity, comp.value);
 				registry
 					.emplace<exec_beforechange_storage<C>>(entity, comp.value, false);
 				add_system_markers_if_needed<C>(registry, entity);
-				lifecycle_on_add<C>(registry, entity, comp);
+				// lifecycle_on_add<C>(registry, entity, comp.value);
 			}
 		);
 	}

ecsact/entt/detail/internal_lifecycle.hh

@@ -28,7 +28,29 @@ auto provider::association::initialization(
 ) -> void {
 	auto assoc_ids = ecsact::meta::system_assoc_ids(sys_like_id);
 	for(auto assoc_id : assoc_ids) {
+		auto assoc_comp_id =
+			ecsact::meta::system_assoc_component_id(sys_like_id, assoc_id);
+		auto assoc_field_ids =
+			ecsact::meta::system_assoc_fields(sys_like_id, assoc_id);
 		assoc_view_names.insert({assoc_id, get_unique_view_name()});
+
+		for(auto field_id : assoc_field_ids) {
+			auto field_type = ecsact::meta::get_field_type(assoc_comp_id, field_id);
+			if(field_type.kind == ECSACT_TYPE_KIND_BUILTIN &&
+				 field_type.type.builtin == ECSACT_ENTITY_TYPE) {
+				auto compo_id = ecsact_id_cast<ecsact_composite_id>(assoc_comp_id);
+				assoc_fields[compo_id].push_back(field_id);
+				assoc_composites[assoc_id].insert(compo_id);
+			} else if(field_type.kind == ECSACT_TYPE_KIND_FIELD_INDEX) {
+				auto compo_id = field_type.type.field_index.composite_id;
+				assoc_fields[compo_id].push_back(field_id);
+				assoc_composites[assoc_id].insert(compo_id);
+			} else {
+				// Should never get here. Association fields may only be an indexed
+				// field or entity field.
+				assert(false);
+			}
+		}
 	}
 }
 
@@ -84,35 +106,45 @@ auto provider::association::entity_iteration(
 			make_view_opts.view_var_name = assoc_view_names.at(assoc_id);
 			make_view_opts.registry_var_name = names.registry_var_name;
 
+			for(auto compo_id : assoc_composites.at(assoc_id)) {
+			}
+
 			util::make_view(ctx, make_view_opts);
 		}
 
+		for(auto&& [assoc_id, compo_ids] : assoc_composites) {
+			for(auto compo_id : compo_ids) {
+				auto field_ids = assoc_fields.at(compo_id);
+				auto compo_cpp_ident = cpp_identifier(decl_full_name(compo_id));
+
+				ctx.write(std::format(
+					"{0}.storage({3}.storage<{1}>(static_cast<::entt::id_type>(::ecsact::"
+					"entt::detail::"
+					"hash_vals({1}::"
+					"id, {2}))));\n",
+					assoc_view_names.at(assoc_id),
+					compo_cpp_ident,
+					util::comma_delim(
+						field_ids |
+						std::views::transform([&](auto field_id) -> std::string {
+							return std::format(
+								"view.get<{}>(entity).{}",
+								compo_cpp_ident,
+								ecsact::meta::field_name(compo_id, field_id)
+							);
+						})
+					),
+					names.registry_var_name
+				));
+			}
+		}
+
 		for(auto assoc_id : ecsact::meta::system_assoc_ids(sys_like_id)) {
 			auto assoc_comp_id =
 				ecsact::meta::system_assoc_component_id(sys_like_id, assoc_id);
 			auto assoc_field_ids =
 				ecsact::meta::system_assoc_fields(sys_like_id, assoc_id);
 			auto assoc_comp_cpp_ident = cpp_identifier(decl_full_name(assoc_comp_id));
-
-			ctx.write(std::format(
-				"{0}.storage({3}.storage<{1}>(static_cast<::entt::id_type>(::ecsact::"
-				"entt::detail::"
-				"hash_vals({1}::"
-				"id, {2}))));\n",
-				assoc_view_names.at(assoc_id),
-				assoc_comp_cpp_ident,
-				util::comma_delim(
-					assoc_field_ids |
-					std::views::transform([&](auto field_id) -> std::string {
-						return std::format(
-							"view.get<{}>(entity).{}",
-							assoc_comp_cpp_ident,
-							ecsact::meta::field_name(assoc_comp_id, field_id)
-						);
-					})
-				),
-				names.registry_var_name
-			));
 		}
 
 		for(auto assoc_id : ecsact::meta::system_assoc_ids(sys_like_id)) {

rt_entt_codegen/core/system_provider/association/association.cc

@@ -2,6 +2,7 @@
 
 #include <string>
 #include <map>
+#include <set>
 #include "rt_entt_codegen/core/system_provider/system_provider.hh"
 #include "rt_entt_codegen/core/sys_exec/sys_exec.hh"
 #include "rt_entt_codegen/core/system_provider/system_ctx_functions.hh"
@@ -53,7 +54,13 @@ public:
 	) -> handle_exclusive_provide final;
 
 private:
-	std::map<ecsact_system_assoc_id, std::string> assoc_view_names;
+	std::map<ecsact_system_assoc_id, std::string>               assoc_view_names;
+	std::map<ecsact_composite_id, std::vector<ecsact_field_id>> assoc_fields;
+
+	// List of composites the association needs to read from in their view/group
+	// due to indexed fields.
+	std::map<ecsact_system_assoc_id, std::set<ecsact_composite_id>>
+		assoc_composites;
 
 	auto print_other_contexts(
 		ecsact::codegen_plugin_context& ctx,

rt_entt_codegen/core/system_provider/association/association.hh

@@ -5,6 +5,24 @@ auto ecsact::entt::detail::bytes_hash( //
 	std::byte* data,
 	int        data_length
 ) -> std::uint64_t {
+	if(data_length == sizeof(std::uint64_t)) {
+		auto bytes_as_u64 = std::uint64_t{};
+		std::memcpy(&bytes_as_u64, data, sizeof(std::uint64_t));
+		return bytes_as_u64;
+	} else if(data_length == sizeof(std::uint32_t)) {
+		auto bytes_as_u32 = std::uint32_t{};
+		std::memcpy(&bytes_as_u32, data, sizeof(std::uint32_t));
+		return bytes_as_u32;
+	} else if(data_length == sizeof(std::uint16_t)) {
+		auto bytes_as_u16 = std::uint16_t{};
+		std::memcpy(&bytes_as_u16, data, sizeof(std::uint16_t));
+		return bytes_as_u16;
+	} else if(data_length == 1) {
+		return static_cast<std::uint64_t>(data[0]);
+	} else if(data_length == 0) {
+		return 0;
+	}
+
 	XXH64_hash_t hash = XXH3_64bits(data, data_length);
 	return hash;
 }