Changes are in, runtime still crashing will look at it shortly

Author: Kelwan

ecsact/runtime/async.h

@@ -101,22 +101,6 @@ typedef void (*ecsact_execute_sys_error_callback)(
 	void*                        callback_user_data
 );
 
-/**
- * When an entity is sucessfully created this callback is
- * invoked.
- *
- * @param entity_id the entity id of the created entity
- * @param request_id the request ID returned by the create entity callback
- * @param callback_user_data the @ref
- * ecsact_async_events_collector::error_callback_user_data
- */
-typedef void (*ecsact_async_create_entity_callback)(
-	//
-	ecsact_entity_id        entity_id,
-	ecsact_async_request_id request_id,
-	void*                   callback_user_data
-);
-
 typedef struct ecsact_async_events_collector {
 	/**
 	 * invoked when an async request failed.
@@ -130,19 +114,6 @@ typedef struct ecsact_async_events_collector {
 	 */
 	void* async_error_callback_user_data;
 
-	/**
-	 * Invoked when a create entity request succeeds.
-	 * @see ecsact_async_create_entity_callback
-	 * @see ecsact_entity_id
-	 * @see ecsact_async_error
-	 */
-	ecsact_async_create_entity_callback async_entity_callback;
-
-	/**
-	 * `callback_user_data` passed to `async_entity_callback`
-	 */
-	void* async_entity_callback_user_data;
-
 	/**
 	 * invoked when a system execution error occurred.
 	 * @see ecsact_execute_sys_error_callback
@@ -203,11 +174,6 @@ ECSACT_ASYNC_API_FN(ecsact_async_request_id, ecsact_async_connect)
  */
 ECSACT_ASYNC_API_FN(void, ecsact_async_disconnect)(void);
 
-/**
- * Returns an entity
- */
-ECSACT_ASYNC_API_FN(ecsact_async_request_id, ecsact_async_create_entity)(void);
-
 /**
  * Gets the current tick
  */
@@ -218,7 +184,6 @@ ECSACT_ASYNC_API_FN(int32_t, ecsact_async_get_current_tick)(void);
 	fn(ecsact_async_flush_events, __VA_ARGS__);              \
 	fn(ecsact_async_connect, __VA_ARGS__);                   \
 	fn(ecsact_async_disconnect, __VA_ARGS__);                \
-	fn(ecsact_async_create_entity, __VA_ARGS__);             \
 	fn(ecsact_async_get_current_tick, __VA_ARGS__);
 
 #undef ECSACT_ASYNC_API

reference/async_reference/BUILD.bazel

@@ -19,11 +19,10 @@ cc_library(
     deps = [
         "//:async",
         "//:core",
-        "//reference/async_reference/request_id_factory",
         "//reference/async_reference/callbacks:async_callbacks",
         "//reference/async_reference/callbacks:execution_callbacks",
         "//reference/async_reference/detail/c_execution_options",
-        "//reference/async_reference/entity_manager",
+        "//reference/async_reference/request_id_factory",
         "//reference/async_reference/tick_manager",
         "//reference/async_reference/util",
         "//reference/async_reference/util:types",
@@ -50,7 +49,6 @@ filegroup(
     ]) + [
         "//reference/async_reference/callbacks:callback_source",
         "//reference/async_reference/detail/c_execution_options:c_execution_source",
-        "//reference/async_reference/entity_manager:entity_source",
         "//reference/async_reference/tick_manager:tick_source",
         "//reference/async_reference/util:util_source",
         "//reference/serialize_reference:serialize_source",

reference/async_reference/async.cc

@@ -38,20 +38,6 @@ void ecsact_async_flush_events(
 	}
 }
 
-ecsact_async_request_id ecsact_async_create_entity() {
-	auto req_id = request_id_factory.next_id();
-	if(!reference) {
-		async_callbacks.add(detail::types::async_error{
-			.error = ECSACT_ASYNC_ERR_PERMISSION_DENIED,
-			.request_ids = {req_id},
-		});
-		return req_id;
-	}
-
-	reference->create_entity_request(req_id);
-	return req_id;
-}
-
 ecsact_async_request_id ecsact_async_enqueue_execution_options(
 	const ecsact_execution_options options
 ) {

reference/async_reference/async_reference.cc

@@ -168,7 +168,6 @@ void async_reference::execute_systems() {
 				);
 			}
 			auto options = c_exec_options.c();
-			entity_manager.process_entities(async_callbacks, *registry_id);
 
 			auto exec_lk = exec_callbacks.lock();
 			auto systems_error =
@@ -195,22 +194,6 @@ void async_reference::invoke_execution_events(
 	}
 }
 
-void async_reference::create_entity_request(ecsact_async_request_id req_id) {
-	if(is_connected == false && is_connected_notified == false) {
-		types::async_error async_err{
-			.error = ECSACT_ASYNC_ERR_PERMISSION_DENIED,
-			.request_ids = {req_id},
-		};
-
-		async_callbacks.add(async_err);
-		is_connected_notified = true;
-
-		return;
-	}
-
-	entity_manager.request_entity(req_id);
-}
-
 int32_t async_reference::get_current_tick() {
 	return tick_manager.get_current_tick();
 }

reference/async_reference/async_reference.hh

@@ -18,7 +18,6 @@
 #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 "request_id_factory/request_id_factory.hh"
 
 namespace ecsact::async_reference::detail {
@@ -44,7 +43,6 @@ public:
 
 	int32_t get_current_tick();
 
-	void create_entity_request(ecsact_async_request_id req_id);
 	void connect(ecsact_async_request_id req_id, const char* connection_string);
 
 	void disconnect();
@@ -56,7 +54,6 @@ private:
 
 	tick_manager             tick_manager;
 	execution_callbacks      exec_callbacks;
-	entity_manager           entity_manager;
 	detail::async_callbacks& async_callbacks;
 
 	std::thread execution_thread;

reference/async_reference/callbacks/async_callbacks.cc

@@ -48,15 +48,6 @@ void async_callbacks::invoke(const ecsact_async_events_collector* async_events
 						error,
 						async_events->system_error_callback_user_data
 					);
-				} else if constexpr(std::is_same_v<T, types::entity>) {
-					if(async_events->async_entity_callback == nullptr) {
-						return;
-					}
-					async_events->async_entity_callback(
-						*error.entity_id,
-						error.request_id,
-						async_events->async_entity_callback_user_data
-					);
 				}
 			},
 			request

