feat: execution options partiall unrealified

Author: zaucy

Source/Ecsact/Public/EcsactAsyncRunner.cpp

@@ -1,10 +1,13 @@
 #include "EcsactAsyncRunner.h"
 #include "Ecsact.h"
+#include "EcsactUnrealExecutionOptions.h"
 #include "EcsactUnrealEventsCollector.h"
 #include "ecsact/runtime/async.h"
 #include "ecsact/runtime/common.h"
 
 auto UEcsactAsyncRunner::Tick(float DeltaTime) -> void {
+	EnqueueExecutionOptions();
+
 	if(ecsact_async_flush_events == nullptr) {
 		UE_LOG(Ecsact, Error, TEXT("ecsact_async_flush_events is unavailable"));
 	} else {
@@ -16,6 +19,25 @@ auto UEcsactAsyncRunner::Tick(float DeltaTime) -> void {
 	}
 }
 
+auto UEcsactAsyncRunner::EnqueueExecutionOptions() -> void {
+	if(!ExecutionOptions) {
+		return;
+	}
+	if(ecsact_async_enqueue_execution_options == nullptr) {
+		UE_LOG(
+			Ecsact,
+			Error,
+			TEXT("ecsact_async_enqueue_execution_options is unavailable")
+		);
+		return;
+	}
+
+	if(ExecutionOptions->IsNotEmpty()) {
+		ecsact_async_enqueue_execution_options(*ExecutionOptions->GetCPtr());
+		ExecutionOptions->Clear();
+	}
+}
+
 auto UEcsactAsyncRunner::GetStatId() const -> TStatId {
 	RETURN_QUICK_DECLARE_CYCLE_STAT(UEcsactAsyncRunner, STATGROUP_Tickables);
 }

Source/Ecsact/Public/EcsactAsyncRunner.h

@@ -14,4 +14,11 @@ class UEcsactAsyncRunner : public UEcsactRunner {
 public:
 	auto Tick(float DeltaTime) -> void override;
 	auto GetStatId() const -> TStatId override;
+
+	/**
+	 * Usually execution options are enqueued during `Tick`, but if you'd prefer
+	 * to enqueue them earlier then you can call this function to immediate
+	 * enqueue the execution options.
+	 */
+	auto EnqueueExecutionOptions() -> void;
 };

Source/Ecsact/Public/EcsactRunner.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include "CoreMinimal.h"
+#include "Tickable.h"
+#include "ecsact/runtime/common.h"
 #include "EcsactRunner.generated.h"
 
 UCLASS(Abstract)
@@ -12,6 +14,9 @@ class UEcsactRunner : public UObject, public FTickableGameObject {
 	UPROPERTY()
 	class UEcsactUnrealEventsCollector* EventsCollector;
 
+	UPROPERTY()
+	class UEcsactUnrealExecutionOptions* ExecutionOptions;
+
 public:
 	auto Tick(float DeltaTime) -> void override;
 	auto GetStatId() const -> TStatId override;

Source/Ecsact/Public/EcsactSyncRunner.cpp

@@ -1,5 +1,7 @@
 #include "EcsactSyncRunner.h"
 #include "Ecsact.h"
+#include "EcsactUnrealExecutionOptions.h"
+#include "EcsactUnrealEventsCollector.h"
 #include "EcsactExecution.h"
 #include "ecsact/runtime/core.h"
 
@@ -26,7 +28,12 @@ auto UEcsactSyncRunner::Tick(float DeltaTime) -> void {
 		evc_c = EventsCollector->GetCEVC();
 	}
 
-	auto err = ecsact_execute_systems(registry_id, 1, nullptr, evc_c);
+	ecsact_execution_options* exec_opts = nullptr;
+	if(ExecutionOptions != nullptr && ExecutionOptions->IsNotEmpty()) {
+		exec_opts = ExecutionOptions->GetCPtr();
+	}
+
+	auto err = ecsact_execute_systems(registry_id, 1, exec_opts, evc_c);
 	if(err != ECSACT_EXEC_SYS_OK) {
 		UE_LOG(Ecsact, Error, TEXT("Ecsact execution failed"));
 	}

Source/Ecsact/Public/EcsactUnrealExecutionOptions.cpp

@@ -0,0 +1,33 @@
+#include "EcsactUnrealExecutionOptions.h"
+
+UEcsactUnrealExecutionOptions::UEcsactUnrealExecutionOptions() : ExecOpts({}) {
+}
+
+auto UEcsactUnrealExecutionOptions::GetCPtr() -> ecsact_execution_options* {
+	return &ExecOpts;
+}
+
+auto UEcsactUnrealExecutionOptions::IsNotEmpty() const -> bool {
+	return ExecOpts.actions_length > 0 || ExecOpts.create_entities_length > 0 ||
+		ExecOpts.add_components_length > 0 ||
+		ExecOpts.destroy_entities_length > 0 ||
+		ExecOpts.update_components_length > 0 ||
+		ExecOpts.remove_components_length > 0;
+}
+
+auto UEcsactUnrealExecutionOptions::Clear() -> void {
+	for(auto act : ActionList) {
+		FMemory::Free(const_cast<void*>(act.action_data));
+	}
+	for(auto comp : AddComponentList) {
+		FMemory::Free(const_cast<void*>(comp.component_data));
+	}
+	for(auto comp : UpdateComponentList) {
+		FMemory::Free(const_cast<void*>(comp.component_data));
+	}
+	ActionList.Empty();
+	AddComponentList.Empty();
+	UpdateComponentList.Empty();
+	RemoveComponentList.Empty();
+	ExecOpts = {};
+}

Source/Ecsact/Public/EcsactUnrealExecutionOptions.h

@@ -0,0 +1,82 @@
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "ecsact/runtime/common.h"
+#include "EcsactUnrealExecutionOptions.generated.h"
+
+UCLASS()
+
+class UEcsactUnrealExecutionOptions : public UObject {
+	GENERATED_BODY()
+
+	TArray<ecsact_action>       ActionList;
+	TArray<ecsact_component>    AddComponentList;
+	TArray<ecsact_component>    UpdateComponentList;
+	TArray<ecsact_component_id> RemoveComponentList;
+	ecsact_execution_options    ExecOpts;
+
+public:
+	UEcsactUnrealExecutionOptions();
+
+	auto Clear() -> void;
+	auto IsNotEmpty() const -> bool;
+
+	/**
+	 * Get's the C `ecsact_execution_options` pointer typically passed to
+	 * `ecsact_execute_systems` or `ecsact_async_enqueue_execution_options`. The
+	 * lifetime of this pointer is the same as the owning
+	 * `UEcsactUnrealExecutionOptions`.
+	 */
+	auto GetCPtr() -> ecsact_execution_options*;
+
+	template<typename A>
+	auto PushAction(const A& Action) -> void {
+		auto action_data = FMemory::Malloc(sizeof(A));
+		FMemory::Memcpy(action_data, &Action, sizeof(A));
+		ActionList.Push(ecsact_action{
+			.action_id = A::id,
+			.action_data = action_data,
+		});
+
+		ExecOpts.actions_length = ActionList.Num();
+		ExecOpts.actions = ActionList.GetData();
+	}
+
+	template<typename C>
+	auto AddComponent(ecsact_entity_id Entity, const C& Component) -> void {
+		auto component_data = FMemory::Malloc(sizeof(C));
+		FMemory::Memcpy(component_data, &Component, sizeof(C));
+		AddComponentList.Push(ecsact_component{
+			.component_id = C::id,
+			.component_data = component_data,
+		});
+
+		ExecOpts.add_components_length = AddComponentList.Num();
+		ExecOpts.add_components = AddComponentList.GetData();
+	}
+
+	template<typename C>
+	auto UpdateComponent(ecsact_entity_id Entity, const C& Component) -> void {
+		auto component_data = FMemory::Malloc(sizeof(C));
+		FMemory::Memcpy(component_data, &Component, sizeof(C));
+		UpdateComponentList.Push(ecsact_component{
+			.component_id = C::id,
+			.component_data = component_data,
+		});
+
+		ExecOpts.update_components_length = UpdateComponentList.Num();
+		ExecOpts.update_components = UpdateComponentList.GetData();
+	}
+
+	template<typename C>
+	auto RemoveComponent(ecsact_entity_id Entity) -> void {
+		RemoveComponentList.Push(C::id);
+
+		ExecOpts.remove_components_length = RemoveComponentList.Num();
+		ExecOpts.remove_components = RemoveComponentList.GetData();
+	}
+
+	inline auto DestroyEntity(ecsact_entity_id Entity) -> void {
+	}
+};