feat: using code generator (wip)

Author: zaucy

ecsact/entt/detail/globals.hh

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <unordered_map>
+#include "ecsact/runtime/common.h"
+#include "entt/entity/registry.hpp"
+
+/**
+ * A small set of globals exepected to be available the ecsact_rt_entt_codegen
+ * generated source.
+ */
+namespace ecsact::entt::detail::globals {
+
+/**
+ * Ecsact registry ID mapped to EnTT registry instance.
+ */
+extern std::unordered_map< //
+	ecsact_registry_id,
+	::entt::registry>
+	registries;
+
+/**
+ * Stored last registry ID. Used to create new registry IDs.
+ */
+extern ecsact_registry_id last_registry_id;
+
+/**
+ * System-like implementation functions set by dynamic API.
+ */
+extern std::unordered_map< //
+	ecsact_system_like_id,
+	ecsact_system_execution_impl>
+	system_impls;
+} // namespace ecsact::entt::detail::globals

ecsact/entt/execution.hh

@@ -2,19 +2,89 @@
 
 #include <vector>
 #include <unordered_map>
+#include <cassert>
+#include <span>
+#include <type_traits>
 #include "ecsact/runtime/common.h"
 #include "entt/entity/registry.hpp"
 
+namespace ecsact::entt::detail {
+template<typename>
+constexpr bool unimplemented_by_codegen = false;
+}
+
 namespace ecsact::entt {
 
+struct actions_map {
+	using raw_value_t =
+		std::unordered_map<ecsact_action_id, std::vector<const void*>>;
+
+	raw_value_t raw_value = {};
+
+	/**
+	 *  Collect from execution options passed to `ecsact_execute_systems`
+	 */
+	inline auto collect( //
+		int32_t                         index,
+		int32_t                         execution_count,
+		const ecsact_execution_options* execution_options_list
+	) -> void {
+		raw_value.clear();
+
+		if(execution_options_list == nullptr) {
+			return;
+		}
+
+		assert(index < execution_count);
+		auto options = execution_options_list[index];
+
+		if(options.actions_length == 0) {
+			return;
+		}
+
+		auto actions_span = std::span{
+			options.actions,
+			static_cast<size_t>(options.actions_length),
+		};
+
+		for(auto& action : actions_span) {
+			raw_value[action.action_id].push_back(action.action_data);
+		}
+	}
+
+	template<typename Action>
+	auto as_action_span() -> std::span<const Action*> {
+		ecsact_action_id action_id = Action::id;
+
+		if(!raw_value.contains(action_id)) {
+			return {};
+		}
+
+		auto& action_data_list = raw_value.at(action_id);
+
+		return std::span<Action>{
+			static_cast<const Action**>(action_data_list.data()),
+			action_data_list.size(),
+		};
+	}
+};
+
 /**
  * Executes system implementation for @tp System.
  *
  * NOTE: Template specializations are made available via the codegen plugin
  *       `ecsact_rt_entt_codegen`.
  */
 template<typename System>
-auto execute_system(::entt::registry&) -> void;
+auto execute_system(::entt::registry&) -> void {
+	static_assert(detail::unimplemented_by_codegen<System>, R"(
+ -----------------------------------------------------------------------------
+| (!) CODEGEN ERROR                                                           |
+| `execute_system<>` template specialization cannot be found. This is         |
+| typically generated by ecsact_rt_entt_codegen.                              |
+ -----------------------------------------------------------------------------
+)");
+}
 
 /**
  * Executes action implementation for @tp Action for every action in @p
@@ -24,25 +94,33 @@ auto execute_system(::entt::registry&) -> void;
  *       `ecsact_rt_entt_codegen`.
  */
 template<typename Action>
-auto execute_actions(::entt::registry&, auto&& action_range) -> void;
-
-/**
- * Executes all systems/actions
- *
- * NOTE: Implementation is generated by the `ecsact_rt_entt_codegen` plugin
- */
-auto execute_systems(
-	::entt::registry& registry,
-	int32_t           execution_count,
-	std::unordered_map<ecsact_action_id, std::vector<const void*>> actions
-) -> void;
+auto execute_actions( //
+	::entt::registry&          registry,
+	std::span<const Action*>&& action_range
+) -> void {
+	static_assert(detail::unimplemented_by_codegen<Action>, R"(
+ -----------------------------------------------------------------------------
+| (!) CODEGEN ERROR                                                           |
+| `execute_actions<>` template specialization cannot be found. This is        |
+| typically generated by ecsact_rt_entt_codegen.                              |
+ -----------------------------------------------------------------------------
+)");
+}
 
 /**
  * Allocates EnTT groups and storage if necessary for the system or action.
  * NOTE: Template specializations are made available via the codegen plugin
  *       `ecsact_rt_entt_codegen`.
  */
 template<typename SystemLike>
-auto prepare_system_like(::entt::registry&) -> void;
+auto prepare_system_like(::entt::registry&) -> void {
+	static_assert(detail::unimplemented_by_codegen<SystemLike>, R"(
+ -----------------------------------------------------------------------------
+| (!) CODEGEN ERROR                                                           |
+| `prepare_system_like<>` template specialization cannot be found. This is    |
+| typically generated by ecsact_rt_entt_codegen.                              |
+ -----------------------------------------------------------------------------
+)");
+}
 
 } // namespace ecsact::entt