reference/async_reference/callbacks/execution_callbacks.cc

@@ -6,9 +6,15 @@ execution_callbacks::execution_callbacks() {
 	collector.init_callback = &execution_callbacks::init_callback;
 	collector.update_callback = &execution_callbacks::update_callback;
 	collector.remove_callback = &execution_callbacks::remove_callback;
+	collector.entity_created_callback =
+		&execution_callbacks::entity_created_callback;
+	collector.entity_destroyed_callback =
+		&execution_callbacks::entity_destroyed_callback;
 	collector.init_callback_user_data = this;
 	collector.update_callback_user_data = this;
 	collector.remove_callback_user_data = this;
+	collector.entity_created_callback_user_data = this;
+	collector.entity_destroyed_callback_user_data = this;
 }
 
 ecsact_execution_events_collector* execution_callbacks::get_collector() {
@@ -29,6 +35,8 @@ void execution_callbacks::invoke(
 			init_callbacks_info.clear();
 			update_callbacks_info.clear();
 			remove_callbacks_info.clear();
+			create_entity_callbacks_info.clear();
+			destroy_entity_callbacks_info.clear();
 		}
 		return;
 	}
@@ -37,16 +45,25 @@ void execution_callbacks::invoke(
 	std::vector<types::callback_info> update_callbacks;
 	std::vector<types::callback_info> remove_callbacks;
 
+	std::vector<types::entity_callback_info> entity_created_callbacks;
+	std::vector<types::entity_callback_info> entity_destroyed_callbacks;
+
 	std::unique_lock lk(execution_m);
 
 	init_callbacks = std::move(init_callbacks_info);
 	update_callbacks = std::move(update_callbacks_info);
 	remove_callbacks = std::move(remove_callbacks_info);
 
+	entity_created_callbacks = std::move(create_entity_callbacks_info);
+	entity_destroyed_callbacks = std::move(destroy_entity_callbacks_info);
+
 	init_callbacks_info.clear();
 	update_callbacks_info.clear();
 	remove_callbacks_info.clear();
 
+	create_entity_callbacks_info.clear();
+	destroy_entity_callbacks_info.clear();
+
 	lk.unlock();
 
 	if(execution_events->init_callback != nullptr) {
@@ -111,6 +128,26 @@ void execution_callbacks::invoke(
 			}
 		}
 	}
+
+	if(execution_events->entity_created_callback != nullptr) {
+		for(auto& info : entity_created_callbacks) {
+			execution_events->entity_created_callback(
+				info.event,
+				info.entity_id,
+				execution_events->entity_created_callback_user_data
+			);
+		}
+	}
+
+	if(execution_events->entity_destroyed_callback != nullptr) {
+		for(auto& info : entity_destroyed_callbacks) {
+			execution_events->entity_destroyed_callback(
+				info.event,
+				info.entity_id,
+				execution_events->entity_destroyed_callback_user_data
+			);
+		}
+	}
 }
 
 bool execution_callbacks::has_callbacks() {
@@ -126,6 +163,14 @@ bool execution_callbacks::has_callbacks() {
 		return true;
 	}
 
+	if(create_entity_callbacks_info.size() > 0) {
+		return true;
+	}
+
+	if(destroy_entity_callbacks_info.size() > 0) {
+		return true;
+	}
+
 	return false;
 }
 
