Split off entity code and ready for review

Author: Kelwan

ecsact/runtime/serialize.hh

@@ -46,6 +46,32 @@ std::vector<std::byte> serialize(const T& component_or_action) {
 	return bytes;
 }
 
+inline std::vector<std::byte> serialize(const ecsact_component& component) {
+	std::vector<std::byte> out_component;
+	out_component.resize(ecsact_serialize_component_size(component.component_id));
+
+	ecsact_serialize_component(
+		component.component_id,
+		component.component_data,
+		reinterpret_cast<uint8_t*>(out_component.data())
+	);
+	return out_component;
+}
+
+inline std::vector<std::byte> serialize(const ecsact_action& action) {
+	std::vector<std::byte> out_action;
+	out_action.resize(ecsact_serialize_action_size(action.action_id));
+
+	ecsact_serialize_action(
+		action.action_id,
+		action.action_data,
+		reinterpret_cast<uint8_t*>(out_action.data())
+	);
+	return out_action;
+}
+
+// NOTE: Add the wrapper for serialize/derserialize here
+
 /**
  * Calls `ecsact_deserialize_action` or `ecsact_deserialize_component` based on
  * the type of @tp T.
@@ -115,4 +141,40 @@ int deserialize(
 		::ecsact::deserialize<T>(serialized_component_or_action, read_amount);
 	return read_amount;
 }
+
+inline ecsact_action deserialize(
+	const ecsact_action_id& id,
+	std::vector<std::byte>& serialized_action
+) {
+	auto action = ecsact_action{};
+
+	ecsact_deserialize_action(
+		id,
+		reinterpret_cast<uint8_t*>(serialized_action.data()),
+		&action
+	);
+	return action;
+}
+
+inline ecsact_component deserialize(
+	const ecsact_component_id& id,
+	std::vector<std::byte>&    serialized_component
+) {
+	auto component = ecsact_component{};
+
+	std::vector<uint8_t> component_data;
+	component_data.resize(serialized_component.size());
+
+	ecsact_deserialize_component(
+		id,
+		reinterpret_cast<uint8_t*>(serialized_component.data()),
+		component_data.data()
+	);
+
+	component.component_id = id;
+	component.component_data = component_data.data();
+
+	return component;
+}
+
 } // namespace ecsact

reference/async_reference/BUILD.bazel

@@ -20,6 +20,7 @@ cc_library(
         "//:core",
         "//reference/async_reference/callbacks:async_callbacks",
         "//reference/async_reference/callbacks:execution_callbacks",
+        "//reference/async_reference/entity_manager",
         "//reference/async_reference/tick_manager",
         "//reference/async_reference/util",
         "//reference/async_reference/util:types",

reference/async_reference/async_reference.cc

@@ -175,7 +175,7 @@ void async_reference::execute_systems() {
 				);
 			}
 
-			process_entities();
+			entity_manager.process_entities(async_callbacks, *registry_id);
 
 			auto systems_error =
 				ecsact_execute_systems(*registry_id, 1, options.get(), &collector);
@@ -216,8 +216,7 @@ ecsact_async_request_id async_reference::create_entity_request() {
 		return req_id;
 	}
 
-	std::unique_lock lk(pending_m);
-	pending_entity_requests.insert(pending_entity_requests.end(), req_id);
+	entity_manager.request_entity(req_id);
 	return req_id;
 }
 
@@ -237,23 +236,3 @@ ecsact_async_request_id async_reference::next_request_id() {
 ecsact_async_request_id async_reference::convert_request_id(int32_t id) {
 	return static_cast<ecsact_async_request_id>(id);
 }
-
-void async_reference::process_entities() {
-	std::vector<ecsact_async_request_id> pending_entities;
-
-	std::unique_lock lk(pending_m);
-	pending_entities = std::move(pending_entity_requests);
-	pending_entity_requests.clear();
-	lk.unlock();
-
-	for(auto& entity_request_id : pending_entities) {
-		auto entity = ecsact_create_entity(*registry_id);
-
-		types::entity created_entity{
-			.entity_id = entity,
-			.request_id = entity_request_id,
-		};
-
-		async_callbacks.add(created_entity);
-	}
-}

reference/async_reference/async_reference.hh

@@ -14,6 +14,7 @@
 #include "reference/async_reference/tick_manager/tick_manager.hh"
 #include "reference/async_reference/callbacks/execution_callbacks.hh"
 #include "reference/async_reference/callbacks/async_callbacks.hh"
+#include "reference/async_reference/entity_manager/entity_manager.hh"
 
 #include "ecsact/runtime/core.hh"
 #include "ecsact/runtime/async.h"
@@ -32,7 +33,6 @@ public:
 	);
 
 	ecsact_async_request_id create_entity_request();
-
 	ecsact_async_request_id connect(const char* connection_string);
 
 	void disconnect();
@@ -42,16 +42,13 @@ private:
 
 	std::optional<ecsact_registry_id> registry_id;
 
-	void process_entities();
-
 	tick_manager        tick_manager;
 	execution_callbacks exec_callbacks;
 	async_callbacks     async_callbacks;
+	entity_manager      entity_manager;
 
-	std::vector<ecsact_async_request_id> pending_entity_requests;
+	std::thread execution_thread;
 
-	std::thread      execution_thread;
-	std::mutex       pending_m;
 	std::atomic_bool is_connected = false;
 	std::atomic_bool is_connected_notified = false;
 

reference/async_reference/entity_manager/BUILD.bazel

@@ -0,0 +1,18 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("//bazel:copts.bzl", "copts")
+
+cc_library(
+    name = "entity_manager",
+    srcs = ["entity_manager.cc"],
+    hdrs = ["entity_manager.hh"],
+    copts = copts,
+    local_defines = [
+        "ECSACT_CORE_API=",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//:core",
+        "//reference/async_reference/callbacks:async_callbacks",
+        "//reference/async_reference/util:types",
+    ],
+)

reference/async_reference/entity_manager/entity_manager.cc

@@ -0,0 +1,29 @@
+#include "entity_manager.hh"
+
+void entity_manager::process_entities(
+	async_callbacks&          callbacks,
+	const ecsact_registry_id& registry_id
+) {
+	std::vector<ecsact_async_request_id> pending_entities;
+
+	std::unique_lock lk(pending_m);
+	pending_entities = std::move(pending_entity_requests);
+	pending_entity_requests.clear();
+	lk.unlock();
+
+	for(auto& entity_request_id : pending_entities) {
+		auto entity = ecsact_create_entity(registry_id);
+
+		types::entity created_entity{
+			.entity_id = entity,
+			.request_id = entity_request_id,
+		};
+
+		callbacks.add(created_entity);
+	}
+}
+
+void entity_manager::request_entity(const ecsact_async_request_id& req_id) {
+	std::unique_lock lk(pending_m);
+	pending_entity_requests.push_back(req_id);
+}

reference/async_reference/entity_manager/entity_manager.hh

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <vector>
+#include <mutex>
+
+#include "ecsact/runtime/core.hh"
+#include "reference/async_reference/callbacks/async_callbacks.hh"
+#include "reference/async_reference/util/types.hh"
+
+class entity_manager {
+public:
+	void process_entities(
+		async_callbacks&          callbacks,
+		const ecsact_registry_id& registry_id
+	);
+
+	void request_entity(const ecsact_async_request_id& req_id);
+
+private:
+	std::mutex pending_m;
+
+	std::vector<ecsact_async_request_id> pending_entity_requests;
+};

reference/async_reference/tick_manager/tick_manager.cc

@@ -11,7 +11,7 @@ void tick_manager::add_pending_options(types::pending_execution_options& pending
 
 std::optional<types::cpp_execution_options>
 tick_manager::move_and_increment_tick() {
-	std::optional<types::cpp_execution_options> cpp_options;
+	auto cpp_options = std::optional<types::cpp_execution_options>{};
 
 	if(validated_tick_map.contains(tick)) {
 		std::unique_lock lk(tick_m);
@@ -33,7 +33,7 @@ types::async_error tick_manager::validate_pending_options() {
 		lk.unlock();
 
 		for(auto& [key, pending_list] : pending_options) {
-			types::cpp_execution_options merged_options{};
+			auto merged_options = types::cpp_execution_options{};
 
 			for(int i = 0; i < pending_list.size(); i++) {
 				merged_options = {};