ecsact/entt/registry_util.hh

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <cassert>
+#include "entt/entity/registry.hpp"
+#include "ecsact/entt/detail/globals.hh"
+
+namespace ecsact::entt {
+
+inline auto get_registry( //
+	ecsact_registry_id id
+) -> ::entt::registry& {
+	using ecsact::entt::detail::globals::registries;
+
+	// Check to make sure we're not trying to get a registry that doesn't exist
+	// or has been destroyed.
+	assert(registries.contains(id));
+	return registries.at(id);
+}
+
+inline auto create_registry()
+	-> std::tuple<ecsact_registry_id, ::entt::registry&> {
+	using ecsact::entt::detail::globals::last_registry_id;
+	using ecsact::entt::detail::globals::registries;
+
+	auto registry_id = static_cast<ecsact_registry_id>(
+		++reinterpret_cast<int32_t&>(last_registry_id)
+	);
+	auto& registry = registries[registry_id];
+
+	return {registry_id, std::ref(registry)};
+}
+
+} // namespace ecsact::entt

rt_entt_codegen/BUILD.bazel

@@ -1,14 +1,19 @@
 load("//bazel:copts.bzl", "copts")
-load("@ecsact_runtime//:codegen_plugin.bzl", "cc_ecsact_codegen_plugin")
+load("@ecsact_codegen//:codegen_plugin.bzl", "cc_ecsact_codegen_plugin")
 
 package(default_visibility = ["//visibility:public"])
 
 cc_ecsact_codegen_plugin(
     name = "ecsact_rt_entt_codegen",
-    srcs = glob(["*.cc", "*.hh"]),
+    srcs = ["rt_entt_codegen.cc"],
     copts = copts,
-    output_extension = "rt_entt.hh",
-    deps = ["@ecsact_lang_cpp//:support"],
+    output_extension = "rt_entt.cc",
+    deps = [
+        "//rt_entt_codegen/core",
+        "//rt_entt_codegen/shared:ecsact_entt_details",
+        "//rt_entt_codegen/shared:util",
+        "@ecsact_lang_cpp//:support",
+    ],
 )
 
 alias(

rt_entt_codegen/core/BUILD.bazel

@@ -0,0 +1,37 @@
+load("//bazel:copts.bzl", "copts")
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+cc_library(
+    name = "core_internal",
+    visibility = ["//rt_entt_codegen:__pkg__"],
+    copts = copts,
+    hdrs = ["core.hh"],
+    deps = ["//rt_entt_codegen/shared:ecsact_entt_details"],
+)
+
+# keep sorted
+_CORE_CODEGEN_METHODS = {
+    "execute_systems": [],
+    "create_registry": [],
+}
+
+[cc_library(
+    name = method,
+    srcs = ["{}.cc".format(method)],
+    copts = copts,
+    defines = ["ECSACT_META_API_LOAD_AT_RUNTIME"],
+    deps = _CORE_CODEGEN_METHODS[method] + [
+        ":core_internal",
+        "//rt_entt_codegen/shared:util",
+        "@ecsact_runtime//:meta",
+        "@ecsact_runtime//:codegen_plugin_cc",
+        "@ecsact_lang_cpp//:support",
+    ],
+) for method in _CORE_CODEGEN_METHODS]
+
+cc_library(
+    name = "core",
+    visibility = ["//rt_entt_codegen:__pkg__"],
+    copts = copts,
+    deps = [":core_internal"] + [":{}".format(method) for method in _CORE_CODEGEN_METHODS],
+)

rt_entt_codegen/core/core.hh

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "ecsact/runtime/meta.hh"
+#include "ecsact/codegen_plugin.hh"
+#include "rt_entt_codegen/shared/ecsact_entt_details.hh"
+
+namespace ecsact::rt_entt_codegen::core {
+
+auto print_execute_systems( //
+	codegen_plugin_context&    ctx,
+	const ecsact_entt_details& details
+) -> void;
+
+auto print_create_registry( //
+	codegen_plugin_context&    ctx,
+	const ecsact_entt_details& details
+) -> void;
+
+} // namespace ecsact::rt_entt_codegen::core

rt_entt_codegen/core/create_registry.cc

@@ -0,0 +1,30 @@
+#include "core.hh"
+
+#include "ecsact/lang-support/lang-cc.hh"
+#include "rt_entt_codegen/shared/util.hh"
+
+auto ecsact::rt_entt_codegen::core::print_create_registry( //
+	codegen_plugin_context&    ctx,
+	const ecsact_entt_details& details
+) -> void {
+	using ecsact::cc_lang_support::cpp_identifier;
+	using ecsact::rt_entt_codegen::util::method_printer;
+
+	auto printer = //
+		method_printer{ctx, "ecsact_create_registry"}
+			.parameter("const char*", "registry_name")
+			.return_type("ecsact_registry_id");
+
+	ctx.write("auto&& [registry_id, reg] = ecsact::entt::create_registry();\n\n");
+
+	ctx.write(
+		"// These groups were automatically selected based on the input ecsact "
+		"files\n"
+	);
+	for(auto sys_id : details.group_systems) {
+		auto cpp_decl_name = cpp_identifier(ecsact::meta::decl_full_name(sys_id));
+		ctx.write("ecsact::entt::prepare_system_like<", cpp_decl_name, ">(reg);\n");
+	}
+
+	ctx.write("\nreturn registry_id;");
+}

rt_entt_codegen/core/execute_systems.cc

@@ -0,0 +1,56 @@
+#include "core.hh"
+
+#include "ecsact/lang-support/lang-cc.hh"
+#include "rt_entt_codegen/shared/util.hh"
+
+constexpr auto METHOD_BODY_TOP = R"(
+auto& reg = ecsact::entt::get_registry(registry_id);
+auto actions = ecsact::entt::actions_map{};
+)";
+
+auto ecsact::rt_entt_codegen::core::print_execute_systems( //
+	codegen_plugin_context&    ctx,
+	const ecsact_entt_details& details
+) -> void {
+	using ecsact::cc_lang_support::cpp_identifier;
+	using ecsact::rt_entt_codegen::util::method_printer;
+
+	auto printer = //
+		method_printer{ctx, "ecsact_execute_systems"}
+			.parameter("ecsact_registry_id", "registry_id")
+			.parameter("int", "execution_count")
+			.parameter("const ecsact_execution_options*", "execution_options_list")
+			.parameter("const ecsact_execution_events_collector*", "evc")
+			.return_type("ecsact_execute_systems_error");
+
+	ctx.write(METHOD_BODY_TOP);
+
+	ctx.write("for(auto i=0; execution_count > i; ++i) {");
+	ctx.indentation += 1;
+	ctx.write("\n");
+
+	ctx.write("actions.collect(i, execution_count, execution_options_list);\n");
+
+	for(auto sys_like : details.top_execution_order) {
+		auto cpp_decl_name = cpp_identifier(ecsact::meta::decl_full_name(sys_like));
+
+		if(details.is_action(sys_like)) {
+			ctx.write(
+				"ecsact::entt::execute_actions<",
+				cpp_decl_name,
+				">(reg, actions.as_action_span<",
+				cpp_decl_name,
+				">());\n"
+			);
+		} else if(details.is_system(sys_like)) {
+			ctx.write("ecsact::entt::execute_system<", cpp_decl_name, ">(reg);\n");
+		} else {
+			ctx.write("// ??? unhandled ??? ", cpp_decl_name, "\n");
+		}
+	}
+
+	ctx.indentation -= 1;
+	ctx.write("\n}\n");
+
+	ctx.write("return ECSACT_EXEC_SYS_OK;");
+}