@@ -199,7 +244,6 @@ void execution_callbacks::remove_callback(
 			init_cb_info.entity_id == entity_id;
 	});
 
-	// Maybe I can store data from here?
 	std::erase_if(self->update_callbacks_info, [&](auto& update_cb_info) {
 		return update_cb_info.component_id == component_id &&
 			update_cb_info.entity_id == entity_id;
@@ -226,3 +270,33 @@ void execution_callbacks::remove_callback(
 	// maybe...?
 	self->remove_callbacks_info.push_back(info);
 }
+
+void execution_callbacks::entity_created_callback(
+	ecsact_event     event,
+	ecsact_entity_id entity_id,
+	void*            callback_user_data
+) {
+	auto self = static_cast<execution_callbacks*>(callback_user_data);
+
+	auto info = types::entity_callback_info{};
+
+	info.event = event;
+	info.entity_id = entity_id;
+
+	self->create_entity_callbacks_info.push_back(info);
+}
+
+void execution_callbacks::entity_destroyed_callback(
+	ecsact_event     event,
+	ecsact_entity_id entity_id,
+	void*            callback_user_data
+) {
+	auto self = static_cast<execution_callbacks*>(callback_user_data);
+
+	auto info = types::entity_callback_info{};
+
+	info.event = event;
+	info.entity_id = entity_id;
+
+	self->destroy_entity_callbacks_info.push_back(info);
+}

reference/async_reference/callbacks/execution_callbacks.hh

@@ -34,6 +34,9 @@ private:
 	std::vector<types::callback_info> update_callbacks_info;
 	std::vector<types::callback_info> remove_callbacks_info;
 
+	std::vector<types::entity_callback_info> create_entity_callbacks_info;
+	std::vector<types::entity_callback_info> destroy_entity_callbacks_info;
+
 	bool has_callbacks();
 
 	static void init_callback(
@@ -59,5 +62,17 @@ private:
 		const void*         component_data,
 		void*               callback_user_data
 	);
+
+	static void entity_created_callback(
+		ecsact_event     event,
+		ecsact_entity_id entity_id,
+		void*            callback_user_data
+	);
+
+	static void entity_destroyed_callback(
+		ecsact_event     event,
+		ecsact_entity_id entity_id,
+		void*            callback_user_data
+	);
 };
 } // namespace ecsact::async_reference::detail

reference/async_reference/detail/c_execution_options/c_execution_options.cc

@@ -29,7 +29,23 @@ ecsact_execution_options c_execution_options::c() {
 		updates.push_back(component);
 	}
 
+	for(auto& create_info : create_entities_components) {
+		create_entity_components_length.push_back(create_info.size());
+		auto& entity_components = create_entity_components.emplace_back();
+		entity_components.reserve(create_info.size());
+		for(auto& component_info : create_info) {
+			auto component = ecsact_component{};
+			component.component_data = component_info.data.data();
+			component.component_id = component_info.id;
+			entity_components.push_back(component);
+		}
+
+		create_entity_components_datas.push_back(entity_components.data());
+		// Do stuff here
+	}
+
 	options.actions = actions.data();
+
 	options.actions_length = actions.size();
 
 	options.add_components = adds.data();
@@ -44,5 +60,10 @@ ecsact_execution_options c_execution_options::c() {
 	options.remove_components_entities = removes_entities.data();
 	options.remove_components_length = remove_ids.size();
 
+	options.create_entities_components = create_entity_components_datas.data();
+	options.create_entities_length = create_entities_components.size();
+	options.create_entities_components_length =
+		create_entity_components_length.data();
+
 	return options;
 }

reference/async_reference/detail/c_execution_options/c_execution_options.hh

@@ -27,6 +27,10 @@ struct c_execution_options {
 	std::vector<ecsact_entity_id>               updates_entities;
 	std::vector<ecsact_component_id>            remove_ids;
 	std::vector<ecsact_entity_id>               removes_entities;
+	std::vector<ecsact_entity_id>               destroy_entities;
+
+	std::vector<std::vector<data_info<ecsact_component_id>>>
+		create_entities_components;
 
 	ecsact_execution_options c();
 
@@ -36,6 +40,10 @@ private:
 	std::vector<ecsact_action>    actions;
 	std::vector<ecsact_component> adds;
 	std::vector<ecsact_component> updates;
+
+	std::vector<ecsact_component*>             create_entity_components_datas;
+	std::vector<std::vector<ecsact_component>> create_entity_components;
+	std::vector<int32_t>                       create_entity_components_length;
 };
 
 } // namespace ecsact::async_reference::detail